=head1 Wx::AboutDialogInfo

=head2 Wx::AboutDialogInfo::new

   wxAboutDialogInfo()

   Default constructor leaves all fields are initially uninitialized, in
   general you should call at least SetVersion, SetCopyright and
   SetDescription.

=head2 Wx::AboutDialogInfo::AddArtist

   void AddArtist(const wxString& artist)

   Adds an artist name to be shown in the program credits.

   See also

   SetArtists

=head2 Wx::AboutDialogInfo::AddDeveloper

   void AddDeveloper(const wxString& developer)

   Adds a developer name to be shown in the program credits.

   See also

   SetDevelopers

=head2 Wx::AboutDialogInfo::AddDocWriter

   void AddDocWriter(const wxString& docwriter)

   Adds a documentation writer name to be shown in the program credits.

   See also

   SetDocWriters

=head2 Wx::AboutDialogInfo::AddTranslator

   void AddTranslator(const wxString& translator)

   Adds a translator name to be shown in the program credits. Notice that
   if no translator names are specified explicitely, wxAboutBox() will
   try to use the translation of the string translator-credits from the
   currently used message catalog -- this can be used to show just the
   name of the translator of the program in the current language.

   See also

   SetTranslators

=head2 Wx::AboutDialogInfo::SetArtists

   void SetArtists(const wxArrayString& artists)

   Sets the the list of artists to be shown in the program credits.

   See also

   AddArtist

=head2 Wx::AboutDialogInfo::SetCopyright

   void SetCopyright(const wxString& copyright)

   Set the short string containing the program copyright information.
   Notice that any occurrences of "(C)" in copyright will be replaced by
   the copyright symbol (circled C) automatically, which means that you
   can avoid using this symbol in the program source code which can be
   problematic,

=head2 Wx::AboutDialogInfo::SetDescription

   void SetDescription(const wxString& desc)

   Set brief, but possibly multiline, description of the program.

=head2 Wx::AboutDialogInfo::SetDevelopers

   void SetDevelopers(const wxArrayString& developers)

   Set the list of developers of the program.

   See also

   AddDeveloper

=head2 Wx::AboutDialogInfo::SetDocWriters

   void SetDocWriters(const wxArrayString& docwriters)

   Set the list of documentation writers.

   See also

   AddDocWriter

=head2 Wx::AboutDialogInfo::SetIcon

   void SetIcon(const wxIcon& icon)

   Set the icon to be shown in the dialog. By default the icon of the
   main frame will be shown if the native about dialog supports custom
   icons. If it doesn't but a valid icon is specified using this method,
   the generic about dialog is used instead so you should avoid calling
   this function for maximally native look and feel.

=head2 Wx::AboutDialogInfo::SetLicence

   void SetLicence(const wxString& licence)

   Set the long, multiline string containing the text of the program
   licence.

   Only GTK+ version supports showing the licence text in the native
   about dialog currently so the generic version will be used under all
   the other platforms if this method is called. To preserve the native
   look and feel it is advised that you do not call this method but
   provide a separate menu item in the "Help" menu for displaying the
   text of your program licence.

=head2 Wx::AboutDialogInfo::SetLicense

   void SetLicense(const wxString& licence)

   This is the same as SetLicence.

=head2 Wx::AboutDialogInfo::SetName

   void SetName(const wxString& name)

   Set the name of the program. If this method is not called, the string
   returned by wxApp::GetAppName() will be shown in the dialog.

=head2 Wx::AboutDialogInfo::SetTranslators

   void SetTranslators(const wxArrayString& translators)

   Set the list of translators. Please see AddTranslator for additional
   discussion.

=head2 Wx::AboutDialogInfo::SetVersion

   void SetVersion(const wxString& version)

   Set the version of the program. The version is in free format, i.e.
   not necessarily in the x.y.z form but it shouldn't contain the
   "version" word.

=head2 Wx::AboutDialogInfo::SetWebSite

   void SetWebSite(const wxString& url, const wxString& desc =
   wxEmptyString)

   Set the web site for the program and its description (which defaults
   to URL itself if empty).

   Please notice that only GTK+ version currently supports showing the
   link in the native about dialog so if this method is called, the
   generic version will be used under all the other platforms.

=head1 Wx::AcceleratorEntry

=head2 Wx::AcceleratorEntry::new

   wxAcceleratorEntry()

   Default constructor.

   wxAcceleratorEntry(int flags, int keyCode, int cmd)

   Constructor.

   Parameters

   flags

       One of wxACCEL_ALT, wxACCEL_SHIFT, wxACCEL_CTRL and
       wxACCEL_NORMAL. Indicates which modifier key is held down.

   keyCode

       The keycode to be detected. See Keycodes for a full list of
       keycodes.

   cmd 

       The menu or control command identifier.

=head2 Wx::AcceleratorEntry::GetCommand

   int GetCommand() const

   Returns the command identifier for the accelerator table entry.

=head2 Wx::AcceleratorEntry::GetFlags

   int GetFlags() const

   Returns the flags for the accelerator table entry.

=head2 Wx::AcceleratorEntry::GetKeyCode

   int GetKeyCode() const

   Returns the keycode for the accelerator table entry.

=head2 Wx::AcceleratorEntry::Set

   void Set(int flags, int keyCode, int cmd)

   Sets the accelerator entry parameters.

   Parameters

   flags

       One of wxACCEL_ALT, wxACCEL_SHIFT, wxACCEL_CTRL and
       wxACCEL_NORMAL. Indicates which modifier key is held down.

   keyCode

       The keycode to be detected. See Keycodes for a full list of
       keycodes.

   cmd 

       The menu or control command identifier.

=head1 Wx::AcceleratorTable

=head2 Wx::AcceleratorTable::new

   wxAcceleratorTable()

   Default constructor.

   wxAcceleratorTable(const wxAcceleratorTable& table)

   Copy constructor, uses reference counting.

   wxAcceleratorTable(int n, wxAcceleratorEntry entries[])

   Creates from an array of wxAcceleratorEntry objects.

   wxAcceleratorTable(const wxString& resource)

   Loads the accelerator table from a Windows resource (Windows only).

   Parameters

   n   

       Number of accelerator entries.

   entries

       The array of entries.

   resource

       Name of a Windows accelerator.

   wxPython note: The wxPython constructor accepts a list of
   wxAcceleratorEntry objects, or 3-tuples consisting of flags, keyCode,
   and cmd values like you would construct wxAcceleratorEntry objects
   with.

   wxPerl note: The wxPerl constructor accepts a list of either
   Wx::AcceleratorEntry objects or references to 3-element arrays (
   flags, keyCode, cmd ), like the parameters of
   Wx::AcceleratorEntry::new.

=head2 Wx::AcceleratorTable::DESTROY

   ~wxAcceleratorTable()

   Destroys the wxAcceleratorTable object. See reference-counted object
   destruction for more info.

=head2 Wx::AcceleratorTable::IsOk

   bool IsOk() const

   Returns true if the accelerator table is valid.

=head1 Wx::Accessible

=head2 Wx::Accessible::new

   wxAccessible(wxWindow* win = NULL)

   Constructor, taking an optional window. The object can be associated
   with a window later.

=head2 Wx::Accessible::DESTROY

   ~wxAccessible()

   Destructor.

=head2 Wx::Accessible::DoDefaultAction

   virtual wxAccStatus DoDefaultAction(int childId)

   Performs the default action for the object. childId is 0 (the action
   for this object) or greater than 0 (the action for a child). Return
   wxACC_NOT_SUPPORTED if there is no default action for this window
   (e.g. an edit control).

=head2 Wx::Accessible::GetChild

   virtual wxAccStatus GetChild(int childId, wxAccessible** child)

   Gets the specified child (starting from 1). If child is NULL and the
   return value is wxACC_OK, this means that the child is a simple
   element and not an accessible object.

=head2 Wx::Accessible::GetChildCount

   virtual wxAccStatus GetChildCount(int* childCount)

   Returns the number of children in childCount.

=head2 Wx::Accessible::GetDefaultAction

   virtual wxAccStatus GetDefaultAction(int childId, wxString* actionName)

   Gets the default action for this object (0) or a child (greater than
   0). Return wxACC_OK even if there is no action. actionName is the
   action, or the empty string if there is no action. The retrieved
   string describes the action that is performed on an object, not what
   the object does as a result. For example, a toolbar button that prints
   a document has a default action of "Press" rather than "Prints the
   current document."

=head2 Wx::Accessible::GetDescription

   virtual wxAccStatus GetDescription(int childId, wxString* description)

   Returns the description for this object or a child.

=head2 Wx::Accessible::GetFocus

   virtual wxAccStatus GetFocus(int* childId, wxAccessible** child)

   Gets the window with the keyboard focus. If childId is 0 and child is
   NULL, no object in this subhierarchy has the focus. If this object has
   the focus, child should be 'this'.

=head2 Wx::Accessible::GetHelpText

   virtual wxAccStatus GetHelpText(int childId, wxString* helpText)

   Returns help text for this object or a child, similar to tooltip text.

=head2 Wx::Accessible::GetKeyboardShortcut

   virtual wxAccStatus GetKeyboardShortcut(int childId, wxString*
   shortcut)

   Returns the keyboard shortcut for this object or child. Return e.g.
   ALT+K.

=head2 Wx::Accessible::GetLocation

   virtual wxAccStatus GetLocation(wxRect& rect, int elementId)

   Returns the rectangle for this object (id is 0) or a child element (id
   is greater than 0). rect is in screen coordinates.

=head2 Wx::Accessible::GetName

   virtual wxAccStatus GetName(int childId, wxString* name)

   Gets the name of the specified object.

=head2 Wx::Accessible::GetParent

   virtual wxAccStatus GetParent(wxAccessible** parent)

   Returns the parent of this object, or NULL.

=head2 Wx::Accessible::GetRole

   virtual wxAccStatus GetRole(int childId, wxAccRole* role)

   Returns a role constant describing this object. See wxAccessible for a
   list of these roles.

=head2 Wx::Accessible::GetSelections

   virtual wxAccStatus GetSelections(wxVariant* selections)

   Gets a variant representing the selected children of this object.

   Acceptable values are:

=head2 Wx::Accessible::GetState

   virtual wxAccStatus GetState(int childId, long* state)

   Returns a state constant. See wxAccessible for a list of these states.

=head2 Wx::Accessible::GetValue

   virtual wxAccStatus GetValue(int childId, wxString* strValue)

   Returns a localized string representing the value for the object or
   child.

=head2 Wx::Accessible::GetWindow

   wxWindow* GetWindow()

   Returns the window associated with this object.

=head2 Wx::Accessible::HitTest

   virtual wxAccStatus HitTest(const wxPoint& pt, int* childId,
   wxAccessible** childObject)

   Returns a status value and object id to indicate whether the given
   point was on this or a child object. Can return either a child object,
   or an integer representing the child element, starting from 1.

   pt is in screen coordinates.

=head2 Wx::Accessible::Navigate

   virtual wxAccStatus Navigate(wxNavDir navDir, int fromId, int* toId,
   wxAccessible** toObject)

   Navigates from fromId to toId/toObject.

=head2 Wx::Accessible::NotifyEvent

   virtual static void NotifyEvent(int eventType, wxWindow* window,
   wxAccObject objectType, int objectType)

   Allows the application to send an event when something changes in an
   accessible object.

=head2 Wx::Accessible::Select

   virtual wxAccStatus Select(int childId, wxAccSelectionFlags
   selectFlags)

   Selects the object or child. See wxAccessible for a list of the
   selection actions.

=head2 Wx::Accessible::SetWindow

   void SetWindow(wxWindow* window)

   Sets the window associated with this object.

=head1 Wx::ActivateEvent

=head2 Wx::ActivateEvent::new

   wxActivateEvent(WXTYPE eventType = 0, bool active = true, int id = 0)

   Constructor.

=head2 Wx::ActivateEvent::GetActive

   bool GetActive() const

   Returns true if the application or window is being activated, false
   otherwise.

=head1 Wx::ActiveXContainer

=head2 Wx::ActiveXContainer::new

   wxActiveXContainer( wxWindow* parent, REFIID iid, IUnknown* pUnk, )

   Creates this activex container.

   parent

       parent of this control. Must not be NULL.

=head1 Wx::ActiveXEvent

=head2 Wx::ActiveXEvent::ParamCount

   size_t ParamCount() const

   Obtains the number of parameters passed through the activex event.

=head2 Wx::ActiveXEvent::ParamType

   wxString ParamType(size_t idx) const

   Obtains the param type of the param number idx specifies as a string.

=head2 Wx::ActiveXEvent::ParamName

   wxString ParamName(size_t idx) const

   Obtains the param name of the param number idx specifies as a string.

=head2 Wx::ActiveXEvent::GetDispatchId

   DISPID GetDispatchId(int idx) const

   Returns the dispatch id of this activex event. This is the numeric
   value from the .idl file specified by the id().

=head1 Wx::Animation

=head2 Wx::Animation::new

   wxAnimation()

   Default constructor.

   wxAnimation(const wxAnimation& anim)

   Copy constructor, uses reference counting.

   wxAnimation(const wxString& name, wxAnimationType type =
   wxANIMATION_TYPE_ANY)

   Loads an animation from a file.

   name

       The name of the file to load.

   type

       See LoadFile for more info.

=head2 Wx::Animation::DESTROY

   ~wxAnimation()

   Destructor. See reference-counted object destruction for more info.

=head2 Wx::Animation::GetDelay

   int GetDelay(unsigned int i) const

   Returns the delay for the i-th frame in milliseconds. If -1 is
   returned the frame is to be displayed forever.

=head2 Wx::Animation::GetFrameCount

   unsigned int GetFrameCount() const

   Returns the number of frames for this animation.

=head2 Wx::Animation::GetFrame

   wxImage GetFrame(unsigned int i) const

   Returns the i-th frame as a wxImage.

=head2 Wx::Animation::GetSize

   wxSize GetSize() const

   Returns the size of the animation.

=head2 Wx::Animation::IsOk

   bool IsOk() const

   Returns true if animation data is present.

=head2 Wx::Animation::Load

   bool Load(wxInputStream& stream, wxAnimationType type =
   wxANIMATION_TYPE_ANY)

   Loads an animation from the given stream.

   Parameters

   stream

       The stream to use to load the animation.

   type

       One of the following values:

=head2 Wx::Animation::LoadFile

   bool LoadFile(const wxString& name, wxAnimationType type =
   wxANIMATION_TYPE_ANY)

   Loads an animation from a file.

   Parameters

   name

       A filename.

   type

       One of the following values:

=head1 Wx::AnimationCtrl

=head2 Wx::AnimationCtrl::new

   wxAnimationCtrl(wxWindow *parent, wxWindowID id, const wxAnimation&
   anim, const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = wxAC_DEFAULT_STYLE, const wxString& name =
   "animationctrl")

   Initializes the object and calls Create with all the parameters.

=head2 Wx::AnimationCtrl::Create

   bool Create(wxWindow *parent, wxWindowID id, const wxAnimation& anim,
   const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = wxAC_DEFAULT_STYLE, const wxString& name =
   "animationctrl")

   Parameters

   parent

       Parent window, must be non-NULL.

   id  

       The identifier for the control.

   anim

       The initial animation shown in the control.

   pos 

       Initial position.

   size

       Initial size.

   style

       The window style, see wxAC_* flags.

   name

       Control name.

   After control creation you must explicitely call Play to start to play
   the animation. Until that function won't be called, the first frame of
   the animation is displayed.

   Return value

   true if the control was successfully created or false if creation
   failed.

=head2 Wx::AnimationCtrl::GetAnimation

   wxAnimation GetAnimation() const

   Returns the animation associated with this control.

=head2 Wx::AnimationCtrl::GetInactiveBitmap

   wxBitmap GetInactiveBitmap() const

   Returns the inactive bitmap shown in this control when the; see
   SetInactiveBitmap for more info.

=head2 Wx::AnimationCtrl::IsPlaying

   bool IsPlaying() const

   Returns true if the animation is being played.

=head2 Wx::AnimationCtrl::LoadFile

   bool LoadFile(const wxString & file, wxAnimationType animType =
   wxANIMATION_TYPE_ANY)

   Loads the animation from the given file and calls SetAnimation. See
   wxAnimation::LoadFile for more info.

=head2 Wx::AnimationCtrl::Play

   bool Play()

   Starts playing the animation. The animation is always played in loop
   mode (unless the last frame of the animation has an infinite delay
   time) and always start from the first frame (even if you stopped it
   while some other frame was displayed).

=head2 Wx::AnimationCtrl::SetAnimation

   void SetAnimation(const wxAnimation & anim)

   Sets the animation to play in this control. If the previous animation
   is being played, it's Stopped.

   Until Play isn't called, a static image, the first frame of the given
   animation or the background colour will be shown (see
   SetInactiveBitmap for more info).

=head2 Wx::AnimationCtrl::SetInactiveBitmap

   void SetInactiveBitmap(const wxBitmap& bmp)

   Sets the bitmap to show on the control when it's not playing an
   animation. If you set as inactive bitmap wxNullBitmap (which is the
   default), then the first frame of the animation is instead shown when
   the control is inactive; in this case, if there's no valid animation
   associated with the control (see SetAnimation), then the background
   colour of the window is shown.

   If the control is not playing the animation, the given bitmap will be
   immediately shown, otherwise it will be shown as soon as Stop is
   called.

   Note that the inactive bitmap, if smaller than the control's size,
   will be centered in the control; if bigger, it will be stretched to
   fit it.

=head2 Wx::AnimationCtrl::Stop

   void Stop()

   Stops playing the animation. The control will show the first frame of
   the animation, a custom static image or the window's background colour
   as specified by the last SetInactiveBitmap call.

=head1 Wx::App

=head2 Wx::App::new

   wxApp()

   Constructor. Called implicitly with a definition of a wxApp object.

=head2 Wx::App::DESTROY

   virtual ~wxApp()

   Destructor. Will be called implicitly on program exit if the wxApp
   object is created on the stack.

=head2 Wx::App::argc

   int argc

   Number of command line arguments (after environment-specific
   processing).

=head2 Wx::App::argv

   wxChar ** argv

   Command line arguments (after environment-specific processing).

=head2 Wx::App::CreateLogTarget

   virtual wxLog* CreateLogTarget()

   Creates a wxLog class for the application to use for logging errors.
   The default implementation returns a new wxLogGui class.

   See also

   wxLog

=head2 Wx::App::CreateTraits

   virtual wxAppTraits * CreateTraits()

   Creates the wxAppTraits object when GetTraits needs it for the first
   time.

   See also

   wxAppTraits

=head2 Wx::App::Dispatch

   virtual void Dispatch()

   Dispatches the next event in the windowing system event queue.

   This can be used for programming event loops, e.g.

     while (app.Pending())
       Dispatch();

   See also

   wxApp::Pending

=head2 Wx::App::ExitMainLoop

   virtual void ExitMainLoop()

   Call this to explicitly exit the main message (event) loop. You should
   normally exit the main loop (and the application) by deleting the top
   window.

=head2 Wx::App::FilterEvent

   int FilterEvent(wxEvent& event)

   This function is called before processing any event and allows the
   application to preempt the processing of some events. If this method
   returns -1 the event is processed normally, otherwise either true or
   false should be returned and the event processing stops immediately
   considering that the event had been already processed (for the former
   return value) or that it is not going to be processed at all (for the
   latter one).

=head2 Wx::App::GetAppName

   wxString GetAppName() const

   Returns the application name.

   Remarks

   wxWidgets sets this to a reasonable default before calling
   wxApp::OnInit, but the application can reset it at will.

=head2 Wx::App::GetClassName

   wxString GetClassName() const

   Gets the class name of the application. The class name may be used in
   a platform specific manner to refer to the application.

   See also

   wxApp::SetClassName

=head2 Wx::App::GetExitOnFrameDelete

   bool GetExitOnFrameDelete() const

   Returns true if the application will exit when the top-level window is
   deleted, false otherwise.

   See also

   wxApp::SetExitOnFrameDelete,

=head2 Wx::App::GetInstance

   static wxAppConsole * GetInstance()

   Returns the one and only global application object. Usually wxTheApp
   is usead instead.

   See also

   wxApp::SetInstance

=head2 Wx::App::GetTopWindow

   virtual wxWindow * GetTopWindow() const

   Returns a pointer to the top window.

   Remarks

   If the top window hasn't been set using wxApp::SetTopWindow, this
   function will find the first top-level window (frame or dialog) and
   return that.

   See also

   SetTopWindow

=head2 Wx::App::GetTraits

   wxAppTraits * GetTraits()

   Returns a pointer to the wxAppTraits object for the application. If
   you want to customize the wxAppTraits object, you must override the
   CreateTraits function.

=head2 Wx::App::GetUseBestVisual

   bool GetUseBestVisual() const

   Returns true if the application will use the best visual on systems
   that support different visuals, false otherwise.

   See also

   SetUseBestVisual

=head2 Wx::App::GetVendorName

   wxString GetVendorName() const

   Returns the application's vendor name.

=head2 Wx::App::IsActive

   bool IsActive() const

   Returns true if the application is active, i.e. if one of its windows
   is currently in the foreground. If this function returns false and you
   need to attract users attention to the application, you may use
   wxTopLevelWindow::RequestUserAttention to do it.

=head2 Wx::App::IsMainLoopRunning

   static bool IsMainLoopRunning()

   Returns true if the main event loop is currently running, i.e. if the
   application is inside OnRun.

   This can be useful to test whether the events can be dispatched. For
   example, if this function returns false, non-blocking sockets cannot
   be used because the events from them would never be processed.

=head2 Wx::App::MainLoop

   virtual int MainLoop()

   Called by wxWidgets on creation of the application. Override this if
   you wish to provide your own (environment-dependent) main loop.

   Return value

   Returns 0 under X, and the wParam of the WM_QUIT message under
   Windows.

=head2 Wx::App::OnAssertFailure

   void OnAssertFailure(const wxChar *file, int line, const wxChar *func,
   const wxChar *cond, const wxChar *msg)

   This function is called when an assert failure occurs, i.e. the
   condition specified in wxASSERT macro evaluated to false. It is only
   called in debug mode (when __WXDEBUG__ is defined) as asserts are not
   left in the release code at all.

   The base class version shows the default assert failure dialog box
   proposing to the user to stop the program, continue or ignore all
   subsequent asserts.

   Parameters

   file

       the name of the source file where the assert occurred

   line

       the line number in this file where the assert occurred

   func

       the name of the function where the assert occurred, may be empty
       if the compiler doesn't support C99 __FUNCTION__

   cond

       the condition of the failed assert in text form

   msg 

       the message specified as argument to wxASSERT_MSG or wxFAIL_MSG,
       will be NULL if just wxASSERT or wxFAIL was used

=head2 Wx::App::OnCmdLineError

   bool OnCmdLineError(wxCmdLineParser& parser)

   Called when command line parsing fails (i.e. an incorrect command line
   option was specified by the user). The default behaviour is to show
   the program usage text and abort the program.

   Return true to continue normal execution or false to return false from
   OnInit thus terminating the program.

   See also

   OnInitCmdLine

=head2 Wx::App::OnCmdLineHelp

   bool OnCmdLineHelp(wxCmdLineParser& parser)

   Called when the help option (--help) was specified on the command
   line. The default behaviour is to show the program usage text and
   abort the program.

   Return true to continue normal execution or false to return false from
   OnInit thus terminating the program.

   See also

   OnInitCmdLine

=head2 Wx::App::OnCmdLineParsed

   bool OnCmdLineParsed(wxCmdLineParser& parser)

   Called after the command line had been successfully parsed. You may
   override this method to test for the values of the various parameters
   which could be set from the command line.

   Don't forget to call the base class version unless you want to
   suppress processing of the standard command line options.

   Return true to continue normal execution or false to return false from
   OnInit thus terminating the program.

   See also

   OnInitCmdLine

=head2 Wx::App::OnExceptionInMainLoop

   virtual bool OnExceptionInMainLoop()

   This function is called if an unhandled exception occurs inside the
   main application event loop. It can return true to ignore the
   exception and to continue running the loop or false to exit the loop
   and terminate the program. In the latter case it can also use C++
   throw keyword to rethrow the current exception.

   The default behaviour of this function is the latter in all ports
   except under Windows where a dialog is shown to the user which allows
   him to choose between the different options. You may override this
   function in your class to do something more appropriate.

   Finally note that if the exception is rethrown from here, it can be
   caught in OnUnhandledException.

=head2 Wx::App::OnExit

   virtual int OnExit()

   Override this member function for any processing which needs to be
   done as the application is about to exit. OnExit is called after
   destroying all application windows and controls, but before wxWidgets
   cleanup. Note that it is not called at all if OnInit failed.

   The return value of this function is currently ignored, return the
   same value as returned by the base class method if you override it.

=head2 Wx::App::OnFatalException

   void OnFatalException()

   This function may be called if something fatal happens: an unhandled
   exception under Win32 or a a fatal signal under Unix, for example.
   However, this will not happen by default: you have to explicitly call
   wxHandleFatalExceptions to enable this.

   Generally speaking, this function should only show a message to the
   user and return. You may attempt to save unsaved data but this is not
   guaranteed to work and, in fact, probably won't.

   See also

   wxHandleFatalExceptions

=head2 Wx::App::OnInit

   bool OnInit()

   This must be provided by the application, and will usually create the
   application's main window, optionally calling wxApp::SetTopWindow. You
   may use OnExit to clean up anything initialized here, provided that
   the function returns true.

   Notice that if you want to to use the command line processing provided
   by wxWidgets you have to call the base class version in the derived
   class OnInit().

   Return true to continue processing, false to exit the application
   immediately.

=head2 Wx::App::OnInitCmdLine

   void OnInitCmdLine(wxCmdLineParser& parser)

   Called from OnInit and may be used to initialize the parser with the
   command line options for this application. The base class versions
   adds support for a few standard options only.

=head2 Wx::App::OnRun

   virtual int OnRun()

   This virtual function is where the execution of a program written in
   wxWidgets starts. The default implementation just enters the main loop
   and starts handling the events until it terminates, either because
   ExitMainLoop has been explicitly called or because the last frame has
   been deleted and GetExitOnFrameDelete flag is true (this is the
   default).

   The return value of this function becomes the exit code of the
   program, so it should return 0 in case of successful termination.

=head2 Wx::App::OnUnhandledException

   virtual void OnUnhandledException()

   This function is called when an unhandled C++ exception occurs inside
   OnRun() (the exceptions which occur during the program startup and
   shutdown might not be caught at all). Note that the exception type is
   lost by now, so if you want to really handle the exception you should
   override OnRun() and put a try/catch clause around the call to the
   base class version there.

=head2 Wx::App::ProcessMessage

   bool ProcessMessage(WXMSG *msg)

   Windows-only function for processing a message. This function is
   called from the main message loop, checking for windows that may wish
   to process it. The function returns true if the message was processed,
   false otherwise. If you use wxWidgets with another class library with
   its own message loop, you should make sure that this function is
   called to allow wxWidgets to receive messages. For example, to allow
   co-existence with the Microsoft Foundation Classes, override the
   PreTranslateMessage function:

   // Provide wxWidgets message loop compatibility
   BOOL CTheApp::PreTranslateMessage(MSG *msg)
   {
     if (wxTheApp && wxTheApp->ProcessMessage((WXMSW *)msg))
       return true;
     else
       return CWinApp::PreTranslateMessage(msg);
   }

=head2 Wx::App::Pending

   virtual bool Pending()

   Returns true if unprocessed events are in the window system event
   queue.

   See also

   wxApp::Dispatch

=head2 Wx::App::SendIdleEvents

   bool SendIdleEvents(wxWindow* win, wxIdleEvent& event)

   Sends idle events to a window and its children.

   Please note that this function is internal to wxWidgets and shouldn't
   be used by user code.

   Remarks

   These functions poll the top-level windows, and their children, for
   idle event processing. If true is returned, more OnIdle processing is
   requested by one or more window.

   See also

   wxIdleEvent

=head2 Wx::App::SetAppName

   void SetAppName(const wxString& name)

   Sets the name of the application. The name may be used in dialogs (for
   example by the document/view framework). A default name is set by
   wxWidgets.

   See also

   wxApp::GetAppName

=head2 Wx::App::SetClassName

   void SetClassName(const wxString& name)

   Sets the class name of the application. This may be used in a platform
   specific manner to refer to the application.

   See also

   wxApp::GetClassName

=head2 Wx::App::SetExitOnFrameDelete

   void SetExitOnFrameDelete(bool flag)

   Allows the programmer to specify whether the application will exit
   when the top-level frame is deleted.

   Parameters

   flag

       If true (the default), the application will exit when the
       top-level frame is deleted. If false, the application will
       continue to run.

   See also

   wxApp::GetExitOnFrameDelete,

=head2 Wx::App::SetInstance

   static void SetInstance(wxAppConsole* app)

   Allows external code to modify global wxTheApp, but you should really
   know what you're doing if you call it.

   Parameters

   app 

       Replacement for the global application object.

   See also

   wxApp::GetInstance

=head2 Wx::App::SetTopWindow

   void SetTopWindow(wxWindow* window)

   Sets the 'top' window. You can call this from within wxApp::OnInit to
   let wxWidgets know which is the main window. You don't have to set the
   top window; it is only a convenience so that (for example) certain
   dialogs without parents can use a specific window as the top window.
   If no top window is specified by the application, wxWidgets just uses
   the first frame or dialog in its top-level window list, when it needs
   to use the top window.

   Parameters

   window

       The new top window.

   See also

   wxApp::GetTopWindow, wxApp::OnInit

=head2 Wx::App::SetVendorName

   void SetVendorName(const wxString& name)

   Sets the name of application's vendor. The name will be used in
   registry access. A default name is set by wxWidgets.

   See also

   wxApp::GetVendorName

=head2 Wx::App::SetUseBestVisual

   void SetUseBestVisual(bool flag, bool forceTrueColour = false)

   Allows the programmer to specify whether the application will use the
   best visual on systems that support several visual on the same
   display. This is typically the case under Solaris and IRIX, where the
   default visual is only 8-bit whereas certain applications are supposed
   to run in TrueColour mode.

   If forceTrueColour is true then the application will try to force
   using a TrueColour visual and abort the app if none is found.

   Note that this function has to be called in the constructor of the
   wxApp instance and won't have any effect when called later on.

   This function currently only has effect under GTK.

   Parameters

   flag

       If true, the app will use the best visual.

=head2 Wx::App::HandleEvent

   virtual void HandleEvent(wxEvtHandler *handler, wxEventFunction func,
   wxEvent& event) const

   This function simply invokes the given method func of the specified
   event handler handler with the event as parameter. It exists solely to
   allow to catch the C++ exceptions which could be thrown by all event
   handlers in the application in one place: if you want to do this,
   override this function in your wxApp-derived class and add try/catch
   clause(s) to it.

=head2 Wx::App::Yield

   bool Yield(bool onlyIfNeeded = false)

   Yields control to pending messages in the windowing system. This can
   be useful, for example, when a time-consuming process writes to a text
   window. Without an occasional yield, the text window will not be
   updated properly, and on systems with cooperative multitasking, such
   as Windows 3.1 other processes will not respond.

   Caution should be exercised, however, since yielding may allow the
   user to perform actions which are not compatible with the current
   task. Disabling menu items or whole menus during processing can avoid
   unwanted reentrance of code: see ::wxSafeYield for a better function.

   Note that Yield() will not flush the message logs. This is intentional
   as calling Yield() is usually done to quickly update the screen and
   popping up a message box dialog may be undesirable. If you do wish to
   flush the log messages immediately (otherwise it will be done during
   the next idle loop iteration), call wxLog::FlushActive.

   Calling Yield() recursively is normally an error and an assert failure
   is raised in debug build if such situation is detected. However if the
   onlyIfNeeded parameter is true, the method will just silently return
   false instead.

=head1 Wx::AppTraits

=head2 Wx::AppTraits::CreateFontMapper

   virtual wxFontMapper * CreateFontMapper()

   Creates the global font mapper object used for encodings/charset
   mapping.

=head2 Wx::AppTraits::CreateLogTarget

   virtual wxLog * CreateLogTarget()

   Creates the default log target for the application.

=head2 Wx::AppTraits::CreateMessageOutput

   virtual wxMessageOutput * CreateMessageOutput()

   Creates the global object used for printing out messages.

=head2 Wx::AppTraits::CreateRenderer

   virtual wxRendererNative * CreateRenderer()

   Returns the renderer to use for drawing the generic controls (return
   value may be NULL in which case the default renderer for the current
   platform is used); this is used in GUI mode only and always returns
   NULL in console.

   NOTE: returned pointer will be deleted by the caller.

=head2 Wx::AppTraits::GetDesktopEnvironment

   virtual wxString GetDesktopEnvironment() const

   This method returns the name of the desktop environment currently
   running in a Unix desktop. Currently only "KDE" or "GNOME" are
   supported and the code uses the X11 session protocol vendor name to
   figure out, which desktop environment is running. The method returns
   an empty string otherwise and on all other platforms.

=head2 Wx::AppTraits::GetStandardPaths

   virtual wxStandardPaths & GetStandardPaths()

   Returns the wxStandardPaths object for the application. It's normally
   the same for wxBase and wxGUI except in the case of wxMac and wxCocoa.

=head2 Wx::AppTraits::GetToolkitVersion

   virtual wxPortId GetToolkitVersion(int *major = NULL, int *minor =
   NULL)

   Returns the wxWidgets port ID used by the running program and
   eventually fills the given pointers with the values of the major and
   minor digits of the native toolkit currently used. The version numbers
   returned are thus detected at run-time and not compile-time (except
   when this is not possible e.g. wxMotif).

   E.g. if your program is using wxGTK port this function will return
   wxPORT_GTK and put in given pointers the versions of the GTK library
   in use.

   See wxPlatformInfo for more details.

=head2 Wx::AppTraits::HasStderr

   virtual bool HasStderr()

   Returns true if fprintf(stderr) goes somewhere, false otherwise.

=head2 Wx::AppTraits::IsUsingUniversalWidgets

   bool IsUsingUniversalWidgets() const

   Returns true if the library was built as wxUniversal. Always returns
   false for wxBase-only apps.

=head2 Wx::AppTraits::ShowAssertDialog

   virtual bool ShowAssertDialog(const wxString & msg)

   Shows the assert dialog with the specified message in GUI mode or just
   prints the string to stderr in console mode.

   Returns true to suppress subsequent asserts, false to continue as
   before.

=head1 Wx::ArchiveClassFactory

=head2 Wx::ArchiveClassFactory::Get/SetConv

   wxMBConv& GetConv() const

   void SetConv(wxMBConv& conv)

   The wxMBConv object that the created streams will use when translating
   meta-data. The initial default, set by the constructor, is
   wxConvLocal.

=head2 Wx::ArchiveClassFactory::CanHandle

   bool CanHandle(const wxChar* protocol, wxStreamProtocolType type =
   wxSTREAM_PROTOCOL) const

   Returns true if this factory can handle the given protocol, MIME type
   or file extension.

   When using wxSTREAM_FILEEXT for the second parameter, the first
   parameter can be a complete filename rather than just an extension.

=head2 Wx::ArchiveClassFactory::Find

   static const wxArchiveClassFactory* Find(const wxChar* protocol,
   wxStreamProtocolType type = wxSTREAM_PROTOCOL)

   A static member that finds a factory that can handle a given protocol,
   MIME type or file extension. Returns a pointer to the class factory if
   found, or NULL otherwise. It does not give away ownership of the
   factory.

   When using wxSTREAM_FILEEXT for the second parameter, the first
   parameter can be a complete filename rather than just an extension.

=head2 Wx::ArchiveClassFactory::GetFirst/GetNext

   static const wxArchiveClassFactory* GetFirst()

   const wxArchiveClassFactory* GetNext() const

   GetFirst and GetNext can be used to enumerate the available factories.

   For example, to list them:

       wxString list;
       const wxArchiveClassFactory *factory = wxArchiveClassFactory::GetFirst();

=head2 Wx::ArchiveClassFactory::GetInternalName

   wxString GetInternalName(const wxString& name, wxPathFormat format =
   wxPATH_NATIVE) const

   Calls the static GetInternalName() function for the archive entry
   type, for example wxZipEntry::GetInternalName().

=head2 Wx::ArchiveClassFactory::GetProtocol

   wxString GetProtocol() const

   Returns the wxFileSystem protocol supported by this factory.
   Equivalent to wxString(*GetProtcols()).

=head2 Wx::ArchiveClassFactory::GetProtocols

   const wxChar * const* GetProtocols(wxStreamProtocolType type =
   wxSTREAM_PROTOCOL) const

   Returns the protocols, MIME types or file extensions supported by this
   factory, as an array of null terminated strings. It does not give away
   ownership of the array or strings.

   For example, to list the file extensions a factory supports:

       wxString list;
       const wxChar *const *p;

=head2 Wx::ArchiveClassFactory::NewEntry

   wxArchiveEntry* NewEntry() const

   Create a new wxArchiveEntry object of the appropriate type.

=head2 Wx::ArchiveClassFactory::NewStream

   wxArchiveInputStream* NewStream(wxInputStream& stream) const

   wxArchiveOutputStream* NewStream(wxOutputStream& stream) const

   wxArchiveInputStream* NewStream(wxInputStream* stream) const

   wxArchiveOutputStream* NewStream(wxOutputStream* stream) const

   Create a new input or output stream to read or write an archive.

   If the parent stream is passed as a pointer then the new archive
   stream takes ownership of it. If it is passed by reference then it
   does not.

=head2 Wx::ArchiveClassFactory::PushFront

   void PushFront()

   Adds this class factory to the list returned by GetFirst()/GetNext().

   It is not necessary to do this to use the archive streams. It is
   usually used when implementing streams, typically the implementation
   will add a static instance of its factory class.

   It can also be used to change the order of a factory already in the
   list, bringing it to the front. This isn't a thread safe operation so
   can't be done when other threads are running that will be using the
   list.

   The list does not take ownership of the factory.

=head2 Wx::ArchiveClassFactory::Remove

   void Remove()

   Removes this class factory from the list returned by
   GetFirst()/GetNext().

   Removing from the list isn't a thread safe operation so can't be done
   when other threads are running that will be using the list.

   The list does not own the factories, so removing a factory does not
   delete it.

=head1 Wx::ArchiveEntry

=head2 Wx::ArchiveEntry::Clone

   wxArchiveEntry* Clone() const

   Returns a copy of this entry object.

=head2 Wx::ArchiveEntry::Get/SetDateTime

   wxDateTime GetDateTime() const

   void SetDateTime(const wxDateTime& dt)

   The entry's timestamp.

=head2 Wx::ArchiveEntry::GetInternalFormat

   wxPathFormat GetInternalFormat() const

   Returns the path format used internally within the archive to store
   filenames.

=head2 Wx::ArchiveEntry::GetInternalName

   wxString GetInternalName() const

   Returns the entry's filename in the internal format used within the
   archive. The name can include directory components, i.e. it can be a
   full path.

   The names of directory entries are returned without any trailing path
   separator. This gives a canonical name that can be used in
   comparisons.

   See also

   Looking up an archive entry by name

=head2 Wx::ArchiveEntry::Get/SetName

   wxString GetName(wxPathFormat format = wxPATH_NATIVE) const

   void SetName(const wxString& name, wxPathFormat format = wxPATH_NATIVE)

   The entry's name, by default in the native format. The name can
   include directory components, i.e. it can be a full path.

   If this is a directory entry, (i.e. if IsDir() is true) then GetName()
   returns the name with a trailing path separator.

   Similarly, setting a name with a trailing path separator sets IsDir().

=head2 Wx::ArchiveEntry::GetOffset

   off_t GetOffset() const

   Returns a numeric value unique to the entry within the archive.

=head2 Wx::ArchiveEntry::Get/SetSize

   off_t GetSize() const

   void SetSize(off_t size)

   The size of the entry's data in bytes.

=head2 Wx::ArchiveEntry::IsDir/SetIsDir

   bool IsDir() const

   void SetIsDir(bool isDir = true)

   True if this is a directory entry.

   Directory entries are entries with no data, which are used to store
   the meta-data of directories. They also make it possible for
   completely empty directories to be stored.

   The names of entries within an archive can be complete paths, and
   unarchivers typically create whatever directories are necessary as
   they restore files, even if the archive contains no explicit directory
   entries.

=head2 Wx::ArchiveEntry::IsReadOnly/SetIsReadOnly

   bool IsReadOnly() const

   void SetIsReadOnly(bool isReadOnly = true)

   True if the entry is a read-only file.

=head2 Wx::ArchiveEntry::Set/UnsetNotifier

   void SetNotifier(wxArchiveNotifier& notifier)

   void UnsetNotifier()

   Sets the notifier for this entry. Whenever the wxArchiveInputStream
   updates this entry, it will then invoke the associated notifier's
   OnEntryUpdated method.

   Setting a notifier is not usually necessary. It is used to handle
   certain cases when modifying an archive in a pipeline (i.e. between
   non-seekable streams).

   See also

   Archives on non-seekable streams

=head1 Wx::ArchiveInputStream

=head2 Wx::ArchiveInputStream::CloseEntry

   bool CloseEntry()

   Closes the current entry. On a non-seekable stream reads to the end of
   the current entry first.

=head2 Wx::ArchiveInputStream::GetNextEntry

   wxArchiveEntry* GetNextEntry()

   Closes the current entry if one is open, then reads the meta-data for
   the next entry and returns it in a wxArchiveEntry object, giving away
   ownership. Reading this wxArchiveInputStream then returns the entry's
   data.

=head2 Wx::ArchiveInputStream::OpenEntry

   bool OpenEntry(wxArchiveEntry& entry)

   Closes the current entry if one is open, then opens the entry
   specified by the wxArchiveEntry object.

   entry must be from the same archive file that this
   wxArchiveInputStream is reading, and it must be reading it from a
   seekable stream.

   See also

   Looking up an archive entry by name

=head1 Wx::ArchiveIterator

=head2 Wx::ArchiveIterator::new

   wxArchiveIterator()

   Construct an 'end of sequence' instance.

   wxArchiveIterator(Arc& arc)

   Construct iterator that returns all the entries in the archive input
   stream arc.

=head1 Wx::ArchiveNotifier

=head2 Wx::ArchiveNotifier::OnEntryUpdated

   void OnEntryUpdated(class wxArchiveEntry& entry)

   This method must be overridden in your derived class.

=head1 Wx::ArchiveOutputStream

=head2 Wx::ArchiveOutputStream::DESTROY

   ~wxArchiveOutputStream()

   Calls Close() if it has not already been called.

=head2 Wx::ArchiveOutputStream::Close

   bool Close()

   Closes the archive, returning true if it was successfully written.
   Called by the destructor if not called explicitly.

=head2 Wx::ArchiveOutputStream::CloseEntry

   bool CloseEntry()

   Close the current entry. It is called implicitly whenever another new
   entry is created with CopyEntry() or PutNextEntry(), or when the
   archive is closed.

=head2 Wx::ArchiveOutputStream::CopyArchiveMetaData

   bool CopyArchiveMetaData(wxArchiveInputStream& stream)

   Some archive formats have additional meta-data that applies to the
   archive as a whole. For example in the case of zip there is a comment,
   which is stored at the end of the zip file. CopyArchiveMetaData() can
   be used to transfer such information when writing a modified copy of
   an archive.

   Since the position of the meta-data can vary between the various
   archive formats, it is best to call CopyArchiveMetaData() before
   transferring the entries. The wxArchiveOutputStream will then hold on
   to the meta-data and write it at the correct point in the output file.

   When the input archive is being read from a non-seekable stream, the
   meta-data may not be available when CopyArchiveMetaData() is called,
   in which case the two streams set up a link and transfer the data when
   it becomes available.

=head2 Wx::ArchiveOutputStream::CopyEntry

   bool CopyEntry(wxArchiveEntry* entry, wxArchiveInputStream& stream)

   Takes ownership of entry and uses it to create a new entry in the
   archive. entry is then opened in the input stream stream and its
   contents copied to this stream.

   For archive types which compress entry data, CopyEntry() is likely to
   be much more efficient than transferring the data using Read() and
   Write() since it will copy them without decompressing and
   recompressing them.

   entry must be from the same archive file that stream is accessing. For
   non-seekable streams, entry must also be the last thing read from
   stream.

=head2 Wx::ArchiveOutputStream::PutNextDirEntry

   bool PutNextDirEntry(const wxString& name, const wxDateTime& dt =
   wxDateTime::Now())

   Create a new directory entry (see wxArchiveEntry::IsDir()) with the
   given name and timestamp.

   PutNextEntry() can also be used to create directory entries, by
   supplying a name with a trailing path separator.

=head2 Wx::ArchiveOutputStream::PutNextEntry

   bool PutNextEntry(wxArchiveEntry* entry)

   Takes ownership of entry and uses it to create a new entry in the
   archive. The entry's data can then be written by writing to this
   wxArchiveOutputStream.

   bool PutNextEntry(const wxString& name, const wxDateTime& dt =
   wxDateTime::Now(), off_t size = wxInvalidOffset)

   Create a new entry with the given name, timestamp and size. The
   entry's data can then be written by writing to this
   wxArchiveOutputStream.

=head1 Wx::Array

=head2 Macros for template array definition

   To use an array you must first define the array class. This is done
   with the help of the macros in this section. The class of array
   elements must be (at least) forward declared for WX_DEFINE_ARRAY,
   WX_DEFINE_SORTED_ARRAY and WX_DECLARE_OBJARRAY macros and must be
   fully declared before you use WX_DEFINE_OBJARRAY macro.

   WX_DEFINE_ARRAY

=head2 Constructors and destructors

   Array classes are 100% C++ objects and as such they have the
   appropriate copy constructors and assignment operators. Copying
   wxArray just copies the elements but copying wxObjArray copies the
   arrays items. However, for memory-efficiency sake, neither of these
   classes has virtual destructor. It is not very important for wxArray
   which has trivial destructor anyhow, but it does mean that you should
   avoid deleting wxObjArray through a wxBaseArray pointer (as you would
   never use wxBaseArray anyhow it shouldn't be a problem) and that you
   should not derive your own classes from the array classes.

   wxArray default constructor

=head2 Memory management

   Automatic array memory management is quite trivial: the array starts
   by preallocating some minimal amount of memory (defined by
   WX_ARRAY_DEFAULT_INITIAL_SIZE) and when further new items exhaust
   already allocated memory it reallocates it adding 50% of the currently
   allocated amount, but no more than some maximal number which is
   defined by ARRAY_MAXSIZE_INCREMENT constant. Of course, this may lead
   to some memory being wasted (ARRAY_MAXSIZE_INCREMENT in the worst
   case, i.e. 4Kb in the current implementation), so the Shrink()
   function is provided to deallocate the extra memory. The Alloc()
   function can also be quite useful if you know in advance how many
   items you are going to put in the array and will prevent the array
   code from reallocating the memory more times than needed.

   Alloc

=head2 Number of elements and simple item access

   Functions in this section return the total number of array elements
   and allow to retrieve them - possibly using just the C array indexing
   [] operator which does exactly the same as Item() method.

   Count

=head2 Adding items

   Add

=head2 Removing items

   WX_CLEAR_ARRAY

=head2 Searching and sorting

   Index

=head2 WX_DEFINE_ARRAY

   WX_DEFINE_ARRAY(T, name)

   WX_DEFINE_EXPORTED_ARRAY(T, name)

   WX_DEFINE_USER_EXPORTED_ARRAY(T, name, exportspec)

   This macro defines a new array class named name and containing the
   elements of type T. The second form is used when compiling wxWidgets
   as a DLL under Windows and array needs to be visible outside the DLL.
   The third is needed for exporting an array from a user DLL.

   Example:

   WX_DEFINE_ARRAY_INT(int, MyArrayInt);

=head2 WX_DEFINE_SORTED_ARRAY

   WX_DEFINE_SORTED_ARRAY(T, name)

   WX_DEFINE_SORTED_EXPORTED_ARRAY(T, name)

   WX_DEFINE_SORTED_USER_EXPORTED_ARRAY(T, name)

   This macro defines a new sorted array class named name and containing
   the elements of type T. The second form is used when compiling
   wxWidgets as a DLL under Windows and array needs to be visible outside
   the DLL. The third is needed for exporting an array from a user DLL.

   Example:

   WX_DEFINE_SORTED_ARRAY_INT(int, MySortedArrayInt);

=head2 WX_DECLARE_OBJARRAY

   WX_DECLARE_OBJARRAY(T, name)

   WX_DECLARE_EXPORTED_OBJARRAY(T, name)

   WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name)

   This macro declares a new object array class named name and containing
   the elements of type T. The second form is used when compiling
   wxWidgets as a DLL under Windows and array needs to be visible outside
   the DLL. The third is needed for exporting an array from a user DLL.

   Example:

   class MyClass;
   WX_DECLARE_OBJARRAY(MyClass, wxArrayOfMyClass); // note: not "MyClass *"!

   You must use WX_DEFINE_OBJARRAY() macro to define the array class -
   otherwise you would get link errors.

=head2 WX_DEFINE_OBJARRAY

   WX_DEFINE_OBJARRAY(name)

   WX_DEFINE_EXPORTED_OBJARRAY(name)

   WX_DEFINE_USER_EXPORTED_OBJARRAY(name)

   This macro defines the methods of the array class name not defined by
   the WX_DECLARE_OBJARRAY() macro. You must include the file
   <wx/arrimpl.cpp> before using this macro and you must have the full
   declaration of the class of array elements in scope! If you forget to
   do the first, the error will be caught by the compiler, but,
   unfortunately, many compilers will not give any warnings if you forget
   to do the second - but the objects of the class will not be copied
   correctly and their real destructor will not be called. The latter two
   forms are merely aliases of the first to satisfy some people's sense
   of symmetry when using the exported declarations.

   Example of usage:

   // first declare the class!
   class MyClass
   {
   public:
      MyClass(const MyClass&);

=head2 WX_APPEND_ARRAY

   void WX_APPEND_ARRAY(wxArray& array, wxArray& other)

   This macro may be used to append all elements of the other array to
   the array. The two arrays must be of the same type.

=head2 WX_PREPEND_ARRAY

   void WX_PREPEND_ARRAY(wxArray& array, wxArray& other)

   This macro may be used to prepend all elements of the other array to
   the array. The two arrays must be of the same type.

=head2 WX_CLEAR_ARRAY

   void WX_CLEAR_ARRAY(wxArray& array)

   This macro may be used to delete all elements of the array before
   emptying it. It can not be used with wxObjArrays - but they will
   delete their elements anyhow when you call Empty().

=head2 Default constructors

   wxArray()

   wxObjArray()

   Default constructor initializes an empty array object.

   wxSortedArray(int (*)(T first, T second)compareFunction)

   There is no default constructor for wxSortedArray classes - you must
   initialize it with a function to use for item comparison. It is a
   function which is passed two arguments of type T where T is the array
   element type and which should return a negative, zero or positive
   value according to whether the first element passed to it is less
   than, equal to or greater than the second one.

=head2 Wx::Array copy constructor and assignment operator

   wxArray(const wxArray& array)

   wxSortedArray(const wxSortedArray& array)

   wxObjArray(const wxObjArray& array)

   wxArray& operator=(const wxArray& array)

   wxSortedArray& operator=(const wxSortedArray& array)

   wxObjArray& operator=(const wxObjArray& array)

   The copy constructors and assignment operators perform a shallow array
   copy (i.e. they don't copy the objects pointed to even if the source
   array contains the items of pointer type) for wxArray and
   wxSortedArray and a deep copy (i.e. the array element are copied too)
   for wxObjArray.

=head2 Wx::Array::DESTROY

   ~wxArray()

   ~wxSortedArray()

   ~wxObjArray()

   The wxObjArray destructor deletes all the items owned by the array.
   This is not done by wxArray and wxSortedArray versions - you may use
   WX_CLEAR_ARRAY macro for this.

=head2 Wx::Array::Add

   void Add(T item, size_t copies = 1)

   void Add(T *item)

   void Add(T &item, size_t copies = 1)

   Appends the given number of copies of the item to the array consisting
   of the elements of type T.

   The first version is used with wxArray and wxSortedArray. The second
   and the third are used with wxObjArray. There is an important
   difference between them: if you give a pointer to the array, it will
   take ownership of it, i.e. will delete it when the item is deleted
   from the array. If you give a reference to the array, however, the
   array will make a copy of the item and will not take ownership of the
   original item. Once again, it only makes sense for wxObjArrays because
   the other array types never take ownership of their elements. Also
   note that you cannot append more than one pointer as reusing it would
   lead to deleting it twice (or more) and hence to a crash.

   You may also use WX_APPEND_ARRAY macro to append all elements of one
   array to another one but it is more efficient to use copies parameter
   and modify the elements in place later if you plan to append a lot of
   items.

=head2 Wx::Array::Alloc

   void Alloc(size_t count)

   Preallocates memory for a given number of array elements. It is worth
   calling when the number of items which are going to be added to the
   array is known in advance because it will save unneeded memory
   reallocation. If the array already has enough memory for the given
   number of items, nothing happens. In any case, the existing contents
   of the array is not modified.

=head2 Wx::Array::Clear

   void Clear()

   This function does the same as Empty() and additionally frees the
   memory allocated to the array.

=head2 Wx::Array::Count

   size_t Count() const

   Same as GetCount(). This function is deprecated - it exists only for
   compatibility.

=head2 Wx::ObjArray::Detach

   T * Detach(size_t index)

   Removes the element from the array, but, unlike, Remove() doesn't
   delete it. The function returns the pointer to the removed element.

=head2 Wx::Array::Empty

   void Empty()

   Empties the array. For wxObjArray classes, this destroys all of the
   array elements. For wxArray and wxSortedArray this does nothing except
   marking the array of being empty - this function does not free the
   allocated memory, use Clear() for this.

=head2 Wx::Array::GetCount

   size_t GetCount() const

   Return the number of items in the array.

=head2 Wx::Array::Index

   int Index(T& item, bool searchFromEnd = false) const

   int Index(T& item) const

   The first version of the function is for wxArray and wxObjArray, the
   second is for wxSortedArray only.

   Searches the element in the array, starting from either beginning or
   the end depending on the value of searchFromEnd parameter. wxNOT_FOUND
   is returned if the element is not found, otherwise the index of the
   element is returned.

   Linear search is used for the wxArray and wxObjArray classes but
   binary search in the sorted array is used for wxSortedArray (this is
   why searchFromEnd parameter doesn't make sense for it).

   NB: even for wxObjArray classes, the operator==() of the elements in
   the array is not used by this function. It searches exactly the given
   element in the array and so will only succeed if this element had been
   previously added to the array, but fail even if another, identical,
   element is in the array.

=head2 Wx::Array::Insert

   void Insert(T item, size_t n, size_t copies = 1)

   void Insert(T *item, size_t n)

   void Insert(T &item, size_t n, size_t copies = 1)

   Insert the given number of copies of the item into the array before
   the existing item n - thus, Insert(something, 0u) will insert an item
   in such way that it will become the first array element.

   Please see Add() for explanation of the differences between the
   overloaded versions of this function.

=head2 Wx::Array::IsEmpty

   bool IsEmpty() const

   Returns true if the array is empty, false otherwise.

=head2 Wx::Array::Item

   T& Item(size_t index) const

   Returns the item at the given position in the array. If index is out
   of bounds, an assert failure is raised in the debug builds but nothing
   special is done in the release build.

   The returned value is of type "reference to the array element type"
   for all of the array classes.

=head2 Wx::Array::Last

   T& Last() const

   Returns the last element in the array, i.e. is the same as
   Item(GetCount() - 1). An assert failure is raised in the debug mode if
   the array is empty.

   The returned value is of type "reference to the array element type"
   for all of the array classes.

=head2 Wx::Array::Remove

   Remove(T item)

   Removes an element from the array by value: the first item of the
   array equal to item is removed, an assert failure will result from an
   attempt to remove an item which doesn't exist in the array.

   When an element is removed from wxObjArray it is deleted by the array
   - use Detach() if you don't want this to happen. On the other hand,
   when an object is removed from a wxArray nothing happens - you should
   delete it manually if required:

   T *item = array[n];
   delete item;
   array.Remove(n)

   See also WX_CLEAR_ARRAY macro which deletes all elements of a wxArray
   (supposed to contain pointers).

=head2 Wx::Array::RemoveAt

   RemoveAt(size_t index, size_t count = 1)

   Removes count elements starting at index from the array. When an
   element is removed from wxObjArray it is deleted by the array - use
   Detach() if you don't want this to happen. On the other hand, when an
   object is removed from a wxArray nothing happens - you should delete
   it manually if required:

   T *item = array[n];
   delete item;
   array.RemoveAt(n)

   See also WX_CLEAR_ARRAY macro which deletes all elements of a wxArray
   (supposed to contain pointers).

=head2 Wx::Array::SetCount

   void SetCount(size_t count, T defval = T(0))

   This function ensures that the number of array elements is at least
   count. If the array has already count or more items, nothing is done.
   Otherwise, count - GetCount() elements are added and initialized to
   the value defval.

   See also

   GetCount

=head2 Wx::Array::Shrink

   void Shrink()

   Frees all memory unused by the array. If the program knows that no new
   items will be added to the array it may call Shrink() to reduce its
   memory usage. However, if a new item is added to the array, some extra
   memory will be allocated again.

=head2 Wx::Array::Sort

   void Sort(CMPFUNC<T> compareFunction)

   The notation CMPFUNC<T> should be read as if we had the following
   declaration:

   template int CMPFUNC(T *first, T *second);

   where T is the type of the array elements. I.e. it is a function
   returning int which is passed two arguments of type T *.

   Sorts the array using the specified compare function: this function
   should return a negative, zero or positive value according to whether
   the first element passed to it is less than, equal to or greater than
   the second one.

   wxSortedArray doesn't have this function because it is always sorted.

=head1 Wx::ArrayString

=head2 Wx::ArrayString::new

   wxArrayString()

   Default constructor.

   wxArrayString(const wxArrayString& array)

   Copy constructor. Note that when an array is assigned to a sorted
   array, its contents is automatically sorted during construction.

   wxArrayString(size_t sz, const wxChar** arr)

   Constructor from a C string array. Pass a size sz and array arr.

   wxArrayString(size_t sz, const wxString* arr)

   Constructor from a wxString array. Pass a size sz and array arr.

=head2 Wx::ArrayString::DESTROY

   ~wxArrayString()

   Destructor frees memory occupied by the array strings. For the
   performance reasons it is not virtual, so this class should not be
   derived from.

=head2 Wx::ArrayString::Add

   size_t Add(const wxString& str, size_t copies = 1)

   Appends the given number of copies of the new item str to the array
   and returns the index of the first new item in the array.

   Warning: For sorted arrays, the index of the inserted item will not
   be, in general, equal to GetCount() - 1 because the item is inserted
   at the correct position to keep the array sorted and not appended.

   See also: Insert

=head2 Wx::ArrayString::Alloc

   void Alloc(size_t nCount)

   Preallocates enough memory to store nCount items. This function may be
   used to improve array class performance before adding a known number
   of items consecutively.

   See also: Dynamic array memory management

=head2 Wx::ArrayString::Clear

   void Clear()

   Clears the array contents and frees memory.

   See also: Empty

=head2 Wx::ArrayString::Count

   size_t Count() const

   Returns the number of items in the array. This function is deprecated
   and is for backwards compatibility only, please use GetCount instead.

=head2 Wx::ArrayString::Empty

   void Empty()

   Empties the array: after a call to this function GetCount will return
   0. However, this function does not free the memory used by the array
   and so should be used when the array is going to be reused for storing
   other strings. Otherwise, you should use Clear to empty the array and
   free memory.

=head2 Wx::ArrayString::GetCount

   size_t GetCount() const

   Returns the number of items in the array.

=head2 Wx::ArrayString::Index

   int Index(const wxChar * sz, bool bCase = true, bool bFromEnd = false)

   Search the element in the array, starting from the beginning if
   bFromEnd is false or from end otherwise. If bCase, comparison is case
   sensitive (default), otherwise the case is ignored.

   This function uses linear search for wxArrayString and binary search
   for wxSortedArrayString, but it ignores the bCase and bFromEnd
   parameters in the latter case.

   Returns index of the first item matched or wxNOT_FOUND if there is no
   match.

=head2 Wx::ArrayString::Insert

   void Insert(const wxString& str, size_t nIndex, size_t copies = 1)

   Insert the given number of copies of the new element in the array
   before the position nIndex. Thus, for example, to insert the string in
   the beginning of the array you would write

   Insert("foo", 0);

   If nIndex is equal to GetCount() this function behaves as Add.

   Warning: this function should not be used with sorted arrays because
   it could break the order of items and, for example, subsequent calls
   to Index() would then not work!

=head2 Wx::ArrayString::IsEmpty

   bool IsEmpty()

   Returns true if the array is empty, false otherwise. This function
   returns the same result as GetCount() == 0 but is probably easier to
   read.

=head2 Wx::ArrayString::Item

   wxString& Item(size_t nIndex) const

   Return the array element at position nIndex. An assert failure will
   result from an attempt to access an element beyond the end of array in
   debug mode, but no check is done in release mode.

   See also operator[] for the operator version.

=head2 Wx::ArrayString::Last

   wxString Last()

   Returns the last element of the array. Attempt to access the last
   element of an empty array will result in assert failure in debug
   build, however no checks are done in release mode.

=head2 Wx::ArrayString::Remove

   void Remove(const wxChar * sz)

   Removes the first item matching this value. An assert failure is
   provoked by an attempt to remove an element which does not exist in
   debug build.

   See also: Index

=head2 Wx::ArrayString::RemoveAt

   void RemoveAt(size_t nIndex, size_t count = 1)

   Removes count items starting at position nIndex from the array.

=head2 Wx::ArrayString::Shrink

   void Shrink()

   Releases the extra memory allocated by the array. This function is
   useful to minimize the array memory consumption.

   See also: Alloc, Dynamic array memory management

=head2 Wx::ArrayString::Sort

   void Sort(bool reverseOrder = false)

   Sorts the array in alphabetical order or in reverse alphabetical order
   if reverseOrder is true. The sort is case-sensitive.

   Warning: this function should not be used with sorted array because it
   could break the order of items and, for example, subsequent calls to
   Index() would then not work!

   void Sort(CompareFunction compareFunction)

   Sorts the array using the specified compareFunction for item
   comparison. CompareFunction is defined as a function taking two const
   wxString& parameters and returning an int value less than, equal to or
   greater than 0 if the first string is less than, equal to or greater
   than the second one.

   Example

   The following example sorts strings by their length.

   static int CompareStringLen(const wxString& first, const wxString& second)
   {
       return first.length() - second.length();
   }

=head1 Wx::ArtProvider

=head2 Identifying art resources

   Every bitmap is known to wxArtProvider under an unique ID that is used
   by when requesting a resource from it. The ID is represented by
   wxArtID type and can have one of these predefined values (you can see
   bitmaps represented by these constants in the artprov sample):

=head2 Clients

   Client is the entity that calls wxArtProvider's GetBitmap or GetIcon
   function. It is represented by wxClientID type and can have one of
   these values:

=head2 Wx::ArtProvider::DESTROY

   ~wxArtProvider()

   The destructor automatically removes the provider from the provider
   stack used by GetBitmap.

=head2 Wx::ArtProvider::CreateBitmap

   wxBitmap CreateBitmap(const wxArtID& id, const wxArtClient& client,
   const wxSize& size)

   Derived art provider classes must override this method to create
   requested art resource. Note that returned bitmaps are cached by
   wxArtProvider and it is therefore not necessary to optimize
   CreateBitmap for speed (e.g. you may create wxBitmap objects from XPMs
   here).

   Parameters

   id  

       wxArtID unique identifier of the bitmap.

   client

       wxArtClient identifier of the client (i.e. who is asking for the
       bitmap). This only servers as a hint.

   size

       Preferred size of the bitmap. The function may return a bitmap of
       different dimensions, it will be automatically rescaled to meet
       client's request.

   Note

   This is not part of wxArtProvider's public API, use
   wxArtProvider::GetBitmap or wxArtProvider::GetIcon to query
   wxArtProvider for a resource.

=head2 Wx::ArtProvider::Delete

   static bool Delete(wxArtProvider* provider)

   Delete the given provider.

=head2 Wx::ArtProvider::GetBitmap

   static wxBitmap GetBitmap(const wxArtID& id, const wxArtClient& client
   = wxART_OTHER, const wxSize& size = wxDefaultSize)

   Query registered providers for bitmap with given ID.

   Parameters

   id  

       wxArtID unique identifier of the bitmap.

   client

       wxArtClient identifier of the client (i.e. who is asking for the
       bitmap).

   size

       Size of the returned bitmap or wxDefaultSize if size doesn't
       matter.

   Return value

   The bitmap if one of registered providers recognizes the ID or
   wxNullBitmap otherwise.

=head2 Wx::ArtProvider::GetIcon

   static wxIcon GetIcon(const wxArtID& id, const wxArtClient& client =
   wxART_OTHER, const wxSize& size = wxDefaultSize)

   Same as wxArtProvider::GetBitmap, but return a wxIcon object (or
   wxNullIcon on failure).

   static wxSize GetSizeHint(const wxArtClient& client, bool
   platform_default = false)

   Returns a suitable size hint for the given wxArtClient. If
   platform_default is true, return a size based on the current platform,
   otherwise return the size from the topmost wxArtProvider.
   wxDefaultSize may be returned if the client doesn't have a specified
   size, like wxART_OTHER for example.

=head2 Wx::ArtProvider::Insert

   static void Insert(wxArtProvider* provider)

   Register new art provider and add it to the bottom of providers stack
   (i.e. it will be queried as the last one).

   See also

   Push

=head2 Wx::ArtProvider::Pop

   static bool Pop()

   Remove latest added provider and delete it.

=head2 Wx::ArtProvider::Push

   static void Push(wxArtProvider* provider)

   Register new art provider and add it to the top of providers stack
   (i.e. it will be queried as the first provider).

   See also

   Insert

=head2 Wx::ArtProvider::Remove

   static bool Remove(wxArtProvider* provider)

   Remove a provider from the stack if it is on it. The provider is not
   deleted, unlike when using Delete().

=head1 Wx::AuiDockArt

=head2 Wx::AuiDockArt::new

   wxAuiDockArt()

   Constructor.

=head2 Wx::AuiDockArt::DESTROY

   ~wxAuiDockArt()

   Destructor.

=head2 Wx::AuiDockArt::DrawBackground

   virtual void DrawBackground(wxDC& dc, wxWindow* window, int
   orientation, const wxRect& rect)

   Draws a background.

=head2 Wx::AuiDockArt::DrawBorder

   virtual void DrawBorder(wxDC& dc, wxWindow* window, const wxRect& rect,
   wxAuiPaneInfo& pane)

   Draws a border.

=head2 Wx::AuiDockArt::DrawCaption

   virtual void DrawCaption(wxDC& dc, wxWindow* window, const wxString&
   text, const wxRect& rect, wxAuiPaneInfo& pane)

   Draws a caption.

=head2 Wx::AuiDockArt::DrawGripper

   virtual void DrawGripper(wxDC& dc, wxWindow* window, const wxRect&
   rect, wxAuiPaneInfo& pane)

   Draws a gripper.

=head2 Wx::AuiDockArt::DrawPaneButton

   virtual void DrawPaneButton(wxDC& dc, wxWindow* window, int button,
   int button_state, const wxRect& rect, wxAuiPaneInfo& pane)

   Draws a button in the pane's title bar.

   button can be one of the values of wxAuiButtonId.

   button_state can be one of the values of wxAuiPaneButtonState.

=head2 Wx::AuiDockArt::DrawSash

   virtual void DrawSash(wxDC& dc, wxWindow* window, int orientation,
   const wxRect& rect)

   Draws a sash between two windows.

=head2 Wx::AuiDockArt::GetColor

   virtual wxColour GetColor(int id)

   The same as GetColour.

=head2 Wx::AuiDockArt::GetColour

   virtual wxColour GetColour(int id)

   Get the colour of a certain setting.

   id can be one of the colour values of wxAuiPaneDockArtSetting.

=head2 Wx::AuiDockArt::GetFont

   virtual wxFont GetFont(int id)

   Get a font setting.

=head2 Wx::AuiDockArt::GetMetric

   virtual int GetMetric(int id)

   Get the value of a certain setting.

   id can be one of the size values of wxAuiPaneDockArtSetting.

=head2 Wx::AuiDockArt::SetColor

   virtual void SetColor(int id, const wxColour& color)

   The same as SetColour.

=head2 Wx::AuiDockArt::SetColour

   virtual void SetColour(int id, const wxColor& colour)

   Set a certain setting with the value colour.

   id can be one of the colour values of wxAuiPaneDockArtSetting.

=head2 Wx::AuiDockArt::SetFont

   virtual void SetFont(int id, const wxFont& font)

   Set a font setting.

=head2 Wx::AuiDockArt::SetMetric

   virtual void SetMetric(int id, int new_val)

   Set a certain setting with the value new_val.

   id can be one of the size values of wxAuiPaneDockArtSetting.

=head1 Wx::AuiTabArt

=head2 Wx::AuiTabArt::new

   wxAuiTabArt()

   Constructor.

=head2 Wx::AuiTabArt::Clone

   wxAuiTabArt* Clone()

   Clones the art object.

=head2 Wx::AuiTabArt::DrawBackground

   void DrawBackground(wxDC& dc, wxWindow* wnd, const wxRect& rect)

   Draws a background on the given area.

=head2 Wx::AuiTabArt::DrawButton

   void DrawButton(wxDC& dc, wxWindow* wnd, const wxRect& in_rect, int
   bitmap_id, int button_state, int orientation, const wxBitmap&
   bitmap_override, wxRect* out_rect)

   Draws a button.

=head2 Wx::AuiTabArt::DrawTab

   void DrawTab(wxDC& dc, wxWindow* wnd, const wxRect& in_rect, const
   wxString& caption, const wxBitmap& bitmap, bool active, int
   close_button_state, wxRect* out_tab_rect, wxRect* out_button_rect,
   int* x_extent)

   Draws a tab.

=head2 Wx::AuiTabArt::GetBestTabCtrlSize

   int GetBestTabCtrlSize(wxWindow* wnd, wxAuiNotebookPageArray& pages)

   Returns the tab control size.

=head2 Wx::AuiTabArt::GetIndentSize

   int GetIndentSize()

   Returns the indent size.

=head2 Wx::AuiTabArt::GetTabSize

   wxSize GetTabSize(wxDC& dc, wxWindow* wnd, const wxString& caption,
   const wxBitmap& bitmap, bool active, int close_button_state, int*
   x_extent)

   Returns the tab size for the given caption, bitmap and state.

=head2 Wx::AuiTabArt::SetFlags

   void SetFlags(unsigned int flags)

   Sets flags.

=head2 Wx::AuiTabArt::SetMeasuringFont

   void SetMeasuringFont(const wxFont& font)

   Sets the font used for calculating measurements.

=head2 Wx::AuiTabArt::SetNormalFont

   void SetNormalFont(const wxFont& font)

   Sets the normal font for drawing labels.

=head2 Wx::AuiTabArt::SetSelectedFont

   void SetSelectedFont(const wxFont& font)

   Sets the font for drawing text for selected UI elements.

=head2 Wx::AuiTabArt::SetSizingInfo

   void SetSizingInfo(const wxSize& tab_ctrl_size, size_t tab_count)

   Sets sizing information.

=head2 Wx::AuiTabArt::ShowWindowList

   int ShowWindowList(wxWindow* wnd, const wxArrayString& items, int
   active_idx)

   Pops up a menu to show the list of windows managed by wxAui.

=head1 Wx::AuiManager

=head2 Wx::AuiManager::new

   wxAuiManager(wxWindow* managed_wnd = NULL, unsigned int flags =
   wxAUI_MGR_DEFAULT)

   Constructor. managed_wnd specifies the wxFrame which should be
   managed. flags specifies options which allow the frame management
   behavior to be modified.

=head2 Wx::AuiManager::DESTROY

   ~wxAuiManager()

=head2 Wx::AuiManager::AddPane

   bool AddPane(wxWindow* window, const wxAuiPaneInfo& pane_info)

   bool AddPane(wxWindow* window, int direction = wxLEFT, const wxString&
   caption = wxEmptyString)

   bool AddPane(wxWindow* window, const wxAuiPaneInfo& pane_info, const
   wxPoint& drop_pos)

=head2 Wx::AuiManager::DetachPane

   bool DetachPane(wxWindow* window)

   Tells the wxAuiManager to stop managing the pane specified by window.
   The window, if in a floated frame, is reparented to the frame managed
   by wxAuiManager.

=head2 Wx::AuiManager::GetAllPanes

   wxAuiPaneInfoArray& GetAllPanes()

   Returns an array of all panes managed by the frame manager.

=head2 Wx::AuiManager::GetArtProvider

   wxAuiDockArt* GetArtProvider() const

   Returns the current art provider being used.

   See also: wxAuiDockArt.

=head2 Wx::AuiManager::GetDockSizeConstraint

   void GetDockSizeConstraint(double* widthpct, double* heightpct)

   Returns the current dock constraint values. See
   SetDockSizeConstraint() for more information.

=head2 Wx::AuiManager::GetFlags

   unsigned int GetFlags() const

   Returns the current manager's flags.

=head2 Wx::AuiManager::GetManagedWindow

   wxWindow* GetManagedWindow() const

   Returns the frame currently being managed by wxAuiManager.

=head2 Wx::AuiManager::GetManager

   static wxAuiManager* GetManager(wxWindow* window)

   Calling this method will return the wxAuiManager for a given window.
   The window parameter should specify any child window or sub-child
   window of the frame or window managed by wxAuiManager. The window
   parameter need not be managed by the manager itself, nor does it even
   need to be a child or sub-child of a managed window. It must however
   be inside the window hierarchy underneath the managed window.

=head2 Wx::AuiManager::GetPane

   wxAuiPaneInfo& GetPane(wxWindow* window)

   wxAuiPaneInfo& GetPane(const wxString& name)

   GetPane is used to lookup a wxAuiPaneInfo object either by window
   pointer or by pane name, which acts as a unique id for a window pane.
   The returned wxAuiPaneInfo object may then be modified to change a
   pane's look, state or position. After one or more modifications to
   wxAuiPaneInfo, wxAuiManager::Update() should be called to commit the
   changes to the user interface. If the lookup failed (meaning the pane
   could not be found in the manager), a call to the returned
   wxAuiPaneInfo's IsOk() method will return false.

=head2 Wx::AuiManager::HideHint

   void HideHint()

   HideHint() hides any docking hint that may be visible.

=head2 Wx::AuiManager::InsertPane

   bool InsertPane(wxWindow* window, const wxAuiPaneInfo& insert_location,
   int insert_level = wxAUI_INSERT_PANE)

   This method is used to insert either a previously unmanaged pane
   window into the frame manager, or to insert a currently managed pane
   somewhere else. InsertPane will push all panes, rows, or docks aside
   and insert the window into the position specified by insert_location.
   Because insert_location can specify either a pane, dock row, or dock
   layer, the insert_level parameter is used to disambiguate this. The
   parameter insert_level can take a value of wxAUI_INSERT_PANE,
   wxAUI_INSERT_ROW or wxAUI_INSERT_DOCK.

=head2 Wx::AuiManager::LoadPaneInfo

   void LoadPaneInfo(wxString pane_part, wxAuiPaneInfo& pane)

   LoadPaneInfo() is similar to to LoadPerspective, with the exception
   that it only loads information about a single pane. It is used in
   combination with SavePaneInfo().

=head2 Wx::AuiManager::LoadPerspective

   bool LoadPerspective(const wxString& perspective, bool update = true)

   Loads a saved perspective. If update is true, wxAuiManager::Update()
   is automatically invoked, thus realizing the saved perspective on
   screen.

=head2 Wx::AuiManager::ProcessDockResult

   bool ProcessDockResult(wxAuiPaneInfo& target, const wxAuiPaneInfo&
   new_pos)

   ProcessDockResult() is a protected member of the wxAUI layout manager.
   It can be overridden by derived classes to provide custom docking
   calculations.

=head2 Wx::AuiManager::SavePaneInfo

   wxString SavePaneInfo(wxAuiPaneInfo& pane)

   SavePaneInfo() is similar to SavePerspective, with the exception that
   it only saves information about a single pane. It is used in
   combination with LoadPaneInfo().

=head2 Wx::AuiManager::SavePerspective

   wxString SavePerspective()

   Saves the entire user interface layout into an encoded wxString, which
   can then be stored by the application (probably using wxConfig). When
   a perspective is restored using LoadPerspective(), the entire user
   interface will return to the state it was when the perspective was
   saved.

=head2 Wx::AuiManager::SetArtProvider

   void SetArtProvider(wxAuiDockArt* art_provider)

   Instructs wxAuiManager to use art provider specified by parameter
   art_provider for all drawing calls. This allows plugable look-and-feel
   features. The previous art provider object, if any, will be deleted by
   wxAuiManager.

   See also: wxAuiDockArt.

=head2 Wx::AuiManager::SetDockSizeConstraint

   void SetDockSizeConstraint(double widthpct, double heightpct)

   When a user creates a new dock by dragging a window into a docked
   position, often times the large size of the window will create a dock
   that is unwieldly large. wxAuiManager by default limits the size of
   any new dock to 1/3 of the window size. For horizontal docks, this
   would be 1/3 of the window height. For vertical docks, 1/3 of the
   width. Calling this function will adjust this constraint value. The
   numbers must be between 0.0 and 1.0. For instance, calling
   SetDockSizeContraint with 0.5, 0.5 will cause new docks to be limited
   to half of the size of the entire managed window.

=head2 Wx::AuiManager::SetFlags

   void SetFlags(unsigned int flags)

   This method is used to specify wxAuiManager's settings flags. flags
   specifies options which allow the frame management behavior to be
   modified.

=head2 Wx::AuiManager::SetManagedWindow

   void SetManagedWindow(wxWindow* managed_wnd)

   Called to specify the frame or window which is to be managed by
   wxAuiManager. Frame management is not restricted to just frames. Child
   windows or custom controls are also allowed.

=head2 Wx::AuiManager::ShowHint

   void ShowHint(const wxRect& rect)

   This function is used by controls to explicitly show a hint window at
   the specified rectangle. It is rarely called, and is mostly used by
   controls implementing custom pane drag/drop behaviour. The specified
   rectangle should be in screen coordinates.

=head2 Wx::AuiManager::UnInit

   void UnInit()

   Uninitializes the framework and should be called before a managed
   frame or window is destroyed. UnInit() is usually called in the
   managed wxFrame's destructor. It is necessary to call this function
   before the managed frame or window is destroyed, otherwise the manager
   cannot remove its custom event handlers from a window.

=head2 Wx::AuiManager::Update

   void Update()

   This method is called after any number of changes are made to any of
   the managed panes. Update() must be invoked after AddPane() or
   InsertPane() are called in order to "realize" or "commit" the changes.
   In addition, any number of changes may be made to wxAuiPaneInfo
   structures (retrieved with wxAuiManager::GetPane), but to realize the
   changes, Update() must be called. This construction allows pane
   flicker to be avoided by updating the whole layout at one time.

=head1 Wx::AuiNotebook

=head2 Wx::AuiNotebook::new

   wxAuiNotebook()

   wxAuiNotebook(wxWindow* parent, wxWindowID id = wxID_ANY, const
   wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
   long style = wxAUI_NB_DEFAULT_STYLE)

   Constructor. Creates a wxAuiNotebok control.

=head2 Wx::AuiNotebook::AddPage

   bool AddPage(wxWindow* page, const wxString& caption, bool select =
   false, const wxBitmap& bitmap = wxNullBitmap)

   Adds a page. If the select parameter is true, calling this will
   generate a page change event.

=head2 Wx::AuiNotebook::AdvanceSelection

   void AdvanceSelection(bool forward = true)

   Sets the selection to the next or previous page.

=head2 Wx::AuiNotebook::Create

   bool Create(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint&
   pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long
   style = 0)

   Creates the notebook window.

=head2 Wx::AuiNotebook::DeletePage

   bool DeletePage(size_t page)

   Deletes a page at the given index. Calling this method will generate a
   page change event.

=head2 Wx::AuiNotebook::GetArtProvider

   wxAuiTabArt* GetArtProvider() const

   Returns the associated art provider.

=head2 Wx::AuiNotebook::GetHeightForPageHeight

   int GetHeightForPageHeight(int pageHeight)

   Returns the desired height of the notebook for the given page height.
   Use this to fit the notebook to a given page size.

=head2 Wx::AuiNotebook::GetPage

   wxWindow* GetPage(size_t page_idx) const

   Returns the page specified by the given index.

=head2 Wx::AuiNotebook::GetPageBitmap

   wxBitmap GetPageBitmap(size_t page) const

   Returns the tab bitmap for the page.

=head2 Wx::AuiNotebook::GetPageCount

   size_t GetPageCount() const

   Returns the number of pages in the notebook.

=head2 Wx::AuiNotebook::GetPageIndex

   int GetPageIndex(wxWindow* page_wnd) const

   Returns the page index for the specified window. If the window is not
   found in the notebook, wxNOT_FOUND is returned.

=head2 Wx::AuiNotebook::GetPageText

   wxString GetPageText(size_t page) const

   Returns the tab label for the page.

=head2 Wx::AuiNotebook::GetSelection

   int GetSelection() const

   Returns the currently selected page.

=head2 Wx::AuiNotebook::GetTabCtrlHeight

   int GetTabCtrlHeight() const

   Returns the height of the tab control.

=head2 Wx::AuiNotebook::InsertPage

   bool InsertPage(size_t page_idx, wxWindow* page, const wxString&
   caption, bool select = false, const wxBitmap& bitmap = wxNullBitmap)

   InsertPage() is similar to AddPage, but allows the ability to specify
   the insert location. If the select parameter is true, calling this
   will generate a page change event.

=head2 Wx::AuiNotebook::RemovePage

   bool RemovePage(size_t page)

   Removes a page, without deleting the window pointer.

=head2 Wx::AuiNotebook::SetArtProvider

   void SetArtProvider(wxAuiTabArt* art)

   Sets the art provider to be used by the notebook.

=head2 Wx::AuiNotebook::SetFont

   bool SetFont(const wxFont& font)

   Sets the font for drawing the tab labels, using a bold version of the
   font for selected tab labels.

=head2 Wx::AuiNotebook::SetNormalFont

   void SetNormalFont(const wxFont& font)

   Sets the font for drawing unselected tab labels.

=head2 Wx::AuiNotebook::SetSelectedFont

   void SetSelectedFont(const wxFont& font)

   Sets the font for drawing selected tab labels.

=head2 Wx::AuiNotebook::SetMeasuringFont

   void SetMeasuringFont(const wxFont& font)

   Sets the font for measuring tab labels.

=head2 Wx::AuiNotebook::SetPageBitmap

   bool SetPageBitmap(size_t page, const wxBitmap& bitmap)

   Sets the bitmap for the page. To remove a bitmap from the tab caption,
   pass wxNullBitmap.

=head2 Wx::AuiNotebook::SetPageText

   bool SetPageText(size_t page, const wxString& text)

   Sets the tab label for the page.

=head2 Wx::AuiNotebook::SetSelection

   size_t SetSelection(size_t new_page)

   Sets the page selection. Calling this method will generate a page
   change event.

=head2 Wx::AuiNotebook::SetTabCtrlHeight

   void SetTabCtrlHeight(int height)

   Sets the tab height. By default, the tab control height is calculated
   by measuring the text height and bitmap sizes on the tab captions.
   Calling this method will override that calculation and set the tab
   control to the specified height parameter. A call to this method will
   override any call to SetUniformBitmapSize(). Specifying -1 as the
   height will return the control to its default auto-sizing behaviour.

=head2 Wx::AuiNotebook::SetUniformBitmapSize

   void SetUniformBitmapSize(const wxSize& size)

   SetUniformBitmapSize() ensures that all tabs will have the same
   height, even if some tabs don't have bitmaps. Passing wxDefaultSize to
   this function will instruct the control to use dynamic tab height,
   which is the default behaviour. Under the default behaviour, when a
   tab with a large bitmap is added, the tab control's height will
   automatically increase to accommodate the larger bitmap.

   void Split(size_t page, int direction)

   Split performs a split operation programmatically. The argument page
   indicates the page that will be split off. This page will also become
   the active page after the split. The direction argument specifies
   where the pane should go, it should be one of the following: wxTOP,
   wxBOTTOM, wxLEFT, or wxRIGHT.

=head2 Wx::AuiNotebook::ShowWindowMenu

   bool ShowWindowMenu()

   Shows the window menu for the active tab control associated with this
   notebook, and returns true if a selection was made.

=head1 Wx::AuiPaneInfo

=head2 Wx::AuiPaneInfo::new

   wxAuiPaneInfo()

   Default constructor.

   wxAuiPaneInfo(const wxAuiPaneInfo& c)

   Copy constructor.

=head2 Wx::AuiPaneInfo::DESTROY

   ~wxAuiPaneInfo()

=head2 Wx::AuiPaneInfo::BestSize

   wxAuiPaneInfo& BestSize(const wxSize& size)

   wxAuiPaneInfo& BestSize(int x, int y)

   BestSize() sets the ideal size for the pane. The docking manager will
   attempt to use this size as much as possible when docking or floating
   the pane.

=head2 Wx::AuiPaneInfo::Bottom

   wxAuiPaneInfo& Bottom()

   Bottom() sets the pane dock position to the bottom side of the frame.
   This is the same thing as calling Direction(wxAUI_DOCK_BOTTOM).

=head2 Wx::AuiPaneInfo::BottomDockable

   wxAuiPaneInfo& BottomDockable(bool b = true)

   BottomDockable() indicates whether a pane can be docked at the bottom
   of the frame.

=head2 Wx::AuiPaneInfo::Caption

   wxAuiPaneInfo& Caption(const wxString& c)

   Caption() sets the caption of the pane.

=head2 Wx::AuiPaneInfo::CaptionVisible

   wxAuiPaneInfo& CaptionVisible(bool visible = true)

   CaptionVisible indicates that a pane caption should be visible. If
   false, no pane caption is drawn.

=head2 Wx::AuiPaneInfo::Centre

   wxAuiPaneInfo& Centre()

   wxAuiPaneInfo& Center()

   Center() sets the pane dock position to the left side of the frame.
   The centre pane is the space in the middle after all border panes
   (left, top, right, bottom) are subtracted from the layout.

   This is the same thing as calling Direction(wxAUI_DOCK_CENTRE).

=head2 Wx::AuiPaneInfo::CentrePane

   wxAuiPaneInfo& CentrePane()

   wxAuiPaneInfo& CenterPane()

   CentrePane() specifies that the pane should adopt the default center
   pane settings. Centre panes usually do not have caption bars. This
   function provides an easy way of preparing a pane to be displayed in
   the center dock position.

=head2 Wx::AuiPaneInfo::CloseButton

   wxAuiPaneInfo& CloseButton(bool visible = true)

   CloseButton() indicates that a close button should be drawn for the
   pane.

=head2 Wx::AuiPaneInfo::DefaultPane

   wxAuiPaneInfo& DefaultPane()

   DefaultPane() specifies that the pane should adopt the default pane
   settings.

=head2 Wx::AuiPaneInfo::DestroyOnClose

   wxAuiPaneInfo& DestroyOnClose(bool b = true)

   DestroyOnClose() indicates whether a pane should be detroyed when it
   is closed. Normally a pane is simply hidden when the close button is
   clicked. Setting DestroyOnClose to true will cause the window to be
   destroyed when the user clicks the pane's close button.

=head2 Wx::AuiPaneInfo::Direction

   wxAuiPaneInfo& Direction(int direction)

   Direction() determines the direction of the docked pane. It is
   functionally the same as calling Left(), Right(), Top() or Bottom(),
   except that docking direction may be specified programmatically via
   the parameter.

=head2 Wx::AuiPaneInfo::Dock

   wxAuiPaneInfo& Dock()

   Dock() indicates that a pane should be docked. It is the opposite of
   Float().

=head2 Wx::AuiPaneInfo::DockFixed

   wxAuiPaneInfo& DockFixed(bool b = true)

   DockFixed() causes the containing dock to have no resize sash. This is
   useful for creating panes that span the entire width or height of a
   dock, but should not be resizable in the other direction.

=head2 Wx::AuiPaneInfo::Dockable

   wxAuiPaneInfo& Dockable(bool b = true)

   Dockable() specifies whether a frame can be docked or not. It is the
   same as specifying
   TopDockable(b).BottomDockable(b).LeftDockable(b).RightDockable(b).

=head2 Wx::AuiPaneInfo::Fixed

   wxAuiPaneInfo& Fixed()

   Fixed() forces a pane to be fixed size so that it cannot be resized.
   After calling Fixed(), IsFixed() will return true.

=head2 Wx::AuiPaneInfo::Float

   wxAuiPaneInfo& Float()

   Float() indicates that a pane should be floated. It is the opposite of
   Dock().

=head2 Wx::AuiPaneInfo::Floatable

   wxAuiPaneInfo& Floatable(bool b = true)

   Floatable() sets whether the user will be able to undock a pane and
   turn it into a floating window.

=head2 Wx::AuiPaneInfo::FloatingPosition

   wxAuiPaneInfo& FloatingPosition(const wxPoint& pos)

   wxAuiPaneInfo& FloatingPosition(int x, int y)

   FloatingPosition() sets the position of the floating pane.

=head2 Wx::AuiPaneInfo::FloatingSize

   wxAuiPaneInfo& FloatingSize(const wxSize& size)

   wxAuiPaneInfo& FloatingSize(int x, int y)

   FloatingSize() sets the size of the floating pane.

=head2 Wx::AuiPaneInfo::Gripper

   wxAuiPaneInfo& Gripper(bool visible = true)

   Gripper() indicates that a gripper should be drawn for the pane.

=head2 Wx::AuiPaneInfo::GripperTop

   wxAuiPaneInfo& GripperTop(bool attop = true)

   GripperTop() indicates that a gripper should be drawn at the top of
   the pane.

=head2 Wx::AuiPaneInfo::HasBorder

   bool HasBorder() const

   HasBorder() returns true if the pane displays a border.

=head2 Wx::AuiPaneInfo::HasCaption

   bool HasCaption() const

   HasCaption() returns true if the pane displays a caption.

=head2 Wx::AuiPaneInfo::HasCloseButton

   bool HasCloseButton() const

   HasCloseButton() returns true if the pane displays a button to close
   the pane.

=head2 Wx::AuiPaneInfo::HasFlag

   bool HasFlag(unsigned int flag) const

   HasFlag() returns true if the the property specified by flag is active
   for the pane.

=head2 Wx::AuiPaneInfo::HasGripper

   bool HasGripper() const

   HasGripper() returns true if the pane displays a gripper.

=head2 Wx::AuiPaneInfo::HasGripperTop

   bool HasGripperTop() const

   HasGripper() returns true if the pane displays a gripper at the top.

=head2 Wx::AuiPaneInfo::HasMaximizeButton

   bool HasMaximizeButton() const

   HasMaximizeButton() returns true if the pane displays a button to
   maximize the pane.

=head2 Wx::AuiPaneInfo::HasMinimizeButton

   bool HasMinimizeButton() const

   HasMinimizeButton() returns true if the pane displays a button to
   minimize the pane.

=head2 Wx::AuiPaneInfo::HasPinButton

   bool HasPinButton() const

   HasPinButton() returns true if the pane displays a button to float the
   pane.

=head2 Wx::AuiPaneInfo::Hide

   wxAuiPaneInfo& Hide()

   Hide() indicates that a pane should be hidden.

=head2 Wx::AuiPaneInfo::IsBottomDockable

   bool IsBottomDockable() const

   IsBottomDockable() returns true if the pane can be docked at the
   bottom of the managed frame.

=head2 Wx::AuiPaneInfo::IsDocked

   bool IsDocked() const

   IsDocked() returns true if the pane is docked.

=head2 Wx::AuiPaneInfo::IsFixed

   bool IsFixed() const

   IsFixed() returns true if the pane cannot be resized.

=head2 Wx::AuiPaneInfo::IsFloatable

   bool IsFloatable() const

   IsFloatable() returns true if the pane can be undocked and displayed
   as a floating window.

=head2 Wx::AuiPaneInfo::IsFloating

   bool IsFloating() const

   IsFloating() returns true if the pane is floating.

=head2 Wx::AuiPaneInfo::IsLeftDockable

   bool IsLeftDockable() const

   IsLeftDockable() returns true if the pane can be docked on the left of
   the managed frame.

=head2 Wx::AuiPaneInfo::IsMovable

   bool IsMovable() const

   IsMoveable() returns true if the docked frame can be undocked or moved
   to another dock position.

=head2 Wx::AuiPaneInfo::IsOk

   bool IsOk() const

   IsOk() returns true if the wxAuiPaneInfo structure is valid. A pane
   structure is valid if it has an associated window.

=head2 Wx::AuiPaneInfo::IsResizable

   bool IsResizable() const

   IsResizable() returns true if the pane can be resized.

=head2 Wx::AuiPaneInfo::IsRightDockable

   bool IsRightDockable() const

   IsRightDockable() returns true if the pane can be docked on the right
   of the managed frame.

=head2 Wx::AuiPaneInfo::IsShown

   bool IsShown() const

   IsShown() returns true if the pane is currently shown.

=head2 Wx::AuiPaneInfo::IsToolbar

   bool IsToolbar() const

   IsToolbar() returns true if the pane contains a toolbar.

=head2 Wx::AuiPaneInfo::IsTopDockable

   bool IsTopDockable() const

   IsTopDockable() returns true if the pane can be docked at the top of
   the managed frame.

=head2 Wx::AuiPaneInfo::Layer

   wxAuiPaneInfo& Layer(int layer)

   Layer() determines the layer of the docked pane. The dock layer is
   similar to an onion, the inner-most layer being layer 0. Each shell
   moving in the outward direction has a higher layer number. This allows
   for more complex docking layout formation.

=head2 Wx::AuiPaneInfo::Left

   wxAuiPaneInfo& Left()

   Left() sets the pane dock position to the left side of the frame. This
   is the same thing as calling Direction(wxAUI_DOCK_LEFT).

=head2 Wx::AuiPaneInfo::LeftDockable

   wxAuiPaneInfo& LeftDockable(bool b = true)

   LeftDockable() indicates whether a pane can be docked on the left of
   the frame.

=head2 Wx::AuiPaneInfo::MaxSize

   wxAuiPaneInfo& MaxSize(const wxSize& size)

   wxAuiPaneInfo& MaxSize(int x, int y)

   MaxSize() sets the maximum size of the pane.

=head2 Wx::AuiPaneInfo::MaximizeButton

   wxAuiPaneInfo& MaximizeButton(bool visible = true)

   MaximizeButton() indicates that a maximize button should be drawn for
   the pane.

=head2 Wx::AuiPaneInfo::MinSize

   wxAuiPaneInfo& MinSize(const wxSize& size)

   wxAuiPaneInfo& MinSize(int x, int y)

   MinSize() sets the minimum size of the pane. Please note that this is
   only partially supported as of this writing.

=head2 Wx::AuiPaneInfo::MinimizeButton

   wxAuiPaneInfo& MinimizeButton(bool visible = true)

   MinimizeButton() indicates that a minimize button should be drawn for
   the pane.

=head2 Wx::AuiPaneInfo::Movable

   wxAuiPaneInfo& Movable(bool b = true)

   Movable indicates whether a frame can be moved.

=head2 Wx::AuiPaneInfo::Name

   wxAuiPaneInfo& Name(const wxString& n)

   Name() sets the name of the pane so it can be referenced in lookup
   functions. If a name is not specified by the user, a random name is
   assigned to the pane when it is added to the manager.

=head2 Wx::AuiPaneInfo::PaneBorder

   wxAuiPaneInfo& PaneBorder(bool visible = true)

   PaneBorder indicates that a border should be drawn for the pane.

=head2 Wx::AuiPaneInfo::PinButton

   wxAuiPaneInfo& PinButton(bool visible = true)

   PinButton() indicates that a pin button should be drawn for the pane.

=head2 Wx::AuiPaneInfo::Position

   wxAuiPaneInfo& Position(int pos)

   Position() determines the position of the docked pane.

=head2 Wx::AuiPaneInfo::Resizable

   wxAuiPaneInfo& Resizable(bool resizable = true)

   Resizable() allows a pane to be resized if the parameter is true, and
   forces it to be a fixed size if the parameter is false. This is simply
   an antonym for Fixed().

=head2 Wx::AuiPaneInfo::Right

   wxAuiPaneInfo& Right()

   Right() sets the pane dock position to the right side of the frame.

=head2 Wx::AuiPaneInfo::RightDockable

   wxAuiPaneInfo& RightDockable(bool b = true)

   RightDockable() indicates whether a pane can be docked on the right of
   the frame.

=head2 Wx::AuiPaneInfo::Row

   wxAuiPaneInfo& Row(int row)

   Row() determines the row of the docked pane.

=head2 Wx::AuiPaneInfo::SafeSet

   void SafeSet(wxAuiPaneInfo source)

   Write the safe parts of a newly loaded PaneInfo structure "source"
   into "this" used on loading perspectives etc.

=head2 Wx::AuiPaneInfo::SetFlag

   wxAuiPaneInfo& SetFlag(unsigned int flag, bool option_state)

   SetFlag() turns the property given by flag on or off with the
   option_state parameter.

=head2 Wx::AuiPaneInfo::Show

   wxAuiPaneInfo& Show(bool show = true)

   Show() indicates that a pane should be shown.

=head2 Wx::AuiPaneInfo::ToolbarPane

   wxAuiPaneInfo& ToolbarPane()

   ToolbarPane() specifies that the pane should adopt the default toolbar
   pane settings.

=head2 Wx::AuiPaneInfo::Top

   wxAuiPaneInfo& Top()

   Top() sets the pane dock position to the top of the frame.

=head2 Wx::AuiPaneInfo::TopDockable

   wxAuiPaneInfo& TopDockable(bool b = true)

   TopDockable() indicates whether a pane can be docked at the top of the
   frame.

=head2 Wx::AuiPaneInfo::Window

   wxAuiPaneInfo& Window(wxWindow* w)

   Window() assigns the window pointer that the wxAuiPaneInfo should use.
   This normally does not need to be specified, as the window pointer is
   automatically assigned to the wxAuiPaneInfo structure as soon as it is
   added to the manager.

=head1 Wx::AutomationObject

=head2 Wx::AutomationObject::new

   wxAutomationObject(WXIDISPATCH* dispatchPtr = NULL)

   Constructor, taking an optional IDispatch pointer which will be
   released when the object is deleted.

=head2 Wx::AutomationObject::DESTROY

   ~wxAutomationObject()

   Destructor. If the internal IDispatch pointer is non-null, it will be
   released.

=head2 Wx::AutomationObject::CallMethod

   wxVariant CallMethod(const wxString& method, int noArgs, wxVariant
   args[]) const

   wxVariant CallMethod(const wxString& method, ...) const

   Calls an automation method for this object. The first form takes a
   method name, number of arguments, and an array of variants. The second
   form takes a method name and zero to six constant references to
   variants. Since the variant class has constructors for the basic data
   types, and C++ provides temporary objects automatically, both of the
   following lines are syntactically valid:

     wxVariant res = obj.CallMethod("Sum", wxVariant(1.2), wxVariant(3.4));
     wxVariant res = obj.CallMethod("Sum", 1.2, 3.4);

   Note that method can contain dot-separated property names, to save the
   application needing to call GetProperty several times using several
   temporary objects. For example:

     object.CallMethod("ActiveCell.Font.ShowDialog", "My caption");

=head2 Wx::AutomationObject::CreateInstance

   bool CreateInstance(const wxString& classId) const

   Creates a new object based on the class id, returning true if the
   object was successfully created, or false if not.

=head2 Wx::AutomationObject::GetDispatchPtr

   IDispatch* GetDispatchPtr() const

   Gets the IDispatch pointer.

=head2 Wx::AutomationObject::GetInstance

   bool GetInstance(const wxString& classId) const

   Retrieves the current object associated with a class id, and attaches
   the IDispatch pointer to this object. Returns true if a pointer was
   successfully retrieved, false otherwise.

   Note that this cannot cope with two instances of a given OLE object
   being active simultaneously, such as two copies of Excel running.
   Which object is referenced cannot currently be specified.

=head2 Wx::AutomationObject::GetObject

   bool GetObject(wxAutomationObject&obj const wxString& property, int
   noArgs = 0, wxVariant args[] = NULL) const

   Retrieves a property from this object, assumed to be a dispatch
   pointer, and initialises obj with it. To avoid having to deal with
   IDispatch pointers directly, use this function in preference to
   wxAutomationObject::GetProperty when retrieving objects from other
   objects.

   Note that an IDispatch pointer is stored as a void* pointer in
   wxVariant objects.

   See also

   wxAutomationObject::GetProperty

=head2 Wx::AutomationObject::GetProperty

   wxVariant GetProperty(const wxString& property, int noArgs, wxVariant
   args[]) const

   wxVariant GetProperty(const wxString& property, ...) const

   Gets a property value from this object. The first form takes a
   property name, number of arguments, and an array of variants. The
   second form takes a property name and zero to six constant references
   to variants. Since the variant class has constructors for the basic
   data types, and C++ provides temporary objects automatically, both of
   the following lines are syntactically valid:

     wxVariant res = obj.GetProperty("Range", wxVariant("A1"));
     wxVariant res = obj.GetProperty("Range", "A1");

   Note that property can contain dot-separated property names, to save
   the application needing to call GetProperty several times using
   several temporary objects.

=head2 Wx::AutomationObject::Invoke

   bool Invoke(const wxString& member, int action, wxVariant& retValue,
   int noArgs, wxVariant args[], const wxVariant* ptrArgs[] = 0) const

   This function is a low-level implementation that allows access to the
   IDispatch Invoke function. It is not meant to be called directly by
   the application, but is used by other convenience functions.

   Parameters

   member

       The member function or property name.

   action

       Bitlist: may contain DISPATCH_PROPERTYPUT,
       DISPATCH_PROPERTYPUTREF, DISPATCH_METHOD.

   retValue

       Return value (ignored if there is no return value)

   .

   noArgs

       Number of arguments in args or ptrArgs.

   args

       If non-null, contains an array of variants.

   ptrArgs

       If non-null, contains an array of constant pointers to variants.

   Return value

   true if the operation was successful, false otherwise.

   Remarks

   Two types of argument array are provided, so that when possible
   pointers are used for efficiency.

=head2 Wx::AutomationObject::PutProperty

   bool PutProperty(const wxString& property, int noArgs, wxVariant
   args[]) const

   bool PutProperty(const wxString& property, ...)

   Puts a property value into this object. The first form takes a
   property name, number of arguments, and an array of variants. The
   second form takes a property name and zero to six constant references
   to variants. Since the variant class has constructors for the basic
   data types, and C++ provides temporary objects automatically, both of
   the following lines are syntactically valid:

     obj.PutProperty("Value", wxVariant(23));
     obj.PutProperty("Value", 23);

   Note that property can contain dot-separated property names, to save
   the application needing to call GetProperty several times using
   several temporary objects.

=head2 Wx::AutomationObject::SetDispatchPtr

   void SetDispatchPtr(WXIDISPATCH* dispatchPtr)

   Sets the IDispatch pointer. This function does not check if there is
   already an IDispatch pointer.

   You may need to cast from IDispatch* to WXIDISPATCH* when calling this
   function.

=head1 Wx::Bitmap

=head2 Wx::Bitmap::new

   wxBitmap()

   Default constructor.

   wxBitmap(const wxBitmap& bitmap)

   Copy constructor, uses reference counting. To make a real copy, you
   can use:

       wxBitmap newBitmap = oldBitmap.GetSubBitmap(
                                wxRect(0, 0, oldBitmap.GetWidth(), oldBitmap.GetHeight()));

   wxBitmap(const void* data, int type, int width, int height, int depth
   = -1)

   Creates a bitmap from the given data which is interpreted in
   platform-dependent manner.

   wxBitmap(const char bits[], int width, int height

=head2 Wx::Bitmap::DESTROY

   ~wxBitmap()

   Destructor. See reference-counted object destruction for more info.

   If the application omits to delete the bitmap explicitly, the bitmap
   will be destroyed automatically by wxWidgets when the application
   exits.

   Do not delete a bitmap that is selected into a memory device context.

=head2 Wx::Bitmap::AddHandler

   static void AddHandler(wxBitmapHandler* handler)

   Adds a handler to the end of the static list of format handlers.

   handler

       A new bitmap format handler object. There is usually only one
       instance of a given handler class in an application session.

   See also

   wxBitmapHandler

=head2 Wx::Bitmap::CleanUpHandlers

   static void CleanUpHandlers()

   Deletes all bitmap handlers.

   This function is called by wxWidgets on exit.

=head2 Wx::Bitmap::ConvertToImage

   wxImage ConvertToImage()

   Creates an image from a platform-dependent bitmap. This preserves mask
   information so that bitmaps and images can be converted back and forth
   without loss in that respect.

=head2 Wx::Bitmap::CopyFromIcon

   bool CopyFromIcon(const wxIcon& icon)

   Creates the bitmap from an icon.

=head2 Wx::Bitmap::Create

   virtual bool Create(int width, int height, int depth = -1)

   Creates a fresh bitmap. If the final argument is omitted, the display
   depth of the screen is used.

   virtual bool Create(const void* data, int type, int width, int height,
   int depth = -1)

   Creates a bitmap from the given data, which can be of arbitrary type.

   Parameters

   width

       The width of the bitmap in pixels.

   height

       The height of the bitmap in pixels.

   depth

       The depth of the bitmap in pixels. If this is -1, the screen depth
       is used.

   data

       Data whose type depends on the value of type.

   type

       A bitmap type identifier - see wxBitmap::wxBitmap for a list of
       possible values.

   Return value

   true if the call succeeded, false otherwise.

   Remarks

   The first form works on all platforms. The portability of the second
   form depends on the type of data.

   See also

   wxBitmap::wxBitmap

=head2 Wx::Bitmap::FindHandler

   static wxBitmapHandler* FindHandler(const wxString& name)

   Finds the handler with the given name.

   static wxBitmapHandler* FindHandler(const wxString& extension,
   wxBitmapType bitmapType)

   Finds the handler associated with the given extension and type.

   static wxBitmapHandler* FindHandler(wxBitmapType bitmapType)

   Finds the handler associated with the given bitmap type.

   name

       The handler name.

   extension

       The file extension, such as "bmp".

   bitmapType

       The bitmap type, such as wxBITMAP_TYPE_BMP.

   Return value

   A pointer to the handler if found, NULL otherwise.

   See also

   wxBitmapHandler

=head2 Wx::Bitmap::GetDepth

   int GetDepth() const

   Gets the colour depth of the bitmap. A value of 1 indicates a
   monochrome bitmap.

=head2 Wx::Bitmap::GetHandlers

   static wxList& GetHandlers()

   Returns the static list of bitmap format handlers.

   See also

   wxBitmapHandler

=head2 Wx::Bitmap::GetHeight

   int GetHeight() const

   Gets the height of the bitmap in pixels.

=head2 Wx::Bitmap::GetPalette

   wxPalette* GetPalette() const

   Gets the associated palette (if any) which may have been loaded from a
   file or set for the bitmap.

   See also

   wxPalette

=head2 Wx::Bitmap::GetMask

   wxMask* GetMask() const

   Gets the associated mask (if any) which may have been loaded from a
   file or set for the bitmap.

   See also

   wxBitmap::SetMask, wxMask

=head2 Wx::Bitmap::GetWidth

   int GetWidth() const

   Gets the width of the bitmap in pixels.

   See also

   wxBitmap::GetHeight

=head2 Wx::Bitmap::GetSubBitmap

   wxBitmap GetSubBitmap(const wxRect&rect) const

   Returns a sub bitmap of the current one as long as the rect belongs
   entirely to the bitmap. This function preserves bit depth and mask
   information.

=head2 Wx::Bitmap::InitStandardHandlers

   static void InitStandardHandlers()

   Adds the standard bitmap format handlers, which, depending on
   wxWidgets configuration, can be handlers for Windows bitmap, Windows
   bitmap resource, and XPM.

   This function is called by wxWidgets on startup.

   See also

   wxBitmapHandler

=head2 Wx::Bitmap::InsertHandler

   static void InsertHandler(wxBitmapHandler* handler)

   Adds a handler at the start of the static list of format handlers.

   handler

       A new bitmap format handler object. There is usually only one
       instance of a given handler class in an application session.

   See also

   wxBitmapHandler

=head2 Wx::Bitmap::LoadFile

   bool LoadFile(const wxString& name, wxBitmapType type)

   Loads a bitmap from a file or resource.

   Parameters

   name

       Either a filename or a Windows resource name. The meaning of name
       is determined by the type parameter.

   type

       One of the following values:

=head2 Wx::Bitmap::IsOk

   bool IsOk() const

   Returns true if bitmap data is present.

=head2 Wx::Bitmap::RemoveHandler

   static bool RemoveHandler(const wxString& name)

   Finds the handler with the given name, and removes it. The handler is
   not deleted.

   name

       The handler name.

   Return value

   true if the handler was found and removed, false otherwise.

   See also

   wxBitmapHandler

=head2 Wx::Bitmap::SaveFile

   bool SaveFile(const wxString& name, wxBitmapType type, wxPalette*
   palette = NULL)

   Saves a bitmap in the named file.

   Parameters

   name

       A filename. The meaning of name is determined by the type
       parameter.

   type

       One of the following values:

=head2 Wx::Bitmap::SetDepth

   void SetDepth(int depth)

   Sets the depth member (does not affect the bitmap data).

   Parameters

   depth

       Bitmap depth.

=head2 Wx::Bitmap::SetHeight

   void SetHeight(int height)

   Sets the height member (does not affect the bitmap data).

   Parameters

   height

       Bitmap height in pixels.

=head2 Wx::Bitmap::SetMask

   void SetMask(wxMask* mask)

   Sets the mask for this bitmap.

   Remarks

   The bitmap object owns the mask once this has been called.

   See also

   wxBitmap::GetMask, wxMask

=head2 Wx::Bitmap::SetPalette

   void SetPalette(const wxPalette& palette)

   Sets the associated palette. (Not implemented under GTK+).

   Parameters

   palette

       The palette to set.

   See also

   wxPalette

=head2 Wx::Bitmap::SetWidth

   void SetWidth(int width)

   Sets the width member (does not affect the bitmap data).

   Parameters

   width

       Bitmap width in pixels.

=head1 Wx::BitmapComboBox

=head2 Wx::BitmapComboBox::new

   wxBitmapComboBox()

   Default constructor.

   wxBitmapComboBox(wxWindow* parent, wxWindowID id, const wxString&
   value = "", const wxPoint& pos = wxDefaultPosition, const wxSize& size
   = wxDefaultSize, int n = 0, const wxString choices[] = NULL, long
   style = 0, const wxValidator& validator = wxDefaultValidator, const
   wxString& name = "comboBox")

   wxBitmapComboBox(wxWindow* parent, wxWindowID id, const wxString&
   value, const wxPoint& pos, const wxSize& size, const wxArrayString&
   choices, long style = 0, const wxValidator& validator =
   wxDefaultValidator, const wxString& name = "comboBox")

   Constructor, creating and showing a combobox.

   Parameters

   parent

       Parent window. Must not be NULL.

   id  

       Window identifier. A value of -1 indicates a default value.

   value

       Initial selection string. An empty string indicates no selection.

   pos 

       Window position.

   size

       Window size. If the default size (-1, -1) is specified then the
       window is sized appropriately.

   n   

       Number of strings with which to initialise the control.

   choices

       An array of strings with which to initialise the control.

   style

       Window style. See wxBitmapComboBox.

   validator

       Window validator.

   name

       Window name.

   See also

   wxBitmapComboBox::Create, wxValidator

=head2 Wx::BitmapComboBox::DESTROY

   ~wxBitmapComboBox()

   Destructor, destroying the combobox.

=head2 Wx::BitmapComboBox::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxString& value =
   "", const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, int n, const wxString choices[], long style = 0, const
   wxValidator& validator = wxDefaultValidator, const wxString& name =
   "comboBox")

   bool Create(wxWindow* parent, wxWindowID id, const wxString& value,
   const wxPoint& pos, const wxSize& size, const wxArrayString& choices,
   long style = 0, const wxValidator& validator = wxDefaultValidator,
   const wxString& name = "comboBox")

   Creates the combobox for two-step construction. Derived classes should
   call or replace this function. See wxBitmapComboBox::wxBitmapComboBox
   for further details.

=head2 Wx::BitmapComboBox::Append

   int Append(const wxString& item, const wxBitmap& bitmap = wxNullBitmap)

   Adds the item to the end of the combo box.

   int Append(const wxString& item, const wxBitmap& bitmap, void *clientData)

   int Append(const wxString& item, const wxBitmap& bitmap, wxClientData
   *clientData)

   Adds the item to the end of the combo box, associating the given,
   typed or untyped, client data pointer with the item.

=head2 Wx::BitmapComboBox::GetBitmapSize

   wxSize GetBitmapSize() const

   Returns size of bitmaps used in the list.

=head2 Wx::BitmapComboBox::GetItemBitmap

   wxBitmap GetItemBitmap(unsigned int n) const

   Returns the bitmap of the item with the given index.

=head2 Wx::BitmapComboBox::Insert

   int Insert(const wxString& item, const wxBitmap& bitmap, unsigned int
   pos)

   Inserts the item into the list before pos. Not valid for wxCB_SORT
   style, use Append instead.

   int Insert(const wxString& item, const wxBitmap& bitmap, unsigned int
   pos, void *clientData)

   int Insert(const wxString& item, const wxBitmap& bitmap, unsigned int
   pos, wxClientData *clientData)

   Inserts the item into the list before pos, associating the given,
   typed or untyped, client data pointer with the item. Not valid for
   wxCB_SORT style, use Append instead.

=head2 Wx::BitmapComboBox::SetItemBitmap

   void SetItemBitmap(unsigned int n, const wxBitmap& bitmap)

   Sets the bitmap for the given item.

=head1 Wx::BitmapButton

=head2 Wx::BitmapButton::new

   wxBitmapButton()

   Default constructor.

   wxBitmapButton( wxWindow* parent, wxWindowID id, const wxBitmap&
   bitmap, const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = wxBU_AUTODRAW, const wxValidator&
   validator = wxDefaultValidator, const wxString& name = "button")

   Constructor, creating and showing a button.

   Parameters

   parent

       Parent window. Must not be NULL.

   id  

       Button identifier. A value of -1 indicates a default value.

   bitmap

       Bitmap to be displayed.

   pos 

       Button position.

   size

       Button size. If the default size (-1, -1) is specified then the
       button is sized appropriately for the bitmap.

   style

       Window style. See wxBitmapButton.

   validator

       Window validator.

   name

       Window name.

   Remarks

   The bitmap parameter is normally the only bitmap you need to provide,
   and wxWidgets will draw the button correctly in its different states.
   If you want more control, call any of the functions
   wxBitmapButton::SetBitmapSelected, wxBitmapButton::SetBitmapFocus,
   wxBitmapButton::SetBitmapDisabled.

   Note that the bitmap passed is smaller than the actual button created.

   See also

   wxBitmapButton::Create, wxValidator

=head2 Wx::BitmapButton::DESTROY

   ~wxBitmapButton()

   Destructor, destroying the button.

=head2 Wx::BitmapButton::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxBitmap& bitmap,
   const wxPoint& pos, const wxSize& size = wxDefaultSize, long style = 0,
   const wxValidator& validator, const wxString& name = "button")

   Button creation function for two-step creation. For more details, see
   wxBitmapButton::wxBitmapButton.

=head2 Wx::BitmapButton::GetBitmapDisabled

   const wxBitmap& GetBitmapDisabled() const wxBitmap& GetBitmapDisabled()

   Returns the bitmap for the disabled state, may be invalid.

   Return value

   A reference to the disabled state bitmap.

   See also

   wxBitmapButton::SetBitmapDisabled

=head2 Wx::BitmapButton::GetBitmapFocus

   const wxBitmap& GetBitmapFocus() const wxBitmap& GetBitmapFocus()

   Returns the bitmap for the focused state, may be invalid.

   Return value

   A reference to the focused state bitmap.

   See also

   wxBitmapButton::SetBitmapFocus

=head2 Wx::BitmapButton::GetBitmapHover

   const wxBitmap& GetBitmapHover() const wxBitmap& GetBitmapHover()

   Returns the bitmap used when the mouse is over the button, may be
   invalid.

   See also

   wxBitmapButton::SetBitmapHover

=head2 Wx::BitmapButton::GetBitmapLabel

   const wxBitmap& GetBitmapLabel() const wxBitmap& GetBitmapLabel()

   Returns the label bitmap (the one passed to the constructor), always
   valid.

   Return value

   A reference to the button's label bitmap.

   See also

   wxBitmapButton::SetBitmapLabel

=head2 Wx::BitmapButton::GetBitmapSelected

   wxBitmap& GetBitmapSelected() const wxBitmap& GetBitmapSelected()

   Returns the bitmap for the pushed button state, may be invalid.

   Return value

   A reference to the selected state bitmap.

   See also

   wxBitmapButton::SetBitmapSelected

=head2 Wx::BitmapButton::SetBitmapDisabled

   void SetBitmapDisabled(const wxBitmap& bitmap)

   Sets the bitmap for the disabled button appearance.

   Parameters

   bitmap

       The bitmap to set.

   See also

   wxBitmapButton::GetBitmapDisabled, wxBitmapButton::SetBitmapLabel,
   wxBitmapButton::SetBitmapSelected, wxBitmapButton::SetBitmapFocus

=head2 Wx::BitmapButton::SetBitmapFocus

   void SetBitmapFocus(const wxBitmap& bitmap)

   Sets the bitmap for the button appearance when it has the keyboard
   focus.

   Parameters

   bitmap

       The bitmap to set.

   See also

   wxBitmapButton::GetBitmapFocus, wxBitmapButton::SetBitmapLabel,
   wxBitmapButton::SetBitmapSelected, wxBitmapButton::SetBitmapDisabled

=head2 Wx::BitmapButton::SetBitmapHover

   void SetBitmapHover(const wxBitmap& bitmap)

   Sets the bitmap to be shown when the mouse is over the button.

   This function is new since wxWidgets version 2.7.0 and the hover
   bitmap is currently only supported in wxMSW.

   See also

   wxBitmapButton::GetBitmapHover

=head2 Wx::BitmapButton::SetBitmapLabel

   void SetBitmapLabel(const wxBitmap& bitmap)

   Sets the bitmap label for the button.

   Parameters

   bitmap

       The bitmap label to set.

   Remarks

   This is the bitmap used for the unselected state, and for all other
   states if no other bitmaps are provided.

   See also

   wxBitmapButton::GetBitmapLabel

=head2 Wx::BitmapButton::SetBitmapSelected

   void SetBitmapSelected(const wxBitmap& bitmap)

   Sets the bitmap for the selected (depressed) button appearance.

   Parameters

   bitmap

       The bitmap to set.

   See also

   wxBitmapButton::GetBitmapSelected, wxBitmapButton::SetBitmapLabel,
   wxBitmapButton::SetBitmapFocus, wxBitmapButton::SetBitmapDisabled

=head1 Wx::BitmapDataObject

=head2 Wx::BitmapDataObject::GetBitmap

   virtual wxBitmap GetBitmap() const

   Returns the bitmap associated with the data object. You may wish to
   override this method when offering data on-demand, but this is not
   required by wxWidgets' internals. Use this method to get data in
   bitmap form from the wxClipboard.

=head2 Wx::BitmapDataObject::SetBitmap

   virtual void SetBitmap(const wxBitmap& bitmap)

   Sets the bitmap associated with the data object. This method is called
   when the data object receives data. Usually there will be no reason to
   override this function.

=head1 Wx::BitmapHandler

=head2 Wx::BitmapHandler::new

   wxBitmapHandler()

   Default constructor. In your own default constructor, initialise the
   members m_name, m_extension and m_type.

=head2 Wx::BitmapHandler::DESTROY

   ~wxBitmapHandler()

   Destroys the wxBitmapHandler object.

=head2 Wx::BitmapHandler::Create

   virtual bool Create(wxBitmap* bitmap, const void* data, int type, int
   width, int height, int depth = -1)

   Creates a bitmap from the given data, which can be of arbitrary type.
   The wxBitmap object bitmap is manipulated by this function.

   Parameters

   bitmap

       The wxBitmap object.

   width

       The width of the bitmap in pixels.

   height

       The height of the bitmap in pixels.

   depth

       The depth of the bitmap in pixels. If this is -1, the screen depth
       is used.

   data

       Data whose type depends on the value of type.

   type

       A bitmap type identifier - see wxBitmapHandler::wxBitmapHandler
       for a list of possible values.

   Return value

   true if the call succeeded, false otherwise (the default).

=head2 Wx::BitmapHandler::GetName

   const wxString& GetName() const

   Gets the name of this handler.

=head2 Wx::BitmapHandler::GetExtension

   const wxString& GetExtension() const

   Gets the file extension associated with this handler.

=head2 Wx::BitmapHandler::GetType

   long GetType() const

   Gets the bitmap type associated with this handler.

=head2 Wx::BitmapHandler::LoadFile

   bool LoadFile(wxBitmap* bitmap, const wxString& name, long type)

   Loads a bitmap from a file or resource, putting the resulting data
   into bitmap.

   Parameters

   bitmap

       The bitmap object which is to be affected by this operation.

   name

       Either a filename or a Windows resource name. The meaning of name
       is determined by the type parameter.

   type

       See wxBitmap::wxBitmap for values this can take.

   Return value

   true if the operation succeeded, false otherwise.

   See also

   wxBitmap::LoadFile

=head2 Wx::BitmapHandler::SaveFile

   bool SaveFile(wxBitmap* bitmap, const wxString& name, int type,
   wxPalette* palette = NULL)

   Saves a bitmap in the named file.

   Parameters

   bitmap

       The bitmap object which is to be affected by this operation.

   name

       A filename. The meaning of name is determined by the type
       parameter.

   type

       See wxBitmap::wxBitmap for values this can take.

   palette

       An optional palette used for saving the bitmap.

   Return value

   true if the operation succeeded, false otherwise.

   See also

   wxBitmap::LoadFile

=head2 Wx::BitmapHandler::SetName

   void SetName(const wxString& name)

   Sets the handler name.

   Parameters

   name

       Handler name.

=head2 Wx::BitmapHandler::SetExtension

   void SetExtension(const wxString& extension)

   Sets the handler extension.

   Parameters

   extension

       Handler extension.

=head2 Wx::BitmapHandler::SetType

   void SetType(long type)

   Sets the handler type.

   Parameters

   name

       Handler type.

=head1 Wx::BoxSizer

=head2 Wx::BoxSizer::new

   wxBoxSizer(int orient)

   Constructor for a wxBoxSizer. orient may be either of wxVERTICAL or
   wxHORIZONTAL for creating either a column sizer or a row sizer.

=head2 Wx::BoxSizer::RecalcSizes

   void RecalcSizes()

   Implements the calculation of a box sizer's dimensions and then sets
   the size of its children (calling wxWindow::SetSize if the child is a
   window). It is used internally only and must not be called by the
   user. Documented for information.

=head2 Wx::BoxSizer::CalcMin

   wxSize CalcMin()

   Implements the calculation of a box sizer's minimal. It is used
   internally only and must not be called by the user. Documented for
   information.

=head2 Wx::BoxSizer::GetOrientation

   int GetOrientation()

   Returns the orientation of the box sizer, either wxVERTICAL or
   wxHORIZONTAL.

=head1 Wx::Brush

=head2 Wx::Brush::new

   wxBrush()

   Default constructor. The brush will be uninitialised, and wxBrush:IsOk
   will return false.

   wxBrush(const wxColour& colour, int style = wxSOLID)

   Constructs a brush from a colour object and style.

   wxBrush(const wxString& colourName, int style)

   Constructs a brush from a colour name and style.

   wxBrush(const wxBitmap& stippleBitmap)

   Constructs a stippled brush using a bitmap.

   wxBrush(const wxBrush& brush)

   Copy constructor, uses reference counting.

   Parameters

   colour

       Colour object.

   colourName

       Colour name. The name will be looked up in the colour database.

   style

       One of:

=head2 Wx::Brush::DESTROY

   ~wxBrush()

   Destructor. See reference-counted object destruction for more info.

   Remarks

   Although all remaining brushes are deleted when the application exits,
   the application should try to clean up all brushes itself. This is
   because wxWidgets cannot know if a pointer to the brush object is
   stored in an application data structure, and there is a risk of double
   deletion.

=head2 Wx::Brush::GetColour

   wxColour& GetColour() const

   Returns a reference to the brush colour.

   See also

   wxBrush::SetColour

=head2 Wx::Brush::GetStipple

   wxBitmap * GetStipple() const

   Gets a pointer to the stipple bitmap. If the brush does not have a
   wxSTIPPLE style, this bitmap may be non-NULL but uninitialised (wxBitmap:IsOk
   returns false).

   See also

   wxBrush::SetStipple

=head2 Wx::Brush::GetStyle

   int GetStyle() const

   Returns the brush style, one of:

=head2 Wx::Brush::IsHatch

   bool IsHatch() const

   Returns true if the style of the brush is any of hatched fills.

   See also

   wxBrush::GetStyle

=head2 Wx::Brush::IsOk

   bool IsOk() const

   Returns true if the brush is initialised. It will return false if the
   default constructor has been used (for example, the brush is a member
   of a class, or NULL has been assigned to it).

=head2 Wx::Brush::SetColour

   void SetColour(wxColour& colour)

   Sets the brush colour using a reference to a colour object.

   void SetColour(const wxString& colourName)

   Sets the brush colour using a colour name from the colour database.

   void SetColour(unsigned char red, unsigned char green, unsigned char
   blue)

   Sets the brush colour using red, green and blue values.

   See also

   wxBrush::GetColour

=head2 Wx::Brush::SetStipple

   void SetStipple(const wxBitmap& bitmap)

   Sets the stipple bitmap.

   Parameters

   bitmap

       The bitmap to use for stippling.

   Remarks

   The style will be set to wxSTIPPLE, unless the bitmap has a mask
   associated to it, in which case the style will be set to
   wxSTIPPLE_MASK_OPAQUE.

   If the wxSTIPPLE variant is used, the bitmap will be used to fill out
   the area to be drawn. If the wxSTIPPLE_MASK_OPAQUE is used, the
   current text foreground and text background determine what colours are
   used for displaying and the bits in the mask (which is a mono-bitmap
   actually) determine where to draw what.

   Note that under Windows 95, only 8x8 pixel large stipple bitmaps are
   supported, Windows 98 and NT as well as GTK support arbitrary bitmaps.

   See also

   wxBitmap

=head2 Wx::Brush::SetStyle

   void SetStyle(int style)

   Sets the brush style.

   style

       One of:

=head1 Wx::BrushList

=head2 Wx::BrushList::new

   void wxBrushList()

   Constructor. The application should not construct its own brush list:
   use the object pointer wxTheBrushList.

=head2 Wx::BrushList::FindOrCreateBrush

   wxBrush * FindOrCreateBrush(const wxColour& colour, int style =
   wxSOLID)

   Finds a brush with the specified attributes and returns it, else
   creates a new brush, adds it to the brush list, and returns it.

   Parameters

   colour

       Colour object.

   style

       Brush style. See wxBrush::SetStyle for a list of styles.

=head1 Wx::BufferedDC

=head2 Wx::BufferedDC::new

   wxBufferedDC()

   wxBufferedDC(wxDC *dc, const wxSize& area, int style =
   wxBUFFER_CLIENT_AREA)

   wxBufferedDC(wxDC *dc, wxBitmap& buffer, int style =
   wxBUFFER_CLIENT_AREA)

   If you use the first, default, constructor, you must call one of the
   Init methods later in order to use the object.

   The other constructors initialize the object immediately and Init()
   must not be called after using them.

   Parameters

   dc  

       The underlying DC: everything drawn to this object will be flushed
       to this DC when this object is destroyed. You may pass NULL in
       order to just initialize the buffer, and not flush it.

   area

       The size of the bitmap to be used for buffering (this bitmap is
       created internally when it is not given explicitly).

   buffer

       Explicitly provided bitmap to be used for buffering: this is the
       most efficient solution as the bitmap doesn't have to be recreated
       each time but it also requires more memory as the bitmap is never
       freed. The bitmap should have appropriate size, anything drawn
       outside of its bounds is clipped.

   style

       wxBUFFER_CLIENT_AREA to indicate that just the client area of the
       window is buffered, or wxBUFFER_VIRTUAL_AREA to indicate that the
       buffer bitmap covers the virtual area (in which case PrepareDC is
       automatically called for the actual window device context).

=head2 Wx::BufferedDC::Init

   void Init(wxDC *dc, const wxSize& area, int style =
   wxBUFFER_CLIENT_AREA)

   void Init(wxDC *dc, wxBitmap& buffer, int style = wxBUFFER_CLIENT_AREA)

   These functions initialize the object created using the default
   constructor. Please see constructors documentation for details.

=head2 Wx::BufferedDC::DESTROY

   Copies everything drawn on the DC so far to the underlying DC
   associated with this object, if any.

=head1 Wx::BufferedPaintDC

=head2 Wx::BufferedPaintDC::new

   wxBufferedPaintDC(wxWindow *window, wxBitmap& buffer, int style =
   wxBUFFER_CLIENT_AREA)

   wxBufferedPaintDC(wxWindow *window, int style = wxBUFFER_CLIENT_AREA)

   As with wxBufferedDC, you may either provide the bitmap to be used for
   buffering or let this object create one internally (in the latter
   case, the size of the client part of the window is used).

   Pass wxBUFFER_CLIENT_AREA for the style parameter to indicate that
   just the client area of the window is buffered, or
   wxBUFFER_VIRTUAL_AREA to indicate that the buffer bitmap covers the
   virtual area (in which case PrepareDC is automatically called for the
   actual window device context).

=head2 Wx::BufferedPaintDC::DESTROY

   Copies everything drawn on the DC so far to the window associated with
   this object, using a wxPaintDC.

=head1 Wx::AutoBufferedPaintDC

=head2 Wx::AutoBufferedPaintDC::new

   wxAutoBufferedPaintDC(wxWindow *window)

   Constructor. Pass a pointer to the window on which you wish to paint.

=head1 Wx::BufferedOutputStream

=head2 Wx::BufferedOutputStream::new

   wxBufferedOutputStream(const wxOutputStream& parent)

   Creates a buffered stream using a buffer of a default size of 1024
   bytes for cashing the stream parent.

=head2 Wx::BufferedOutputStream::DESTROY

   ~wxBufferedOutputStream()

   Destructor. Calls Sync() and destroys the internal buffer.

=head2 Wx::BufferedOutputStream::SeekO

   off_t SeekO(off_t pos, wxSeekMode mode)

   Calls Sync() and changes the stream position.

=head2 Wx::BufferedOutputStream::Sync

   void Sync()

   Flushes the buffer and calls Sync() on the parent stream.

=head1 Wx::BusyCursor

=head2 Wx::BusyCursor::new

   wxBusyCursor(wxCursor* cursor = wxHOURGLASS_CURSOR)

   Constructs a busy cursor object, calling wxBeginBusyCursor.

=head2 Wx::BusyCursor::DESTROY

   ~wxBusyCursor()

   Destroys the busy cursor object, calling wxEndBusyCursor.

=head1 Wx::BusyInfo

=head2 Wx::BusyInfo::new

   wxBusyInfo(const wxString& msg, wxWindow* parent = NULL)

   Constructs a busy info window as child of parent and displays msg in
   it.

   NB: If parent is not NULL you must ensure that it is not closed while
   the busy info is shown.

=head2 Wx::BusyInfo::DESTROY

   ~wxBusyInfo()

   Hides and closes the window containing the information text.

=head1 Wx::Button

=head2 Wx::Button::new

   wxButton()

   Default constructor.

   wxButton(wxWindow* parent, wxWindowID id, const wxString& label =
   wxEmptyString, const wxPoint& pos = wxDefaultPosition, const wxSize&
   size = wxDefaultSize, long style = 0, const wxValidator& validator =
   wxDefaultValidator, const wxString& name = "button")

   Constructor, creating and showing a button.

   The preferred way to create standard buttons is to use default value
   of label. If no label is supplied and id is one of standard IDs from
   this list, standard label will be used. In addition to that, the
   button will be decorated with stock icons under GTK+ 2.

   Parameters

   parent

       Parent window. Must not be NULL.

   id  

       Button identifier. A value of wxID_ANY indicates a default value.

   label

       Text to be displayed on the button.

   pos 

       Button position.

   size

       Button size. If the default size is specified then the button is
       sized appropriately for the text.

   style

       Window style. See wxButton.

   validator

       Window validator.

   name

       Window name.

   See also

   wxButton::Create, wxValidator

=head2 Wx::Button::DESTROY

   ~wxButton()

   Destructor, destroying the button.

=head2 Wx::Button::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxString& label =
   wxEmptyString, const wxPoint& pos = wxDefaultPosition, const wxSize&
   size = wxDefaultSize, long style = 0, const wxValidator& validator,
   const wxString& name = "button")

   Button creation function for two-step creation. For more details, see
   wxButton::wxButton.

=head2 Wx::Button::GetLabel

   wxString GetLabel() const

   Returns the string label for the button.

   Return value

   The button's label.

   See also

   wxButton::SetLabel

=head2 Wx::Button::GetDefaultSize

   wxSize GetDefaultSize()

   Returns the default size for the buttons. It is advised to make all
   the dialog buttons of the same size and this function allows to
   retrieve the (platform and current font dependent size) which should
   be the best suited for this.

=head2 Wx::Button::SetDefault

   void SetDefault()

   This sets the button to be the default item for the panel or dialog
   box.

   Remarks

   Under Windows, only dialog box buttons respond to this function. As
   normal under Windows and Motif, pressing return causes the default
   button to be depressed when the return key is pressed. See also
   wxWindow::SetFocus which sets the keyboard focus for windows and text
   panel items, and wxTopLevelWindow::SetDefaultItem.

   Note that under Motif, calling this function immediately after
   creation of a button and before the creation of other buttons will
   cause misalignment of the row of buttons, since default buttons are
   larger. To get around this, call SetDefault after you have created a
   row of buttons: wxWidgets will then set the size of all buttons
   currently on the panel to the same size.

=head2 Wx::Button::SetLabel

   void SetLabel(const wxString& label)

   Sets the string label for the button.

   Parameters

   label

       The label to set.

   See also

   wxButton::GetLabel

=head1 Wx::CalculateLayoutEvent

=head2 Wx::CalculateLayoutEvent::new

   wxCalculateLayoutEvent(wxWindowID id = 0)

   Constructor.

=head2 Wx::CalculateLayoutEvent::GetFlags

   int GetFlags() const

   Returns the flags associated with this event. Not currently used.

=head2 Wx::CalculateLayoutEvent::GetRect

   wxRect GetRect() const

   Before the event handler is entered, returns the remaining parent
   client area that the window could occupy. When the event handler
   returns, this should contain the remaining parent client rectangle,
   after the event handler has subtracted the area that its window
   occupies.

=head2 Wx::CalculateLayoutEvent::SetFlags

   void SetFlags(int flags)

   Sets the flags associated with this event. Not currently used.

=head2 Wx::CalculateLayoutEvent::SetRect

   void SetRect(const wxRect& rect)

   Call this to specify the new remaining parent client area, after the
   space occupied by the window has been subtracted.

=head1 Wx::CalendarCtrl

=head2 Wx::CalendarCtrl::new

   wxCalendarCtrl()

   Default constructor, use Create after it.

   wxCalendarCtrl(wxWindow* parent, wxWindowID id, const wxDateTime& date
   = wxDefaultDateTime, const wxPoint& pos = wxDefaultPosition, const
   wxSize& size = wxDefaultSize, long style = wxCAL_SHOW_HOLIDAYS, const
   wxString& name = wxCalendarNameStr)

   Does the same as Create method.

=head2 Wx::CalendarCtrl::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxDateTime& date =
   wxDefaultDateTime, const wxPoint& pos = wxDefaultPosition, const
   wxSize& size = wxDefaultSize, long style = wxCAL_SHOW_HOLIDAYS, const
   wxString& name = wxCalendarNameStr)

   Creates the control. See wxWindow for the meaning of the parameters
   and the control overview for the possible styles.

=head2 Wx::CalendarCtrl::DESTROY

   ~wxCalendarCtrl()

   Destroys the control.

=head2 Wx::CalendarCtrl::SetDate

   void SetDate(const wxDateTime& date)

   Sets the current date.

=head2 Wx::CalendarCtrl::GetDate

   const wxDateTime& GetDate() const

   Gets the currently selected date.

=head2 Wx::CalendarCtrl::EnableYearChange

   void EnableYearChange(bool enable = true)

   This function should be used instead of changing wxCAL_NO_YEAR_CHANGE
   style bit directly. It allows or disallows the user to change the year
   interactively.

=head2 Wx::CalendarCtrl::EnableMonthChange

   void EnableMonthChange(bool enable = true)

   This function should be used instead of changing wxCAL_NO_MONTH_CHANGE
   style bit. It allows or disallows the user to change the month
   interactively. Note that if the month can not be changed, the year can
   not be changed neither.

=head2 Wx::CalendarCtrl::EnableHolidayDisplay

   void EnableHolidayDisplay(bool display = true)

   This function should be used instead of changing wxCAL_SHOW_HOLIDAYS
   style bit directly. It enables or disables the special highlighting of
   the holidays.

=head2 Wx::CalendarCtrl::SetHeaderColours

   void SetHeaderColours(const wxColour& colFg, const wxColour& colBg)

   Set the colours used for painting the weekdays at the top of the
   control.

=head2 Wx::CalendarCtrl::GetHeaderColourFg

   const wxColour& GetHeaderColourFg() const

   Gets the foreground colour of the header part of the calendar window.

   See also

   SetHeaderColours

=head2 Wx::CalendarCtrl::GetHeaderColourBg

   const wxColour& GetHeaderColourBg() const

   Gets the background colour of the header part of the calendar window.

   See also

   SetHeaderColours

=head2 Wx::CalendarCtrl::SetHighlightColours

   void SetHighlightColours(const wxColour& colFg, const wxColour& colBg)

   Set the colours to be used for highlighting the currently selected
   date.

=head2 Wx::CalendarCtrl::GetHighlightColourFg

   const wxColour& GetHighlightColourFg() const

   Gets the foreground highlight colour.

   See also

   SetHighlightColours

=head2 Wx::CalendarCtrl::GetHighlightColourBg

   const wxColour& GetHighlightColourBg() const

   Gets the background highlight colour.

   See also

   SetHighlightColours

=head2 Wx::CalendarCtrl::SetHolidayColours

   void SetHolidayColours(const wxColour& colFg, const wxColour& colBg)

   Sets the colours to be used for the holidays highlighting (only used
   if the window style includes wxCAL_SHOW_HOLIDAYS flag).

=head2 Wx::CalendarCtrl::GetHolidayColourFg

   const wxColour& GetHolidayColourFg() const

   Return the foreground colour currently used for holiday highlighting.

   See also

   SetHolidayColours

=head2 Wx::CalendarCtrl::GetHolidayColourBg

   const wxColour& GetHolidayColourBg() const

   Return the background colour currently used for holiday highlighting.

   See also

   SetHolidayColours

=head2 Wx::CalendarCtrl::GetAttr

   wxCalendarDateAttr * GetAttr(size_t day) const

   Returns the attribute for the given date (should be in the range
   1...31).

   The returned pointer may be NULL.

=head2 Wx::CalendarCtrl::SetAttr

   void SetAttr(size_t day, wxCalendarDateAttr* attr)

   Associates the attribute with the specified date (in the range
   1...31).

   If the pointer is NULL, the items attribute is cleared.

=head2 Wx::CalendarCtrl::SetHoliday

   void SetHoliday(size_t day)

   Marks the specified day as being a holiday in the current month.

=head2 Wx::CalendarCtrl::ResetAttr

   void ResetAttr(size_t day)

   Clears any attributes associated with the given day (in the range
   1...31).

=head2 Wx::CalendarCtrl::HitTest

   wxCalendarHitTestResult HitTest(const wxPoint& pos, wxDateTime* date =
   NULL, wxDateTime::WeekDay* wd = NULL)

   Returns one of wxCAL_HITTEST_XXX constants and fills either date or wd
   pointer with the corresponding value depending on the hit test code.

=head1 Wx::CalendarDateAttr

=head2 Wx::CalendarDateAttr::new

   wxCalendarDateAttr()

   wxCalendarDateAttr(const wxColour& colText, const wxColour& colBack =
   wxNullColour, const wxColour& colBorder = wxNullColour, const wxFont&
   font = wxNullFont, wxCalendarDateBorder border = wxCAL_BORDER_NONE)

   wxCalendarDateAttr(wxCalendarDateBorder border, const wxColour&
   colBorder = wxNullColour)

   The constructors.

=head2 Wx::CalendarDateAttr::SetTextColour

   void SetTextColour(const wxColour& colText)

   Sets the text (foreground) colour to use.

=head2 Wx::CalendarDateAttr::SetBackgroundColour

   void SetBackgroundColour(const wxColour& colBack)

   Sets the text background colour to use.

=head2 Wx::CalendarDateAttr::SetBorderColour

   void SetBorderColour(const wxColour& col)

   Sets the border colour to use.

=head2 Wx::CalendarDateAttr::SetFont

   void SetFont(const wxFont& font)

   Sets the font to use.

=head2 Wx::CalendarDateAttr::SetBorder

   void SetBorder(wxCalendarDateBorder border)

   Sets the border kind

=head2 Wx::CalendarDateAttr::SetHoliday

   void SetHoliday(bool holiday)

   Display the date with this attribute as a holiday.

=head2 Wx::CalendarDateAttr::HasTextColour

   bool HasTextColour() const

   Returns true if this item has a non-default text foreground colour.

=head2 Wx::CalendarDateAttr::HasBackgroundColour

   bool HasBackgroundColour() const

   Returns true if this attribute specifies a non-default text background
   colour.

=head2 Wx::CalendarDateAttr::HasBorderColour

   bool HasBorderColour() const

   Returns true if this attribute specifies a non-default border colour.

=head2 Wx::CalendarDateAttr::HasFont

   bool HasFont() const

   Returns true if this attribute specifies a non-default font.

=head2 Wx::CalendarDateAttr::HasBorder

   bool HasBorder() const

   Returns true if this attribute specifies a non-default (i.e. any)
   border.

=head2 Wx::CalendarDateAttr::IsHoliday

   bool IsHoliday() const

   Returns true if this attribute specifies that this item should be
   displayed as a holiday.

=head2 Wx::CalendarDateAttr::GetTextColour

   const wxColour& GetTextColour() const

   Returns the text colour to use for the item with this attribute.

=head2 Wx::CalendarDateAttr::GetBackgroundColour

   const wxColour& GetBackgroundColour() const

   Returns the background colour to use for the item with this attribute.

=head2 Wx::CalendarDateAttr::GetBorderColour

   const wxColour& GetBorderColour() const

   Returns the border colour to use for the item with this attribute.

=head2 Wx::CalendarDateAttr::GetFont

   const wxFont& GetFont() const

   Returns the font to use for the item with this attribute.

=head2 Wx::CalendarDateAttr::GetBorder

   wxCalendarDateBorder GetBorder() const

   Returns the border to use for the item with this attribute.

=head1 Wx::CalendarEvent

=head2 Wx::CalendarEvent::GetWeekDay

   wxDateTime::WeekDay GetWeekDay() const

   Returns the week day on which the user clicked in
   EVT_CALENDAR_WEEKDAY_CLICKED handler. It doesn't make sense to call
   this function in other handlers.

=head2 Wx::CalendarEvent::SetWeekDay

   void SetWeekDay(wxDateTime::WeekDay day)

   Sets the week day carried by the event, normally only used by the
   library internally.

=head1 Wx::Caret

=head2 Wx::Caret::new

   wxCaret()

   Default constructor: you must use one of Create() functions later.

   wxCaret(wxWindow* window, int width, int height)

   wxCaret(wxWindowBase* window, const wxSize& size)

   Create the caret of given (in pixels) width and height and associates
   it with the given window.

=head2 Wx::Caret::Create

   bool Create(wxWindowBase* window, int width, int height)

   bool Create(wxWindowBase* window, const wxSize& size)

   Create the caret of given (in pixels) width and height and associates
   it with the given window (same as constructor).

=head2 Wx::Caret::GetBlinkTime

   static int GetBlinkTime()

   Returns the blink time which is measured in milliseconds and is the
   time elapsed between 2 inversions of the caret (blink time of the
   caret is the same for all carets, so this functions is static).

=head2 Wx::Caret::GetPosition

   void GetPosition(int* x, int* y) const

   wxPoint GetPosition() const

   Get the caret position (in pixels).

   wxPerl note: In wxPerl there are two methods instead of a single
   overloaded method:

=head2 Wx::Caret::GetSize

   void GetSize(int* width, int* height) const

   wxSize GetSize() const

   Get the caret size.

   wxPerl note: In wxPerl there are two methods instead of a single
   overloaded method:

=head2 Wx::Caret::GetWindow

   wxWindow* GetWindow() const

   Get the window the caret is associated with.

=head2 Wx::Caret::Hide

   void Hide()

   Same as wxCaret::Show(false).

=head2 Wx::Caret::IsOk

   bool IsOk() const

   Returns true if the caret was created successfully.

=head2 Wx::Caret::IsVisible

   bool IsVisible() const

   Returns true if the caret is visible and false if it is permanently
   hidden (if it is is blinking and not shown currently but will be after
   the next blink, this method still returns true).

=head2 Wx::Caret::Move

   void Move(int x, int y)

   void Move(const wxPoint& pt)

   Move the caret to given position (in logical coordinates).

=head2 Wx::Caret::SetBlinkTime

   static void SetBlinkTime(int milliseconds)

   Sets the blink time for all the carets.

   Remarks

   Under Windows, this function will change the blink time for all carets
   permanently (until the next time it is called), even for the carets in
   other applications.

   See also

   GetBlinkTime

=head2 Wx::Caret::SetSize

   void SetSize(int width, int height)

   void SetSize(const wxSize& size)

   Changes the size of the caret.

=head2 Wx::Caret::Show

   void Show(bool show = true)

   Shows or hides the caret. Notice that if the caret was hidden N times,
   it must be shown N times as well to reappear on the screen.

=head1 Wx::CheckBox

=head2 Wx::CheckBox::new

   wxCheckBox()

   Default constructor.

   wxCheckBox(wxWindow* parent, wxWindowID id, const wxString& label,
   const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = 0, const wxValidator& val, const wxString&
   name = "checkBox")

   Constructor, creating and showing a checkbox.

   Parameters

   parent

       Parent window. Must not be NULL.

   id  

       Checkbox identifier. A value of -1 indicates a default value.

   label

       Text to be displayed next to the checkbox.

   pos 

       Checkbox position. If the position (-1, -1) is specified then a
       default position is chosen.

   size

       Checkbox size. If the default size (-1, -1) is specified then a
       default size is chosen.

   style

       Window style. See wxCheckBox.

   validator

       Window validator.

   name

       Window name.

   See also

   wxCheckBox::Create, wxValidator

=head2 Wx::CheckBox::DESTROY

   ~wxCheckBox()

   Destructor, destroying the checkbox.

=head2 Wx::CheckBox::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxString& label,
   const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = 0, const wxValidator& val, const wxString&
   name = "checkBox")

   Creates the checkbox for two-step construction. See
   wxCheckBox::wxCheckBox for details.

=head2 Wx::CheckBox::GetValue

   bool GetValue() const

   Gets the state of a 2-state checkbox.

   Return value

   Returns true if it is checked, false otherwise.

=head2 Wx::CheckBox::Get3StateValue

   wxCheckBoxState Get3StateValue() const

   Gets the state of a 3-state checkbox.

   Return value

   Returns wxCHK_UNCHECKED when the checkbox is unchecked, wxCHK_CHECKED
   when it is checked and wxCHK_UNDETERMINED when it's in the
   undetermined state. Asserts when the function is used with a 2-state
   checkbox.

=head2 Wx::CheckBox::Is3rdStateAllowedForUser

   bool Is3rdStateAllowedForUser() const

   Returns whether or not the user can set the checkbox to the third
   state.

   Return value

   Returns true if the user can set the third state of this checkbox,
   false if it can only be set programmatically or if it's a 2-state
   checkbox.

=head2 Wx::CheckBox::Is3State

   bool Is3State() const

   Returns whether or not the checkbox is a 3-state checkbox.

   Return value

   Returns true if this checkbox is a 3-state checkbox, false if it's a
   2-state checkbox.

=head2 Wx::CheckBox::IsChecked

   bool IsChecked() const

   This is just a maybe more readable synonym for GetValue: just as the
   latter, it returns true if the checkbox is checked and false
   otherwise.

=head2 Wx::CheckBox::SetValue

   void SetValue(bool state)

   Sets the checkbox to the given state. This does not cause a
   wxEVT_COMMAND_CHECKBOX_CLICKED event to get emitted.

   Parameters

   state

       If true, the check is on, otherwise it is off.

=head2 Wx::CheckBox::Set3StateValue

   void Set3StateValue(const wxCheckBoxState state)

   Sets the checkbox to the given state. This does not cause a
   wxEVT_COMMAND_CHECKBOX_CLICKED event to get emitted.

   Parameters

   state

       Can be one of: wxCHK_UNCHECKED (Check is off), wxCHK_CHECKED
       (Check is on) or wxCHK_UNDETERMINED (Check is mixed). Asserts when
       the checkbox is a 2-state checkbox and setting the state to
       wxCHK_UNDETERMINED.

=head1 Wx::CheckListBox

=head2 Wx::CheckListBox::new

   wxCheckListBox()

   Default constructor.

   wxCheckListBox(wxWindow* parent, wxWindowID id, const wxPoint& pos =
   wxDefaultPosition, const wxSize& size = wxDefaultSize, int n, const
   wxString choices[] = NULL, long style = 0, const wxValidator&
   validator = wxDefaultValidator, const wxString& name = "listBox")

   wxCheckListBox(wxWindow* parent, wxWindowID id, const wxPoint& pos,
   const wxSize& size, const wxArrayString& choices, long style = 0,
   const wxValidator& validator = wxDefaultValidator, const wxString&
   name = "listBox")

   Constructor, creating and showing a list box.

   Parameters

   parent

       Parent window. Must not be NULL.

   id  

       Window identifier. A value of -1 indicates a default value.

   pos 

       Window position.

   size

       Window size. If the default size (-1, -1) is specified then the
       window is sized appropriately.

   n   

       Number of strings with which to initialise the control.

   choices

       An array of strings with which to initialise the control.

   style

       Window style. See wxCheckListBox.

   validator

       Window validator.

   name

       Window name.

   wxPython note: The wxCheckListBox constructor in wxPython reduces the
   n and choices arguments are to a single argument, which is a list of
   strings.

   wxPerl note: In wxPerl there is just an array reference in place of n
   and choices.

=head2 Wx::CheckListBox::DESTROY

   void ~wxCheckListBox()

   Destructor, destroying the list box.

=head2 Wx::CheckListBox::Check

   void Check(int item, bool check = true)

   Checks the given item. Note that calling this method doesn't result in
   wxEVT_COMMAND_CHECKLISTBOX_TOGGLE being emitted.

   Parameters

   item

       Index of item to check.

   check

       true if the item is to be checked, false otherwise.

=head2 Wx::CheckListBox::IsChecked

   bool IsChecked(unsigned int item) const

   Returns true if the given item is checked, false otherwise.

   Parameters

   item

       Index of item whose check status is to be returned.

=head1 Wx::Choice

=head2 Wx::Choice::new

   wxChoice()

   Default constructor.

   wxChoice(wxWindow *parent, wxWindowID id, const wxPoint& pos, const
   wxSize& size, int n, const wxString choices[], long style = 0, const
   wxValidator& validator = wxDefaultValidator, const wxString& name =
   "choice")

   wxChoice(wxWindow *parent, wxWindowID id, const wxPoint& pos, const
   wxSize& size, const wxArrayString& choices, long style = 0, const
   wxValidator& validator = wxDefaultValidator, const wxString& name =
   "choice")

   Constructor, creating and showing a choice.

   Parameters

   parent

       Parent window. Must not be NULL.

   id  

       Window identifier. A value of -1 indicates a default value.

   pos 

       Window position.

   size

       Window size. If the default size (-1, -1) is specified then the
       choice is sized appropriately.

   n   

       Number of strings with which to initialise the choice control.

   choices

       An array of strings with which to initialise the choice control.

   style

       Window style. See wxChoice.

   validator

       Window validator.

   name

       Window name.

   See also

   wxChoice::Create, wxValidator

   wxPython note: The wxChoice constructor in wxPython reduces the n and
   choices arguments are to a single argument, which is a list of
   strings.

   wxPerl note: In wxPerl there is just an array reference in place of n
   and choices.

=head2 Wx::Choice::DESTROY

   ~wxChoice()

   Destructor, destroying the choice item.

=head2 Wx::Choice::Create

   bool Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const
   wxSize& size, int n, const wxString choices[], long style = 0, const
   wxValidator& validator = wxDefaultValidator, const wxString& name =
   "choice")

   bool Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const
   wxSize& size, const wxArrayString& choices, long style = 0, const
   wxValidator& validator = wxDefaultValidator, const wxString& name =
   "choice")

   Creates the choice for two-step construction. See wxChoice::wxChoice.

=head2 Wx::Choice::GetColumns

   int GetColumns() const

   Gets the number of columns in this choice item.

   Remarks

   This is implemented for Motif only and always returns 1 for the other
   platforms.

=head2 Wx::Choice::GetCurrentSelection

   int GetCurrentSelection() const

   Unlike GetSelection which only returns the accepted selection value,
   i.e. the selection in the control once the user closes the dropdown
   list, this function returns the current selection. That is, while the
   dropdown list is shown, it returns the currently selected item in it.
   When it is not shown, its result is the same as for the other
   function.

   This function is new since wxWidgets version 2.6.2 (before this
   version GetSelection itself behaved like this).

=head2 Wx::Choice::SetColumns

   void SetColumns(int n = 1)

   Sets the number of columns in this choice item.

   Parameters

   n   

       Number of columns.

   Remarks

   This is implemented for Motif only and doesn't do anything under other
   platforms.

=head1 Wx::ClassInfo

=head2 Wx::ClassInfo::new

   wxClassInfo(const wxChar * className, const wxClassInfo * baseClass1,
   const wxClassInfo * baseClass2, int size, wxObjectConstructorFn fn)

   Constructs a wxClassInfo object. The supplied macros implicitly
   construct objects of this class, so there is no need to create such
   objects explicitly in an application.

=head2 Wx::ClassInfo::CreateObject

   wxObject* CreateObject() const

   Creates an object of the appropriate kind. Returns NULL if the class
   has not been declared dynamically creatable (typically, it is an
   abstract class).

=head2 Wx::ClassInfo::FindClass

   static wxClassInfo * FindClass(wxChar * name)

   Finds the wxClassInfo object for a class of the given string name.

=head2 Wx::ClassInfo::GetBaseClassName1

   wxChar * GetBaseClassName1() const

   Returns the name of the first base class (NULL if none).

=head2 Wx::ClassInfo::GetBaseClassName2

   wxChar * GetBaseClassName2() const

   Returns the name of the second base class (NULL if none).

=head2 Wx::ClassInfo::GetClassName

   wxChar * GetClassName() const

   Returns the string form of the class name.

=head2 Wx::ClassInfo::GetSize

   int GetSize() const

   Returns the size of the class.

=head2 Wx::ClassInfo::InitializeClasses

   static void InitializeClasses()

   Initializes pointers in the wxClassInfo objects for fast execution of
   IsKindOf. Called in base wxWidgets library initialization.

=head2 Wx::ClassInfo::IsDynamic

   bool IsDynamic() const

   Returns true if this class info can create objects of the associated
   class.

=head2 Wx::ClassInfo::IsKindOf

   bool IsKindOf(wxClassInfo* info)

   Returns true if this class is a kind of (inherits from) the given
   class.

=head1 Wx::Client

=head2 Wx::Client::new

   wxClient()

   Constructs a client object.

=head2 Wx::Client::MakeConnection

   wxConnectionBase * MakeConnection(const wxString& host, const wxString&
   service, const wxString& topic)

   Tries to make a connection with a server by host (machine name under
   UNIX - use 'localhost' for same machine; ignored when using native DDE
   in Windows), service name and topic string. If the server allows a
   connection, a wxConnection object will be returned. The type of
   wxConnection returned can be altered by overriding the
   wxClient::OnMakeConnection member to return your own derived
   connection object.

   Under Unix, the service name may be either an integer port identifier
   in which case an Internet domain socket will be used for the
   communications, or a valid file name (which shouldn't exist and will
   be deleted afterwards) in which case a Unix domain socket is created.

   SECURITY NOTE: Using Internet domain sockets if extremely insecure for
   IPC as there is absolutely no access control for them, use Unix domain
   sockets whenever possible!

=head2 Wx::Client::OnMakeConnection

   wxConnectionBase * OnMakeConnection()

   Called by wxClient::MakeConnection, by default this simply returns a
   new wxConnection object. Override this method to return a wxConnection
   descendant customised for the application.

   The advantage of deriving your own connection class is that it will
   enable you to intercept messages initiated by the server, such as
   wxConnection::OnAdvise. You may also want to store
   application-specific data in instances of the new class.

=head2 Wx::Client::ValidHost

   bool ValidHost(const wxString& host)

   Returns true if this is a valid host name, false otherwise. This
   always returns true under MS Windows.

=head1 Wx::ClientDC

=head2 Wx::ClientDC::new

   wxClientDC(wxWindow* window)

   Constructor. Pass a pointer to the window on which you wish to paint.

=head1 Wx::ClientData

=head2 Wx::ClientData::new

   wxClientData()

   Constructor.

=head2 Wx::ClientData::DESTROY

   ~wxClientData()

   Virtual destructor.

=head1 Wx::ClientDataContainer

=head2 Wx::ClientDataContainer::new

   wxClientDataContainer()

=head2 Wx::ClientDataContainer::DESTROY

   ~wxClientDataContainer()

=head2 Wx::ClientDataContainer::GetClientData

   void* GetClientData() const

   Get the untyped client data.

=head2 Wx::ClientDataContainer::GetClientObject

   wxClientData* GetClientObject() const

   Get a pointer to the client data object.

=head2 Wx::ClientDataContainer::SetClientData

   void SetClientData(void* data)

   Set the untyped client data.

=head2 Wx::ClientDataContainer::SetClientObject

   void SetClientObject(wxClientData* data)

   Set the client data object. Any previous object will be deleted.

=head1 Wx::Clipboard

=head2 Wx::Clipboard::new

   wxClipboard()

   Constructor.

=head2 Wx::Clipboard::DESTROY

   ~wxClipboard()

   Destructor.

=head2 Wx::Clipboard::AddData

   bool AddData(wxDataObject* data)

   Call this function to add the data object to the clipboard. You may
   call this function repeatedly after having cleared the clipboard using
   wxClipboard::Clear.

   After this function has been called, the clipboard owns the data, so
   do not delete the data explicitly.

   See also

   wxClipboard::SetData

=head2 Wx::Clipboard::Clear

   void Clear()

   Clears the global clipboard object and the system's clipboard if
   possible.

=head2 Wx::Clipboard::Close

   void Close()

   Call this function to close the clipboard, having opened it with
   wxClipboard::Open.

=head2 Wx::Clipboard::Flush

   bool Flush()

   Flushes the clipboard: this means that the data which is currently on
   clipboard will stay available even after the application exits
   (possibly eating memory), otherwise the clipboard will be emptied on
   exit. Returns false if the operation is unsuccessful for any reason.

=head2 Wx::Clipboard::GetData

   bool GetData(wxDataObject& data)

   Call this function to fill data with data on the clipboard, if
   available in the required format. Returns true on success.

=head2 Wx::Clipboard::IsOpened

   bool IsOpened() const

   Returns true if the clipboard has been opened.

=head2 Wx::Clipboard::IsSupported

   bool IsSupported(const wxDataFormat& format)

   Returns true if there is data which matches the data format of the
   given data object currently available (IsSupported sounds like a
   misnomer, FIXME: better deprecate this name?) on the clipboard.

=head2 Wx::Clipboard::Open

   bool Open()

   Call this function to open the clipboard before calling
   wxClipboard::SetData and wxClipboard::GetData.

   Call wxClipboard::Close when you have finished with the clipboard. You
   should keep the clipboard open for only a very short time.

   Returns true on success. This should be tested (as in the sample shown
   above).

=head2 Wx::Clipboard::SetData

   bool SetData(wxDataObject* data)

   Call this function to set the data object to the clipboard. This
   function will clear all previous contents in the clipboard, so calling
   it several times does not make any sense.

   After this function has been called, the clipboard owns the data, so
   do not delete the data explicitly.

   See also

   wxClipboard::AddData

=head2 Wx::Clipboard::UsePrimarySelection

   void UsePrimarySelection(bool primary = true)

   On platforms supporting it (currently only GTK), selects the so called
   PRIMARY SELECTION as the clipboard as opposed to the normal clipboard,
   if primary is true.

=head1 Wx::ClipboardTextEvent

=head2 Wx::ClipboardTextEvent::new

   wxClipboardTextEvent(wxEventType commandType = wxEVT_NULL, int id = 0)

=head1 Wx::CloseEvent

=head2 Wx::CloseEvent::new

   wxCloseEvent(WXTYPE commandEventType = 0, int id = 0)

   Constructor.

=head2 Wx::CloseEvent::CanVeto

   bool CanVeto()

   Returns true if you can veto a system shutdown or a window close
   event. Vetoing a window close event is not possible if the calling
   code wishes to force the application to exit, and so this function
   must be called to check this.

=head2 Wx::CloseEvent::GetLoggingOff

   bool GetLoggingOff() const

   Returns true if the user is just logging off or false if the system is
   shutting down. This method can only be called for end session and
   query end session events, it doesn't make sense for close window
   event.

=head2 Wx::CloseEvent::SetCanVeto

   void SetCanVeto(bool canVeto)

   Sets the 'can veto' flag.

=head2 Wx::CloseEvent::SetForce

   void SetForce(bool force) const

   Sets the 'force' flag.

=head2 Wx::CloseEvent::SetLoggingOff

   void SetLoggingOff(bool loggingOff) const

   Sets the 'logging off' flag.

=head2 Wx::CloseEvent::Veto

   void Veto(bool veto = true)

   Call this from your event handler to veto a system shutdown or to
   signal to the calling application that a window close did not happen.

   You can only veto a shutdown if wxCloseEvent::CanVeto returns true.

=head1 Wx::CmdLineParser

=head2 Construction

   Before Parse can be called, the command line parser object must have
   the command line to parse and also the rules saying which switches,
   options and parameters are valid - this is called command line
   description in what follows.

   You have complete freedom of choice as to when specify the required
   information, the only restriction is that it must be done before
   calling Parse.

   To specify the command line to parse you may use either one of
   constructors accepting it (wxCmdLineParser(argc, argv) or
   wxCmdLineParser usually) or, if you use the default constructor, you
   can do it later by calling SetCmdLine.

   The same holds for command line description: it can be specified
   either in the constructor (without command line or together with it)
   or constructed later using either SetDesc or combination of AddSwitch,
   AddOption and AddParam methods.

   Using constructors or SetDesc uses a (usually const static) table
   containing the command line description. If you want to decide which
   options to accept during the run-time, using one of the AddXXX()
   functions above might be preferable.

=head2 Customization

   wxCmdLineParser has several global options which may be changed by the
   application. All of the functions described in this section should be
   called before Parse.

   First global option is the support for long (also known as GNU-style)
   options. The long options are the ones which start with two dashes ("--")
   and look like this: --verbose, i.e. they generally are complete words
   and not some abbreviations of them. As long options are used by more
   and more applications, they are enabled by default, but may be
   disabled with DisableLongOptions.

   Another global option is the set of characters which may be used to
   start an option (otherwise, the word on the command line is assumed to
   be a parameter). Under Unix, '-' is always used, but Windows has at
   least two common choices for this: '-' and '/'. Some programs also use
   '+'. The default is to use what suits most the current platform, but
   may be changed with SetSwitchChars method.

   Finally, SetLogo can be used to show some application-specific text
   before the explanation given by Usage function.

=head2 Parsing command line

   After the command line description was constructed and the desired
   options were set, you can finally call Parse method. It returns 0 if
   the command line was correct and was parsed, -1 if the help option was
   specified (this is a separate case as, normally, the program will
   terminate after this) or a positive number if there was an error
   during the command line parsing.

   In the latter case, the appropriate error message and usage
   information are logged by wxCmdLineParser itself using the standard
   wxWidgets logging functions.

=head2 Getting results

   After calling Parse (and if it returned 0), you may access the results
   of parsing using one of overloaded Found() methods.

   For a simple switch, you will simply call Found to determine if the
   switch was given or not, for an option or a parameter, you will call a
   version of Found() which also returns the associated value in the
   provided variable. All Found() functions return true if the switch or
   option were found in the command line or false if they were not
   specified.

=head2 Wx::CmdLineParser::new

   wxCmdLineParser()

   Default constructor. You must use SetCmdLine later.

=head2 Wx::CmdLineParser::new

   wxCmdLineParser(int argc, char** argv)

   wxCmdLineParser(int argc, wchar_t** argv)

   Constructor specifies the command line to parse. This is the
   traditional (Unix) command line format. The parameters argc and argv
   have the same meaning as for main() function.

   The second overloaded constructor is only available in Unicode build.
   The first one is available in both ANSI and Unicode modes because
   under some platforms the command line arguments are passed as ASCII
   strings even to Unicode programs.

=head2 Wx::CmdLineParser::new

   wxCmdLineParser(const wxString& cmdline)

   Constructor specifies the command line to parse in Windows format. The
   parameter cmdline has the same meaning as the corresponding parameter
   of WinMain().

=head2 Wx::CmdLineParser::new

   wxCmdLineParser(const wxCmdLineEntryDesc* desc)

   Same as wxCmdLineParser, but also specifies the command line
   description.

=head2 Wx::CmdLineParser::new

   wxCmdLineParser(const wxCmdLineEntryDesc* desc, int argc, char** argv)

   Same as wxCmdLineParser, but also specifies the command line
   description.

=head2 Wx::CmdLineParser::new

   wxCmdLineParser(const wxCmdLineEntryDesc* desc, const wxString&
   cmdline)

   Same as wxCmdLineParser, but also specifies the command line
   description.

=head2 Wx::CmdLineParser::ConvertStringToArgs

   static wxArrayString ConvertStringToArgs(const wxChar *cmdline)

   Breaks down the string containing the full command line in words. The
   words are separated by whitespace. The quotes can be used in the input
   string to quote the white space and the back slashes can be used to
   quote the quotes.

=head2 Wx::CmdLineParser::SetCmdLine

   void SetCmdLine(int argc, char** argv)

   void SetCmdLine(int argc, wchar_t** argv)

   Set command line to parse after using one of the constructors which
   don't do it. The second overload of this function is only available in
   Unicode build.

   See also

   wxCmdLineParser

=head2 Wx::CmdLineParser::SetCmdLine

   void SetCmdLine(const wxString& cmdline)

   Set command line to parse after using one of the constructors which
   don't do it.

   See also

   wxCmdLineParser

=head2 Wx::CmdLineParser::DESTROY

   ~wxCmdLineParser()

   Frees resources allocated by the object.

   NB: destructor is not virtual, don't use this class polymorphically.

=head2 Wx::CmdLineParser::SetSwitchChars

   void SetSwitchChars(const wxString& switchChars)

   switchChars contains all characters with which an option or switch may
   start. Default is "-" for Unix, "-/" for Windows.

=head2 Wx::CmdLineParser::EnableLongOptions

   void EnableLongOptions(bool enable = true)

   Enable or disable support for the long options.

   As long options are not (yet) POSIX-compliant, this option allows to
   disable them.

   See also

   Customization and AreLongOptionsEnabled

=head2 Wx::CmdLineParser::DisableLongOptions

   void DisableLongOptions()

   Identical to EnableLongOptions(false).

=head2 Wx::CmdLineParser::AreLongOptionsEnabled

   bool AreLongOptionsEnabled()

   Returns true if long options are enabled, otherwise false.

   See also

   EnableLongOptions

=head2 Wx::CmdLineParser::SetLogo

   void SetLogo(const wxString& logo)

   logo is some extra text which will be shown by Usage method.

=head2 Wx::CmdLineParser::SetDesc

   void SetDesc(const wxCmdLineEntryDesc* desc)

   Construct the command line description

   Take the command line description from the wxCMD_LINE_NONE terminated
   table.

   Example of usage:

   static const wxCmdLineEntryDesc cmdLineDesc[] =
   {
       { wxCMD_LINE_SWITCH, "v", "verbose", "be verbose" },
       { wxCMD_LINE_SWITCH, "q", "quiet",   "be quiet" },

=head2 Wx::CmdLineParser::AddSwitch

   void AddSwitch(const wxString& name, const wxString& lng =
   wxEmptyString, const wxString& desc = wxEmptyString, int flags = 0)

   Add a switch name with an optional long name lng (no long name if it
   is empty, which is default), description desc and flags flags to the
   command line description.

=head2 Wx::CmdLineParser::AddOption

   void AddOption(const wxString& name, const wxString& lng =
   wxEmptyString, const wxString& desc = wxEmptyString,
   wxCmdLineParamType type = wxCMD_LINE_VAL_STRING, int flags = 0)

   Add an option name with an optional long name lng (no long name if it
   is empty, which is default) taking a value of the given type (string
   by default) to the command line description.

=head2 Wx::CmdLineParser::AddParam

   void AddParam(const wxString& desc = wxEmptyString, wxCmdLineParamType
   type = wxCMD_LINE_VAL_STRING, int flags = 0)

   Add a parameter of the given type to the command line description.

=head2 Wx::CmdLineParser::Parse

   int Parse(bool giveUsage = true)

   Parse the command line, return 0 if ok, -1 if "-h" or "--help" option
   was encountered and the help message was given or a positive value if
   a syntax error occurred.

   Parameters

   giveUsage

       If true (default), the usage message is given if a syntax error
       was encountered while parsing the command line or if help was
       requested. If false, only error messages about possible syntax
       errors are given, use Usage to show the usage message from the
       caller if needed.

=head2 Wx::CmdLineParser::Usage

   void Usage()

   Give the standard usage message describing all program options. It
   will use the options and parameters descriptions specified earlier, so
   the resulting message will not be helpful to the user unless the
   descriptions were indeed specified.

   See also

   SetLogo

=head2 Wx::CmdLineParser::Found

   bool Found(const wxString& name) const

   Returns true if the given switch was found, false otherwise.

=head2 Wx::CmdLineParser::Found

   bool Found(const wxString& name, wxString* value) const

   Returns true if an option taking a string value was found and stores
   the value in the provided pointer (which should not be NULL).

=head2 Wx::CmdLineParser::Found

   bool Found(const wxString& name, long* value) const

   Returns true if an option taking an integer value was found and stores
   the value in the provided pointer (which should not be NULL).

=head2 Wx::CmdLineParser::Found

   bool Found(const wxString& name, wxDateTime* value) const

   Returns true if an option taking a date value was found and stores the
   value in the provided pointer (which should not be NULL).

=head2 Wx::CmdLineParser::GetParamCount

   size_t GetParamCount() const

   Returns the number of parameters found. This function makes sense
   mostly if you had used wxCMD_LINE_PARAM_MULTIPLE flag.

=head2 Wx::CmdLineParser::GetParam

   wxString GetParam(size_t n = 0u) const

   Returns the value of Nth parameter (as string only for now).

   See also

   GetParamCount

=head1 Wx::CollapsiblePane

=head2 Wx::CollapsiblePane::new

   wxCollapsiblePane(wxWindow *parent, wxWindowID id, const wxString&
   label, const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = wxCP_DEFAULT_STYLE, const wxValidator&
   validator = wxDefaultValidator, const wxString& name =
   "collapsiblePane")

   Initializes the object and calls Create with all the parameters.

=head2 Wx::CollapsiblePane::Create

   bool Create(wxWindow *parent, wxWindowID id, const wxString& label,
   const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = wxCP_DEFAULT_STYLE, const wxValidator&
   validator = wxDefaultValidator, const wxString& name =
   "collapsiblePane")

   Parameters

   parent

       Parent window, must not be non-NULL.

   id  

       The identifier for the control.

   label

       The initial label shown in the button which allows the user to
       expand or collapse the pane window.

   pos 

       Initial position.

   size

       Initial size.

   style

       The window style, see wxCP_* flags.

   validator

       Validator which can be used for additional date checks.

   name

       Control name.

   Return value

   true if the control was successfully created or false if creation
   failed.

=head2 Wx::CollapsiblePane::IsCollapsed

   bool IsCollapsed() const

   Returns true if the pane window is currently hidden.

=head2 Wx::CollapsiblePane::IsExpanded

   bool IsExpanded() const

   Returns true if the pane window is currently shown.

=head2 Wx::CollapsiblePane::Collapse

   void Collapse(bool collapse = true)

   Collapses or expands the pane window.

=head2 Wx::CollapsiblePane::Expand

   void Expand()

   Same as Collapse(false).

=head2 Wx::CollapsiblePane::GetPane

   wxWindow * GetPane() const

   Returns a pointer to the pane window. Add controls to the returned
   wxWindow to make them collapsible.

=head1 Wx::CollapsiblePaneEvent

=head2 Wx::CollapsiblePaneEvent::new

   wxCollapsiblePaneEvent(wxObject * generator, int id, bool collapsed)

   The constructor is not normally used by the user code.

=head2 Wx::CollapsiblePaneEvent::GetCollapsed

   bool GetCollapsed() const

   Returns true if the pane has been collapsed.

=head2 Wx::CollapsiblePaneEvent::SetCollapsed

   void SetCollapsed(bool collapsed)

   Sets this as a collapsed pane event (if collapsed is true) or as an
   expanded pane event (if collapsed is false).

=head1 Wx::Colour

=head2 Wx::Colour::new

   wxColour()

   Default constructor.

   wxColour(unsigned char red, unsigned char green, unsigned char blue,
   unsigned char alpha=wxALPHA_OPAQUE)

   Constructs a colour from red, green, blue and alpha values.

   wxColour(const wxString& colourNname)

   Constructs a colour using the given string. See Set for more info.

   wxColour(const wxColour& colour)

   Copy constructor.

   Parameters

   red 

       The red value.

   green

       The green value.

   blue

       The blue value.

   alpha

       The alpha value. Alpha values range from 0 (wxALPHA_TRANSPARENT)
       to 255 (wxALPHA_OPAQUE).

   colourName

       The colour name.

   colour

       The colour to copy.

   See also

   wxColourDatabase

   wxPython note: Constructors supported by wxPython are:

=head2 Wx::Colour::Alpha

   unsigned char Alpha() const

   Returns the alpha value, on platforms where alpha is not yet
   supported, this always returns wxALPHA_OPAQUE.

=head2 Wx::Colour::Blue

   unsigned char Blue() const

   Returns the blue intensity.

=head2 Wx::Colour::GetAsString

   wxString GetAsString(long flags) const

   Converts this colour to a wxString using the given flags.

   The supported flags are wxC2S_NAME, to obtain the colour name (e.g.
   wxColour(255,0,0) -> "red"), wxC2S_CSS_SYNTAX, to obtain the colour in
   the "rgb(r,g,b)" syntax (e.g. wxColour(255,0,0) -> "rgb(255,0,0)"),
   and wxC2S_HTML_SYNTAX, to obtain the colour as "#" followed by 6
   hexadecimal digits (e.g. wxColour(255,0,0) -> "#FF0000").

   This function never fails and always returns a non-empty string.

   This function is new since wxWidgets version 2.7.0

=head2 Wx::Colour::GetPixel

   long GetPixel() const

   Returns a pixel value which is platform-dependent. On Windows, a
   COLORREF is returned. On X, an allocated pixel value is returned.

   -1 is returned if the pixel is invalid (on X, unallocated).

=head2 Wx::Colour::Green

   unsigned char Green() const

   Returns the green intensity.

=head2 Wx::Colour::IsOk

   bool IsOk() const

   Returns true if the colour object is valid (the colour has been
   initialised with RGB values).

=head2 Wx::Colour::Red

   unsigned char Red() const

   Returns the red intensity.

=head2 Wx::Colour::Set

   void Set(unsigned char red, unsigned char green, unsigned char blue,
   unsigned char alpha=wxALPHA_OPAQUE)

   void Set(unsigned long RGB)

   bool Set(const wxString & str)

   Sets the RGB intensity values using the given values (first overload),
   extracting them from the packed long (second overload), using the
   given string (third overloard).

   When using third form, Set() accepts: colour names (those listed in
   wxTheColourDatabase), the CSS-like "RGB(r,g,b)" syntax (case
   insensitive) and the HTML-like syntax (i.e. "#" followed by 6
   hexadecimal digits for red, green, blue components).

   Returns true if the conversion was successful, false otherwise.

   This function is new since wxWidgets version 2.7.0

=head1 Wx::ColourData

=head2 Wx::ColourData::new

   wxColourData()

   Constructor. Initializes the custom colours to wxNullColour, the data
   colour setting to black, and the choose full setting to true.

=head2 Wx::ColourData::DESTROY

   ~wxColourData()

   Destructor.

=head2 Wx::ColourData::GetChooseFull

   bool GetChooseFull() const

   Under Windows, determines whether the Windows colour dialog will
   display the full dialog with custom colour selection controls. Under
   PalmOS, determines whether colour dialog will display full rgb colour
   picker or only available palette indexer. Has no meaning under other
   platforms.

   The default value is true.

=head2 Wx::ColourData::GetColour

   wxColour& GetColour() const

   Gets the current colour associated with the colour dialog.

   The default colour is black.

=head2 Wx::ColourData::GetCustomColour

   wxColour& GetCustomColour(int i) const

   Gets the ith custom colour associated with the colour dialog. i should
   be an integer between 0 and 15.

   The default custom colours are invalid colours.

=head2 Wx::ColourData::SetChooseFull

   void SetChooseFull(const bool flag)

   Under Windows, tells the Windows colour dialog to display the full
   dialog with custom colour selection controls. Under other platforms,
   has no effect.

   The default value is true.

=head2 Wx::ColourData::SetColour

   void SetColour(const wxColour& colour)

   Sets the default colour for the colour dialog.

   The default colour is black.

=head2 Wx::ColourData::SetCustomColour

   void SetCustomColour(int i, const wxColour& colour)

   Sets the ith custom colour for the colour dialog. i should be an
   integer between 0 and 15.

   The default custom colours are invalid colours.

=head1 Wx::ColourDatabase

=head2 Wx::ColourDatabase::new

   wxColourDatabase()

   Constructs the colour database. It will be initialized at the first
   use.

=head2 Wx::ColourDatabase::AddColour

   void AddColour(const wxString& colourName, const wxColour&colour)

   void AddColour(const wxString& colourName, wxColour* colour)

   Adds a colour to the database. If a colour with the same name already
   exists, it is replaced.

   Please note that the overload taking a pointer is deprecated and will
   be removed in the next wxWidgets version, please don't use it.

=head2 Wx::ColourDatabase::Find

   wxColour Find(const wxString& colourName)

   Finds a colour given the name. Returns an invalid colour object (that
   is, such that its Ok() method returns false) if the colour wasn't
   found in the database.

=head2 Wx::ColourDatabase::FindName

   wxString FindName(const wxColour& colour) const

   Finds a colour name given the colour. Returns an empty string if the
   colour is not found in the database.

=head1 Wx::ColourDialog

=head2 Wx::ColourDialog::new

   wxColourDialog(wxWindow* parent, wxColourData* data = NULL)

   Constructor. Pass a parent window, and optionally a pointer to a block
   of colour data, which will be copied to the colour dialog's colour
   data. Custom colours from colour data object will be be used in
   dialog's colour palette. Invalid entries in custom colours list will
   be ignored on some platforms (GTK) or replaced with white colour on
   platforms where custom colours palette has fixed size (MSW).

   See also

   wxColourData

=head2 Wx::ColourDialog::DESTROY

   ~wxColourDialog()

   Destructor.

=head2 Wx::ColourDialog::Create

   bool Create(wxWindow* parent, wxColourData* data = NULL)

   Same as constructor.

=head2 Wx::ColourDialog::GetColourData

   wxColourData& GetColourData()

   Returns the colour data associated with the colour dialog.

=head2 Wx::ColourDialog::ShowModal

   int ShowModal()

   Shows the dialog, returning wxID_OK if the user pressed OK, and
   wxID_CANCEL otherwise.

=head1 Wx::ColourPickerCtrl

=head2 Wx::ColourPickerCtrl::new

   wxColourPickerCtrl(wxWindow *parent, wxWindowID id, const wxColour&
   colour = *wxBLACK, const wxPoint& pos = wxDefaultPosition, const
   wxSize& size = wxDefaultSize, long style = wxCLRP_DEFAULT_STYLE, const
   wxValidator& validator = wxDefaultValidator, const wxString& name =
   "colourpickerctrl")

   Initializes the object and calls Create with all the parameters.

=head2 Wx::ColourPickerCtrl::Create

   bool Create(wxWindow *parent, wxWindowID id, const wxColour& colour =
   *wxBLACK, const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = wxCLRP_DEFAULT_STYLE, const wxValidator&
   validator = wxDefaultValidator, const wxString& name =
   "colourpickerctrl")

   Parameters

   parent

       Parent window, must not be non-NULL.

   id  

       The identifier for the control.

   colour

       The initial colour shown in the control.

   pos 

       Initial position.

   size

       Initial size.

   style

       The window style, see wxCRLP_* flags.

   validator

       Validator which can be used for additional date checks.

   name

       Control name.

   Return value

   true if the control was successfully created or false if creation
   failed.

=head2 Wx::ColourPickerCtrl::GetColour

   wxColour GetColour() const

   Returns the currently selected colour.

=head2 Wx::ColourPickerCtrl::SetColour

   void SetColour(const wxColour &col)

   void SetColour(const wxString &colname)

   Sets the currently selected colour. See wxColour::Set.

=head1 Wx::ColourPickerEvent

=head2 Wx::ColourPickerEvent::new

   wxColourPickerEvent(wxObject * generator, int id, const wxColour&
   colour)

   The constructor is not normally used by the user code.

=head2 Wx::ColourPickerEvent::GetColour

   wxColour GetColour() const

   Retrieve the colour the user has just selected.

=head2 Wx::ColourPickerEvent::SetColour

   void SetColour(const wxColour &pos)

   Set the colour associated with the event.

=head1 Wx::ComboBox

=head2 Wx::ComboBox::new

   wxComboBox()

   Default constructor.

   wxComboBox(wxWindow* parent, wxWindowID id, const wxString& value = "",
   const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, int n = 0, const wxString choices[] = NULL, long style
   = 0, const wxValidator& validator = wxDefaultValidator, const wxString&
   name = "comboBox")

   wxComboBox(wxWindow* parent, wxWindowID id, const wxString& value,
   const wxPoint& pos, const wxSize& size, const wxArrayString& choices,
   long style = 0, const wxValidator& validator = wxDefaultValidator,
   const wxString& name = "comboBox")

   Constructor, creating and showing a combobox.

   Parameters

   parent

       Parent window. Must not be NULL.

   id  

       Window identifier. A value of -1 indicates a default value.

   value

       Initial selection string. An empty string indicates no selection.

   pos 

       Window position.

   size

       Window size. If the default size (-1, -1) is specified then the
       window is sized appropriately.

   n   

       Number of strings with which to initialise the control.

   choices

       An array of strings with which to initialise the control.

   style

       Window style. See wxComboBox.

   validator

       Window validator.

   name

       Window name.

   See also

   wxComboBox::Create, wxValidator

   wxPython note: The wxComboBox constructor in wxPython reduces the n
   and choices arguments are to a single argument, which is a list of
   strings.

   wxPerl note: In wxPerl there is just an array reference in place of n
   and choices.

=head2 Wx::ComboBox::DESTROY

   ~wxComboBox()

   Destructor, destroying the combobox.

=head2 Wx::ComboBox::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxString& value =
   "", const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, int n, const wxString choices[], long style = 0, const
   wxValidator& validator = wxDefaultValidator, const wxString& name =
   "comboBox")

   bool Create(wxWindow* parent, wxWindowID id, const wxString& value,
   const wxPoint& pos, const wxSize& size, const wxArrayString& choices,
   long style = 0, const wxValidator& validator = wxDefaultValidator,
   const wxString& name = "comboBox")

   Creates the combobox for two-step construction. Derived classes should
   call or replace this function. See wxComboBox::wxComboBox for further
   details.

=head2 Wx::ComboBox::CanCopy

   bool CanCopy() const

   Returns true if the combobox is editable and there is a text selection
   to copy to the clipboard. Only available on Windows.

=head2 Wx::ComboBox::CanCut

   bool CanCut() const

   Returns true if the combobox is editable and there is a text selection
   to copy to the clipboard. Only available on Windows.

=head2 Wx::ComboBox::CanPaste

   bool CanPaste() const

   Returns true if the combobox is editable and there is text on the
   clipboard that can be pasted into the text field. Only available on
   Windows.

=head2 Wx::ComboBox::CanRedo

   bool CanRedo() const

   Returns true if the combobox is editable and the last undo can be
   redone. Only available on Windows.

=head2 Wx::ComboBox::CanUndo

   bool CanUndo() const

   Returns true if the combobox is editable and the last edit can be
   undone. Only available on Windows.

=head2 Wx::ComboBox::Copy

   void Copy()

   Copies the selected text to the clipboard.

=head2 Wx::ComboBox::Cut

   void Cut()

   Copies the selected text to the clipboard and removes the selection.

=head2 Wx::ComboBox::GetCurrentSelection

   int GetCurrentSelection() const

   This function does the same things as wxChoice::GetCurrentSelection
   and returns the item currently selected in the dropdown list if it's
   open or the same thing as GetSelection otherwise.

=head2 Wx::ComboBox::GetInsertionPoint

   long GetInsertionPoint() const

   Returns the insertion point for the combobox's text field.

   Note: Under wxMSW, this function always returns 0 if the combobox
   doesn't have the focus.

=head2 Wx::ComboBox::GetLastPosition

   virtual wxTextPos GetLastPosition() const

   Returns the last position in the combobox text field.

=head2 Wx::ComboBox::GetSelection

   void GetSelection(long *from, long *to) const

   This is the same as wxTextCtrl::GetSelection for the text control
   which is part of the combobox. Notice that this is a different method
   from wxControlWithItems::GetSelection.

   Currently this method is only implemented in wxMSW and wxGTK.

=head2 Wx::ComboBox::GetValue

   wxString GetValue() const

   Returns the current value in the combobox text field.

=head2 Wx::ComboBox::Paste

   void Paste()

   Pastes text from the clipboard to the text field.

=head2 Wx::ComboBox::Redo

   void Redo()

   Redoes the last undo in the text field. Windows only.

=head2 Wx::ComboBox::Replace

   void Replace(long from, long to, const wxString& text)

   Replaces the text between two positions with the given text, in the
   combobox text field.

   Parameters

   from

       The first position.

   to  

       The second position.

   text

       The text to insert.

=head2 Wx::ComboBox::Remove

   void Remove(long from, long to)

   Removes the text between the two positions in the combobox text field.

   Parameters

   from

       The first position.

   to  

       The last position.

=head2 Wx::ComboBox::SetInsertionPoint

   void SetInsertionPoint(long pos)

   Sets the insertion point in the combobox text field.

   Parameters

   pos 

       The new insertion point.

=head2 Wx::ComboBox::SetInsertionPointEnd

   void SetInsertionPointEnd()

   Sets the insertion point at the end of the combobox text field.

=head2 Wx::ComboBox::SetSelection

   void SetSelection(long from, long to)

   Selects the text between the two positions, in the combobox text
   field.

   Parameters

   from

       The first position.

   to  

       The second position.

   wxPython note: This method is called SetMark in wxPython, SetSelection
   name is kept for wxControlWithItems::SetSelection.

=head2 Wx::ComboBox::SetValue

   void SetValue(const wxString& text)

   Sets the text for the combobox text field.

   NB: For a combobox with wxCB_READONLY style the string must be in the
   combobox choices list, otherwise the call to SetValue() is ignored.

   Parameters

   text

       The text to set.

=head2 Wx::ComboBox::Undo

   void Undo()

   Undoes the last edit in the text field. Windows only.

=head1 Wx::ComboCtrl

=head2 Wx::ComboCtrl::new

   wxComboCtrl()

   Default constructor.

   wxComboCtrl(wxWindow* parent, wxWindowID id, const wxString& value =
   "", const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = 0, const wxValidator& validator =
   wxDefaultValidator, const wxString& name = "comboCtrl")

   Constructor, creating and showing a combo control.

   Parameters

   parent

       Parent window. Must not be NULL.

   id  

       Window identifier. A value of -1 indicates a default value.

   value

       Initial selection string. An empty string indicates no selection.

   pos 

       Window position.

   size

       Window size. If the default size (-1, -1) is specified then the
       window is sized appropriately.

   style

       Window style. See wxComboCtrl.

   validator

       Window validator.

   name

       Window name.

   See also

   wxComboCtrl::Create, wxValidator

=head2 Wx::ComboCtrl::DESTROY

   ~wxComboCtrl()

   Destructor, destroying the combo control.

=head2 Wx::ComboCtrl::AnimateShow

   virtual bool AnimateShow(const wxRect& rect, int flags)

   This member function is not normally called in application code.
   Instead, it can be implemented in a derived class to create a custom
   popup animation.

   Parameters

   Same as in DoShowPopup.

   Return value

   true if animation finishes before the function returns. false
   otherwise. In the latter case you need to manually call DoShowPopup
   after the animation ends.

=head2 Wx::ComboCtrl::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxString& value =
   "", const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = 0, const wxValidator& validator =
   wxDefaultValidator, const wxString& name = "comboCtrl")

   Creates the combo control for two-step construction. Derived classes
   should call or replace this function. See wxComboCtrl::wxComboCtrl for
   further details.

=head2 Wx::ComboCtrl::Copy

   void Copy()

   Copies the selected text to the clipboard.

=head2 Wx::ComboCtrl::Cut

   void Cut()

   Copies the selected text to the clipboard and removes the selection.

=head2 Wx::ComboCtrl::DoSetPopupControl

   void DoSetPopupControl(wxComboPopup* popup)

   This member function is not normally called in application code.
   Instead, it can be implemented in a derived class to return default
   wxComboPopup, incase popup is NULL.

   Note: If you have implemented OnButtonClick to do something else than
   show the popup, then DoSetPopupControl must always return NULL.

=head2 Wx::ComboCtrl::DoShowPopup

   virtual void DoShowPopup(const wxRect& rect, int flags)

   This member function is not normally called in application code.
   Instead, it must be called in a derived class to make sure popup is
   properly shown after a popup animation has finished (but only if
   AnimateShow did not finish the animation within it's function scope).

   Parameters

   rect

       Position to show the popup window at, in screen coordinates.

   flags

       Combination of any of the following:

=head2 Wx::ComboCtrl::EnablePopupAnimation

   void EnablePopupAnimation(bool enable = true)

   Enables or disables popup animation, if any, depending on the value of
   the argument.

=head2 Wx::ComboCtrl::GetBitmapDisabled

   const wxBitmap& GetBitmapDisabled() const

   Returns disabled button bitmap that has been set with SetButtonBitmaps.

   Return value

   A reference to the disabled state bitmap.

=head2 Wx::ComboCtrl::GetBitmapHover

   const wxBitmap& GetBitmapHover() const

   Returns button mouse hover bitmap that has been set with
   SetButtonBitmaps.

   Return value

   A reference to the mouse hover state bitmap.

=head2 Wx::ComboCtrl::GetBitmapNormal

   const wxBitmap& GetBitmapNormal() const

   Returns default button bitmap that has been set with SetButtonBitmaps.

   Return value

   A reference to the normal state bitmap.

=head2 Wx::ComboCtrl::GetBitmapPressed

   const wxBitmap& GetBitmapPressed() const

   Returns depressed button bitmap that has been set with
   SetButtonBitmaps.

   Return value

   A reference to the depressed state bitmap.

=head2 Wx::ComboCtrl::GetButtonSize

   wxSize GetButtonSize()

   Returns current size of the dropdown button.

=head2 Wx::ComboCtrl::GetCustomPaintWidth

   int GetCustomPaintWidth() const

   Returns custom painted area in control.

   See also

   wxComboCtrl::SetCustomPaintWidth.

=head2 Wx::ComboCtrl::GetFeatures

   static int GetFeatures()

   Returns features supported by wxComboCtrl. If needed feature is
   missing, you need to instead use wxGenericComboCtrl, which however may
   lack native look and feel (but otherwise sports identical API).

   Return value

   Value returned is a combination of following flags:

=head2 Wx::ComboCtrl::GetInsertionPoint

   long GetInsertionPoint() const

   Returns the insertion point for the combo control's text field.

   Note: Under wxMSW, this function always returns 0 if the combo control
   doesn't have the focus.

=head2 Wx::ComboCtrl::IsPopupWindowState

   bool IsPopupWindowState(int state) const

   Returns true if the popup window is in the given state. Possible
   values are:

=head2 Wx::ComboCtrl::GetLastPosition

   long GetLastPosition() const

   Returns the last position in the combo control text field.

=head2 Wx::ComboCtrl::GetPopupControl

   wxComboPopup* GetPopupControl()

   Returns current popup interface that has been set with
   SetPopupControl.

=head2 Wx::ComboCtrl::GetPopupWindow

   wxWindow* GetPopupWindow() const

   Returns popup window containing the popup control.

=head2 Wx::ComboCtrl::GetTextCtrl

   wxTextCtrl* GetTextCtrl() const

   Get the text control which is part of the combo control.

=head2 Wx::ComboCtrl::GetTextIndent

   wxCoord GetTextIndent() const

   Returns actual indentation in pixels.

=head2 Wx::ComboCtrl::GetTextRect

   const wxRect& GetTextRect() const

   Returns area covered by the text field (includes everything except
   borders and the dropdown button).

=head2 Wx::ComboCtrl::GetValue

   wxString GetValue() const

   Returns text representation of the current value. For writable combo
   control it always returns the value in the text field.

=head2 Wx::ComboCtrl::HidePopup

   void HidePopup()

   Dismisses the popup window.

=head2 Wx::ComboCtrl::IsPopupShown

   bool IsPopupShown() const

   Returns true if the popup is currently shown

=head2 Wx::ComboCtrl::OnButtonClick

   void OnButtonClick()

   Implement in a derived class to define what happens on dropdown button
   click.

   Default action is to show the popup.

   Note: If you implement this to do something else than show the popup,
   you must then also implement DoSetPopupControl to always return NULL.

=head2 Wx::ComboCtrl::Paste

   void Paste()

   Pastes text from the clipboard to the text field.

=head2 Wx::ComboCtrl::Remove

   void Remove(long from, long to)

   Removes the text between the two positions in the combo control text
   field.

   Parameters

   from

       The first position.

   to  

       The last position.

=head2 Wx::ComboCtrl::Replace

   void Replace(long from, long to, const wxString& value)

   Replaces the text between two positions with the given text, in the
   combo control text field.

   Parameters

   from

       The first position.

   to  

       The second position.

   text

       The text to insert.

=head2 Wx::ComboCtrl::SetButtonBitmaps

   void SetButtonBitmaps(const wxBitmap& bmpNormal, bool pushButtonBg =
   false, const wxBitmap& bmpPressed = wxNullBitmap, const wxBitmap&
   bmpHover = wxNullBitmap, const wxBitmap& bmpDisabled = wxNullBitmap)

   Sets custom dropdown button graphics.

   Parameters

   bmpNormal

       Default button image.

=head2 Wx::ComboCtrl::SetButtonPosition

   void SetButtonPosition(int width = -1, int height = -1, int side =
   wxRIGHT, int spacingX = 0)

   Sets size and position of dropdown button.

   Parameters

   width

       Button width. Value <= 0 specifies default.

=head2 Wx::ComboCtrl::SetCustomPaintWidth

   void SetCustomPaintWidth(int width)

   Set width, in pixels, of custom painted area in control without
   wxCB_READONLY style. In read-only wxOwnerDrawnComboBox, this is used
   to indicate area that is not covered by the focus rectangle.

=head2 Wx::ComboCtrl::SetInsertionPoint

   void SetInsertionPoint(long pos)

   Sets the insertion point in the text field.

   Parameters

   pos 

       The new insertion point.

=head2 Wx::ComboCtrl::SetInsertionPointEnd

   void SetInsertionPointEnd()

   Sets the insertion point at the end of the combo control text field.

=head2 Wx::ComboCtrl::SetPopupAnchor

   void SetPopupAnchor(int anchorSide)

   Set side of the control to which the popup will align itself. Valid
   values are wxLEFT, wxRIGHT and 0. The default value 0 means that the
   most appropriate side is used (which, currently, is always wxLEFT).

=head2 Wx::ComboCtrl::SetPopupControl

   void SetPopupControl(wxComboPopup* popup)

   Set popup interface class derived from wxComboPopup. This method
   should be called as soon as possible after the control has been
   created, unless OnButtonClick has been overridden.

=head2 Wx::ComboCtrl::SetPopupExtents

   void SetPopupExtents(int extLeft, int extRight)

   Extends popup size horizontally, relative to the edges of the combo
   control.

   Parameters

   extLeft

       How many pixel to extend beyond the left edge of the control.
       Default is 0.

=head2 Wx::ComboCtrl::SetPopupMaxHeight

   void SetPopupMaxHeight(int height)

   Sets preferred maximum height of the popup.

   Remarks

   Value -1 indicates the default.

   Also, popup implementation may choose to ignore this.

=head2 Wx::ComboCtrl::SetPopupMinWidth

   void SetPopupMinWidth(int width)

   Sets minimum width of the popup. If wider than combo control, it will
   extend to the left.

   Remarks

   Value -1 indicates the default.

   Also, popup implementation may choose to ignore this.

=head2 Wx::ComboCtrl::SetSelection

   void SetSelection(long from, long to)

   Selects the text between the two positions, in the combo control text
   field.

   Parameters

   from

       The first position.

   to  

       The second position.

=head2 Wx::ComboCtrl::SetText

   void SetText(const wxString& value)

   Sets the text for the text field without affecting the popup. Thus,
   unlike SetValue, it works equally well with combo control using
   wxCB_READONLY style.

=head2 Wx::ComboCtrl::SetTextIndent

   void SetTextIndent(int indent)

   This will set the space in pixels between left edge of the control and
   the text, regardless whether control is read-only or not. Value -1 can
   be given to indicate platform default.

=head2 Wx::ComboCtrl::SetValue

   void SetValue(const wxString& value)

   Sets the text for the combo control text field.

   NB: For a combo control with wxCB_READONLY style the string must be
   accepted by the popup (for instance, exist in the dropdown list),
   otherwise the call to SetValue() is ignored

=head2 Wx::ComboCtrl::SetValueWithEvent

   void SetValueWithEvent(const wxString& value, bool withEvent = true)

   Same as SetValue, but also sends wxCommandEvent of type
   wxEVT_COMMAND_TEXT_UPDATED if withEvent is true.

=head2 Wx::ComboCtrl::ShowPopup

   void ShowPopup()

   Show the popup.

=head2 Wx::ComboCtrl::Undo

   void Undo()

   Undoes the last edit in the text field. Windows only.

=head2 Wx::ComboCtrl::UseAltPopupWindow

   void UseAltPopupWindow(bool enable = true)

   Enable or disable usage of an alternative popup window, which
   guarantees ability to focus the popup control, and allows common
   native controls to function normally. This alternative popup window is
   usually a wxDialog, and as such, when it is shown, its parent
   top-level window will appear as if the focus has been lost from it.

=head1 Wx::ComboPopup

=head2 Wx::ComboPopup::new

   wxComboPopup()

   Default constructor. It is recommended that internal variables are
   prepared in Init instead (because m_combo is not valid in
   constructor).

=head2 Wx::ComboPopup::m_combo

   wxComboCtrl* m_combo

   Parent wxComboCtrl. This protected member variable is prepared
   automatically before Init is called.

=head2 Wx::ComboPopup::Create

   bool Create(wxWindow* parent)

   The derived class must implement this to create the popup control.

   Return value

   true if the call succeeded, false otherwise.

=head2 Wx::ComboPopup::Dismiss

   void Dismiss()

   Utility function that hides the popup.

=head2 Wx::ComboPopup::GetAdjustedSize

   wxSize GetAdjustedSize(int minWidth, int prefHeight, int maxHeight)

   The derived class may implement this to return adjusted size for the
   popup control, according to the variables given.

   Parameters

   minWidth

       Preferred minimum width.

=head2 Wx::ComboPopup::GetControl

   wxWindow* GetControl()

   The derived class must implement this to return pointer to the
   associated control created in Create.

=head2 Wx::ComboPopup::GetStringValue

   wxString GetStringValue() const

   The derived class must implement this to return string representation
   of the value.

=head2 Wx::ComboPopup::Init

   void Init()

   The derived class must implement this to initialize its internal
   variables. This method is called immediately after construction
   finishes. m_combo member variable has been initialized before the
   call.

=head2 Wx::ComboPopup::IsCreated

   bool IsCreated() const

   Utility method that returns true if Create has been called.

   Useful in conjunction with LazyCreate.

=head2 Wx::ComboPopup::LazyCreate

   bool LazyCreate()

   The derived class may implement this to return true if it wants to
   delay call to Create until the popup is shown for the first time. It
   is more efficient, but on the other hand it is often more convenient
   to have the control created immediately.

   Remarks

   Base implementation returns false.

=head2 Wx::ComboPopup::OnComboDoubleClick

   void OnComboDoubleClick()

   The derived class may implement this to do something when the parent
   wxComboCtrl gets double-clicked.

=head2 Wx::ComboPopup::OnComboKeyEvent

   void OnComboKeyEvent(wxKeyEvent& event)

   The derived class may implement this to receive key events from the
   parent wxComboCtrl.

   Events not handled should be skipped, as usual.

=head2 Wx::ComboPopup::OnDismiss

   void OnDismiss()

   The derived class may implement this to do special processing when
   popup is hidden.

=head2 Wx::ComboPopup::OnPopup

   void OnPopup()

   The derived class may implement this to do special processing when
   popup is shown.

=head2 Wx::ComboPopup::PaintComboControl

   void PaintComboControl(wxDC& dc, const wxRect& rect)

   The derived class may implement this to paint the parent wxComboCtrl.

   Default implementation draws value as string.

=head2 Wx::ComboPopup::SetStringValue

   void SetStringValue(const wxString& value)

   The derived class must implement this to receive string value changes
   from wxComboCtrl.

=head1 Wx::Command

=head2 Wx::Command::new

   wxCommand(bool canUndo = false, const wxString& name = NULL)

   Constructor. wxCommand is an abstract class, so you will need to
   derive a new class and call this constructor from your own
   constructor.

   canUndo tells the command processor whether this command is undo-able.
   You can achieve the same functionality by overriding the CanUndo
   member function (if for example the criteria for undoability is
   context-dependent).

   name must be supplied for the command processor to display the command
   name in the application's edit menu.

=head2 Wx::Command::DESTROY

   ~wxCommand()

   Destructor.

=head2 Wx::Command::CanUndo

   bool CanUndo()

   Returns true if the command can be undone, false otherwise.

=head2 Wx::Command::Do

   bool Do()

   Override this member function to execute the appropriate action when
   called. Return true to indicate that the action has taken place, false
   otherwise. Returning false will indicate to the command processor that
   the action is not undoable and should not be added to the command
   history.

=head2 Wx::Command::GetName

   wxString GetName()

   Returns the command name.

=head2 Wx::Command::Undo

   bool Undo()

   Override this member function to un-execute a previous Do. Return true
   to indicate that the action has taken place, false otherwise.
   Returning false will indicate to the command processor that the action
   is not redoable and no change should be made to the command history.

   How you implement this command is totally application dependent, but
   typical strategies include:

=head1 Wx::CommandEvent

=head2 Wx::CommandEvent::new

   wxCommandEvent(WXTYPE commandEventType = 0, int id = 0)

   Constructor.

=head2 Wx::CommandEvent::Checked

   bool Checked() const

   Deprecated, use IsChecked instead.

=head2 Wx::CommandEvent::GetClientData

   void* GetClientData()

   Returns client data pointer for a listbox or choice selection event
   (not valid for a deselection).

=head2 Wx::CommandEvent::GetClientObject

   wxClientData * GetClientObject()

   Returns client object pointer for a listbox or choice selection event
   (not valid for a deselection).

=head2 Wx::CommandEvent::GetExtraLong

   long GetExtraLong()

   Returns extra information dependant on the event objects type. If the
   event comes from a listbox selection, it is a boolean determining
   whether the event was a selection (true) or a deselection (false). A
   listbox deselection only occurs for multiple-selection boxes, and in
   this case the index and string values are indeterminate and the
   listbox must be examined by the application.

=head2 Wx::CommandEvent::GetInt

   int GetInt()

   Returns the integer identifier corresponding to a listbox, choice or
   radiobox selection (only if the event was a selection, not a
   deselection), or a boolean value representing the value of a checkbox.

=head2 Wx::CommandEvent::GetSelection

   int GetSelection()

   Returns item index for a listbox or choice selection event (not valid
   for a deselection).

=head2 Wx::CommandEvent::GetString

   wxString GetString()

   Returns item string for a listbox or choice selection event (not valid
   for a deselection).

=head2 Wx::CommandEvent::IsChecked

   bool IsChecked() const

   This method can be used with checkbox and menu events: for the
   checkboxes, the method returns true for a selection event and false
   for a deselection one. For the menu events, this method indicates if
   the menu item just has become checked or unchecked (and thus only
   makes sense for checkable menu items).

=head2 Wx::CommandEvent::IsSelection

   bool IsSelection()

   For a listbox or similar event, returns true if it is a selection,
   false if it is a deselection.

=head2 Wx::CommandEvent::SetClientData

   void SetClientData(void* clientData)

   Sets the client data for this event.

=head2 Wx::CommandEvent::SetClientObject

   void SetClientObject(wxClientData* clientObject)

   Sets the client object for this event. The client object is not owned
   by the event object and the event object will not delete the client
   object in its destructor. The client object must be owned and deleted
   by another object (e.g. a control) that has longer life time than the
   event object.

=head2 Wx::CommandEvent::SetExtraLong

   void SetExtraLong(long extraLong)

   Sets the m_extraLong member.

=head2 Wx::CommandEvent::SetInt

   void SetInt(int intCommand)

   Sets the m_commandInt member.

=head2 Wx::CommandEvent::SetString

   void SetString(const wxString& string)

   Sets the m_commandString member.

=head1 Wx::CommandProcessor

=head2 Wx::CommandProcessor::new

   wxCommandProcessor(int maxCommands = -1)

   Constructor.

   maxCommands may be set to a positive integer to limit the number of
   commands stored to it, otherwise (and by default) the list of commands
   can grow arbitrarily.

=head2 Wx::CommandProcessor::DESTROY

   ~wxCommandProcessor()

   Destructor.

=head2 Wx::CommandProcessor::CanUndo

   virtual bool CanUndo()

   Returns true if the currently-active command can be undone, false
   otherwise.

=head2 Wx::CommandProcessor::ClearCommands

   virtual void ClearCommands()

   Deletes all commands in the list and sets the current command pointer
   to NULL.

=head2 Wx::CommandProcessor::Redo

   virtual bool Redo()

   Executes (redoes) the current command (the command that has just been
   undone if any).

=head2 Wx::CommandProcessor::GetCommands

   wxList& GetCommands() const

   Returns the list of commands.

=head2 Wx::CommandProcessor::GetMaxCommands

   int GetMaxCommands() const

   Returns the maximum number of commands that the command processor
   stores.

=head2 Wx::CommandProcessor::GetEditMenu

   wxMenu* GetEditMenu() const

   Returns the edit menu associated with the command processor.

=head2 Wx::CommandProcessor::GetRedoAccelerator

   const wxString& GetRedoAccelerator() const

   Returns the string that will be appended to the Redo menu item.

=head2 Wx::CommandProcessor::GetRedoMenuLabel

   wxString GetRedoMenuLabel() const

   Returns the string that will be shown for the redo menu item.

=head2 Wx::CommandProcessor::GetUndoAccelerator

   const wxString& GetUndoAccelerator() const

   Returns the string that will be appended to the Undo menu item.

=head2 Wx::CommandProcessor::GetUndoMenuLabel

   wxString GetUndoMenuLabel() const

   Returns the string that will be shown for the undo menu item.

=head2 Wx::CommandProcessor::Initialize

   virtual void Initialize()

   Initializes the command processor, setting the current command to the
   last in the list (if any), and updating the edit menu (if one has been
   specified).

=head2 Wx::CommandProcessor::IsDirty

   virtual bool IsDirty()

   Returns a boolean value that indicates if changes have been made since
   the last save operation. This only works if
   wxCommandProcessor::MarkAsSaved is called whenever the project is
   saved.

=head2 Wx::CommandProcessor::MarkAsSaved

   virtual void MarkAsSaved()

   You must call this method whenever the project is saved if you plan to
   use wxCommandProcessor::IsDirty.

=head2 Wx::CommandProcessor::SetEditMenu

   void SetEditMenu(wxMenu* menu)

   Tells the command processor to update the Undo and Redo items on this
   menu as appropriate. Set this to NULL if the menu is about to be
   destroyed and command operations may still be performed, or the
   command processor may try to access an invalid pointer.

=head2 Wx::CommandProcessor::SetMenuStrings

   void SetMenuStrings()

   Sets the menu labels according to the currently set menu and the
   current command state.

=head2 Wx::CommandProcessor::SetRedoAccelerator

   void SetRedoAccelerator(const wxString&accel)

   Sets the string that will be appended to the Redo menu item.

=head2 Wx::CommandProcessor::SetUndoAccelerator

   void SetUndoAccelerator(const wxString&accel)

   Sets the string that will be appended to the Undo menu item.

=head2 Wx::CommandProcessor::Submit

   virtual bool Submit(wxCommand *command, bool storeIt = true)

   Submits a new command to the command processor. The command processor
   calls wxCommand::Do to execute the command; if it succeeds, the
   command is stored in the history list, and the associated edit menu
   (if any) updated appropriately. If it fails, the command is deleted
   immediately. Once Submit has been called, the passed command should
   not be deleted directly by the application.

   storeIt indicates whether the successful command should be stored in
   the history list.

=head2 Wx::CommandProcessor::Undo

   virtual bool Undo()

   Undoes the command just executed.

=head1 Wx::Condition

=head2 Wx::Condition::new

   wxCondition(wxMutex& mutex)

   Default and only constructor. The mutex must be locked by the caller
   before calling Wait function.

   Use IsOk to check if the object was successfully initialized.

=head2 Wx::Condition::DESTROY

   ~wxCondition()

   Destroys the wxCondition object. The destructor is not virtual so this
   class should not be used polymorphically.

=head2 Wx::Condition::Broadcast

   void Broadcast()

   Broadcasts to all waiting threads, waking all of them up. Note that
   this method may be called whether the mutex associated with this
   condition is locked or not.

   See also

   wxCondition::Signal

=head2 Wx::Condition::IsOk

   bool IsOk() const

   Returns true if the object had been initialized successfully, false if
   an error occurred.

=head2 Wx::Condition::Signal

   void Signal()

   Signals the object waking up at most one thread. If several threads
   are waiting on the same condition, the exact thread which is woken up
   is undefined. If no threads are waiting, the signal is lost and the
   condition would have to be signalled again to wake up any thread which
   may start waiting on it later.

   Note that this method may be called whether the mutex associated with
   this condition is locked or not.

   See also

   wxCondition::Broadcast

=head2 Wx::Condition::Wait

   wxCondError Wait()

   Waits until the condition is signalled.

   This method atomically releases the lock on the mutex associated with
   this condition (this is why it must be locked prior to calling Wait)
   and puts the thread to sleep until Signal or Broadcast is called. It
   then locks the mutex again and returns.

   Note that even if Signal had been called before Wait without waking up
   any thread, the thread would still wait for another one and so it is
   important to ensure that the condition will be signalled after Wait or
   the thread may sleep forever.

   Return value

   Returns wxCOND_NO_ERROR on success, another value if an error
   occurred.

   See also

   WaitTimeout

=head2 Wx::Condition::WaitTimeout

   wxCondError WaitTimeout(unsigned long milliseconds)

   Waits until the condition is signalled or the timeout has elapsed.

   This method is identical to Wait except that it returns, with the
   return code of wxCOND_TIMEOUT as soon as the given timeout expires.

   Parameters

   milliseconds

       Timeout in milliseconds

   Return value

   Returns wxCOND_NO_ERROR if the condition was signalled, wxCOND_TIMEOUT
   if the timeout elapsed before this happened or another error code from
   wxCondError enum.

=head1 Wx::ConfigBase

=head2 Static functions

   These functions deal with the "default" config object. Although its
   usage is not at all mandatory it may be convenient to use a global
   config object instead of creating and deleting the local config
   objects each time you need one (especially because creating a
   wxFileConfig object might be a time consuming operation). In this
   case, you may create this global config object in the very start of
   the program and Set() it as the default. Then, from anywhere in your
   program, you may access it using the Get() function. This global
   wxConfig object will be deleted by wxWidgets automatically if it
   exists. Note that this implies that if you do delete this object
   yourself (usually in wxApp::OnExit) you must use Set(NULL) to prevent
   wxWidgets from deleting it the second time.

   As it happens, you may even further simplify the procedure described
   above: you may forget about calling Set(). When Get() is called and
   there is no current object, it will create one using Create()
   function. To disable this behaviour DontCreateOnDemand() is provided.

   Note: You should use either Set() or Get() because wxWidgets library
   itself would take advantage of it and could save various information
   in it. For example wxFontMapper or Unix version of wxFileDialog have
   the ability to use wxConfig class.

   Set

=head2 Constructor and destructor

   wxConfigBase

=head2 Path management

   As explained in config overview, the config classes support a file
   system-like hierarchy of keys (files) and groups (directories). As in
   the file system case, to specify a key in the config class you must
   use a path to it. Config classes also support the notion of the
   current group, which makes it possible to use the relative paths. To
   clarify all this, here is an example (it is only for the sake of
   demonstration, it doesn't do anything sensible!):

     wxConfig *config = new wxConfig("FooBarApp");

=head2 Enumeration

   The functions in this section allow to enumerate all entries and
   groups in the config file. All functions here return false when there
   are no more items.

   You must pass the same index to GetNext and GetFirst (don't modify
   it). Please note that it is not the index of the current item (you
   will have some great surprises with wxRegConfig if you assume this)
   and you shouldn't even look at it: it is just a "cookie" which stores
   the state of the enumeration. It can't be stored inside the class
   because it would prevent you from running several enumerations
   simultaneously, that's why you must pass it explicitly.

   Having said all this, enumerating the config entries/groups is very
   simple:

     wxConfigBase *config = ...;
     wxArrayString aNames;

=head2 Tests of existence

   HasGroup

=head2 Miscellaneous functions

   GetAppName

=head2 Key access

   These function are the core of wxConfigBase class: they allow you to
   read and write config file data. All Read function take a default
   value which will be returned if the specified key is not found in the
   config file.

   Currently, only two types of data are supported: string and long (but
   it might change in the near future). To work with other types: for int
   or bool you can work with function taking/returning long and just use
   the casts. Better yet, just use long for all variables which you're
   going to save in the config file: chances are that sizeof(bool) ==
   sizeof(int) == sizeof(long) anyhow on your system. For float, double
   and, in general, any other type you'd have to translate them to/from
   string representation and use string functions.

   Try not to read long values into string variables and vice versa:
   although it just might work with wxFileConfig, you will get a system
   error with wxRegConfig because in the Windows registry the different
   types of entries are indeed used.

   Final remark: the szKey parameter for all these functions can contain
   an arbitrary path (either relative or absolute), not just the key
   name.

   Read

=head2 Rename entries/groups

   The functions in this section allow to rename entries or subgroups of
   the current group. They will return false on error. typically because
   either the entry/group with the original name doesn't exist, because
   the entry/group with the new name already exists or because the
   function is not supported in this wxConfig implementation.

   RenameEntry

=head2 Delete entries/groups

   The functions in this section delete entries and/or groups of entries
   from the config file. DeleteAll() is especially useful if you want to
   erase all traces of your program presence: for example, when you
   uninstall it.

   DeleteEntry

=head2 Options

   Some aspects of wxConfigBase behaviour can be changed during run-time.
   The first of them is the expansion of environment variables in the
   string values read from the config file: for example, if you have the
   following in your config file:

     # config file for my program
     UserData = $HOME/data

=head2 Wx::ConfigBase::new

   wxConfigBase(const wxString& appName = wxEmptyString, const wxString&
   vendorName = wxEmptyString, const wxString& localFilename =
   wxEmptyString, const wxString& globalFilename = wxEmptyString, long
   style = 0, wxMBConv& conv = wxConvUTF8)

   This is the default and only constructor of the wxConfigBase class,
   and derived classes.

   Parameters

   appName

       The application name. If this is empty, the class will normally
       use wxApp::GetAppName to set it. The application name is used in
       the registry key on Windows, and can be used to deduce the local
       filename parameter if that is missing.

   vendorName

       The vendor name. If this is empty, it is assumed that no vendor
       name is wanted, if this is optional for the current config class.
       The vendor name is appended to the application name for
       wxRegConfig.

   localFilename

       Some config classes require a local filename. If this is not
       present, but required, the application name will be used instead.

   globalFilename

       Some config classes require a global filename. If this is not
       present, but required, the application name will be used instead.

   style

       Can be one of wxCONFIG_USE_LOCAL_FILE and
       wxCONFIG_USE_GLOBAL_FILE. The style interpretation depends on the
       config class and is ignored by some implementations. For
       wxFileConfig, these styles determine whether a local or global
       config file is created or used: if wxCONFIG_USE_GLOBAL_FILE is
       used, then settings are read from the global config file and if
       wxCONFIG_USE_LOCAL_FILE is used, settings are read from and
       written to local config file (if they are both set, global file is
       read first, then local file, overwriting global settings). If the
       flag is present but the parameter is empty, the parameter will be
       set to a default. If the parameter is present but the style flag
       not, the relevant flag will be added to the style. For
       wxRegConfig, thie GLOBAL flag refers to HKLM key while LOCAL one
       is for the usual HKCU one.

       For wxFileConfig you can also add wxCONFIG_USE_RELATIVE_PATH by
       logically or'ing it to either of the _FILE options to tell
       wxFileConfig to use relative instead of absolute paths.

       On non-VMS Unix systems, the default local configuration file is
       ~/.appname. However, this path may be also used as user data
       directory (see wxStandardPaths::GetUserDataDir) if the application
       has several data files. In this case wxCONFIG_USE_SUBDIR flag,
       which changes the default local configuration file to
       ~/.appname/appname should be used. Notice that this flag is
       ignored on non-Unix system, including VMS, or if a non-default
       localFilename is provided. This function is new since wxWidgets
       version 2.8.2

       For wxFileConfig, you can also add
       wxCONFIG_USE_NO_ESCAPE_CHARACTERS which will turn off character
       escaping for the values of entries stored in the config file: for
       example a foo key with some backslash characters will be stored as
       foo=C:\mydir instead of the usual storage of foo=C:\\mydir.

       The wxCONFIG_USE_NO_ESCAPE_CHARACTERS style can be helpful if your
       config file must be read or written to by a non-wxWidgets program
       (which might not understand the escape characters). Note, however,
       that if wxCONFIG_USE_NO_ESCAPE_CHARACTERS style is used, it is is
       now your application's responsibility to ensure that there is no
       newline or other illegal characters in a value, before writing
       that value to the file.

   conv

       This parameter is only used by wxFileConfig when compiled in
       Unicode mode. It specifies the encoding in which the configuration
       file is written.

=head2 Wx::ConfigBase::DESTROY

   ~wxConfigBase()

   Empty but ensures that dtor of all derived classes is virtual.

=head2 Wx::ConfigBase::Create

   static wxConfigBase * Create()

   Create a new config object: this function will create the "best"
   implementation of wxConfig available for the current platform, see
   comments near the definition of wxCONFIG_WIN32_NATIVE for details. It
   returns the created object and also sets it as the current one.

=head2 Wx::ConfigBase::DontCreateOnDemand

   void DontCreateOnDemand()

   Calling this function will prevent Get() from automatically creating a
   new config object if the current one is NULL. It might be useful to
   call it near the program end to prevent "accidental" creation of a new
   config object.

=head2 Wx::ConfigBase::DeleteAll

   bool DeleteAll()

   Delete the whole underlying object (disk file, registry key, ...).
   Primarly for use by uninstallation routine.

=head2 Wx::ConfigBase::DeleteEntry

   bool DeleteEntry(const wxString& key, bool bDeleteGroupIfEmpty = true)

   Deletes the specified entry and the group it belongs to if it was the
   last key in it and the second parameter is true.

=head2 Wx::ConfigBase::DeleteGroup

   bool DeleteGroup(const wxString& key)

   Delete the group (with all subgroups). If the current path is under
   the group being deleted it is changed to its deepest still existing
   component. E.g. if the current path is /A/B/C/D and the group C is
   deleted the path becomes /A/B.

=head2 Wx::ConfigBase::Exists

   bool Exists(wxString& strName) const

   returns true if either a group or an entry with a given name exists

=head2 Wx::ConfigBase::Flush

   bool Flush(bool bCurrentOnly = false)

   permanently writes all changes (otherwise, they're only written from
   object's destructor)

=head2 Wx::ConfigBase::Get

   static wxConfigBase * Get(bool CreateOnDemand = true)

   Get the current config object. If there is no current object and
   CreateOnDemand is true, creates one (using Create) unless
   DontCreateOnDemand was called previously.

=head2 Wx::ConfigBase::GetAppName

   wxString GetAppName() const

   Returns the application name.

=head2 Wx::ConfigBase::GetEntryType

   enum wxConfigBase::EntryType GetEntryType(const wxString& name) const

   Returns the type of the given entry or Unknown if the entry doesn't
   exist. This function should be used to decide which version of Read()
   should be used because some of wxConfig implementations will complain
   about type mismatch otherwise: e.g., an attempt to read a string value
   from an integer key with wxRegConfig will fail.

   The result is an element of enum EntryType:

     enum EntryType
     {
       Type_Unknown,
       Type_String,
       Type_Boolean,
       Type_Integer,
       Type_Float
     };

=head2 Wx::ConfigBase::GetFirstGroup

   bool GetFirstGroup(wxString& str, long& index) const

   Gets the first group.

   wxPython note: The wxPython version of this method returns a 3-tuple
   consisting of the continue flag, the value string, and the index for
   the next call.

   wxPerl note: In wxPerl this method takes no arguments and returns a
   3-element list ( continue, str, index ).

=head2 Wx::ConfigBase::GetFirstEntry

   bool GetFirstEntry(wxString& str, long& index) const

   Gets the first entry.

   wxPython note: The wxPython version of this method returns a 3-tuple
   consisting of the continue flag, the value string, and the index for
   the next call.

   wxPerl note: In wxPerl this method takes no arguments and returns a
   3-element list ( continue, str, index ).

=head2 Wx::ConfigBase::GetNextGroup

   bool GetNextGroup(wxString& str, long& index) const

   Gets the next group.

   wxPython note: The wxPython version of this method returns a 3-tuple
   consisting of the continue flag, the value string, and the index for
   the next call.

   wxPerl note: In wxPerl this method only takes the index parameter and
   returns a 3-element list ( continue, str, index ).

=head2 Wx::ConfigBase::GetNextEntry

   bool GetNextEntry(wxString& str, long& index) const

   Gets the next entry.

   wxPython note: The wxPython version of this method returns a 3-tuple
   consisting of the continue flag, the value string, and the index for
   the next call.

   wxPerl note: In wxPerl this method only takes the index parameter and
   returns a 3-element list ( continue, str, index ).

=head2 Wx::ConfigBase::GetNumberOfEntries

   uint GetNumberOfEntries(bool bRecursive = false) const

=head2 Wx::ConfigBase::GetNumberOfGroups

   uint GetNumberOfGroups(bool bRecursive = false) const

   Get number of entries/subgroups in the current group, with or without
   its subgroups.

=head2 Wx::ConfigBase::GetPath

   const wxString& GetPath() const

   Retrieve the current path (always as absolute path).

=head2 Wx::ConfigBase::GetVendorName

   wxString GetVendorName() const

   Returns the vendor name.

=head2 Wx::ConfigBase::HasEntry

   bool HasEntry(wxString& strName) const

   returns true if the entry by this name exists

=head2 Wx::ConfigBase::HasGroup

   bool HasGroup(const wxString& strName) const

   returns true if the group by this name exists

=head2 Wx::ConfigBase::IsExpandingEnvVars

   bool IsExpandingEnvVars() const

   Returns true if we are expanding environment variables in key values.

=head2 Wx::ConfigBase::IsRecordingDefaults

   bool IsRecordingDefaults() const

   Returns true if we are writing defaults back to the config file.

=head2 Wx::ConfigBase::Read

   bool Read(const wxString& key, wxString* str) const

   Read a string from the key, returning true if the value was read. If
   the key was not found, str is not changed.

   bool Read(const wxString& key, wxString* str, const wxString&
   defaultVal) const

   Read a string from the key. The default value is returned if the key
   was not found.

   Returns true if value was really read, false if the default was used.

   wxString Read(const wxString& key, const wxString& defaultVal) const

   Another version of Read(), returning the string value directly.

   bool Read(const wxString& key, long* l) const

   Reads a long value, returning true if the value was found. If the
   value was not found, l is not changed.

   bool Read(const wxString& key, long* l, long defaultVal) const

   Reads a long value, returning true if the value was found. If the
   value was not found, defaultVal is used instead.

   long Read(const wxString& key, long defaultVal) const

   Reads a long value from the key and returns it. defaultVal is returned
   if the key is not found.

   NB: writing

       conf->Read("key", 0);

   won't work because the call is ambiguous: compiler can not choose
   between two Read functions. Instead, write:

       conf->Read("key", 0l);

   bool Read(const wxString& key, double* d) const

   Reads a double value, returning true if the value was found. If the
   value was not found, d is not changed.

   bool Read(const wxString& key, double* d, double defaultVal) const

   Reads a double value, returning true if the value was found. If the
   value was not found, defaultVal is used instead.

   bool Read(const wxString& key, bool* b) const

   Reads a bool value, returning true if the value was found. If the
   value was not found, b is not changed.

   bool Read(const wxString& key, bool* d, bool defaultVal) const

   Reads a bool value, returning true if the value was found. If the
   value was not found, defaultVal is used instead.

   wxPython note: In place of a single overloaded method name, wxPython
   implements the following methods:

=head2 Wx::ConfigBase::RenameEntry

   bool RenameEntry(const wxString& oldName, const wxString& newName)

   Renames an entry in the current group. The entries names (both the old
   and the new one) shouldn't contain backslashes, i.e. only simple names
   and not arbitrary paths are accepted by this function.

   Returns false if oldName doesn't exist or if newName already exists.

=head2 Wx::ConfigBase::RenameGroup

   bool RenameGroup(const wxString& oldName, const wxString& newName)

   Renames a subgroup of the current group. The subgroup names (both the
   old and the new one) shouldn't contain backslashes, i.e. only simple
   names and not arbitrary paths are accepted by this function.

   Returns false if oldName doesn't exist or if newName already exists.

=head2 Wx::ConfigBase::Set

   static wxConfigBase * Set(wxConfigBase *pConfig)

   Sets the config object as the current one, returns the pointer to the
   previous current object (both the parameter and returned value may be
   NULL)

=head2 Wx::ConfigBase::SetExpandEnvVars

   void SetExpandEnvVars (bool bDoIt = true)

   Determine whether we wish to expand environment variables in key
   values.

=head2 Wx::ConfigBase::SetPath

   void SetPath(const wxString& strPath)

   Set current path: if the first character is '/', it is the absolute
   path, otherwise it is a relative path. '..' is supported. If strPath
   doesn't exist it is created.

=head2 Wx::ConfigBase::SetRecordDefaults

   void SetRecordDefaults(bool bDoIt = true)

   Sets whether defaults are recorded to the config file whenever an
   attempt to read the value which is not present in it is done.

   If on (default is off) all default values for the settings used by the
   program are written back to the config file. This allows the user to
   see what config options may be changed and is probably useful only for
   wxFileConfig.

=head2 Wx::ConfigBase::Write

   bool Write(const wxString& key, const wxString& value)

   bool Write(const wxString& key, long value)

   bool Write(const wxString& key, double value)

   bool Write(const wxString& key, bool value)

   These functions write the specified value to the config file and
   return true on success.

   wxPython note: In place of a single overloaded method name, wxPython
   implements the following methods:

=head1 Wx::Connection

=head2 Wx::Connection::new

   wxConnection()

   wxConnection(char* buffer, int size)

   Constructs a connection object. If no user-defined connection object
   is to be derived from wxConnection, then the constructor should not be
   called directly, since the default connection object will be provided
   on requesting (or accepting) a connection. However, if the user
   defines his or her own derived connection object, the
   wxServer::OnAcceptConnection and/or wxClient::OnMakeConnection members
   should be replaced by functions which construct the new connection
   object.

   If the arguments of the wxConnection constructor are void then the
   wxConnection object manages its own connection buffer, allocating
   memory as needed. A programmer-supplied buffer cannot be increased if
   necessary, and the program will assert if it is not large enough. The
   programmer-supplied buffer is included mainly for backwards
   compatibility.

=head2 Wx::Connection::Advise

   bool Advise(const wxString& item, char* data, int size = -1,
   wxIPCFormat format = wxCF_TEXT)

   Called by the server application to advise the client of a change in
   the data associated with the given item. Causes the client
   connection's wxConnection::OnAdvise member to be called. Returns true
   if successful.

=head2 Wx::Connection::Execute

   bool Execute(char* data, int size = -1, wxIPCFormat format = wxCF_TEXT)

   Called by the client application to execute a command on the server.
   Can also be used to transfer arbitrary data to the server (similar to
   wxConnection::Poke in that respect). Causes the server connection's
   wxConnection::OnExecute member to be called. Returns true if
   successful.

=head2 Wx::Connection::Disconnect

   bool Disconnect()

   Called by the client or server application to disconnect from the
   other program; it causes the wxConnection::OnDisconnect message to be
   sent to the corresponding connection object in the other program.
   Returns true if successful or already disconnected. The application
   that calls Disconnect must explicitly delete its side of the
   connection.

=head2 Wx::Connection::OnAdvise

   virtual bool OnAdvise(const wxString& topic, const wxString& item,
   char* data, int size, wxIPCFormat format)

   Message sent to the client application when the server notifies it of
   a change in the data associated with the given item, using Advise.

=head2 Wx::Connection::OnDisconnect

   virtual bool OnDisconnect()

   Message sent to the client or server application when the other
   application notifies it to end the connection. The default behaviour
   is to delete the connection object and return true, so applications
   should generally override OnDisconnect (finally calling the inherited
   method as well) so that they know the connection object is no longer
   available.

=head2 Wx::Connection::OnExecute

   virtual bool OnExecute(const wxString& topic, char* data, int size,
   wxIPCFormat format)

   Message sent to the server application when the client notifies it to
   execute the given data, using Execute. Note that there is no item
   associated with this message.

=head2 Wx::Connection::OnPoke

   virtual bool OnPoke(const wxString& topic, const wxString& item, char*
   data, int size, wxIPCFormat format)

   Message sent to the server application when the client notifies it to
   accept the given data.

=head2 Wx::Connection::OnRequest

   virtual char* OnRequest(const wxString& topic, const wxString& item,
   int *size, wxIPCFormat format)

   Message sent to the server application when the client calls
   wxConnection::Request. The server's OnRequest method should respond by
   returning a character string, or NULL to indicate no data, and setting
   *size. The character string must of course persist after the call
   returns.

=head2 Wx::Connection::OnStartAdvise

   virtual bool OnStartAdvise(const wxString& topic, const wxString& item)

   Message sent to the server application by the client, when the client
   wishes to start an 'advise loop' for the given topic and item. The
   server can refuse to participate by returning false.

=head2 Wx::Connection::OnStopAdvise

   virtual bool OnStopAdvise(const wxString& topic, const wxString& item)

   Message sent to the server application by the client, when the client
   wishes to stop an 'advise loop' for the given topic and item. The
   server can refuse to stop the advise loop by returning false, although
   this doesn't have much meaning in practice.

=head2 Wx::Connection::Poke

   bool Poke(const wxString& item, char* data, int size = -1, wxIPCFormat
   format = wxCF_TEXT)

   Called by the client application to poke data into the server. Can be
   used to transfer arbitrary data to the server. Causes the server
   connection's wxConnection::OnPoke member to be called. If size is -1
   the size is computed from the string length of data.

   Returns true if successful.

=head2 Wx::Connection::Request

   char* Request(const wxString& item, int *size, wxIPCFormat format =
   wxIPC_TEXT)

   Called by the client application to request data from the server.
   Causes the server connection's wxConnection::OnRequest member to be
   called. Size may be NULL or a pointer to a variable to receive the
   size of the requested item.

   Returns a character string (actually a pointer to the connection's
   buffer) if successful, NULL otherwise. This buffer does not need to be
   deleted.

=head2 Wx::Connection::StartAdvise

   bool StartAdvise(const wxString& item)

   Called by the client application to ask if an advise loop can be
   started with the server. Causes the server connection's
   wxConnection::OnStartAdvise member to be called. Returns true if the
   server okays it, false otherwise.

=head2 Wx::Connection::StopAdvise

   bool StopAdvise(const wxString& item)

   Called by the client application to ask if an advise loop can be
   stopped. Causes the server connection's wxConnection::OnStopAdvise
   member to be called. Returns true if the server okays it, false
   otherwise.

=head1 Wx::ChildFocusEvent

=head2 Wx::ChildFocusEvent::new

   wxChildFocusEvent(wxWindow *win = NULL)

   Constructor.

   Parameters

   win 

       The direct child which is (or which contains the window which is)
       receiving the focus.

=head2 Wx::ChildFocusEvent::GetWindow

   Returns the direct child which receives the focus, or a (grand-)parent
   of the control receiving the focus.

   To get the actually focused control use wxWindow::FindFocus.

=head1 Wx::ContextMenuEvent

=head2 Wx::ContextMenuEvent::new

   wxContextMenuEvent(WXTYPE id = 0, int id = 0, const wxPoint&
   pos=wxDefaultPosition)

   Constructor.

=head2 Wx::ContextMenuEvent::GetPosition

   wxPoint GetPosition() const

   Returns the position in screen coordinates at which the menu should be
   shown. Use wxWindow::ScreenToClient to convert to client coordinates.
   You can also omit a position from wxWindow::PopupMenu in order to use
   the current mouse pointer position.

   If the event originated from a keyboard event, the value returned from
   this function will be wxDefaultPosition.

=head2 Wx::ContextMenuEvent::SetPosition

   void SetPosition(const wxPoint& point)

   Sets the position at which the menu should be shown.

=head1 Wx::ContextHelp

=head2 Wx::ContextHelp::new

   wxContextHelp(wxWindow* window = NULL, bool doNow = true)

   Constructs a context help object, calling BeginContextHelp if doNow is
   true (the default).

   If window is NULL, the top window is used.

=head2 Wx::ContextHelp::DESTROY

   ~wxContextHelp()

   Destroys the context help object.

=head2 Wx::ContextHelp::BeginContextHelp

   bool BeginContextHelp(wxWindow* window = NULL)

   Puts the application into context-sensitive help mode. window is the
   window which will be used to catch events; if NULL, the top window
   will be used.

   Returns true if the application was successfully put into
   context-sensitive help mode. This function only returns when the event
   loop has finished.

=head2 Wx::ContextHelp::EndContextHelp

   bool EndContextHelp()

   Ends context-sensitive help mode. Not normally called by the
   application.

=head1 Wx::ContextHelpButton

=head2 Wx::ContextHelpButton::new

   wxContextHelpButton()

   Default constructor.

   wxContextHelpButton( wxWindow* parent, wxWindowID id =
   wxID_CONTEXT_HELP, const wxPoint& pos = wxDefaultPosition, const
   wxSize& size = wxDefaultSize, long style = wxBU_AUTODRAW)

   Constructor, creating and showing a context help button.

   Parameters

   parent

       Parent window. Must not be NULL.

   id  

       Button identifier. Defaults to wxID_CONTEXT_HELP.

   pos 

       Button position.

   size

       Button size. If the default size (-1, -1) is specified then the
       button is sized appropriately for the question mark bitmap.

   style

       Window style.

   Remarks

   Normally you need pass only the parent window to the constructor, and
   use the defaults for the remaining parameters.

=head1 Wx::Control

=head2 Wx::Control::Command

   void Command(wxCommandEvent& event)

   Simulates the effect of the user issuing a command to the item. See
   wxCommandEvent.

=head2 Wx::Control::GetLabel

   const wxString& GetLabel() const

   Returns the control's text.

   Note that the returned string contains the mnemonics (& characters) if
   any, use wxControl::GetLabelText if they are undesired.

=head2 Wx::Control::GetLabelText

   const wxString& GetLabelText() const

   static const wxString& GetLabelText(const wxString& label)

   Returns the control's label or the given label string for the static
   version without the mnemonics characters.

=head2 Wx::Control::SetLabel

   void SetLabel(const wxString& label)

   Sets the item's text.

   The & characters in the label are special and indicate that the
   following character is a mnemonic for this control and can be used to
   activate it from the keyboard (typically by using Alt key in
   combination with it). To insert a literal ampersand character, you
   need to double it, i.e. use "&&".

=head1 Wx::ControlWithItems

=head2 Wx::ControlWithItems::Append

   int Append(const wxString& item)

   Adds the item to the end of the list box.

   int Append(const wxString& item, void *clientData)

   int Append(const wxString& item, wxClientData *clientData)

   Adds the item to the end of the list box, associating the given, typed
   or untyped, client data pointer with the item.

   void Append(const wxArrayString& strings)

   Appends several items at once to the control. Notice that calling this
   method may be much faster than appending the items one by one if you
   need to add a lot of items.

   Parameters

   item

       String to add.

   clientData

       Client data to associate with the item.

   Return value

   When appending a single item, the return value is the index of the
   newly added item which may be different from the last one if the
   control is sorted (e.g. has wxLB_SORT or wxCB_SORT style).

=head2 Wx::ControlWithItems::Clear

   void Clear()

   Removes all items from the control.

   Clear() also deletes the client data of the existing items if it is
   owned by the control.

=head2 Wx::ControlWithItems::Delete

   void Delete(unsigned int n)

   Deletes an item from the control. The client data associated with the
   item will be also deleted if it is owned by the control.

   Note that it is an error (signalled by an assert failure in debug
   builds) to remove an item with the index negative or greater or equal
   than the number of items in the control.

   Parameters

   n   

       The zero-based item index.

   See also

   Clear

=head2 Wx::ControlWithItems::FindString

   int FindString(const wxString& string, bool caseSensitive = false)

   Finds an item whose label matches the given string.

   Parameters

   string

       String to find.

   caseSensitive

       Whether search is case sensitive (default is not).

   Return value

   The zero-based position of the item, or wxNOT_FOUND if the string was
   not found.

=head2 Wx::ControlWithItems::GetClientData

   void * GetClientData(unsigned int n) const

   Returns a pointer to the client data associated with the given item
   (if any). It is an error to call this function for a control which
   doesn't have untyped client data at all although it is ok to call it
   even if the given item doesn't have any client data associated with it
   (but other items do).

   Parameters

   n   

       The zero-based position of the item.

   Return value

   A pointer to the client data, or NULL if not present.

=head2 Wx::ControlWithItems::GetClientObject

   wxClientData * GetClientObject(unsigned int n) const

   Returns a pointer to the client data associated with the given item
   (if any). It is an error to call this function for a control which
   doesn't have typed client data at all although it is ok to call it
   even if the given item doesn't have any client data associated with it
   (but other items do).

   Parameters

   n   

       The zero-based position of the item.

   Return value

   A pointer to the client data, or NULL if not present.

=head2 Wx::ControlWithItems::GetCount

   unsigned int GetCount() const

   Returns the number of items in the control.

   See also

   IsEmpty

=head2 Wx::ControlWithItems::GetSelection

   int GetSelection() const

   Returns the index of the selected item or wxNOT_FOUND if no item is
   selected.

   Return value

   The position of the current selection.

   Remarks

   This method can be used with single selection list boxes only, you
   should use wxListBox::GetSelections for the list boxes with
   wxLB_MULTIPLE style.

   See also

   SetSelection, GetStringSelection

=head2 Wx::ControlWithItems::GetString

   wxString GetString(unsigned int n) const

   Returns the label of the item with the given index.

   Parameters

   n   

       The zero-based index.

   Return value

   The label of the item or an empty string if the position was invalid.

=head2 Wx::ControlWithItems::GetStrings

   wxArrayString GetStrings() const

   Returns the array of the labels of all items in the control.

=head2 Wx::ControlWithItems::GetStringSelection

   wxString GetStringSelection() const

   Returns the label of the selected item or an empty string if no item
   is selected.

   See also

   GetSelection

=head2 Wx::ControlWithItems::Insert

   int Insert(const wxString& item, unsigned int pos)

   Inserts the item into the list before pos. Not valid for wxLB_SORT or
   wxCB_SORT styles, use Append instead.

   int Insert(const wxString& item, unsigned int pos, void *clientData)

   int Insert(const wxString& item, unsigned int pos, wxClientData *clientData)

   Inserts the item into the list before pos, associating the given,
   typed or untyped, client data pointer with the item. Not valid for
   wxLB_SORT or wxCB_SORT styles, use Append instead.

   Parameters

   item

       String to add.

   pos 

       Position to insert item before, zero based.

   clientData

       Client data to associate with the item.

   Return value

   The return value is the index of the newly inserted item. If the
   insertion failed for some reason, -1 is returned.

=head2 Wx::ControlWithItems::IsEmpty

   bool IsEmpty() const

   Returns true if the control is empty or false if it has some items.

   See also

   GetCount

=head2 Wx::ControlWithItems::Number

   int Number() const

   Obsolescence note: This method is obsolete and was replaced with
   GetCount, please use the new method in the new code. This method is
   only available if wxWidgets was compiled with WXWIN_COMPATIBILITY_2_2
   defined and will disappear completely in future versions.

=head2 Wx::ControlWithItems::Select

   void Select(int n)

   This is the same as SetSelection and exists only because it is
   slightly more natural for controls which support multiple selection.

=head2 Wx::ControlWithItems::SetClientData

   void SetClientData(unsigned int n, void *data)

   Associates the given untyped client data pointer with the given item.
   Note that it is an error to call this function if any typed client
   data pointers had been associated with the control items before.

   Parameters

   n   

       The zero-based item index.

   data

       The client data to associate with the item.

=head2 Wx::ControlWithItems::SetClientObject

   void SetClientObject(unsigned int n, wxClientData *data)

   Associates the given typed client data pointer with the given item:
   the data object will be deleted when the item is deleted (either
   explicitly by using Deletes or implicitly when the control itself is
   destroyed).

   Note that it is an error to call this function if any untyped client
   data pointers had been associated with the control items before.

   Parameters

   n   

       The zero-based item index.

   data

       The client data to associate with the item.

=head2 Wx::ControlWithItems::SetSelection

   void SetSelection(int n)

   Sets the selection to the given item n or removes the selection
   entirely if n == wxNOT_FOUND.

   Note that this does not cause any command events to be emitted nor
   does it deselect any other items in the controls which support
   multiple selections.

   Parameters

   n   

       The string position to select, starting from zero.

   See also

   SetString, SetStringSelection

=head2 Wx::ControlWithItems::SetString

   void SetString(unsigned int n, const wxString& string)

   Sets the label for the given item.

   Parameters

   n   

       The zero-based item index.

   string

       The label to set.

=head2 Wx::ControlWithItems::SetStringSelection

   bool SetStringSelection(const wxString& string)

   Selects the item with the specified string in the control. This
   doesn't cause any command events being emitted.

   Parameters

   string

       The string to select.

   Return value

   true if the specified string has been selected, false if it wasn't
   found in the control.

   See also

   SetSelection

=head1 Wx::CountingOutputStream

=head2 Wx::CountingOutputStream::new

   wxCountingOutputStream()

   Creates a wxCountingOutputStream object.

=head2 Wx::CountingOutputStream::DESTROY

   ~wxCountingOutputStream()

   Destructor.

=head2 Wx::CountingOutputStream::GetSize

   size_t GetSize() const

   Returns the current size of the stream.

=head1 Wx::CriticalSection

=head2 Wx::CriticalSection::new

   wxCriticalSection()

   Default constructor initializes critical section object.

=head2 Wx::CriticalSection::DESTROY

   ~wxCriticalSection()

   Destructor frees the resources.

=head2 Wx::CriticalSection::Enter

   void Enter()

   Enter the critical section (same as locking a mutex). There is no
   error return for this function. After entering the critical section
   protecting some global data the thread running in critical section may
   safely use/modify it.

=head2 Wx::CriticalSection::Leave

   void Leave()

   Leave the critical section allowing other threads use the global data
   protected by it. There is no error return for this function.

=head1 Wx::CriticalSectionLocker

=head2 Wx::CriticalSectionLocker::new

   wxCriticalSectionLocker(wxCriticalSection& criticalsection)

   Constructs a wxCriticalSectionLocker object associated with given
   criticalsection and enters it.

=head2 Wx::CriticalSectionLocker::DESTROY

   ~wxCriticalSectionLocker()

   Destructor leaves the critical section.

=head1 Wx::CSConv

=head2 Wx::CSConv::new

   wxCSConv(const wxChar* charset)

   wxCSConv(wxFontEncoding encoding)

   Constructor. You may specify either the name of the character set you
   want to convert from/to or an encoding constant. If the character set
   name (or the encoding) is not recognized, ISO 8859-1 is used as fall
   back.

=head2 Wx::CSConv::DESTROY

   ~wxCSConv()

   Destructor frees any resources needed to perform the conversion.

=head2 Wx::CSConv::IsOk

   bool IsOk() const

   Returns true if the charset (or the encoding) given at constructor is
   really available to use. Returns false if ISO 8859-1 will be used
   instead.

   Note this does not mean that a given string will be correctly
   converted. A malformed string may still make conversion functions
   return wxCONV_FAILED.

   This function is new since wxWidgets version 2.8.2

=head2 Wx::CSConv::MB2WC

   size_t MB2WC(wchar_t* buf, const char* psz, size_t n) const

   Converts from the selected character set to Unicode. Returns length of
   string written to destination buffer.

=head2 Wx::CSConv::WC2MB

   size_t WC2MB(char* buf, const wchar_t* psz, size_t n) const

   Converts from Unicode to the selected character set. Returns length of
   string written to destination buffer.

=head1 Wx::Cursor

=head2 Wx::Cursor::new

   wxCursor()

   Default constructor.

   wxCursor(const char bits[], int width, int height, int hotSpotX=-1,
   int hotSpotY=-1, const char maskBits[]=NULL, wxColour* fg=NULL,
   wxColour* bg=NULL)

   Constructs a cursor by passing an array of bits (Motif and GTK+ only).
   maskBits is used only under Motif and GTK+. The parameters fg and bg
   are only present on GTK+, and force the cursor to use particular
   background and foreground colours.

   If either hotSpotX or hotSpotY is -1, the hotspot will be the centre
   of the cursor image (Motif only).

   wxCursor(const wxString& cursorName, long type, int hotSpotX=0, int
   hotSpotY=0)

   Constructs a cursor by passing a string resource name or filename.

   On MacOS when specifying a string resource name, first the color
   cursors 'crsr' and then the black/white cursors 'CURS' in the resource
   chain are scanned through.

   hotSpotX and hotSpotY are currently only used under Windows when
   loading from an icon file, to specify the cursor hotspot relative to
   the top left of the image.

   wxCursor(int cursorId)

   Constructs a cursor using a cursor identifier.

   wxCursor(const wxImage& image)

   Constructs a cursor from a wxImage. If the cursor is monochrome on the
   current platform, colors with the RGB elements all greater than 127
   will be foreground, colors less than this will be background. The mask
   (if any) will be used to specify the transparent area.

   In wxMSW the foreground will be white and the background black. If the
   cursor is larger than 32x32 it is resized.

   In wxGTK, colour cursors and alpha channel are supported (starting
   from GTK+ 2.2). Otherwise the two most frequent colors will be used
   for foreground and background. In any case, the cursor will be
   displayed at the size of the image.

   In wxMac, if the cursor is larger than 16x16 it is resized and
   currently only shown as black/white (mask respected).

   wxCursor(const wxCursor& cursor)

   Copy constructor, uses reference counting.

   Parameters

   bits

       An array of bits.

   maskBits

       Bits for a mask bitmap.

   width

       Cursor width.

   height

       Cursor height.

   hotSpotX

       Hotspot x coordinate.

   hotSpotY

       Hotspot y coordinate.

   type

       Icon type to load. Under Motif, type defaults to wxBITMAP_TYPE_XBM.
       Under Windows, it defaults to wxBITMAP_TYPE_CUR_RESOURCE. Under
       MacOS, it defaults to wxBITMAP_TYPE_MACCURSOR_RESOURCE.

       Under X, the permitted cursor types are:

=head2 Wx::Cursor::DESTROY

   ~wxCursor()

   Destroys the cursor. See reference-counted object destruction for more
   info.

   A cursor can be reused for more than one window, and does not get
   destroyed when the window is destroyed. wxWidgets destroys all cursors
   on application exit, although it is best to clean them up explicitly.

=head2 Wx::Cursor::IsOk

   bool IsOk() const

   Returns true if cursor data is present.

=head1 Wx::CustomDataObject

=head2 Wx::CustomDataObject::new

   wxCustomDataObject(const wxDataFormat& format = wxFormatInvalid)

   The constructor accepts a format argument which specifies the (single)
   format supported by this object. If it isn't set here, SetFormat
   should be used.

=head2 Wx::CustomDataObject::DESTROY

   ~wxCustomDataObject()

   The destructor will free the data hold by the object. Notice that
   although it calls a virtual Free() function, the base class version
   will always be called (C++ doesn't allow calling virtual functions
   from constructors or destructors), so if you override Free(), you
   should override the destructor in your class as well (which would
   probably just call the derived class' version of Free()).

=head2 Wx::CustomDataObject::Alloc

   virtual void * Alloc(size_t size)

   This function is called to allocate size bytes of memory from
   SetData(). The default version just uses the operator new.

=head2 Wx::CustomDataObject::Free

   virtual void Free()

   This function is called when the data is freed, you may override it to
   anything you want (or may be nothing at all). The default version
   calls operator delete[] on the data.

=head2 Wx::CustomDataObject::GetSize

   virtual size_t GetSize() const

   Returns the data size in bytes.

=head2 Wx::CustomDataObject::GetData

   virtual void * GetData() const

   Returns a pointer to the data.

=head2 Wx::CustomDataObject::SetData

   virtual void SetData( size_t size, const void *data)

   Set the data. The data object will make an internal copy.

   wxPython note: This method expects a string in wxPython. You can pass
   nearly any object by pickling it first.

=head2 Wx::CustomDataObject::TakeData

   virtual void TakeData( size_t size, const void *data)

   Like SetData, but doesn't copy the data - instead the object takes
   ownership of the pointer.

   wxPython note: This method expects a string in wxPython. You can pass
   nearly any object by pickling it first.

=head1 Wx::DataFormat

=head2 Wx::DataFormat::new

   wxDataFormat(NativeFormat format = wxDF_INVALID)

   Constructs a data format object for one of the standard data formats
   or an empty data object (use SetType or SetId later in this case)

   wxPerl note: In wxPerl this function is named newNative.

=head2 Wx::DataFormat::new

   wxDataFormat(const wxChar *format)

   Constructs a data format object for a custom format identified by its
   name format.

   wxPerl note: In wxPerl this function is named newUser.

=head2 Wx::DataFormat::GetId

   wxString GetId() const

   Returns the name of a custom format (this function will fail for a
   standard format).

=head2 Wx::DataFormat::GetType

   NativeFormat GetType() const

   Returns the platform-specific number identifying the format.

=head2 Wx::DataFormat::SetId

   void SetId(const wxChar *format)

   Sets the format to be the custom format identified by the given name.

=head2 Wx::DataFormat::SetType

   void SetType(NativeFormat format)

   Sets the format to the given value, which should be one of wxDF_XXX
   constants.

=head1 Wx::DatagramSocket

=head2 Wx::DatagramSocket::new

   wxDatagramSocket(wxSocketFlags flags = wxSOCKET_NONE)

   Constructor.

   Parameters

   flags

       Socket flags (See wxSocketBase::SetFlags)

=head2 Wx::DatagramSocket::DESTROY

   ~wxDatagramSocket()

   Destructor. Please see wxSocketBase::Destroy.

=head2 Wx::DatagramSocket::ReceiveFrom

   wxDatagramSocket& ReceiveFrom(wxSockAddress& address, void * buffer,
   wxUint32 nbytes)

   This function reads a buffer of nbytes bytes from the socket.

   Use LastCount to verify the number of bytes actually read.

   Use Error to determine if the operation succeeded.

   Parameters

   address

       Any address - will be overwritten with the address of the peer
       that sent that data.

   buffer

       Buffer where to put read data.

   nbytes

       Number of bytes.

   Return value

   Returns a reference to the current object, and the address of the peer
   that sent the data on address param.

   See also

   wxSocketBase::Error, wxSocketBase::LastError, wxSocketBase::LastCount,
   wxSocketBase::SetFlags,

=head2 Wx::DatagramSocket::SendTo

   wxDatagramSocket& SendTo(const wxSockAddress& address, const void *
   buffer, wxUint32 nbytes)

   This function writes a buffer of nbytes bytes to the socket.

   Use LastCount to verify the number of bytes actually wrote.

   Use Error to determine if the operation succeeded.

   Parameters

   address

       The address of the destination peer for this data.

   buffer

       Buffer where read data is.

   nbytes

       Number of bytes.

   Return value

   Returns a reference to the current object.

   See also

   wxSocketBase::Error, wxSocketBase::LastError, wxSocketBase::LastCount,
   wxSocketBase::SetFlags

=head1 Wx::DataInputStream

=head2 Wx::DataInputStream::new

   wxDataInputStream(wxInputStream& stream)

   wxDataInputStream(wxInputStream& stream, wxMBConv& conv = wxMBConvUTF8)

   Constructs a datastream object from an input stream. Only read methods
   will be available. The second form is only available in Unicode build
   of wxWidgets.

   Parameters

   stream

       The input stream.

   conv

       Charset conversion object object used to decode strings in Unicode
       mode (see wxDataInputStream::ReadString documentation for detailed
       description). Note that you must not destroy conv before you
       destroy this wxDataInputStream instance!

=head2 Wx::DataInputStream::DESTROY

   ~wxDataInputStream()

   Destroys the wxDataInputStream object.

=head2 Wx::DataInputStream::BigEndianOrdered

   void BigEndianOrdered(bool be_order)

   If be_order is true, all data will be read in big-endian order, such
   as written by programs on a big endian architecture (e.g. Sparc) or
   written by Java-Streams (which always use big-endian order).

=head2 Wx::DataInputStream::Read8

   wxUint8 Read8()

   Reads a single byte from the stream.

   void Read8(wxUint8 *buffer, size_t size)

   Reads bytes from the stream in a specified buffer. The amount of bytes
   to read is specified by the size variable.

=head2 Wx::DataInputStream::Read16

   wxUint16 Read16()

   Reads a 16 bit unsigned integer from the stream.

   void Read16(wxUint16 *buffer, size_t size)

   Reads 16 bit unsigned integers from the stream in a specified buffer.
   the amount of 16 bit unsigned integer to read is specified by the size
   variable.

=head2 Wx::DataInputStream::Read32

   wxUint32 Read32()

   Reads a 32 bit unsigned integer from the stream.

   void Read32(wxUint32 *buffer, size_t size)

   Reads 32 bit unsigned integers from the stream in a specified buffer.
   the amount of 32 bit unsigned integer to read is specified by the size
   variable.

=head2 Wx::DataInputStream::Read64

   wxUint64 Read64()

   Reads a 64 bit unsigned integer from the stream.

   void Read64(wxUint64 *buffer, size_t size)

   Reads 64 bit unsigned integers from the stream in a specified buffer.
   the amount of 64 bit unsigned integer to read is specified by the size
   variable.

=head2 Wx::DataInputStream::ReadDouble

   double ReadDouble()

   Reads a double (IEEE encoded) from the stream.

   void ReadDouble(double *buffer, size_t size)

   Reads double data (IEEE encoded) from the stream in a specified
   buffer. the amount of double to read is specified by the size
   variable.

=head2 Wx::DataInputStream::ReadString

   wxString ReadString()

   Reads a string from a stream. Actually, this function first reads a
   long integer specifying the length of the string (without the last
   null character) and then reads the string.

   In Unicode build of wxWidgets, the fuction first reads multibyte
   (char*) string from the stream and then converts it to Unicode using
   the conv object passed to constructor and returns the result as
   wxString. You are responsible for using the same convertor as when
   writing the stream.

   See also wxDataOutputStream::WriteString.

=head1 Wx::DataObject

=head2 Wx::DataObject::new

   wxDataObject()

   Constructor.

=head2 Wx::DataObject::DESTROY

   ~wxDataObject()

   Destructor.

=head2 Wx::DataObject::GetAllFormats

   virtual void GetAllFormats( wxDataFormat *formats, Direction dir = Get)
   const

   Copy all supported formats in the given direction to the array pointed
   to by formats. There is enough space for GetFormatCount(dir) formats
   in it.

   wxPerl note: In wxPerl this method only takes the dir parameter. In
   scalar context it returns the first format, in list context it returns
   a list containing all the supported formats.

=head2 Wx::DataObject::GetDataHere

   virtual bool GetDataHere(const wxDataFormat& format, void *buf ) const

   The method will write the data of the format format in the buffer buf
   and return true on success, false on failure.

=head2 Wx::DataObject::GetDataSize

   virtual size_t GetDataSize(const wxDataFormat& format ) const

   Returns the data size of the given format format.

=head2 Wx::DataObject::GetFormatCount

   virtual size_t GetFormatCount(Direction dir = Get) const

   Returns the number of available formats for rendering or setting the
   data.

=head2 Wx::DataObject::GetPreferredFormat

   virtual wxDataFormat GetPreferredFormat(Direction dir = Get) const

   Returns the preferred format for either rendering the data (if dir is
   Get, its default value) or for setting it. Usually this will be the
   native format of the wxDataObject.

=head2 Wx::DataObject::SetData

   virtual bool SetData( const wxDataFormat& format, size_t len, const
   void *buf )

   Set the data in the format format of the length len provided in the
   buffer buf.

   Returns true on success, false on failure.

=head1 Wx::DataViewColumn

=head2 Wx::DataViewColumn::new

   wxDataViewColumn(const wxString& title, wxDataViewRenderer* renderer,
   unsigned int model_column, int width = 80, int flags =
   wxDATAVIEW_COL_RESIZABLE)

=head2 Wx::DataViewColumn::DESTROY

   ~wxDataViewColumn()

   Destructor.

=head2 Wx::DataViewColumn::GetBitmap

   const wxBitmap& GetBitmap()

   Returns the bitmap in the header of the column, if any.

=head2 Wx::DataViewColumn::GetModelColumn

   unsigned int GetModelColumn()

   Returns the index of the column of the model, which this
   wxDataViewColumn is displaying.

=head2 Wx::DataViewColumn::GetOwner

   wxDataViewCtrl* GetOwner()

   Returns the owning wxDataViewCtrl.

=head2 Wx::DataViewColumn::GetRenderer

   wxDataViewRenderer* GetRenderer()

   Returns the renderer of this wxDataViewColumn.

   See also wxDataViewRenderer.

=head2 Wx::DataViewColumn::GetSortable

   bool GetSortable()

   Returns true if the column is sortable.

   See SetSortable

=head2 Wx::DataViewColumn::GetWidth

   int GetWidth()

   Returns the width of the column.

=head2 Wx::DataViewColumn::IsSortOrderAscending

   bool IsSortOrderAscending()

   Returns true, if the sort order is ascending.

   See also SetSortOrder

=head2 Wx::DataViewColumn::SetAlignment

   void SetAlignment(wxAlignment align)

   Set the alignment of the column header.

=head2 Wx::DataViewColumn::SetBitmap

   void SetBitmap(const wxBitmap& bitmap)

   Set the bitmap of the column header.

=head2 Wx::DataViewColumn::SetSortOrder

   void SetSortOrder(bool ascending)

   Indicate the sort order if the implementation of the wxDataViewCtrl
   supports it, most commonly by showing a little arrow. Use this in
   conjunction with wxDataViewSortedListModel::SetAscending to sort the
   actual data.

=head2 Wx::DataViewColumn::SetSortable

   void SetSortable(bool sortable)

   Indicate that the column is sortable. This is only to provide a visual
   hint in the column (such as a sort order indicator). It will not
   actually sort the data. Use a wxDataViewSortedListModel to so the
   sorting.

=head2 Wx::DataViewColumn::SetTitle

   void SetTitle(const wxString& title)

   Set the title of the column header to title.

=head1 Wx::DataViewCtrl

=head2 Wx::DataViewCtrl::new

   wxDataViewCtrl()

   wxDataViewCtrl(wxWindow* parent, wxWindowID id, const wxPoint& pos =
   wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0,
   const wxValidator& validator = wxDefaultValidator)

   Constructor. Calls Create.

=head2 Wx::DataViewCtrl::DESTROY

   ~wxDataViewCtrl()

   Destructor.

=head2 Wx::DataViewCtrl::AppendColumn

   virtual bool AppendColumn(wxDataViewColumn* col)

   Add a wxDataViewColumn to the control. Note that there is a number of
   short cut methods which implicitly create a wxDataViewColumn and a
   wxDataViewRenderer for it (see below).

=head2 Wx::DataViewCtrl::AppendBitmapColumn

   bool AppendBitmapColumn(const wxString& label, unsigned int
   model_column, wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT, int
   width = -1)

   bool AppendBitmapColumn(const wxBitmap& label, unsigned int
   model_column, wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT, int
   width = -1)

   Appends a column for rendering a bitmap.

=head2 Wx::DataViewCtrl::AppendDateColumn

   bool AppendDateColumn(const wxString& label, unsigned int model_column,
   wxDataViewCellMode mode = wxDATAVIEW_CELL_ACTIVATABLE, int width = -1)

   bool AppendDateColumn(const wxBitmap& label, unsigned int model_column,
   wxDataViewCellMode mode = wxDATAVIEW_CELL_ACTIVATABLE, int width = -1)

   Appends a column for rendering a date.

=head2 Wx::DataViewCtrl::AppendProgressColumn

   bool AppendProgressColumn(const wxString& label, unsigned int
   model_column, wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT, int
   width = 80)

   bool AppendProgressColumn(const wxBitmap& label, unsigned int
   model_column, wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT, int
   width = 80)

   Appends a column for rendering a progress indicator.

=head2 Wx::DataViewCtrl::AppendTextColumn

   bool AppendTextColumn(const wxString& label, unsigned int model_column,
   wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT, int width = -1)

   bool AppendTextColumn(const wxBitmap& label, unsigned int model_column,
   wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT, int width = -1)

   Appends a column for rendering text.

=head2 Wx::DataViewCtrl::AppendToggleColumn

   bool AppendToggleColumn(const wxString& label, unsigned int
   model_column, wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT, int
   width = 30)

   bool AppendToggleColumn(const wxBitmap& label, unsigned int
   model_column, wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT, int
   width = 30)

   Appends a column for rendering a toggle.

=head2 Wx::DataViewCtrl::AssociateModel

   virtual bool AssociateModel(wxDataViewListModel* model)

   Associates a wxDataViewListModel with the control. In the future this
   should be changed to supporting any data model including a
   to-be-written wxDataViewTreeModel.

=head2 Wx::DataViewCtrl::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxPoint& pos =
   wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0,
   const wxValidator& validator = wxDefaultValidator)

   Create the control. Useful for two step creation.

=head2 Wx::DataViewCtrl::ClearColumns

   virtual bool ClearColumns()

   Removes all columns.

=head2 Wx::DataViewCtrl::ClearSelection

   void ClearSelection()

   Unselects all rows.

=head2 Wx::DataViewCtrl::DeleteColumn

   virtual bool DeleteColumn(unsigned int pos)

   Deletes given column.

=head2 Wx::DataViewCtrl::GetColumn

   virtual wxDataViewColumn* GetColumn(unsigned int pos)

   Returns pointer to the column.

=head2 Wx::DataViewCtrl::GetModel

   virtual wxDataViewListModel* GetModel()

   Returns pointer to the data model associated with the control (if
   any).

=head2 Wx::DataViewCtrl::GetNumberOfColumns

   virtual unsigned int GetNumberOfColumns()

   Returns the number of columns.

=head2 Wx::DataViewCtrl::GetSelection

   virtual int GetSelection() const

   Returns the index of the currently selected row. It will return -1 if
   no row is selected and the index of the first selected row if more
   than one row are selected.

=head2 Wx::DataViewCtrl::GetSelections

   virtual int GetSelections(wxArrayInt& aSelections) const

   Returns the number of selected rows and fills an array of int with the
   indeces of the selected rows.

=head2 Wx::DataViewCtrl::IsSelected

   virtual bool IsSelected(unsigned int row) const

   Returns true if the row is selected, false otherwise.

=head2 Wx::DataViewCtrl::SetSelection

   virtual void SetSelection(int row)

   Sets the selection. Use -1 to unselect all rows.

=head2 Wx::DataViewCtrl::SetSelectionRange

   virtual void SetSelectionRange(unsigned int from, unsigned int to)

   Set a range of selection.

=head2 Wx::DataViewCtrl::SetSelections

   virtual void SetSelections(const wxArrayInt& aSelections)

   Set the selection to the array of int.

=head2 Wx::DataViewCtrl::Unselect

   virtual void Unselect(unsigned int row)

   Unselect a particular row.

=head1 Wx::DataViewEvent

=head2 Wx::DataViewEvent::new

   wxDataViewEvent(wxEventType commandType = wxEVT_NULL, int winid = 0)

=head2 Wx::DataViewEvent::Clone

   wxEvent* Clone() const

=head2 Wx::DataViewEvent::GetColumn

   int GetColumn() const

=head2 Wx::DataViewEvent::GetDataViewColumn

   wxDataViewColumn* GetDataViewColumn()

=head2 Wx::DataViewEvent::GetModel

   wxDataViewModel* GetModel() const

=head2 Wx::DataViewEvent::GetRow

   int GetRow() const

=head2 Wx::DataViewEvent::GetValue

   const wxVariant& GetValue() const

=head2 Wx::DataViewEvent::IsEditCancelled

   bool IsEditCancelled() const

   Was cell editing canceled? For wxEVT_COMMAND_DATAVIEW_END_CELL_EDIT
   only.

=head2 Wx::DataViewEvent::SetColumn

   void SetColumn(int col)

=head2 Wx::DataViewEvent::SetDataViewColumn

   void SetDataViewColumn(wxDataViewColumn* col)

   For wxEVT_DATAVIEW_COLUMN_HEADER_CLICKED only.

=head2 Wx::DataViewEvent::SetEditCanceled

   void SetEditCanceled(bool editCancelled)

=head2 Wx::DataViewEvent::SetModel

   void SetModel(wxDataViewModel* model)

=head2 Wx::DataViewEvent::SetRow

   void SetRow(int row)

=head2 Wx::DataViewEvent::SetValue

   void SetValue(const wxVariant& value)

=head1 Wx::DataViewListModelNotifier

=head2 Wx::DataViewListModelNotifier::new

   wxDataViewListModelNotifier()

   Constructor.

=head2 Wx::DataViewListModelNotifier::DESTROY

   ~wxDataViewListModelNotifier()

   Destructor.

=head2 Wx::DataViewListModelNotifier::Cleared

   bool Cleared()

   Called by owning list model.

=head2 Wx::DataViewListModelNotifier::GetOwner

   wxDataViewListModel* GetOwner()

   Returns the owning wxDataViewListModel.

=head2 Wx::DataViewListModelNotifier::RowAppended

   bool RowAppended()

   Called by owning list model.

=head2 Wx::DataViewListModelNotifier::RowChanged

   bool RowChanged(unsigned int row)

   Called by owning list model.

=head2 Wx::DataViewListModelNotifier::RowDeleted

   bool RowDeleted(unsigned int row)

   Called by owning list model.

=head2 Wx::DataViewListModelNotifier::RowInserted

   bool RowInserted(unsigned int before)

   Called by owning list model.

=head2 Wx::DataViewListModelNotifier::RowPrepended

   bool RowPrepended()

   Called by owning list model.

=head2 Wx::DataViewListModelNotifier::RowsReordered

   bool RowsReordered(unsigned int* new_order)

   Called by owning list model.

=head2 Wx::DataViewListModelNotifier::SetOwner

   void SetOwner(wxDataViewListModel* owner)

   Set the owning wxDataViewListModel. This method is called by the
   wxDataViewListModel::AddNotifier.

=head2 Wx::DataViewListModelNotifier::ValueChanged

   bool ValueChanged(unsigned int col, unsigned int row)

   Called by owning list model.

=head1 Wx::DataViewModel

=head2 Wx::DataViewModel::new

   wxDataViewModel()

   Constructor.

=head2 Wx::DataViewModel::DESTROY

   ~wxDataViewModel()

   Destructor.

=head1 Wx::DataViewListModel

=head2 Wx::DataViewListModel::new

   wxDataViewListModel()

   Constructor.

=head2 Wx::DataViewListModel::DESTROY

   ~wxDataViewListModel()

   Destructor.

=head2 Wx::DataViewListModel::AddNotifier

   void AddNotifier(wxDataViewListModelNotifier* notifier)

   Adds notifier to the internal list of notifers.

   See also RemoveNotifier.

=head2 Wx::DataViewListModel::AddViewingColumn

   void AddViewingColumn(wxDataViewColumn* view_column, unsigned int
   model_column)

   Used internally. Used for maintaining a list of wxDataViewColumn that
   display a certain column of this model.

=head2 Wx::DataViewListModel::Cleared

   bool virtual Cleared()

   Call this if all data in your model has been cleared.

=head2 Wx::DataViewListModel::GetColType

   virtual wxString GetColType(unsigned int col)

   Override this to indicate what type of data is stored in the column
   specified by col. This should return a string indicating the type of
   data as reported by wxVariant.

=head2 Wx::DataViewListModel::GetNumberOfCols

   virtual unsigned int GetNumberOfCols()

   Override this to indicate, how many columns the list model has.

=head2 Wx::DataViewListModel::GetNumberOfRows

   virtual unsigned int GetNumberOfRows()

   Override this to indicate, how many rows the list model has.

=head2 Wx::DataViewListModel::GetValue

   virtual void GetValue(wxVariant& variant, unsigned int col, unsigned
   int row)

   Override this to indicate the value of a given value in the list
   model. A wxVariant is used to store the data.

=head2 Wx::DataViewListModel::RemoveNotifier

   void RemoveNotifier(wxDataViewListModelNotifier* notifier)

   Removes the notifier from the list of notifiers.

   See also AddNotifier.

=head2 Wx::DataViewListModel::RemoveViewingColumn

   void RemoveViewingColumn(wxDataViewColumn* column)

   Used internally. Used for maintaining a list of wxDataViewColumn that
   display a certain column of this model.

=head2 Wx::DataViewListModel::RowAppended

   virtual bool RowAppended()

   Call this if a row has been appended to the list model.

=head2 Wx::DataViewListModel::RowChanged

   virtual bool RowChanged(unsigned int row)

   Call this if the values of this row have been changed.

=head2 Wx::DataViewListModel::RowDeleted

   virtual bool RowDeleted(unsigned int row)

   Call this if this row has been deleted.

=head2 Wx::DataViewListModel::RowInserted

   virtual bool RowInserted(unsigned int before)

   Call this if a row has been inserted.

=head2 Wx::DataViewListModel::RowPrepended

   virtual bool RowPrepended()

   Call this if a row has been prepended.

=head2 Wx::DataViewListModel::RowsReordered

   virtual bool RowsReordered(unsigned int* new_order)

   Call this if the rows have been reorderd.

=head2 Wx::DataViewListModel::SetValue

   virtual bool SetValue(wxVariant& variant, unsigned int col, unsigned
   int row)

   This method gets called by e.g. the wxDataViewCtrl class if a value
   has been changed through its graphical interface. You need to override
   this method in order to update the data in the underlying data
   structur. Afterwards, ValueChanged is called.

=head2 Wx::DataViewListModel::ValueChanged

   virtual bool ValueChanged(unsigned int col, unsigned int row)

   Call this if a value in the model has been changed.

=head1 Wx::DataViewSortedListModel

=head2 Wx::DataViewSortedListModel::new

   wxDataViewSortedListModel(wxDataViewListModel* child)

   Constructor. child is the child data model the data of which this
   model is supposed to present in a sorted way.

=head2 Wx::DataViewSortedListModel::DESTROY

   ~wxDataViewSortedListModel()

   Destructor.

=head2 Wx::DataViewSortedListModel::GetAscending

   bool GetAscending()

   Returns true if the data is sorted in ascending order.

=head2 Wx::DataViewSortedListModel::Resort

   void Resort()

   Tell the model to resort its data.

=head2 Wx::DataViewSortedListModel::SetAscending

   void SetAscending(bool ascending)

   Set the sort order of the data.

=head1 Wx::DataViewRenderer

=head2 Wx::DataViewRenderer::new

   wxDataViewRenderer(const wxString& varianttype, wxDataViewCellMode
   mode = wxDATAVIEW_CELL_INERT)

   Constructor.

=head2 Wx::DataViewRenderer::GetMode

   virtual wxDataViewCellMode GetMode()

   Returns the cell mode.

=head2 Wx::DataViewRenderer::GetOwner

   virtual wxDataViewColumn* GetOwner()

   Returns pointer to the owning wxDataViewColumn.

=head2 Wx::DataViewRenderer::GetValue

   virtual bool GetValue(wxVariant& value)

   This methods retrieves the value from the renderer in order to
   transfer the value back to the data model. Returns false on failure.

=head2 Wx::DataViewRenderer::GetVariantType

   virtual wxString GetVariantType()

   Returns a string with the type of the wxVariant supported by this
   renderer.

=head2 Wx::DataViewRenderer::SetOwner

   virtual void SetOwner(wxDataViewColumn* owner)

   Sets the owning wxDataViewColumn. This is usually called from within
   wxDataViewColumn.

=head2 Wx::DataViewRenderer::SetValue

   virtual bool SetValue(const wxVariant& value)

   Set the value of the renderer (and thus its cell) to value. The
   internal code will then render this cell with this data.

=head2 Wx::DataViewRenderer::Validate

   virtual bool Validate(wxVariant& value)

   To be implemented.

=head1 Wx::DataViewTextRenderer

=head2 Wx::DataViewTextRenderer::new

   wxDataViewTextRenderer(const wxString& varianttype = wxT("string"),
   wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT)

=head1 Wx::DataViewProgressRenderer

=head2 Wx::DataViewProgressRenderer::new

   wxDataViewProgressRenderer(const wxString& label = wxEmptyString,
   const wxString& varianttype = wxT("long"), wxDataViewCellMode mode =
   wxDATAVIEW_CELL_INERT)

=head1 Wx::DataViewToggleRenderer

=head2 Wx::DataViewToggleRenderer::new

   wxDataViewToggleRenderer(const wxString& varianttype = wxT("bool"),
   wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT)

=head1 Wx::DataViewBitmapRenderer

=head2 Wx::DataViewBitmapRenderer::new

   wxDataViewBitmapRenderer(const wxString& varianttype = wxT("wxBitmap"),
   wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT)

=head1 Wx::DataViewDateRenderer

=head2 Wx::DataViewDateRenderer::new

   wxDataViewDateRenderer(const wxString& varianttype = wxT("datetime"),
   wxDataViewCellMode mode = wxDATAVIEW_CELL_ACTIVATABLE)

=head1 Wx::DataViewCustomRenderer

=head2 Wx::DataViewCustomRenderer::new

   wxDataViewCustomRenderer(const wxString& varianttype = wxT("string"),
   wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT, bool no_init = false)

   Constructor.

=head2 Wx::DataViewCustomRenderer::DESTROY

   ~wxDataViewCustomRenderer()

   Destructor.

=head2 Wx::DataViewCustomRenderer::Activate

   virtual bool Activate(wxRect cell, wxDataViewListModel* model,
   unsigned int col, unsigned int row)

   Override this to react to double clicks or <ENTER>.

=head2 Wx::DataViewCustomRenderer::GetDC

   virtual wxDC* GetDC()

   Create DC on request. Internal.

=head2 Wx::DataViewCustomRenderer::GetSize

   virtual wxSize GetSize()

   Return size required to show content.

=head2 Wx::DataViewCustomRenderer::LeftClick

   virtual bool LeftClick(wxPoint cursor, wxRect cell,
   wxDataViewListModel* model, unsigned int col, unsigned int row)

   Overrride this to react to a left click.

=head2 Wx::DataViewCustomRenderer::Render

   virtual bool Render(wxRect cell, wxDC* dc, int state)

   Override this to render the cell. Before this is called, SetValue was
   called so that this instance knows what to render.

=head2 Wx::DataViewCustomRenderer::RightClick

   virtual bool RightClick(wxPoint cursor, wxRect cell,
   wxDataViewListModel* model, unsigned int col, unsigned int row)

   Overrride this to react to a right click.

=head2 Wx::DataViewCustomRenderer::StartDrag

   virtual bool StartDrag(wxPoint cursor, wxRect cell,
   wxDataViewListModel* model, unsigned int col, unsigned int row)

   Overrride this to start a drag operation.

=head1 Wx::DataObjectComposite

=head2 Wx::DataObjectComposite::new

   wxDataObjectComposite()

   The default constructor.

=head2 Wx::DataObjectComposite::Add

   void Add( wxDataObjectSimple *dataObject, bool preferred = false)

   Adds the dataObject to the list of supported objects and it becomes
   the preferred object if preferred is true.

=head2 Wx::DataObjectComposite::GetReceivedFormat

   wxDataFormat GetReceivedFormat() const

   Report the format passed to the SetData method. This should be the
   format of the data object within the composite that recieved data from
   the clipboard or the DnD operation. You can use this method to find
   out what kind of data object was recieved.

=head1 Wx::DataObjectSimple

=head2 Wx::DataObjectSimple::new

   wxDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)

   Constructor accepts the supported format (none by default) which may
   also be set later with SetFormat.

=head2 Wx::DataObjectSimple::GetFormat

   const wxDataFormat& GetFormat() const

   Returns the (one and only one) format supported by this object. It is
   supposed that the format is supported in both directions.

=head2 Wx::DataObjectSimple::SetFormat

   void SetFormat(const wxDataFormat& format)

   Sets the supported format.

=head2 Wx::DataObjectSimple::GetDataSize

   virtual size_t GetDataSize() const

   Gets the size of our data. Must be implemented in the derived class if
   the object supports rendering its data.

=head2 Wx::DataObjectSimple::GetDataHere

   virtual bool GetDataHere(void *buf) const

   Copy the data to the buffer, return true on success. Must be
   implemented in the derived class if the object supports rendering its
   data.

   wxPython note: When implementing this method in wxPython, no
   additional parameters are required and the data should be returned
   from the method as a string.

=head2 Wx::DataObjectSimple::SetData

   virtual bool SetData(size_t len, const void *buf)

   Copy the data from the buffer, return true on success. Must be
   implemented in the derived class if the object supports setting its
   data.

   wxPython note: When implementing this method in wxPython, the data
   comes as a single string parameter rather than the two shown here.

=head1 Wx::DataOutputStream

=head2 Wx::DataOutputStream::new

   wxDataOutputStream(wxOutputStream& stream)

   wxDataOutputStream(wxOutputStream& stream, wxMBConv& conv =
   wxMBConvUTF8)

   Constructs a datastream object from an output stream. Only write
   methods will be available. The second form is only available in
   Unicode build of wxWidgets.

   Parameters

   stream

       The output stream.

   conv

       Charset conversion object object used to encoding Unicode strings
       before writing them to the stream in Unicode mode (see
       wxDataOutputStream::WriteString documentation for detailed
       description). Note that you must not destroy conv before you
       destroy this wxDataOutputStream instance! It is recommended to use
       default value (UTF-8).

=head2 Wx::DataOutputStream::DESTROY

   ~wxDataOutputStream()

   Destroys the wxDataOutputStream object.

=head2 Wx::DataOutputStream::BigEndianOrdered

   void BigEndianOrdered(bool be_order)

   If be_order is true, all data will be written in big-endian order,
   e.g. for reading on a Sparc or from Java-Streams (which always use
   big-endian order), otherwise data will be written in little-endian
   order.

=head2 Wx::DataOutputStream::Write8

   void Write8(wxUint8 i8)

   Writes the single byte i8 to the stream.

   void Write8(const wxUint8 *buffer, size_t size)

   Writes an array of bytes to the stream. The amount of bytes to write
   is specified with the size variable.

=head2 Wx::DataOutputStream::Write16

   void Write16(wxUint16 i16)

   Writes the 16 bit unsigned integer i16 to the stream.

   void Write16(const wxUint16 *buffer, size_t size)

   Writes an array of 16 bit unsigned integer to the stream. The amount
   of 16 bit unsigned integer to write is specified with the size
   variable.

=head2 Wx::DataOutputStream::Write32

   void Write32(wxUint32 i32)

   Writes the 32 bit unsigned integer i32 to the stream.

   void Write32(const wxUint32 *buffer, size_t size)

   Writes an array of 32 bit unsigned integer to the stream. The amount
   of 32 bit unsigned integer to write is specified with the size
   variable.

=head2 Wx::DataOutputStream::Write64

   void Write64(wxUint64 i64)

   Writes the 64 bit unsigned integer i64 to the stream.

   void Write64(const wxUint64 *buffer, size_t size)

   Writes an array of 64 bit unsigned integer to the stream. The amount
   of 64 bit unsigned integer to write is specified with the size
   variable.

=head2 Wx::DataOutputStream::WriteDouble

   void WriteDouble(double f)

   Writes the double f to the stream using the IEEE format.

   void WriteDouble(const double *buffer, size_t size)

   Writes an array of double to the stream. The amount of double to write
   is specified with the size variable.

=head2 Wx::DataOutputStream::WriteString

   void WriteString(const wxString&string)

   Writes string to the stream. Actually, this method writes the size of
   the string before writing string itself.

   In ANSI build of wxWidgets, the string is written to the stream in
   exactly same way it is represented in memory. In Unicode build,
   however, the string is first converted to multibyte representation
   with conv object passed to stream's constructor (consequently, ANSI
   application can read data written by Unicode application, as long as
   they agree on encoding) and this representation is written to the
   stream. UTF-8 is used by default.

=head1 Wx::DateEvent

=head2 Wx::DateEvent::GetDate

   const wxDateTime& GetDate() const

   Returns the date.

=head2 Wx::DateEvent::SetDate

   void SetDate(const wxDateTime& date)

   Sets the date carried by the event, normally only used by the library
   internally.

=head1 Wx::DatePickerCtrl

=head2 Wx::DatePickerCtrl::new

   wxDatePickerCtrl(wxWindow *parent, wxWindowID id, const wxDateTime& dt
   = wxDefaultDateTime, const wxPoint& pos = wxDefaultPosition, const
   wxSize& size = wxDefaultSize, long style = wxDP_DEFAULT |
   wxDP_SHOWCENTURY, const wxValidator& validator = wxDefaultValidator,
   const wxString& name = "datectrl")

   Initializes the object and calls Create with all the parameters.

=head2 Wx::DatePickerCtrl::Create

   bool Create(wxWindow *parent, wxWindowID id, const wxDateTime& dt =
   wxDefaultDateTime, const wxPoint& pos = wxDefaultPosition, const
   wxSize& size = wxDefaultSize, long style = wxDP_DEFAULT |
   wxDP_SHOWCENTURY, const wxValidator& validator = wxDefaultValidator,
   const wxString& name = "datectrl")

   Parameters

   parent

       Parent window, must not be non-NULL.

   id  

       The identifier for the control.

   dt  

       The initial value of the control, if an invalid date (such as the
       default value) is used, the control is set to today.

   pos 

       Initial position.

   size

       Initial size. If left at default value, the control chooses its
       own best size by using the height approximately equal to a text
       control and width large enough to show the date string fully.

   style

       The window style, should be left at 0 as there are no special
       styles for this control in this version.

   validator

       Validator which can be used for additional date checks.

   name

       Control name.

   Return value

   true if the control was successfully created or false if creation
   failed.

=head2 Wx::DatePickerCtrl::GetRange

   bool GetRange(wxDateTime *dt1, wxDateTime *dt2) const

   If the control had been previously limited to a range of dates using
   SetRange(), returns the lower and upper bounds of this range. If no
   range is set (or only one of the bounds is set), dt1 and/or dt2 are
   set to be invalid.

   Parameters

   dt1 

       Pointer to the object which receives the lower range limit or
       becomes invalid if it is not set. May be NULL if the caller is not
       interested in lower limit

   dt2 

       Same as above but for the upper limit

   Return value

   false if no range limits are currently set, true if at least one bound
   is set.

=head2 Wx::DatePickerCtrl::GetValue

   wxDateTime GetValue() const

   Returns the currently selected. If there is no selection or the
   selection is outside of the current range, an invalid object is
   returned.

=head2 Wx::DatePickerCtrl::SetFormat

   void SetFormat(const wxChar* format)

   Please note that this function is only available in the generic
   version of this control. The native version always uses the current
   system locale.

   Sets the display format for the date in the control. See wxDateTime
   for the meaning of format strings.

   Remarks

   If the format parameter is invalid, the behaviour is undefined.

=head2 Wx::DatePickerCtrl::SetRange

   void SetRange(const wxDateTime& dt1, const wxDateTime& dt2)

   Sets the valid range for the date selection. If dt1 is valid, it
   becomes the earliest date (inclusive) accepted by the control. If dt2
   is valid, it becomes the latest possible date.

   Remarks

   If the current value of the control is outside of the newly set range
   bounds, the behaviour is undefined.

=head2 Wx::DatePickerCtrl::SetValue

   void SetValue(const wxDateTime& dt)

   Changes the current value of the control. The date should be valid and
   included in the currently selected range, if any.

   Calling this method does not result in a date change event.

=head1 Wx::DateSpan

=head2 Wx::DateSpan::new

   wxDateSpan(int years = 0, int months = 0, int weeks = 0, int days = 0)

   Constructs the date span object for the given number of years, months,
   weeks and days. Note that the weeks and days add together if both are
   given.

=head2 Wx::DateSpan::Add

   wxDateSpan Add(const wxDateSpan& other) const

   wxDateSpan& Add(const wxDateSpan& other)

   wxDateSpan& operator+=(const wxDateSpan& other)

   Returns the sum of two date spans. The first version returns a new
   object, the second and third ones modify this object in place.

=head2 Wx::DateSpan::Day

   static wxDateSpan Day()

   Returns a date span object corresponding to one day.

   See also

   Days

=head2 Wx::DateSpan::Days

   static wxDateSpan Days(int days)

   Returns a date span object corresponding to the given number of days.

   See also

   Day

=head2 Wx::DateSpan::GetDays

   int GetDays() const

   Returns the number of days (only, that it not counting the weeks
   component!) in this date span.

   See also

   GetTotalDays

=head2 Wx::DateSpan::GetMonths

   int GetMonths() const

   Returns the number of the months (not counting the years) in this date
   span.

=head2 Wx::DateSpan::GetTotalDays

   int GetTotalDays() const

   Returns the combined number of days in this date span, counting both
   weeks and days. It still doesn't take neither months nor years into
   the account.

   See also

   GetWeeks, GetDays

=head2 Wx::DateSpan::GetWeeks

   int GetWeeks() const

   Returns the number of weeks in this date span.

   See also

   GetTotalDays

=head2 Wx::DateSpan::GetYears

   int GetYears() const

   Returns the number of years in this date span.

=head2 Wx::DateSpan::Month

   static wxDateSpan Month()

   Returns a date span object corresponding to one month.

   See also

   Months

=head2 Wx::DateSpan::Months

   static wxDateSpan Months(int mon)

   Returns a date span object corresponding to the given number of
   months.

   See also

   Month

=head2 Wx::DateSpan::Multiply

   wxDateSpan Multiply(int factor) const

   wxDateSpan& Multiply(int factor)

   wxDateSpan& operator*=(int factor)

   Returns the product of the date span by the specified factor. The
   product is computed by multiplying each of the components by the
   factor.

   The first version returns a new object, the second and third ones
   modify this object in place.

=head2 Wx::DateSpan::Negate

   wxDateSpan Negate() const

   Returns the date span with the opposite sign.

   See also

   Neg

=head2 Wx::DateSpan::Neg

   wxDateSpan& Neg()

   wxDateSpan& operator-()

   Changes the sign of this date span.

   See also

   Negate

=head2 Wx::DateSpan::SetDays

   wxDateSpan& SetDays(int n)

   Sets the number of days (without modifying any other components) in
   this date span.

=head2 Wx::DateSpan::SetYears

   wxDateSpan& SetYears(int n)

   Sets the number of years (without modifying any other components) in
   this date span.

=head2 Wx::DateSpan::SetMonths

   wxDateSpan& SetMonths(int n)

   Sets the number of months (without modifying any other components) in
   this date span.

=head2 Wx::DateSpan::SetWeeks

   wxDateSpan& SetWeeks(int n)

   Sets the number of weeks (without modifying any other components) in
   this date span.

=head2 Wx::DateSpan::Subtract

   wxDateSpan Subtract(const wxDateSpan& other) const

   wxDateSpan& Subtract(const wxDateSpan& other)

   wxDateSpan& operator+=(const wxDateSpan& other)

   Returns the difference of two date spans. The first version returns a
   new object, the second and third ones modify this object in place.

=head2 Wx::DateSpan::Week

   static wxDateSpan Week()

   Returns a date span object corresponding to one week.

   See also

   Weeks

=head2 Wx::DateSpan::Weeks

   static wxDateSpan Weeks(int weeks)

   Returns a date span object corresponding to the given number of weeks.

   See also

   Week

=head2 Wx::DateSpan::Year

   static wxDateSpan Year()

   Returns a date span object corresponding to one year.

   See also

   Years

=head2 Wx::DateSpan::Years

   static wxDateSpan Years(int years)

   Returns a date span object corresponding to the given number of years.

   See also

   Year

=head1 Wx::DateTime

=head2 Static functions

   For convenience, all static functions are collected here. These
   functions either set or return the static variables of wxDateSpan (the
   country), return the current moment, year, month or number of days in
   it, or do some general calendar-related actions.

   Please note that although several function accept an extra Calendar
   parameter, it is currently ignored as only the Gregorian calendar is
   supported. Future versions will support other calendars.

   wxPython note: These methods are standalone functions named
   wxDateTime_<StaticMethodName> in wxPython.

   SetCountry

=head2 Constructors, assignment operators and setters

   Constructors and various Set() methods are collected here. If you
   construct a date object from separate values for day, month and year,
   you should use IsValid method to check that the values were correct as
   constructors can not return an error code.

   wxDateTime()

=head2 Accessors

   Here are the trivial accessors. Other functions, which might have to
   perform some more complicated calculations to find the answer are
   under the Calendar calculations section.

   IsValid

=head2 Date comparison

   There are several function to allow date comparison. To supplement
   them, a few global operators >, < etc taking wxDateTime are defined.

   IsEqualTo

=head2 Date arithmetics

   These functions carry out arithmetics on the wxDateTime objects. As
   explained in the overview, either wxTimeSpan or wxDateSpan may be
   added to wxDateTime, hence all functions are overloaded to accept both
   arguments.

   Also, both Add() and Subtract() have both const and non-const version.
   The first one returns a new object which represents the sum/difference
   of the original one with the argument while the second form modifies
   the object to which it is applied. The operators -= and += are defined
   to be equivalent to the second forms of these functions.

   Add(wxTimeSpan)

=head2 Parsing and formatting dates

   These functions convert wxDateTime objects to and from text. The
   conversions to text are mostly trivial: you can either do it using the
   default date and time representations for the current locale (
   FormatDate and FormatTime), using the international standard
   representation defined by ISO 8601 ( FormatISODate and FormatISOTime)
   or by specifying any format at all and using Format directly.

   The conversions from text are more interesting, as there are much more
   possibilities to care about. The simplest cases can be taken care of
   with ParseFormat which can parse any date in the given (rigid) format.
   ParseRfc822Date is another function for parsing dates in predefined
   format -- the one of RFC 822 which (still...) defines the format of
   email messages on the Internet. This format can not be described with
   strptime(3)-like format strings used by Format, hence the need for a
   separate function.

   But the most interesting functions are ParseTime, ParseDate and
   ParseDateTime. They try to parse the date ans time (or only one of
   them) in 'free' format, i.e. allow them to be specified in any of
   possible ways. These functions will usually be used to parse the
   (interactive) user input which is not bound to be in any predefined
   format. As an example, ParseDateTime can parse the strings such as
   "tomorrow", "March first" and even "next Sunday".

   ParseRfc822Date

=head2 Calendar calculations

   The functions in this section perform the basic calendar calculations,
   mostly related to the week days. They allow to find the given week day
   in the week with given number (either in the month or in the year) and
   so on.

   All (non-const) functions in this section don't modify the time part
   of the wxDateTime -- they only work with the date part of it.

   SetToWeekDayInSameWeek

=head2 Astronomical/historical functions

   Some degree of support for the date units used in astronomy and/or
   history is provided. You can construct a wxDateTime object from a JDN
   and you may also get its JDN, MJD or Rata Die number from it.

   wxDateTime(double jdn)

=head2 Time zone and DST support

   Please see the time zone overview for more information about time
   zones. Normally, these functions should be rarely used.

   FromTimezone

=head2 Wx::DateTime::ConvertYearToBC

   static int ConvertYearToBC(int year)

   Converts the year in absolute notation (i.e. a number which can be
   negative, positive or zero) to the year in BC/AD notation. For the
   positive years, nothing is done, but the year 0 is year 1 BC and so
   for other years there is a difference of 1.

   This function should be used like this:

       wxDateTime dt(...);
       int y = dt.GetYear();
       printf("The year is %d%s", wxDateTime::ConvertYearToBC(y), y > 0 ? "AD" : "BC");

=head2 Wx::DateTime::GetAmPmStrings

   static void GetAmPmStrings(wxString *am, wxString *pm)

   Returns the translations of the strings AM and PM used for time
   formatting for the current locale. Either of the pointers may be NULL
   if the corresponding value is not needed.

=head2 Wx::DateTime::GetBeginDST

   static wxDateTime GetBeginDST(int year = Inv_Year, Country country =
   Country_Default)

   Get the beginning of DST for the given country in the given year
   (current one by default). This function suffers from limitations
   described in DST overview.

   See also

   GetEndDST

=head2 Wx::DateTime::GetCountry

   static Country GetCountry()

   Returns the current default country. The default country is used for
   DST calculations, for example.

   See also

   SetCountry

=head2 Wx::DateTime::GetCurrentYear

   static int GetCurrentYear(Calendar cal = Gregorian)

   Get the current year in given calendar (only Gregorian is currently
   supported).

=head2 Wx::DateTime::GetCurrentMonth

   static Month GetCurrentMonth(Calendar cal = Gregorian)

   Get the current month in given calendar (only Gregorian is currently
   supported).

=head2 Wx::DateTime::GetCentury

   static int GetCentury(int year)

   Get the current century, i.e. first two digits of the year, in given
   calendar (only Gregorian is currently supported).

=head2 Wx::DateTime::GetEndDST

   static wxDateTime GetEndDST(int year = Inv_Year, Country country =
   Country_Default)

   Returns the end of DST for the given country in the given year
   (current one by default).

   See also

   GetBeginDST

=head2 Wx::DateTime::GetMonthName

   static wxString GetMonthName(Month month, NameFlags flags = Name_Full)

   Gets the full (default) or abbreviated (specify Name_Abbr name of the
   given month.

   See also

   GetWeekDayName

=head2 Wx::DateTime::GetNumberOfDays

   static wxDateTime_t GetNumberOfDays(int year, Calendar cal = Gregorian)

   static wxDateTime_t GetNumberOfDays(Month month, int year = Inv_Year,
   Calendar cal = Gregorian)

   Returns the number of days in the given year or in the given month of
   the year.

   The only supported value for cal parameter is currently Gregorian.

   wxPython note: These two methods are named GetNumberOfDaysInYear and
   GetNumberOfDaysInMonth in wxPython.

=head2 Wx::DateTime::GetTimeNow

   static time_t GetTimeNow()

   Returns the current time.

=head2 Wx::DateTime::GetTmNow

   static struct tm * GetTmNow(struct tm *tm)

   Returns the current time broken down, uses the buffer whose adress is
   passed to the function via tm to store the result.

=head2 Wx::DateTime::GetTmNow

   static struct tm * GetTmNow()

   Returns the current time broken down. Note that this function returns
   a pointer to a static buffer that's reused by calls to this function
   and certain C library functions (e.g. localtime). If there is any
   chance your code might be used in a multi-threaded application, you
   really should use the flavour of function wxDateTime::GetTmNow taking
   a parameter.

=head2 Wx::DateTime::GetWeekDayName

   static wxString GetWeekDayName(WeekDay weekday, NameFlags flags =
   Name_Full)

   Gets the full (default) or abbreviated (specify Name_Abbr name of the
   given week day.

   See also

   GetMonthName

=head2 Wx::DateTime::IsLeapYear

   static bool IsLeapYear(int year = Inv_Year, Calendar cal = Gregorian)

   Returns true if the year is a leap one in the specified calendar.

   This functions supports Gregorian and Julian calendars.

=head2 Wx::DateTime::IsWestEuropeanCountry

   static bool IsWestEuropeanCountry(Country country = Country_Default)

   This function returns true if the specified (or default) country is
   one of Western European ones. It is used internally by wxDateTime to
   determine the DST convention and date and time formatting rules.

=head2 Wx::DateTime::IsDSTApplicable

   static bool IsDSTApplicable(int year = Inv_Year, Country country =
   Country_Default)

   Returns true if DST was used n the given year (the current one by
   default) in the given country.

=head2 Wx::DateTime::Now

   static wxDateTime Now()

   Returns the object corresponding to the current time.

   Example:

       wxDateTime now = wxDateTime::Now();
       printf("Current time in Paris:\t%s\n", now.Format("%c", wxDateTime::CET).c_str());

   Note that this function is accurate up to second: wxDateTime::UNow
   should be used for better precision (but it is less efficient and
   might not be available on all platforms).

   See also

   Today

=head2 Wx::DateTime::SetCountry

   static void SetCountry(Country country)

   Sets the country to use by default. This setting influences the DST
   calculations, date formatting and other things.

   The possible values for country parameter are enumerated in wxDateTime
   constants section.

   See also

   GetCountry

=head2 Wx::DateTime::Today

   static wxDateTime Today()

   Returns the object corresponding to the midnight of the current day
   (i.e. the same as Now(), but the time part is set to 0).

   See also

   Now

=head2 Wx::DateTime::UNow

   static wxDateTime UNow()

   Returns the object corresponding to the current time including the
   milliseconds if a function to get time with such precision is
   available on the current platform (supported under most Unices and
   Win32).

   See also

   Now

=head2 Wx::DateTime::new

   wxDateTime()

   Default constructor. Use one of Set() functions to initialize the
   object later.

=head2 Wx::DateTime::new

   wxDateTime& wxDateTime(time_t timet)

   Same as Set.

   wxPython note: This constructor is named wxDateTimeFromTimeT in
   wxPython.

=head2 Wx::DateTime::new

   wxDateTime& wxDateTime(const struct tm& tm)

   Same as Set

   wxPython note: Unsupported.

=head2 Wx::DateTime::new

   wxDateTime& wxDateTime(double jdn)

   Same as Set

   wxPython note: This constructor is named wxDateTimeFromJDN in
   wxPython.

=head2 Wx::DateTime::new

   wxDateTime& wxDateTime(wxDateTime_t hour, wxDateTime_t minute = 0,
   wxDateTime_t second = 0, wxDateTime_t millisec = 0)

   Same as Set

   wxPython note: This constructor is named wxDateTimeFromHMS in
   wxPython.

=head2 Wx::DateTime::new

   wxDateTime& wxDateTime(wxDateTime_t day, Month month = Inv_Month, int
   Inv_Year, wxDateTime_t hour = 0, wxDateTime_t minute = 0, wxDateTime_t
   second = 0, wxDateTime_t millisec = 0)

   Same as Set

   wxPython note: This constructor is named wxDateTimeFromDMY in
   wxPython.

=head2 Wx::DateTime::SetToCurrent

   wxDateTime& SetToCurrent()

   Sets the date and time of to the current values. Same as assigning the
   result of Now() to this object.

=head2 Wx::DateTime::Set

   wxDateTime& Set(time_t timet)

   Constructs the object from timet value holding the number of seconds
   since Jan 1, 1970.

   wxPython note: This method is named SetTimeT in wxPython.

=head2 Wx::DateTime::Set

   wxDateTime& Set(const struct tm& tm)

   Sets the date and time from the broken down representation in the
   standard tm structure.

   wxPython note: Unsupported.

=head2 Wx::DateTime::Set

   wxDateTime& Set(double jdn)

   Sets the date from the so-called Julian Day Number.

   By definition, the Julian Day Number, usually abbreviated as JDN, of a
   particular instant is the fractional number of days since 12 hours
   Universal Coordinated Time (Greenwich mean noon) on January 1 of the
   year -4712 in the Julian proleptic calendar.

   wxPython note: This method is named SetJDN in wxPython.

=head2 Wx::DateTime::Set

   wxDateTime& Set(wxDateTime_t hour, wxDateTime_t minute = 0,
   wxDateTime_t second = 0, wxDateTime_t millisec = 0)

   Sets the date to be equal to Today and the time from supplied
   parameters.

   wxPython note: This method is named SetHMS in wxPython.

=head2 Wx::DateTime::Set

   wxDateTime& Set(wxDateTime_t day, Month month = Inv_Month, int year =
   Inv_Year, wxDateTime_t hour = 0, wxDateTime_t minute = 0, wxDateTime_t
   second = 0, wxDateTime_t millisec = 0)

   Sets the date and time from the parameters.

=head2 Wx::DateTime::ResetTime

   wxDateTime& ResetTime()

   Reset time to midnight (00:00:00) without changing the date.

=head2 Wx::DateTime::SetYear

   wxDateTime& SetYear(int year)

   Sets the year without changing other date components.

=head2 Wx::DateTime::SetMonth

   wxDateTime& SetMonth(Month month)

   Sets the month without changing other date components.

=head2 Wx::DateTime::SetDay

   wxDateTime& SetDay(wxDateTime_t day)

   Sets the day without changing other date components.

=head2 Wx::DateTime::SetHour

   wxDateTime& SetHour(wxDateTime_t hour)

   Sets the hour without changing other date components.

=head2 Wx::DateTime::SetMinute

   wxDateTime& SetMinute(wxDateTime_t minute)

   Sets the minute without changing other date components.

=head2 Wx::DateTime::SetSecond

   wxDateTime& SetSecond(wxDateTime_t second)

   Sets the second without changing other date components.

=head2 Wx::DateTime::SetMillisecond

   wxDateTime& SetMillisecond(wxDateTime_t millisecond)

   Sets the millisecond without changing other date components.

=head2 Wx::DateTime::IsValid

   bool IsValid() const

   Returns true if the object represents a valid time moment.

=head2 Wx::DateTime::GetDateOnly

   wxDateTime GetDateOnly() const

   Returns the object having the same date component as this one but time
   of 00:00:00.

   This function is new since wxWidgets version 2.8.2

   See also

   ResetTime

=head2 Wx::DateTime::GetTm

   Tm GetTm(const TimeZone& tz = Local) const

   Returns broken down representation of the date and time.

=head2 Wx::DateTime::GetTicks

   time_t GetTicks() const

   Returns the number of seconds since Jan 1, 1970. An assert failure
   will occur if the date is not in the range covered by time_t type.

=head2 Wx::DateTime::GetCentury

   int GetCentury(const TimeZone& tz = Local) const

   Returns the century of this date.

=head2 Wx::DateTime::GetYear

   int GetYear(const TimeZone& tz = Local) const

   Returns the year in the given timezone (local one by default).

=head2 Wx::DateTime::GetMonth

   Month GetMonth(const TimeZone& tz = Local) const

   Returns the month in the given timezone (local one by default).

=head2 Wx::DateTime::GetDay

   wxDateTime_t GetDay(const TimeZone& tz = Local) const

   Returns the day in the given timezone (local one by default).

=head2 Wx::DateTime::GetWeekDay

   WeekDay GetWeekDay(const TimeZone& tz = Local) const

   Returns the week day in the given timezone (local one by default).

=head2 Wx::DateTime::GetHour

   wxDateTime_t GetHour(const TimeZone& tz = Local) const

   Returns the hour in the given timezone (local one by default).

=head2 Wx::DateTime::GetMinute

   wxDateTime_t GetMinute(const TimeZone& tz = Local) const

   Returns the minute in the given timezone (local one by default).

=head2 Wx::DateTime::GetSecond

   wxDateTime_t GetSecond(const TimeZone& tz = Local) const

   Returns the seconds in the given timezone (local one by default).

=head2 Wx::DateTime::GetMillisecond

   wxDateTime_t GetMillisecond(const TimeZone& tz = Local) const

   Returns the milliseconds in the given timezone (local one by default).

=head2 Wx::DateTime::GetDayOfYear

   wxDateTime_t GetDayOfYear(const TimeZone& tz = Local) const

   Returns the day of the year (in 1...366 range) in the given timezone
   (local one by default).

=head2 Wx::DateTime::GetWeekOfYear

   wxDateTime_t GetWeekOfYear(WeekFlags flags = Monday_First, const
   TimeZone& tz = Local) const

   Returns the number of the week of the year this date is in. The first
   week of the year is, according to international standards, the one
   containing Jan 4 or, equivalently, the first week which has Thursday
   in this year. Both of these definitions are the same as saying that
   the first week of the year must contain more than half of its days in
   this year. Accordingly, the week number will always be in 1...53 range
   (52 for non-leap years).

   The function depends on the week start convention specified by the
   flags argument but its results for Sunday_First are not well-defined
   as the ISO definition quoted above applies to the weeks starting on
   Monday only.

=head2 Wx::DateTime::GetWeekOfMonth

   wxDateTime_t GetWeekOfMonth(WeekFlags flags = Monday_First, const
   TimeZone& tz = Local) const

   Returns the ordinal number of the week in the month (in 1...5 range).

   As GetWeekOfYear, this function supports both conventions for the week
   start. See the description of these week start conventions.

=head2 Wx::DateTime::IsWorkDay

   bool IsWorkDay(Country country = Country_Default) const

   Returns true is this day is not a holiday in the given country.

=head2 Wx::DateTime::IsGregorianDate

   bool IsGregorianDate(GregorianAdoption country = Gr_Standard) const

   Returns true if the given date is later than the date of adoption of
   the Gregorian calendar in the given country (and hence the Gregorian
   calendar calculations make sense for it).

=head2 Wx::DateTime::SetFromDOS

   wxDateTime& Set(unsigned long ddt)

   Sets the date from the date and time in DOS format.

=head2 Wx::DateTime::GetAsDOS

   unsigned long GetAsDOS() const

   Returns the date and time in DOS format.

=head2 Wx::DateTime::IsEqualTo

   bool IsEqualTo(const wxDateTime& datetime) const

   Returns true if the two dates are strictly identical.

=head2 Wx::DateTime::IsEarlierThan

   bool IsEarlierThan(const wxDateTime& datetime) const

   Returns true if this date precedes the given one.

=head2 Wx::DateTime::IsLaterThan

   bool IsLaterThan(const wxDateTime& datetime) const

   Returns true if this date is later than the given one.

=head2 Wx::DateTime::IsStrictlyBetween

   bool IsStrictlyBetween(const wxDateTime& t1, const wxDateTime& t2)
   const

   Returns true if this date lies strictly between the two others,

   See also

   IsBetween

=head2 Wx::DateTime::IsBetween

   bool IsBetween(const wxDateTime& t1, const wxDateTime& t2) const

   Returns true if IsStrictlyBetween is true or if the date is equal to
   one of the limit values.

   See also

   IsStrictlyBetween

=head2 Wx::DateTime::IsSameDate

   bool IsSameDate(const wxDateTime& dt) const

   Returns true if the date is the same without comparing the time parts.

=head2 Wx::DateTime::IsSameTime

   bool IsSameTime(const wxDateTime& dt) const

   Returns true if the time is the same (although dates may differ).

=head2 Wx::DateTime::IsEqualUpTo

   bool IsEqualUpTo(const wxDateTime& dt, const wxTimeSpan& ts) const

   Returns true if the date is equal to another one up to the given time
   interval, i.e. if the absolute difference between the two dates is
   less than this interval.

=head2 Wx::DateTime::Add

   wxDateTime Add(const wxTimeSpan& diff) const

   wxDateTime& Add(const wxTimeSpan& diff)

   wxDateTime& operator+=(const wxTimeSpan& diff)

   Adds the given time span to this object.

   wxPython note: This method is named AddTS in wxPython.

=head2 Wx::DateTime::Add

   wxDateTime Add(const wxDateSpan& diff) const

   wxDateTime& Add(const wxDateSpan& diff)

   wxDateTime& operator+=(const wxDateSpan& diff)

   Adds the given date span to this object.

   wxPython note: This method is named AddDS in wxPython.

=head2 Wx::DateTime::Subtract

   wxDateTime Subtract(const wxTimeSpan& diff) const

   wxDateTime& Subtract(const wxTimeSpan& diff)

   wxDateTime& operator-=(const wxTimeSpan& diff)

   Subtracts the given time span from this object.

   wxPython note: This method is named SubtractTS in wxPython.

=head2 Wx::DateTime::Subtract

   wxDateTime Subtract(const wxDateSpan& diff) const

   wxDateTime& Subtract(const wxDateSpan& diff)

   wxDateTime& operator-=(const wxDateSpan& diff)

   Subtracts the given date span from this object.

   wxPython note: This method is named SubtractDS in wxPython.

=head2 Wx::DateTime::Subtract

   wxTimeSpan Subtract(const wxDateTime& dt) const

   Subtracts another date from this one and returns the difference
   between them as wxTimeSpan.

=head2 Wx::DateTime::ParseRfc822Date

   const wxChar * ParseRfc822Date(const wxChar* date)

   Parses the string date looking for a date formatted according to the
   RFC 822 in it. The exact description of this format may, of course, be
   found in the RFC (section 5), but, briefly, this is the format used in
   the headers of Internet email messages and one of the most common
   strings expressing date in this format may be something like "Sat, 18
   Dec 1999 00:48:30 +0100".

   Returns NULL if the conversion failed, otherwise return the pointer to
   the character immediately following the part of the string which could
   be parsed. If the entire string contains only the date in RFC 822
   format, the returned pointer will be pointing to a NUL character.

   This function is intentionally strict, it will return an error for any
   string which is not RFC 822 compliant. If you need to parse date
   formatted in more free ways, you should use ParseDateTime or ParseDate
   instead.

=head2 Wx::DateTime::ParseFormat

   const wxChar * ParseFormat(const wxChar *date, const wxChar *format =
   wxDefaultDateTimeFormat, const wxDateTime& dateDef = wxDefaultDateTime)

   This function parses the string date according to the given format.
   The system strptime(3) function is used whenever available, but even
   if it is not, this function is still implemented, although support for
   locale-dependent format specifiers such as "%c", "%x" or "%X" may not
   be perfect and GNU extensions such as "%z" and "%Z" are not
   implemented. This function does handle the month and weekday names in
   the current locale on all platforms, however.

   Please see the description of the ANSI C function strftime(3) for the
   syntax of the format string.

   The dateDef parameter is used to fill in the fields which could not be
   determined from the format string. For example, if the format is "%d"
   (the ay of the month), the month and the year are taken from dateDef.
   If it is not specified, Today is used as the default date.

   Returns NULL if the conversion failed, otherwise return the pointer to
   the character which stopped the scan.

=head2 Wx::DateTime::ParseDateTime

   const wxChar * ParseDateTime(const wxChar *datetime)

   Parses the string datetime containing the date and time in free
   format. This function tries as hard as it can to interpret the given
   string as date and time. Unlike ParseRfc822Date, it will accept
   anything that may be accepted and will only reject strings which can
   not be parsed in any way at all.

   Returns NULL if the conversion failed, otherwise return the pointer to
   the character which stopped the scan.

=head2 Wx::DateTime::ParseDate

   const wxChar * ParseDate(const wxChar *date)

   This function is like ParseDateTime, but it only allows the date to be
   specified. It is thus less flexible then ParseDateTime, but also has
   less chances to misinterpret the user input.

   Returns NULL if the conversion failed, otherwise return the pointer to
   the character which stopped the scan.

=head2 Wx::DateTime::ParseTime

   const wxChar * ParseTime(const wxChar *time)

   This functions is like ParseDateTime, but only allows the time to be
   specified in the input string.

   Returns NULL if the conversion failed, otherwise return the pointer to
   the character which stopped the scan.

=head2 Wx::DateTime::Format

   wxString Format(const wxChar *format = wxDefaultDateTimeFormat, const
   TimeZone& tz = Local) const

   This function does the same as the standard ANSI C strftime(3)
   function. Please see its description for the meaning of format
   parameter.

   It also accepts a few wxWidgets-specific extensions: you can
   optionally specify the width of the field to follow using printf(3)-like
   syntax and the format specification %l can be used to get the number
   of milliseconds.

   See also

   ParseFormat

=head2 Wx::DateTime::FormatDate

   wxString FormatDate() const

   Identical to calling Format() with "%x" argument (which means
   'preferred date representation for the current locale').

=head2 Wx::DateTime::FormatTime

   wxString FormatTime() const

   Identical to calling Format() with "%X" argument (which means
   'preferred time representation for the current locale').

=head2 Wx::DateTime::FormatISODate

   wxString FormatISODate() const

   This function returns the date representation in the ISO 8601 format
   (YYYY-MM-DD).

=head2 Wx::DateTime::FormatISOTime

   wxString FormatISOTime() const

   This function returns the time representation in the ISO 8601 format
   (HH:MM:SS).

=head2 Wx::DateTime::SetToWeekDayInSameWeek

   wxDateTime& SetToWeekDayInSameWeek(WeekDay weekday, WeekFlagsflags =
   Monday_First)

   Adjusts the date so that it will still lie in the same week as before,
   but its week day will be the given one.

   Returns the reference to the modified object itself.

=head2 Wx::DateTime::GetWeekDayInSameWeek

   wxDateTime GetWeekDayInSameWeek(WeekDay weekday, WeekFlagsflags =
   Monday_First) const

   Returns the copy of this object to which SetToWeekDayInSameWeek was
   applied.

=head2 Wx::DateTime::SetToNextWeekDay

   wxDateTime& SetToNextWeekDay(WeekDay weekday)

   Sets the date so that it will be the first weekday following the
   current date.

   Returns the reference to the modified object itself.

=head2 Wx::DateTime::GetNextWeekDay

   wxDateTime GetNextWeekDay(WeekDay weekday) const

   Returns the copy of this object to which SetToNextWeekDay was applied.

=head2 Wx::DateTime::SetToPrevWeekDay

   wxDateTime& SetToPrevWeekDay(WeekDay weekday)

   Sets the date so that it will be the last weekday before the current
   date.

   Returns the reference to the modified object itself.

=head2 Wx::DateTime::GetPrevWeekDay

   wxDateTime GetPrevWeekDay(WeekDay weekday) const

   Returns the copy of this object to which SetToPrevWeekDay was applied.

=head2 Wx::DateTime::SetToWeekDay

   bool SetToWeekDay(WeekDay weekday, int n = 1, Month month = Inv_Month,
   int year = Inv_Year)

   Sets the date to the n-th weekday in the given month of the given year
   (the current month and year are used by default). The parameter n may
   be either positive (counting from the beginning of the month) or
   negative (counting from the end of it).

   For example, SetToWeekDay(2, wxDateTime::Wed) will set the date to the
   second Wednesday in the current month and SetToWeekDay(-1,
   wxDateTime::Sun) -- to the last Sunday in it.

   Returns true if the date was modified successfully, false otherwise
   meaning that the specified date doesn't exist.

=head2 Wx::DateTime::GetWeekDay

   wxDateTime GetWeekDay(WeekDay weekday, int n = 1, Month month =
   Inv_Month, int year = Inv_Year) const

   Returns the copy of this object to which SetToWeekDay was applied.

=head2 Wx::DateTime::SetToLastWeekDay

   bool SetToLastWeekDay(WeekDay weekday, Month month = Inv_Month, int
   year = Inv_Year)

   The effect of calling this function is the same as of calling
   SetToWeekDay(-1, weekday, month, year). The date will be set to the
   last weekday in the given month and year (the current ones by
   default).

   Always returns true.

=head2 Wx::DateTime::GetLastWeekDay

   wxDateTime GetLastWeekDay(WeekDay weekday, Month month = Inv_Month,
   int year = Inv_Year)

   Returns the copy of this object to which SetToLastWeekDay was applied.

=head2 Wx::DateTime::SetToWeekOfYear

   static wxDateTime SetToWeekOfYear(int year, wxDateTime_t numWeek,
   WeekDay weekday = Mon)

   Set the date to the given weekday in the week number numWeek of the
   given year . The number should be in range 1...53.

   Note that the returned date may be in a different year than the one
   passed to this function because both the week 1 and week 52 or 53 (for
   leap years) contain days from different years. See GetWeekOfYear for
   the explanation of how the year weeks are counted.

=head2 Wx::DateTime::SetToLastMonthDay

   wxDateTime& SetToLastMonthDay(Month month = Inv_Month, int year =
   Inv_Year)

   Sets the date to the last day in the specified month (the current one
   by default).

   Returns the reference to the modified object itself.

=head2 Wx::DateTime::GetLastMonthDay

   wxDateTime GetLastMonthDay(Month month = Inv_Month, int year =
   Inv_Year) const

   Returns the copy of this object to which SetToLastMonthDay was
   applied.

=head2 Wx::DateTime::SetToYearDay

   wxDateTime& SetToYearDay(wxDateTime_t yday)

   Sets the date to the day number yday in the same year (i.e., unlike
   the other functions, this one does not use the current year). The day
   number should be in the range 1...366 for the leap years and 1...365
   for the other ones.

   Returns the reference to the modified object itself.

=head2 Wx::DateTime::GetYearDay

   wxDateTime GetYearDay(wxDateTime_t yday) const

   Returns the copy of this object to which SetToYearDay was applied.

=head2 Wx::DateTime::GetJulianDayNumber

   double GetJulianDayNumber() const

   Returns the JDN corresponding to this date. Beware of rounding errors!

   See also

   GetModifiedJulianDayNumber

=head2 Wx::DateTime::GetJDN

   double GetJDN() const

   Synonym for GetJulianDayNumber.

=head2 Wx::DateTime::GetModifiedJulianDayNumber

   double GetModifiedJulianDayNumber() const

   Returns the Modified Julian Day Number (MJD) which is, by definition,
   equal to JDN - 2400000.5. The MJDs are simpler to work with as the
   integral MJDs correspond to midnights of the dates in the Gregorian
   calendar and not th noons like JDN. The MJD 0 is Nov 17, 1858.

=head2 Wx::DateTime::GetMJD

   double GetMJD() const

   Synonym for GetModifiedJulianDayNumber.

=head2 Wx::DateTime::GetRataDie

   double GetRataDie() const

   Return the Rata Die number of this date.

   By definition, the Rata Die number is a date specified as the number
   of days relative to a base date of December 31 of the year 0. Thus
   January 1 of the year 1 is Rata Die day 1.

=head2 Wx::DateTime::FromTimezone

   wxDateTime FromTimezone(const TimeZone& tz, bool noDST = false) const

   Transform the date from the given time zone to the local one. If noDST
   is true, no DST adjustments will be made.

   Returns the date in the local time zone.

=head2 Wx::DateTime::ToTimezone

   wxDateTime ToTimezone(const TimeZone& tz, bool noDST = false) const

   Transform the date to the given time zone. If noDST is true, no DST
   adjustments will be made.

   Returns the date in the new time zone.

=head2 Wx::DateTime::MakeTimezone

   wxDateTime& MakeTimezone(const TimeZone& tz, bool noDST = false)

   Modifies the object in place to represent the date in another time
   zone. If noDST is true, no DST adjustments will be made.

=head2 Wx::DateTime::MakeFromTimezone

   wxDateTime& MakeFromTimezone(const TimeZone& tz, bool noDST = false)

   Same as FromTimezone but modifies the object in place.

=head2 Wx::DateTime::ToUTC

   wxDateTime ToUTC(bool noDST = false) const

   This is the same as calling ToTimezone with the argument GMT0.

=head2 Wx::DateTime::MakeUTC

   wxDateTime& MakeUTC(bool noDST = false)

   This is the same as calling MakeTimezone with the argument GMT0.

=head2 Wx::DateTime::IsDST

   int IsDST(Country country = Country_Default) const

   Returns true if the DST is applied for this date in the given country.

   See also

   GetBeginDST and GetEndDST

=head1 Wx::Db

=head2 Enumerated types

   Enumerated types

   enum wxDbSqlLogState

       sqlLogOFF, sqlLogON

   enum wxDBMS

   These are the databases currently tested and working with the ODBC
   classes. A call to wxDb::Dbms will return one of these enumerated
   values listed below.

=head2 Associated non-class functions

   The following functions are used in conjunction with the wxDb class.

   void wxDbCloseConnections()

   Remarks

   Closes all cached connections that have been made through use of the
   wxDbGetConnection function.

   NOTE: These connections are closed regardless of whether they are in
   use or not. This function should only be called after the program has
   finished using the connections and all wxDbTable instances that use
   any of the connections have been closed.

   This function performs a wxDb::CommitTrans on the connection before
   closing it to commit any changes that are still pending, as well as to
   avoid any function sequence errors upon closing each connection.

=head2 Wx::Db::new

   wxDb()

   Default constructor.

   wxDb(const HENV &aHenv, bool
   FwdOnlyCursors=(bool)wxODBC_FWD_ONLY_CURSORS)

   Constructor, used to create an ODBC connection to a datasource.

   Parameters

   aHenv

       Environment handle used for this connection. See
       wxDConnectInf::AllocHenv

   FwdOnlyCursors

       Will cursors created for use with this datasource connection only
       allow forward scrolling cursors.

   Remarks

   This is the constructor for the wxDb class. The wxDb object must be
   created and opened before any database activity can occur.

   Example

      wxDbConnectInf ConnectInf;
      ....Set values for member variables of ConnectInf here

=head2 Wx::Db::Catalog

   bool Catalog(wxChar * userID, const wxString &fileName =
   SQL_CATALOG_FILENAME)

   Allows a data "dictionary" of the datasource to be created, dumping
   pertinent information about all data tables to which the user
   specified in userID has access.

   Parameters

   userID

       Database user name to use in accessing the database. All tables to
       which this user has rights will be evaluated in the catalog.

   fileName

       OPTIONAL. Name of the text file to create and write the DB catalog
       to. Default is SQL_CATALOG_FILENAME.

   Return value

   Returns true if the catalog request was successful, or false if there
   was some reason that the catalog could not be generated.

   Example

   ============== ============== ================ ========= =======
   TABLE NAME     COLUMN NAME    DATA TYPE        PRECISION  LENGTH
   ============== ============== ================ ========= =======
   EMPLOYEE       RECID          (0008)NUMBER            15       8
   EMPLOYEE       USER_ID        (0012)VARCHAR2          13      13
   EMPLOYEE       FULL_NAME      (0012)VARCHAR2          26      26
   EMPLOYEE       PASSWORD       (0012)VARCHAR2          26      26
   EMPLOYEE       START_DATE     (0011)DATE              19      16

=head2 Wx::Db::Close

   void Close()

   Closes the database connection.

   Remarks

   At the end of your program, when you have finished all of your
   database work, you must close the ODBC connection to the datasource.
   There are actually four steps involved in doing this as illustrated in
   the example.

   Any wxDbTable instances which use this connection must be deleted
   before closing the database connection.

   Example

      // Commit any open transactions on the datasource
      sampleDB.CommitTrans();

=head2 Wx::Db::CommitTrans

   bool CommitTrans()

   Permanently "commits" changes (insertions/deletions/updates) to the
   database.

   Return value

   Returns true if the commit was successful, or false if the commit
   failed.

   Remarks

   Transactions begin implicitly as soon as you make a change to the
   database with an insert/update/delete, or any other direct SQL command
   that performs one of these operations against the datasource. At any
   time thereafter, to save the changes to disk permanently, "commit"
   them by calling this function.

   Calling this member function commits ALL open transactions on this
   ODBC connection. For example, if three different wxDbTable instances
   used the same connection to the datasource, committing changes made on
   one of those wxDbTable instances commits any pending transactions on
   all three wxDbTable instances.

   Until a call to wxDb::CommitTrans() is made, no other user or cursor
   is able to see any changes made to the row(s) that have been
   inserted/modified/deleted.

=head2 Wx::Db::CreateView

   bool CreateView(const wxString & viewName, const wxString & colList,
   const wxString &pSqlStmt)

   Creates a SQL VIEW of one or more tables in a single datasource. Note
   that this function will only work against databases which support
   views (currently only Oracle as of November 21 2000).

   Parameters

   viewName

       The name of the view. e.g. PARTS_V

   colList

       OPTIONAL Pass in a comma delimited list of column names if you
       wish to explicitly name each column in the result set. If not
       desired, pass in an empty string and the column names from the
       associated table(s) will be used.

   pSqlStmt

       Pointer to the select statement portion of the CREATE VIEW
       statement. Must be a complete, valid SQL SELECT statement.

   Remarks

   A 'view' is a logical table that derives columns from one or more
   other tables or views. Once the view is created, it can be queried
   exactly like any other table in the database.

   NOTE: Views are not available with all datasources. Oracle is one
   example of a datasource which does support views.

   Example

      // Incomplete code sample
      db.CreateView("PARTS_SD1", "PN, PD, QTY",
                    "SELECT PART_NUM, PART_DESC, QTY_ON_HAND * 1.1 FROM PARTS \
                     WHERE STORAGE_DEVICE = 1");

=head2 Wx::Db::Dbms

   wxDBMS Dbms()

   Remarks

   The return value will be of the enumerated type wxDBMS. This
   enumerated type contains a list of all the currently tested and
   supported databases.

   Additional databases may work with these classes, but the databases
   returned by this function have been tested and confirmed to work with
   these ODBC classes.

   Possible values returned by this function can be viewed in the
   Enumerated types section of wxDb.

   There are known issues with conformance to the ODBC standards with
   several datasources supported by the wxWidgets ODBC classes. Please
   see the overview for specific details on which datasource have which
   issues.

   Return value

   The return value will indicate which of the supported datasources is
   currently connected to by this connection. In the event that the
   datasource is not recognized, a value of 'dbmsUNIDENTIFIED' is
   returned.

=head2 Wx::Db::DispAllErrors

   bool DispAllErrors(HENV aHenv, HDBC aHdbc = SQL_NULL_HDBC, HSTMT
   aHstmt = SQL_NULL_HSTMT)

   Used to log all database errors that occurred as a result of an
   executed database command. This logging is automatic and also includes
   debug logging when compiled in debug mode via wxLogDebug. If logging
   is turned on via wxDb::SetSqlLogging, then an entry is also logged to
   the defined log file.

   Parameters

   aHenv

       Handle to the ODBC environment.

   aHdbc

       Handle to the ODBC connection. Pass this in if the ODBC function
       call that erred required a hdbc or hstmt argument.

   aHstmt

       Handle to the ODBC statement being executed against. Pass this in
       if the ODBC function call that failed required a hstmt argument.

   Remarks

   This member function will log all of the ODBC error messages for the
   last ODBC function call that was made. This function is normally used
   internally within the ODBC class library, but can be used
   programmatically after calling ODBC functions directly (i.e.
   SQLFreeEnv()).

   Return value

   The function always returns false, so a call to this function can be
   made in the return statement of a code block in the event of a failure
   to perform an action (see the example below).

   See also

   wxDb::SetSqlLogging, wxDbSqlLog

   Example

      if (SQLExecDirect(hstmt, (UCHAR FAR *) pSqlStmt, SQL_NTS) != SQL_SUCCESS)
         // Display all ODBC errors for this stmt
         return(db.DispAllErrors(db.henv, db.hdbc, hstmt));

=head2 Wx::Db::DispNextError

   void DispNextError()

   Remarks

   This function is normally used internally within the ODBC class
   library. It could be used programmatically after calling ODBC
   functions directly. This function works in conjunction with
   wxDb::GetNextError when errors (or sometimes informational messages)
   returned from ODBC need to be analyzed rather than simply displaying
   them as an error. GetNextError() retrieves the next ODBC error from
   the ODBC error queue. The wxDb member variables "sqlState",
   "nativeError" and "errorMsg" could then be evaluated. To display the
   error retrieved, DispNextError() could then be called. The combination
   of GetNextError() and DispNextError() can be used to iteratively step
   through the errors returned from ODBC evaluating each one in context
   and displaying the ones you choose.

   Example

      // Drop the table before attempting to create it
      sprintf(sqlStmt, "DROP TABLE %s", tableName);
      // Execute the drop table statement
      if (SQLExecDirect(hstmt,(UCHAR FAR *)sqlStmt,SQL_NTS) != SQL_SUCCESS)
      {
         // Check for sqlState = S0002, "Table or view not found".
         // Ignore this error, bomb out on any other error.
         pDb->GetNextError(henv, hdbc, hstmt);
         if (wxStrcmp(pDb->sqlState, "S0002"))
         {
            pDb->DispNextError();   // Displayed error retrieved
            pDb->DispAllErrors(henv, hdbc, hstmt); // Display all other errors, if any
            pDb->RollbackTrans();   // Rollback the transaction
            CloseCursor();          // Close the cursor
            return(false);          // Return Failure
         }
      }

=head2 Wx::Db::DropView

   bool DropView(const wxString &viewName)

   Drops the data table view named in 'viewName'.

   Parameters

   viewName

       Name of the view to be dropped.

   Remarks

   If the view does not exist, this function will return true. Note that
   views are not supported with all datasources.

=head2 Wx::Db::EscapeSqlChars

   wxString EscapeSqlChars(const wxString& value)

   This function is used internally by wxWidgets while building SQL
   statements. It has been provided to help users who wish to explicity
   construct SQL statements to be sent to the server. The function takes
   the value passed and returns it with any special characters escaped.
   Which characters are considered special depends on what type of
   datasource the object is connected to. For example, most database
   servers use a backslash as the escape character; if the value passed
   contains a backlash it will be replaced with a double backslash before
   it is passed to the server. This function can be used to avoid passing
   statements with syntax errors to the server as well as prevent SQL
   injection attacks.

   Parameters

   value

       The value to be escaped.

=head2 Wx::Db::ExecSql

   bool ExecSql(const wxString &pSqlStmt)

   bool ExecSql(const wxString &pSqlStmt, wxDbColInf **columns, short &numcols)

   Allows a native SQL command to be executed directly against the
   datasource. In addition to being able to run any standard SQL command,
   use of this function allows a user to (potentially) utilize features
   specific to the datasource they are connected to that may not be
   available through ODBC. The ODBC driver will pass the specified
   command directly to the datasource.

   To get column amount and column names or other information about
   returned columns, pass 'columns' and 'numcols' parameters to the
   function also.

   Parameters

   pSqlStmt

       Pointer to the SQL statement to be executed.

   columns

       On success, this function will set this pointer to point to array
       of wxDbColInf objects, holding information about columns returned
       by the query. You need to call delete[] for the pointer you pass
       here after you don't use it anymore to prevent memory leak.

   numcols

       Reference to variable where amount of objects in 'columns'-parameter
       will be set.

   Remarks

   This member extends the wxDb class and allows you to build and execute
   ANY VALID SQL statement against the datasource. This allows you to
   extend the class library by being able to issue any SQL statement that
   the datasource is capable of processing.

   See also

   wxDb::GetData, wxDb::GetNext

=head2 Wx::Db::FwdOnlyCursors

   bool IsFwdOnlyCursors()

   Older form (pre-2.3/2.4 of wxWidgets) of the wxDb::IsFwdOnlyCursors.
   This method is provided for backward compatibility only. The method
   wxDb::IsFwdOnlyCursors should be used in place of this method.

=head2 Wx::Db::GetCatalog

   wxDbInf * GetCatalog(const wxChar *userID)

   Returns a wxDbInf pointer that points to the catalog (datasource)
   name, schema, number of tables accessible to the current user, and a
   wxDbTableInf pointer to all data pertaining to all tables in the users
   catalog.

   Parameters

   userID

       Owner/Schema of the table. Specify a userID when the datasource
       you are connected to allows multiple unique tables with the same
       name to be owned by different users. userID is evaluated as
       follows:

            userID == NULL  ... UserID is ignored (DEFAULT)
            userID == ""    ... UserID set equal to 'this->uid'
            userID != ""    ... UserID set equal to 'userID'

   Remarks

   The returned catalog will only contain catalog entries for tables to
   which the user specified in 'userID' has sufficient privileges. If no
   user is specified (NULL passed in), a catalog pertaining to all tables
   in the datasource accessible to the connected user (permissions apply)
   via this connection will be returned.

=head2 Wx::Db::GetColumnCount

   int GetColumnCount(const wxString &tableName, const wxChar *userID)

   Parameters

   tableName

       The table name you wish to obtain column information about.

   userID

       Name of the user that owns the table(s) (also referred to as
       schema). Required for some datasources for situations where there
       may be multiple tables with the same name in the datasource, but
       owned by different users. userID is evaluated in the following
       manner:

            userID == NULL  ... UserID is ignored (DEFAULT)
            userID == ""    ... UserID set equal to 'this->uid'
            userID != ""    ... UserID set equal to 'userID'

   Return value

   Returns a count of how many columns are in the specified table. If an
   error occurs retrieving the number of columns, this function will
   return a -1.

=head2 Wx::Db::GetColumns

   wxDbColInf * GetColumns(const wxString &tableName, UWORD *numCols,
   const wxChar *userID=NULL)

   wxDbColInf * GetColumns(wxChar *tableName[], const wxChar *userID)

   Parameters

   tableName

       The table name you wish to obtain column information about.

=head2 Wx::Db::GetData

   bool GetData(UWORD colNumber, SWORD cType, PTR pData, SDWORD maxLen,
   SDWORD FAR * cbReturned )

   Used to retrieve result set data without binding column values to
   memory variables (i.e. not using a wxDbTable instance to access table
   data).

   Parameters

   colNumber

       Ordinal number of the desired column in the result set to be
       returned.

=head2 Wx::Db::GetDatabaseName

   const wxChar * GetDatabaseName()

   Returns the name of the database engine.

=head2 Wx::Db::GetDatasourceName

   const wxString & GetDatasourceName()

   Returns the ODBC datasource name.

=head2 Wx::Db::GetHDBC

   HDBC GetHDBC()

   Returns the ODBC handle to the database connection.

=head2 Wx::Db::GetHENV

   HENV GetHENV()

   Returns the ODBC environment handle.

=head2 Wx::Db::GetHSTMT

   HSTMT GetHSTMT()

   Returns the ODBC statement handle associated with this database
   connection.

=head2 Wx::Db::GetKeyFields

   int GetKeyFields(const wxString &tableName, wxDbColInf *colInf, UWORD
   numColumns)

   Used to determine which columns are members of primary or non-primary
   indexes on the specified table. If a column is a member of a foreign
   key for some other table, that information is detected also.

   This function is primarily for use by the wxDb::GetColumns function,
   but may be called if desired from the client application.

   Parameters

   tableName

       Name of the table for which the columns will be evaluated as to
       their inclusion in any indexes.

=head2 Wx::Db::GetNext

   bool GetNext()

   Called after executing a query, this function requests the next row in
   the result set after the current position of the cursor.

   See also

   wxDb::ExecSql, wxDb::GetData

=head2 Wx::Db::GetNextError

   bool GetNextError(HENV aHenv, HDBC aHdbc = SQL_NULL_HDBC, HSTMT aHstmt
   = SQL_NULL_HSTMT)

   Parameters

   aHenv

       A handle to the ODBC environment.

=head2 Wx::Db::GetPassword

   const wxString & GetPassword()

   Returns the password used to establish this connection to the
   datasource.

=head2 Wx::Db::GetTableCount

   int GetTableCount()

   Returns the number of wxDbTable() instances currently using this
   datasource connection.

=head2 Wx::Db::GetUsername

   const wxString & GetUsername()

   Returns the user name (uid) used to establish this connection to the
   datasource.

=head2 Wx::Db::Grant

   bool Grant(int privileges, const wxString &tableName, const wxString &userList
   = "PUBLIC")

   Use this member function to GRANT privileges to users for accessing
   tables in the datasource.

   Parameters

   privileges

       Use this argument to select which privileges you want to grant.
       Pass DB_GRANT_ALL to grant all privileges. To grant individual
       privileges pass one or more of the following OR'd together:

            DB_GRANT_SELECT  = 1
            DB_GRANT_INSERT  = 2
            DB_GRANT_UPDATE  = 4
            DB_GRANT_DELETE  = 8
            DB_GRANT_ALL     = DB_GRANT_SELECT | DB_GRANT_INSERT |
                               DB_GRANT_UPDATE | DB_GRANT_DELETE

   tableName

       The name of the table you wish to grant privileges on.

=head2 Wx::Db::IsFwdOnlyCursors

   bool IsFwdOnlyCursors()

   This setting indicates whether this database connection was created as
   being capable of using only forward scrolling cursors.

   This function does NOT indicate if the ODBC driver or datasource
   supports backward scrolling cursors. There is no standard way of
   detecting if the driver or datasource can support backward scrolling
   cursors.

   If a wxDb instance was created as being capable of only forward
   scrolling cursors, then even if the datasource and ODBC driver support
   backward scrolling cursors, tables using this database connection
   would only be able to use forward scrolling cursors.

   The default setting of whether a wxDb connection to a database allows
   forward-only or also backward scrolling cursors is defined in setup.h
   by the value of wxODBC_FWD_ONLY_CURSORS. This default setting can be
   overridden when the wxDb connection is initially created (see wxDb
   constructor and wxDbGetConnection).

   Return value

   Returns true if this datasource connection is defined as using only
   forward scrolling cursors, or false if the connection is defined as
   being allowed to use backward scrolling cursors and their associated
   functions (see note above).

   Remarks

   Added as of wxWidgets v2.4 release, this function is a renamed version
   of wxDb::FwdOnlyCursors() to match the normal wxWidgets naming
   conventions for class member functions.

   This function is not available in versions prior to v2.4. You should
   use wxDb::FwdOnlyCursors for wxWidgets versions prior to 2.4.

   See also

   wxDb constructor, wxDbGetConnection

=head2 Wx::Db::IsOpen

   bool IsOpen()

   Indicates whether the database connection to the datasource is
   currently opened.

   Remarks

   This function may indicate that the database connection is open, even
   if the call to wxDb::Open may have failed to fully initialize the
   connection correctly. The connection to the database is open and can
   be used via the direct SQL commands, if this function returns true.
   Other functions which depend on the wxDb::Open to have completed
   correctly may not function as expected. The return result from
   wxDb::Open is the only way to know if complete initialization of this
   wxDb connection was successful or not. See wxDb::Open for more details
   on partial failures to open a connection instance.

=head2 Wx::Db::LogError

   void LogError(const wxString &errMsg const wxString &SQLState="")

   errMsg

       Free-form text to display describing the error/text to be logged.

=head2 Wx::Db::ModifyColumn

   void ModifyColumn(const wxString &tableName const wxString &ColumnName
   int dataType ULONG columnLength=0 const wxString &optionalParam="")

   Used to change certain properties of a column such as the length, or
   whether a column allows NULLs or not.

   tableName

       Name of the table that the column to be modified is in.

=head2 Wx::Db::Open

   bool Open(const wxString &Dsn, const wxString &Uid, const wxString &AuthStr,
   bool failOnDataTypeUnsupported)

   bool Open(const wxString &inConnectStr, bool failOnDataTypeUnsupported)

   bool Open(wxDbConnectInf *dbConnectInf, bool failOnDataTypeUnsupported)

   bool Open(wxDb *copyDb)

   Opens a connection to the datasource, sets certain behaviors of the
   datasource to confirm to the accepted behaviors (e.g. cursor position
   maintained on commits), and queries the datasource for its
   representations of the basic datatypes to determine the form in which
   the data going to/from columns in the data tables are to be handled.

   The second form of this function, which accepts a "wxDb *" as a
   parameter, can be used to avoid the overhead (execution time, database
   load, network traffic) which are needed to determine the data types
   and representations of data that are necessary for cross-datasource
   support by these classes.

   Normally the first form of the wxDb::Open() function will open the
   connection and then send a series of queries to the datasource asking
   it for its representation of data types, and all the features it
   supports. If one connection to the datasource has already been made
   previously, the information gathered when that connection was created
   can just be copied to any new connections to the same datasource by
   passing a pointer to the first connection in as a parameter to the
   wxDb::Open() function. Note that this new connection created from the
   first connections information will use the same Dsn/Uid/AuthStr as the
   first connection used.

   Parameters

   Dsn 

       datasource name. The name of the ODBC datasource as assigned when
       the datasource is initially set up through the ODBC data source
       manager.

=head2 Wx::Db::RollbackTrans

   bool RollbackTrans()

   Function to "undo" changes made to the database. After an
   insert/update/delete, the operation may be "undone" by issuing this
   command any time before a wxDb::CommitTrans is called on the database
   connection.

   Remarks

   Transactions begin implicitly as soon as you make a change to the
   database. The transaction continues until either a commit or rollback
   is executed. Calling wxDb::RollbackTrans() will result in ALL changes
   done using this database connection that have not already been
   committed to be "undone" back to the last commit/rollback that was
   successfully executed.

   ---------------------------------------------------------------------

   Calling this member function rolls back ALL open (uncommitted)
   transactions on this ODBC connection, including all wxDbTable
   instances that use this connection.

   ---------------------------------------------------------------------

   See also

   wxDb::CommitTrans for a special note on cursors

=head2 Wx::Db::SetDebugErrorMessages

   void SetDebugErrorMessages(bool state)

   state

       Either true (debug messages are logged) or false (debug messages
       are not logged).

   Remarks

   Turns on/off debug error messages from the ODBC class library. When
   this function is passed true, errors are reported to the user/logged
   automatically in a text or pop-up dialog when an ODBC error occurs.
   When passed false, errors are silently handled.

   When compiled in release mode (FINAL=1), this setting has no affect.

   See also

   wxDb constructor

=head2 Wx::Db::SetSqlLogging

   bool SetSqlLogging(wxDbSqlLogState state, const wxString &filename =
   SQL_LOG_FILENAME, bool append = false)

   Parameters

   state

       Either sqlLogOFF or sqlLogON (see enum wxDbSqlLogState). Turns
       logging of SQL commands sent to the datasource OFF or ON.

=head2 Wx::Db::SQLColumnName

   const wxString SQLColumnName(const wxChar * colName)

   Returns the column name in a form ready for use in SQL statements. In
   most cases, the column name is returned verbatim. But some databases
   (e.g. MS Access, SQL Server, MSDE) allow for spaces in column names,
   which must be specially quoted. For example, if the datasource allows
   spaces in the column name, the returned string will have the correct
   enclosing marks around the name to allow it to be properly included in
   a SQL statement for the DBMS that is currently connected to with this
   connection.

   Parameters

   colName

       Native name of the column in the table that is to be evaluated to
       determine if any special quoting marks needed to be added to it
       before including the column name in a SQL statement

   See also

   wxDb::SQLTableName

=head2 Wx::Db::SQLTableName

   const wxString SQLTableName(const wxChar * tableName)

   Returns the table name in a form ready for use in SQL statements. In
   most cases, the table name is returned verbatim. But some databases
   (e.g. MS Access, SQL Server, MSDE) allow for spaces in table names,
   which must be specially quoted. For example, if the datasource allows
   spaces in the table name, the returned string will have the correct
   enclosing marks around the name to allow it to be properly included in
   a SQL statement for the data source that is currently connected to
   with this connection.

   Parameters

   tableName

       Native name of the table that is to be evaluated to determine if
       any special quoting marks needed to be added to it before
       including the table name in a SQL statement

   See also

   wxDb::SQLColumnName

=head2 Wx::Db::TableExists

   bool TableExists(const wxString &tableName, const wxChar *userID=NULL,
   const wxString &path="")

   Checks the ODBC datasource for the existence of a table. If a userID
   is specified, then the table must be accessible by that user (user
   must have at least minimal privileges to the table).

   Parameters

   tableName

       Name of the table to check for the existence of.

=head2 Wx::Db::TablePrivileges

   bool TablePrivileges(const wxString &tableName, const wxString &priv,
   const wxChar *userID=NULL, const wxChar *schema=NULL, const wxString &path="")

   Checks the ODBC datasource for the existence of a table. If a userID
   is specified, then the table must be accessible by that user (user
   must have at least minimal privileges to the table).

   Parameters

   tableName

       Name of the table on which to check privileges. tableName may
       refer to a table, view, alias or synonym.

=head2 Wx::Db::TranslateSqlState

   int TranslateSqlState(const wxString &SQLState)

   Converts an ODBC sqlstate to an internal error code.

   Parameters

   SQLState

       State to be converted.

   Return value

   Returns the internal class DB_ERR code. See wxDb::DB_STATUS
   definition.

=head2 Wx::Db::WriteSqlLog

   bool WriteSqlLog(const wxString &logMsg)

   Parameters

   logMsg

       Free form string to be written to the log file.

   Remarks

   Very useful debugging tool that may be turned on/off during run time
   (see (see wxDb::SetSqlLogging for details on turning logging on/off).
   The passed in string logMsg will be written to a log file if SQL
   logging is turned on.

   Return value

   If SQL logging is off when a call to WriteSqlLog() is made, or there
   is a failure to write the log message to the log file, the function
   returns false without performing the requested log, otherwise true is
   returned.

   See also

   wxDb::SetSqlLogging

=head1 Wx::DbColDef

=head2 Wx::DbColDef::Initialize

   Simply initializes all member variables to a cleared state. Called by
   the constructor automatically.

=head1 Wx::DbColFor

=head2 Wx::DbColFor::Format

   int Format(int Nation, int dbDataType, SWORD sqlDataType, short
   columnSize, short decimalDigits)

   Work in progress, and should be inter-related with wxLocale
   eventually.

=head2 Wx::DbColFor::Initialize

   Simply initializes all member variables to a cleared state. Called by
   the constructor automatically.

=head1 Wx::DbColInf

=head2 Wx::DbColInf::Initialize

   Simply initializes all member variables to a cleared state. Called by
   the constructor automatically.

=head1 Wx::DbConnectInf

=head2 Wx::DbConnectInf::new

   wxDbConnectInf()

   Default constructor.

   wxDbConnectInf(HENV henv, const wxString &dsn, const wxString &userID="",
   const wxString &password, const wxString &defaultDir="", const
   wxString &description="", const wxString &fileType="")

   Constructor which allows initial settings of all the classes member
   variables.

   See the special note below on the henv parameter for forcing this
   constructor to create a SQL environment handle automatically, rather
   than needing to pass one in to the function.

   Parameters

   henv

       Environment handle used for this connection. See
       wxDConnectInf::AllocHenv for how to create an SQL environment
       handle. NOTE: Passing in a NULL for this parameter will inform the
       constructor that it should create its own SQL environment handle.
       If NULL is passed for this parameter, the constructor will call
       wxDConnectInf::AllocHenv internally. A flag is set internally also
       to indicate that the HENV was created by the constructor so that
       when the default class destructor is called, the destructor will
       call wxDConnectInf::FreeHenv to free the environment handle
       automatically.

=head2 Wx::DbConnectInf::DESTROY

   ~wxDbConnectInf()

   Handles the default destruction of the instance of the class. If the
   long form of the wxDConnectInf was used, then this destructor also
   takes care of calling wxDConnectInf::FreeHenv to free the SQL
   environment handle.

=head2 Wx::DbConnectInf::AllocHenv

   bool AllocHenv()

   Allocates a SQL environment handle that will be used to interface with
   an ODBC datasource.

   Remarks

   This function can be automatically called by the long from of the
   wxDbConnectInf constructor.

=head2 Wx::DbConnectInf::FreeHenv

   void FreeHenv()

   Frees the SQL environment handle being managed by the instance of this
   class.

   Remarks

   If the SQL environment handle was created using the long form of the
   wxDbConnectInf constructor, then the flag indicating that the HENV
   should be destroyed when the classes destructor is called is reset to
   be false, so that any future handles created using the
   wxDbConnectInf::AllocHenv function must be manually released with a
   call to this function.

=head2 Wx::DbConnectInf::Initialize

   Simply initializes all member variables to a cleared state. Called by
   the constructor automatically.

=head2 Wx::DbConnectInf::GetAuthStr

   const wxChar * GetAuthStr()

   Accessor function to return the password assigned for this class
   instance that will be used with the user ID.

   Synonymous with wxDbConnectInf::GetPassword

=head2 Wx::DbConnectInf::GetDefaultDir

   const wxChar * GetDefaultDir()

   Accessor function to return the default directory in which the
   datasource's data table is stored. This directory is only used for
   file based datasources like dBase. MS-Access does not require this to
   be set, as the path is set in the ODBC Administrator for MS-Access.

=head2 Wx::DbConnectInf::GetDescription

   const wxChar * GetDescription()

   Accessor function to return the description assigned for this class
   instance.

   NOTE: Description is a FUTURE USE item and is unused currently.

=head2 Wx::DbConnectInf::GetDsn

   const wxChar * GetDsn()

   Accessor function to return the datasource name assigned for this
   class instance.

=head2 Wx::DbConnectInf::GetFileType

   const wxChar * GetFileType()

   Accessor function to return the filetype of the ODBC datasource
   assigned for this class instance.

   NOTE: FileType is a FUTURE USE item and is unused currently.

=head2 Wx::DbConnectInf::GetHenv

   const HENV GetHenv()

   Accessor function to return the SQL environment handle being managed
   by this class instance.

=head2 Wx::DbConnectInf::GetPassword

   const wxChar * GetPassword()

   Accessor function to return the password assigned for this class
   instance that will be used with the user ID.

   Synonymous with wxDbConnectInf::GetAuthStr

=head2 Wx::DbConnectInf::GetUid

   const wxChar * GetUid()

   Accessor function to return the user ID assigned for this class
   instance.

=head2 Wx::DbConnectInf::GetUserID

   const wxChar * GetUserID()

   Accessor function to return the user ID assigned for this class
   instance.

=head2 Wx::DbConnectInf::SetAuthStr

   SetAuthStr(const wxString &authstr)

   Accessor function to assign the password for this class instance that
   will be used with the user ID.

   Synonymous with wxDbConnectInf::SetPassword

=head2 Wx::DbConnectInf::SetDefaultDir

   SetDefaultDir(const wxString &defDir)

   Accessor function to assign the default directory in which the
   datasource's data table is stored. This directory is only used for
   file based datasources like dBase. MS-Access does not require this to
   be set, as the path is set in the ODBC Administrator for MS-Access.

=head2 Wx::DbConnectInf::SetDescription

   SetDescription(const wxString &desc)

   Accessor function to assign the description assigned for this class
   instance.

   NOTE: Description is a FUTURE USE item and is unused currently.

=head2 Wx::DbConnectInf::SetDsn

   SetDsn(const wxString &dsn)

   Accessor function to assign the datasource name for this class
   instance.

=head2 Wx::DbConnectInf::SetFileType

   SetFileType(const wxString &)

   Accessor function to return the filetype of the ODBC datasource
   assigned for this class instance.

   NOTE: FileType is a FUTURE USE item and is unused currently.

=head2 Wx::DbConnectInf::SetHenv

   void SetHenv(const HENV henv)

   Accessor function to set the SQL environment handle for this class
   instance.

=head2 Wx::DbConnectInf::SetPassword

   SetPassword(const wxString &password)

   Accessor function to assign the password for this class instance that
   will be used with the user ID.

   Synonymous with wxDbConnectInf::SetAuthStr

=head2 Wx::DbConnectInf::SetUid

   SetUid(const wxString &uid)

   Accessor function to set the user ID for this class instance.

=head2 Wx::DbConnectInf::SetUserID

   SetUserID(const wxString &userID)

   Accessor function to assign the user ID for this class instance.

=head1 Wx::DbInf

=head2 Wx::DbInf::Initialize

   Simply initializes all member variables to a cleared state. Called by
   the constructor automatically.

=head1 Wx::DbTable

=head2 Wx::DbTable::new

   wxDbTable(wxDb *pwxDb, const wxString &tblName, const UWORD numColumns,
   const wxString &qryTblName = "", bool qryOnly = !wxDB_QUERY_ONLY,
   const wxString &tblPath = "")

   Default constructor.

   Parameters

   pwxDb

       Pointer to the wxDb instance to be used by this wxDbTable
       instance.

=head2 Wx::DbTable::new

   virtual ~wxDbTable()

   Virtual default destructor.

=head2 Wx::DbTable::BuildDeleteStmt

   void BuildDeleteStmt(wxString &pSqlStmt, int typeOfDel, const wxString
   &pWhereClause="")

   Constructs the full SQL statement that can be used to delete all rows
   matching the criteria in the pWhereClause.

   Parameters

   pSqlStmt

       Pointer to buffer for the SQL statement retrieved. To be sure you
       have adequate space allocated for the SQL statement, allocate
       DB_MAX_STATEMENT_LEN bytes.

=head2 Wx::DbTable::BuildSelectStmt

   void BuildSelectStmt(wxString &pSqlStmt, int typeOfSelect, bool
   distinct)

   Constructs the full SQL statement that can be used to select all rows
   matching the criteria in the pWhereClause. This function is called
   internally in the wxDbTable class whenever the function
   wxDbTable::Query is called.

   NOTE: Only the columns specified in wxDbTable::SetColDefs statements
   are included in the list of columns returned by the SQL statement
   created by a call to this function.

   Parameters

   pSqlStmt

       Pointer to storage for the SQL statement retrieved. To be sure you
       have adequate space allocated for the SQL statement, allocate
       DB_MAX_STATEMENT_LEN bytes.

=head2 Wx::DbTable::BuildUpdateStmt

   void BuildUpdateStmt(wxString &pSqlStmt, int typeOfUpd, const wxString
   &pWhereClause="")

   Constructs the full SQL statement that can be used to update all rows
   matching the criteria in the pWhereClause.

   If typeOfUpdate is DB_UPD_KEYFIELDS, then the current values in the
   bound columns are used to determine which row(s) in the table are to
   be updated. The exception to this is when a datasource supports ROW
   IDs (Oracle). The ROW ID column is used for efficiency purposes when
   available.

   NOTE: Only the columns specified in wxDbTable::SetColDefs statements
   are included in the list of columns updated by the SQL statement
   created by a call to this function. Any column definitions that were
   defined as being non-updateable will be excluded from the SQL UPDATE
   statement created by this function.

   Parameters

   pSqlStmt

       Pointer to storage for the SQL statement retrieved. To be sure you
       have adequate space allocated for the SQL statement, allocate
       DB_MAX_STATEMENT_LEN bytes.

=head2 Wx::DbTable::BuildWhereClause



=head2 Wx::DbTable::CanSelectForUpdate

   bool CanSelectForUpdate()

   Use this function to determine if the datasource supports SELECT ...
   FOR UPDATE. When the keywords "FOR UPDATE" are included as part of
   your SQL SELECT statement, all records retrieved (not just queried,
   but actually retrieved using wxDbTable::GetNext, etc) from the result
   set are locked.

   Remarks

   Not all datasources support the "FOR UPDATE" clause, so you must use
   this member function to determine if the datasource currently
   connected to supports this behavior or not before trying to select
   using "FOR UPDATE".

   If the wxDbTable instance was created with the parameter
   wxDB_QUERY_ONLY, then this function will return false. For all known
   databases which do not support the FOR UPDATE clause, this function
   will return false also.

=head2 Wx::DbTable::CanUpdateByROWID

   bool CanUpdateByROWID()

   CURRENTLY ONLY POSSIBLE IF USING ORACLE.

   --- CURRENTLY DISABLED FOR *ALL* DATASOURCES --- NOV 1 2000 - gt

   Every Oracle table has a hidden column named ROWID. This is a pointer
   to the physical location of the record in the datasource and allows
   for very fast updates and deletes. The key is to retrieve this ROWID
   during your query so it is available during an update or delete
   operation.

   Use of the ROWID feature is always handled by the class library except
   in the case of wxDbTable::QueryBySqlStmt. Since you are passing in the
   SQL SELECT statement, it is up to you to include the ROWID column in
   your query. If you do not, the application will still work, but may
   not be as optimized. The ROWID is always the last column in the column
   list in your SQL SELECT statement. The ROWID is not a column in the
   normal sense and should not be considered part of the column
   definitions for the wxDbTable object.

   Remarks

   The decision to include the ROWID in your SQL SELECT statement must be
   deferred until runtime since it depends on whether you are connected
   to an Oracle datasource or not.

   Example

       // Incomplete code sample
       wxDbTable parts;
       .....
       if (parts.CanUpdateByROWID())
       {
           // Note that the ROWID column must always be the last column selected
           sqlStmt = "SELECT PART_NUM, PART_DESC, ROWID" FROM PARTS";
       }
       else
           sqlStmt = "SELECT PART_NUM, PART_DESC FROM PARTS";

=head2 Wx::DbTable::ClearMemberVar

   void ClearMemberVar(UWORD colNumber, bool setToNull=false)

   Same as wxDbTable::ClearMemberVars except that this function clears
   only the specified column of its values, and optionally sets the
   column to be a NULL column.

   colNumber

       Column number that is to be cleared. This number (between 0 and
       (numColumns-1)) is the index of the column definition created
       using the wxDbTable::SetColDefs function.

=head2 Wx::DbTable::ClearMemberVars

   void ClearMemberVars(bool setToNull=false)

   Initializes all bound columns of the wxDbTable instance to zero. In
   the case of a string, zero is copied to the first byte of the string.

   setToNull

       OPTIONAL. Indicates whether all columns should be flagged as
       having a NULL value stored in the bound memory variable. If true,
       then any value stored in the bound member variable is cleared.
       Default is false.

   Remarks

   This is useful before calling functions such as
   wxDbTable::QueryMatching or wxDbTable::DeleteMatching since these
   functions build their WHERE clauses from non-zero columns. To call
   either wxDbTable::QueryMatching or wxDbTable::DeleteMatching use this
   sequence:

   1)  ClearMemberVars()
   2)  Assign columns values you wish to match on
   3)  Call wxDbTable::QueryMatching() or wxDbTable::DeleteMatching()

=head2 Wx::DbTable::CloseCursor

   bool CloseCursor(HSTMTcursor)

   Closes the specified cursor associated with the wxDbTable object.

   Parameters

   cursor

       The cursor to be closed.

   Remarks

   Typically handled internally by the ODBC class library, but may be
   used by the programmer if desired.

   ---------------------------------------------------------------------

   DO NOT CLOSE THE wxDB_DEFAULT_CURSOR!

   ---------------------------------------------------------------------

=head2 Wx::DbTable::Count

   ULONG Count(const wxString &args="*")

   Returns the number of records which would be in the result set using
   the current query parameters specified in the WHERE and FROM clauses.

   Parameters

   args

       OPTIONAL. This argument allows the use of the DISTINCT keyword
       against a column name to cause the returned count to only indicate
       the number of rows in the result set that have a unique value in
       the specified column. An example is shown below. Default is "*",
       meaning a count of the total number of rows matching is returned,
       regardless of uniqueness.

   Remarks

   This function can be called before or after an actual query to obtain
   the count of records in the result set. Count() uses its own cursor,
   so result set cursor positioning is not affected by calls to Count().

   WHERE and FROM clauses specified using wxDbTable::SetWhereClause and
   wxDbTable::SetFromClause ARE used by this function.

   Example

       USERS TABLE

=head2 Wx::DbTable::CreateIndex

   bool CreateIndex(const wxString &IndexName, bool unique, UWORD
   numIndexColumns, wxDbIdxDef *pIndexDefs, bool attemptDrop=true)

   This member function allows you to create secondary (non-primary)
   indexes on your tables. You first create your table, normally
   specifying a primary index, and then create any secondary indexes on
   the table. Indexes in relational model are not required. You do not
   need indexes to look up records in a table or to join two tables
   together. In the relational model, indexes, if available, provide a
   quicker means to look up data in a table. To enjoy the performance
   benefits of indexes, the indexes must be defined on the appropriate
   columns and your SQL code must be written in such a way as to take
   advantage of those indexes.

   Parameters

   IndexName

       Name of the Index. Name must be unique within the table space of
       the datasource.

=head2 Wx::DbTable::CreateTable

   bool CreateTable(bool attemptDrop=true)

   Creates a table based on the definitions previously defined for this
   wxDbTable instance.

   Parameters

   attemptDrop

       OPTIONAL. Indicates whether the driver should attempt to drop the
       table before trying to create it. Some datasources will not allow
       creation of a table if the table already exists in the table space
       being used. Default is true.

   Remarks

   This function creates the table and primary index (if any) in the
   table space associated with the connected datasource. The owner of
   these objects will be the user id that was given when wxDb::Open was
   called. The objects will be created in the default schema/table space
   for that user.

   In your derived wxDbTable object constructor, the columns and primary
   index of the table are described through the wxDbColDef structure.
   wxDbTable::CreateTable uses this information to create the table and
   to add the primary index. See wxDbTable ctor and wxDbColDef
   description for additional information on describing the columns of
   the table.

   It is not necessary to call wxDb::CommitTrans after executing this
   function.

=head2 Wx::DbTable::DB_STATUS

   bool DB_STATUS()

   Accessor function that returns the wxDb private member variable
   DB_STATUS for the database connection used by this instance of
   wxDbTable.

=head2 Wx::DbTable::Delete

   bool Delete()

   Deletes the row from the table indicated by the current cursor.

   Remarks

   Use wxDbTable::GetFirst, wxDbTable::GetLast, wxDbTable::GetNext or
   wxDbTable::GetPrev to position the cursor to a valid record. Once
   positioned on a record, call this function to delete the row from the
   table.

   A wxDb::CommitTrans or wxDb::RollbackTrans must be called after use of
   this function to commit or rollback the deletion.

   NOTE: Most datasources have a limited size "rollback" segment. This
   means that it is only possible to insert/update/delete a finite number
   of rows without performing a wxDb::CommitTrans or wxDb::RollbackTrans.
   Size of the rollback segment varies from database to database, and is
   user configurable in most databases. Therefore it is usually best to
   try to perform a commit or rollback at relatively small intervals when
   processing a larger number of actions that insert/update/delete rows
   in a table.

=head2 Wx::DbTable::DeleteCursor

   bool DeleteCursor(HSTMT *hstmtDel)

   Allows a program to delete a cursor.

   Parameters

   hstmtDel

       Handle of the cursor to delete.

   Remarks

   For default cursors associated with the instance of wxDbTable, it is
   not necessary to specifically delete the cursors. This is
   automatically done in the wxDbTable destructor.

   NOTE: If the cursor could not be deleted for some reason, an error is
   logged indicating the reason. Even if the cursor could not be deleted,
   the HSTMT that is passed in is deleted, and the pointer is set to
   NULL.

   ---------------------------------------------------------------------

   DO NOT DELETE THE wxDB_DEFAULT_CURSOR!

   ---------------------------------------------------------------------

=head2 Wx::DbTable::DeleteMatching

   bool DeleteMatching()

   This member function allows you to delete records from your wxDbTable
   object by specifying the data in the columns to match on.

   Remarks

   To delete all users with a first name of "JOHN", do the following:

=head2 Wx::DbTable::DeleteWhere

   bool DeleteWhere(const wxString &pWhereClause)

   Deletes all rows from the table which match the criteria specified in
   the WHERE clause that is passed in.

   Parameters

   pWhereClause

       SQL WHERE clause. This WHERE clause determines which records will
       be deleted from the table interfaced through the wxDbTable
       instance. The WHERE clause passed in must be compliant with the
       SQL 92 grammar. Do not include the keyword 'WHERE'

   Remarks

   This is the most powerful form of the wxDbTable delete functions. This
   function gives access to the full power of SQL. This function can be
   used to delete records by passing a valid SQL WHERE clause.
   Sophisticated deletions can be performed based on multiple criteria
   using the full functionality of the SQL language.

   A wxDb::CommitTrans must be called after use of this function to
   commit the deletions.

   Note: This function is limited to deleting records from the table
   associated with this wxDbTable object only. Deletions on joined tables
   is not possible.

   NOTE: Most datasources have a limited size "rollback" segment. This
   means that it is only possible to insert/update/delete a finite number
   of rows without performing a wxDb::CommitTrans or wxDb::RollbackTrans.
   Size of the rollback segment varies from database to database, and is
   user configurable in most databases. Therefore it is usually best to
   try to perform a commit or rollback at relatively small intervals when
   processing a larger number of actions that insert/update/delete rows
   in a table.

   WHERE and FROM clauses specified using wxDbTable::SetWhereClause and
   wxDbTable::SetFromClause are ignored by this function.

   Example

       // Delete parts 1 thru 10 from containers 'X', 'Y' and 'Z' that
       // are magenta in color
       parts.DeleteWhere("(PART_NUMBER BETWEEN 1 AND 10) AND \
                           CONTAINER IN ('X', 'Y', 'Z') AND \
                           UPPER(COLOR) = 'MAGENTA'");

=head2 Wx::DbTable::DropIndex

   bool DropIndex(const wxString &IndexName)

   Allows an index on the associated table to be dropped (deleted) if the
   user login has sufficient privileges to do so.

   Parameters

   IndexName

       Name of the index to be dropped.

   Remarks

   If the index specified in the 'IndexName' parameter does not exist, an
   error will be logged, and the function will return a result of false.

   It is not necessary to call wxDb::CommitTrans after executing this
   function.

=head2 Wx::DbTable::DropTable

   bool DropTable()

   Deletes the associated table if the user has sufficient privileges to
   do so.

   Remarks

   This function returns true if the table does not exist, but only for
   supported databases (see wxDb::Dbms). If a datasource is not
   specifically supported, and this function is called, the function will
   return false.

   Most datasources/ODBC drivers will delete any indexes associated with
   the table automatically, and others may not. Check the documentation
   for your database to determine the behavior.

   It is not necessary to call wxDb::CommitTrans after executing this
   function.

=head2 Wx::DbTable::From

   const wxString & From()

   void From(const wxString &From)

   Accessor function for the private class member wxDbTable::from. Can be
   used as a synonym for wxDbTable::GetFromClause (the first form of this
   function) or wxDbTable::SetFromClause (the second form of this
   function).

   Parameters

   From

       A comma separated list of table names that are to be inner joined
       with the base table's columns so that the joined table's columns
       may be returned in the result set or used as a portion of a
       comparison with the base table's columns. NOTE that the base
       tables name must NOT be included in the FROM clause, as it is
       automatically included by the wxDbTable class in constructing
       query statements.

   Return value

   The first form of this function returns the current value of the
   wxDbTable member variable ::from.

   The second form of the function has no return value, as it will always
   set the from clause successfully.

   See also

   wxDbTable::GetFromClause, wxDbTable::SetFromClause

=head2 Wx::DbTable::GetColDefs

   wxDbColDef * GetColDefs()

   Accessor function that returns a pointer to the array of column
   definitions that are bound to the columns that this wxDbTable instance
   is associated with.

   To determine the number of elements pointed to by the returned
   wxDbColDef pointer, use the wxDbTable::GetNumberOfColumns function.

   Remarks

   These column definitions must not be manually redefined after they
   have been set.

=head2 Wx::DbTable::GetCursor

   HSTMT GetCursor()

   Returns the HSTMT value of the current cursor for this wxDbTable
   object.

   Remarks

   This function is typically used just before changing to use a
   different cursor so that after the program is finished using the other
   cursor, the current cursor can be set back to being the cursor in use.

   See also

   wxDbTable::SetCursor, wxDbTable::GetNewCursor

=head2 Wx::DbTable::GetDb

   wxDb * GetDb()

   Accessor function for the private member variable pDb which is a
   pointer to the datasource connection that this wxDbTable instance
   uses.

=head2 Wx::DbTable::GetFirst

   bool GetFirst()

   Retrieves the FIRST row in the record set as defined by the current
   query. Before retrieving records, a query must be performed using
   wxDbTable::Query, wxDbTable::QueryOnKeyFields,
   wxDbTable::QueryMatching or wxDbTable::QueryBySqlStmt.

   Remarks

   This function can only be used if the datasource connection used by
   the wxDbTable instance was created with FwdOnlyCursors set to false.
   If the connection does not allow backward scrolling cursors, this
   function will return false, and the data contained in the bound
   columns will be undefined.

   See also

   wxDb::IsFwdOnlyCursors

=head2 Wx::DbTable::GetFromClause

   const wxString & GetFromClause()

   Accessor function that returns the current FROM setting assigned with
   the wxDbTable::SetFromClause.

   See also

   wxDbTable::From

=head2 Wx::DbTable::GetLast

   bool GetLast()

   Retrieves the LAST row in the record set as defined by the current
   query. Before retrieving records, a query must be performed using
   wxDbTable::Query, wxDbTable::QueryOnKeyFields,
   wxDbTable::QueryMatching or wxDbTable::QueryBySqlStmt.

   Remarks

   This function can only be used if the datasource connection used by
   the wxDbTable instance was created with FwdOnlyCursors set to false.
   If the connection does not allow backward scrolling cursors, this
   function will return false, and the data contained in the bound
   columns will be undefined.

   See also

   wxDb::IsFwdOnlyCursors

=head2 Wx::DbTable::GetNewCursor

   HSTMT * GetNewCursor(bool setCursor=false, bool bindColumns=true)

   This function will create a new cursor that can be used to access the
   table being referenced by this wxDbTable instance, or to execute
   direct SQL commands on without affecting the cursors that are already
   defined and possibly positioned.

   Parameters

   setCursor

       OPTIONAL. Should this new cursor be set to be the current cursor
       after successfully creating the new cursor. Default is false.

=head2 Wx::DbTable::GetNext

   bool GetNext()

   Retrieves the NEXT row in the record set after the current cursor
   position as defined by the current query. Before retrieving records, a
   query must be performed using wxDbTable::Query,
   wxDbTable::QueryOnKeyFields, wxDbTable::QueryMatching or
   wxDbTable::QueryBySqlStmt.

   Return value

   This function returns false when the current cursor has reached the
   end of the result set. When false is returned, data in the bound
   columns is undefined.

   Remarks

   This function works with both forward and backward scrolling cursors.

   See also wxDbTable::++

=head2 Wx::DbTable::GetNumberOfColumns

   UWORD GetNumberOfColumns()

   Accessor function that returns the number of columns that are
   statically bound for access by the wxDbTable instance.

=head2 Wx::DbTable::GetOrderByClause

   const wxString & GetOrderByClause()

   Accessor function that returns the current ORDER BY setting assigned
   with the wxDbTable::SetOrderByClause.

   See also

   wxDbTable::OrderBy

=head2 Wx::DbTable::GetPrev

   bool GetPrev()

   Retrieves the PREVIOUS row in the record set before the current cursor
   position as defined by the current query. Before retrieving records, a
   query must be performed using wxDbTable::Query,
   wxDbTable::QueryOnKeyFields, wxDbTable::QueryMatching or
   wxDbTable::QueryBySqlStmt.

   Return value

   This function returns false when the current cursor has reached the
   beginning of the result set and there are now other rows prior to the
   cursors current position. When false is returned, data in the bound
   columns is undefined.

   Remarks

   This function can only be used if the datasource connection used by
   the wxDbTable instance was created with FwdOnlyCursors set to false.
   If the connection does not allow backward scrolling cursors, this
   function will return false, and the data contained in the bound
   columns will be undefined.

   See also

   wxDb::IsFwdOnlyCursors, wxDbTable::--

=head2 Wx::DbTable::GetQueryTableName

   const wxString & GetQueryTableName()

   Accessor function that returns the name of the table/view that was
   indicated as being the table/view to query against when this wxDbTable
   instance was created.

   See also

   wxDbTable constructor

=head2 Wx::DbTable::GetRowNum

   UWORD GetRowNum()

   Returns the ODBC row number for performing positioned updates and
   deletes.

   Remarks

   This function is not being used within the ODBC class library and may
   be a candidate for removal if no use is found for it.

   Row number with some datasources/ODBC drivers is the position in the
   result set, while in others it may be a physical position in the
   database. Check your database documentation to find out which behavior
   is supported.

=head2 Wx::DbTable::GetTableName

   const wxString & GetTableName()

   Accessor function that returns the name of the table that was
   indicated as being the table that this wxDbTable instance was
   associated with.

=head2 Wx::DbTable::GetTablePath

   const wxString & GetTablePath()

   Accessor function that returns the path to the data table that was
   indicated during creation of this wxDbTable instance.

   Remarks

   Currently only applicable to dBase and MS-Access datasources.

=head2 Wx::DbTable::GetWhereClause

   const wxString & GetWhereClause()

   Accessor function that returns the current WHERE setting assigned with
   the wxDbTable::SetWhereClause

   See also

   wxDbTable::Where

=head2 Wx::DbTable::Insert

   int Insert()

   Inserts a new record into the table being referenced by this wxDbTable
   instance. The values in the member variables of the wxDbTable instance
   are inserted into the columns of the new row in the database.

   Return value

       DB_SUCCESS              Record inserted successfully (value = 1)

=head2 Wx::DbTable::IsColNull

   bool IsColNull(UWORD colNumber) const

   Used primarily in the ODBC class library to determine if a column
   value is set to "NULL". Works for all data types supported by the ODBC
   class library.

   Parameters

   colNumber

       The column number of the bound column as defined by the
       wxDbTable::SetColDefs calls which defined the columns accessible
       to this wxDbTable instance.

   Remarks

   NULL column support is currently not fully implemented as of wxWidgets
   2.4.

=head2 Wx::DbTable::IsCursorClosedOnCommit

   bool IsCursorClosedOnCommit()

   Accessor function to return information collected during the opening
   of the datasource connection that is used by this wxDbTable instance.
   The result returned by this function indicates whether an implicit
   closing of the cursor is done after a commit on the database
   connection.

   Return value

   Returns true if the cursor associated with this wxDbTable object is
   closed after a commit or rollback operation. Returns false otherwise.

   Remarks

   If more than one wxDbTable instance used the same database connection,
   all cursors which use the database connection are closed on the commit
   if this function indicates true.

=head2 Wx::DbTable::IsQueryOnly

   bool IsQueryOnly()

   Accessor function that returns a value indicating if this wxDbTable
   instance was created to allow only queries to be performed on the
   bound columns. If this function returns true, then no actions may be
   performed using this wxDbTable instance that would modify
   (insert/delete/update) the table's data.

=head2 Wx::DbTable::Open

   bool Open(bool checkPrivileges=false, bool checkTableExists=true)

   Every wxDbTable instance must be opened before it can be used. This
   function checks for the existence of the requested table, binds
   columns, creates required cursors, (insert/select and update if
   connection is not wxDB_QUERY_ONLY) and constructs the insert statement
   that is to be used for inserting data as a new row in the datasource.

   NOTE: To retrieve data into an opened table, the of the table must be
   bound to the variables in the program via call(s) to
   wxDbTable::SetColDefs before calling Open().

   See the database classes overview for an introduction to using the
   ODBC classes.

   Parameters

   checkPrivileges

       Indicates whether the Open() function should check whether the
       current connected user has at least SELECT privileges to access
       the table to which they are trying to open. Default is false.

   checkTableExists

       Indicates whether the Open() function should check whether the
       table exists in the database or not before opening it. Default is
       true.

   Remarks

   If the function returns a false value due to the table not existing, a
   log entry is recorded for the datasource connection indicating the
   problem that was detected when checking for table existence. Note that
   it is usually best for the calling routine to check for the existence
   of the table and for sufficient user privileges to access the table in
   the mode (wxDB_QUERY_ONLY or !wxDB_QUERY_ONLY) before trying to open
   the table for the best possible explanation as to why a table cannot
   be opened.

   Checking the user's privileges on a table can be quite time consuming
   during the open phase. With most applications, the programmer already
   knows that the user has sufficient privileges to access the table, so
   this check is normally not required.

   For best performance, open the table, and then use the
   wxDb::TablePrivileges function to check the users privileges. Passing
   a schema to the TablePrivileges() function can significantly speed up
   the privileges checks.

   See also

   wxDb::TableExists, wxDb::TablePrivileges wxDbTable::SetColDefs

=head2 Wx::DbTable::OrderBy

   const wxString & OrderBy()

   void OrderBy(const wxString &OrderBy)

   Accessor function for the private class member wxDbTable::orderBy. Can
   be used as a synonym for wxDbTable::GetOrderByClause (the first form
   of this function) or wxDbTable::SetOrderByClause (the second form of
   this function).

   Parameters

   OrderBy

       A comma separated list of column names that indicate the
       alphabetized/numeric sorting sequence that the result set is to be
       returned in. If a FROM clause has also been specified, each column
       name specified in the ORDER BY clause should be prefaced with the
       table name to which the column belongs using DOT notation
       (TABLE_NAME.COLUMN_NAME).

   Return value

   The first form of this function returns the current value of the
   wxDbTable member variable ::orderBy.

   The second form of the function has no return value.

   See also

   wxDbTable::GetOrderByClause, wxDbTable::SetFromClause

=head2 Wx::DbTable::Query

   virtual bool Query(bool forUpdate=false, bool distinct=false)

   Parameters

   forUpdate

       OPTIONAL. Gives you the option of locking records as they are
       retrieved. If the RDBMS is not capable of the FOR UPDATE clause,
       this argument is ignored. See wxDbTable::CanSelectForUpdate for
       additional information regarding this argument. Default is false.

=head2 Wx::DbTable::QueryBySqlStmt

   bool QueryBySqlStmt(const wxString &pSqlStmt)

   Performs a query against the datasource by accepting and passing
   verbatim the SQL SELECT statement passed to the function.

   Parameters

   pSqlStmt

       Pointer to the SQL SELECT statement to be executed.

   Remarks

   This is the most powerful form of the query functions available. This
   member function allows a programmer to write their own custom SQL
   SELECT statement for requesting data from the datasource. This gives
   the programmer access to the full power of SQL for performing
   operations such as scalar functions, aggregate functions, table joins,
   and sub-queries, as well as datasource specific function calls.

   The requirements of the SELECT statement are the following:

=head2 Wx::DbTable::QueryMatching

   virtual bool QueryMatching(bool forUpdate=false, bool distinct=false)

   QueryMatching allows querying of records from the table associated
   with the wxDbTable object by matching "columns" to values.

   For example: To query the datasource for the row with a PART_NUMBER
   column value of "32", clear all column variables of the wxDbTable
   object, set the PartNumber variable that is bound to the PART_NUMBER
   column in the wxDbTable object to "32", and then call
   wxDbTable::QueryMatching().

   Parameters

   forUpdate

       OPTIONAL. Gives you the option of locking records as they are
       queried (SELECT ... FOR UPDATE). If the RDBMS is not capable of
       the FOR UPDATE clause, this argument is ignored. See
       wxDbTable::CanSelectForUpdate for additional information regarding
       this argument. Default is false.

=head2 Wx::DbTable::QueryOnKeyFields

   bool QueryOnKeyFields(bool forUpdate=false, bool distinct=false)

   QueryOnKeyFields provides an easy mechanism to query records in the
   table associated with the wxDbTable object by the primary index
   column(s). Simply assign the primary index column(s) values and then
   call this member function to retrieve the record.

   Note that since primary indexes are always unique, this function
   implicitly always returns a single record from the database. The base
   table name is prepended to the column names in the event that the
   wxDbTable's FROM clause is non-null.

   Parameters

   forUpdate

       OPTIONAL. Gives you the option of locking records as they are
       queried (SELECT ... FOR UPDATE). If the RDBMS is not capable of
       the FOR UPDATE clause, this argument is ignored. See
       wxDbTable::CanSelectForUpdate for additional information regarding
       this argument. Default is false.

=head2 Wx::DbTable::Refresh

   bool Refresh()

   This function re-reads the bound columns into the memory variables,
   setting them to the current values stored on the disk.

   The cursor position and result set are unaffected by calls to this
   function. (The one exception is in the case where the record to be
   refreshed has been deleted by some other user or transaction since it
   was originally retrieved as part of the result set. For most
   datasources, the default behavior in this situation is to return the
   value that was originally queried for the result set, even though it
   has been deleted from the database. But this is datasource dependent,
   and should be tested before relying on this behavior.)

   Remarks

   This routine is only guaranteed to work if the table has a unique
   primary index defined for it. Otherwise, more than one record may be
   fetched and there is no guarantee that the correct record will be
   refreshed. The table's columns are refreshed to reflect the current
   data in the database.

=head2 Wx::DbTable::SetColDefs

   bool SetColDefs(UWORD index, const wxString &fieldName, int dataType,
   void *pData, SWORD cType, int size, bool keyField = false, bool
   updateable = true, bool insertAllowed = true, bool derivedColumn =
   false)

   wxDbColDataPtr * SetColDefs(wxDbColInf *colInfs, UWORD numCols)

   Parameters

   index

       Column number (0 to n-1, where n is the number of columns
       specified as being defined for this wxDbTable instance when the
       wxDbTable constructor was called.

=head2 Wx::DbTable::SetCursor

   void SetCursor(HSTMT *hstmtActivate = (void **) wxDB_DEFAULT_CURSOR)

   Parameters

   hstmtActivate

       OPTIONAL. Pointer to the cursor that is to become the current
       cursor. Passing no cursor handle will reset the cursor back to the
       wxDbTable's default (original) cursor that was created when the
       wxDbTable instance was first created. Default is
       wxDB_DEFAULT_CURSOR.

   Remarks

   When swapping between cursors, the member variables of the wxDbTable
   object are automatically refreshed with the column values of the row
   that the current cursor is positioned at (if any). If the cursor is
   not positioned, then the data in member variables is undefined.

   The only way to return back to the cursor that was in use before this
   function was called is to programmatically determine the current
   cursor's HSTMT BEFORE calling this function using wxDbTable::GetCursor
   and saving a pointer to that cursor.

   See also

   wxDbTable::GetNewCursor, wxDbTable::GetCursor, wxDbTable::SetCursor

=head2 Wx::DbTable::SetFromClause

   void SetFromClause(const wxString &From)

   Accessor function for setting the private class member wxDbTable::from
   that indicates what other tables should be inner joined with the
   wxDbTable's base table for access to the columns in those other
   tables.

   Synonym to this function is one form of wxDbTable::From

   Parameters

   From

       A comma separated list of table names that are to be inner joined
       with the base table's columns so that the joined table's columns
       may be returned in the result set or used as a portion of a
       comparison with the base table's columns. NOTE that the base
       tables name must NOT be included in the FROM clause, as it is
       automatically included by the wxDbTable class in constructing
       query statements.

   Remarks

   Used by the wxDbTable::Query and wxDbTable::Count member functions to
   allow inner joining of records from multiple tables.

   Do not include the keyword "FROM" when setting the FROM clause.

   If using the FROM clause when performing a query, be certain to
   include in the corresponding WHERE clause a comparison of a column
   from either the base table or one of the other joined tables to each
   other joined table to ensure the datasource knows on which column
   values the tables should be joined on.

   Example

       ...
       // Base table is the "LOCATION" table, and it is being
       // inner joined to the "PART" table via the field "PART_NUMBER"
       // that can be related between the two tables.
       location->SetWhereClause("LOCATION.PART_NUMBER = PART.PART_NUMBER")
       location->SetFromClause("PART");
       ...

   See also

   wxDbTable::From, wxDbTable::GetFromClause

=head2 Wx::DbTable::SetColNull

   bool SetColNull(UWORD colNumber, bool set=true)

   bool SetColNull(const wxString &colName, bool set=true)

   Both forms of this function allow a member variable representing a
   column in the table associated with this wxDbTable object to be set to
   NULL.

   The first form allows the column to be set by the index into the
   column definitions used to create the wxDbTable instance, while the
   second allows the actual column name to be specified.

   Parameters

   colNumber

       Index into the column definitions used when first defining this
       wxDbTable object.

=head2 Wx::DbTable::SetOrderByClause

   void SetOrderByClause(const wxString &OrderBy)

   Accessor function for setting the private class member
   wxDbTable::orderBy which determines sequence/ordering of the rows
   returned in the result set of a query.

   A synonym to this function is one form of the function
   wxDbTable::OrderBy

   Parameters

   OrderBy

       A comma separated list of column names that indicate the
       alphabetized sorting sequence that the result set is to be
       returned in. If a FROM clause has also been specified, each column
       name specified in the ORDER BY clause should be prefaced with the
       table name to which the column belongs using DOT notation
       (TABLE_NAME.COLUMN_NAME).

   Remarks

   Do not include the keywords "ORDER BY" when setting the ORDER BY
   clause.

   Example

       ...
       parts->SetOrderByClause("PART_DESCRIP, QUANTITY");
       ...

=head2 Wx::DbTable::SetQueryTimeout

   bool SetQueryTimeout(UDWORD nSeconds)

   Allows a time period to be set as the timeout period for queries.

   Parameters

   nSeconds

       The number of seconds to wait for the query to complete before
       timing out.

   Remarks

   Neither Oracle or Access support this function as of yet. Other
   databases should be evaluated for support before depending on this
   function working correctly.

=head2 Wx::DbTable::SetWhereClause

   void SetWhereClause(const wxString &Where)

   Accessor function for setting the private class member
   wxDbTable::where that determines which rows are returned in the result
   set by the datasource.

   A synonym to this function is one form of the function
   wxDbTable::Where

   Parameters

   Where

       SQL "where" clause. This clause can contain any SQL language that
       is legal in standard where clauses. If a FROM clause has also been
       specified, each column name specified in the ORDER BY clause
       should be prefaced with the table name to which the column belongs
       using DOT notation (TABLE_NAME.COLUMN_NAME).

   Remarks

   Do not include the keywords "WHERE" when setting the WHERE clause.

   Example

       ...
       // Simple where clause
       parts->SetWhereClause("PART_NUMBER = '32'");
       ...
       // Any comparison operators
       parts->SetWhereClause("PART_DESCRIP LIKE 'HAMMER%'");
       ...
       // Multiple comparisons, including a function call
       parts->Where("QTY > 0 AND {fn UCASE(PART_DESCRIP)} LIKE '%DRILL%'");
       ...
       // Using parameters and multiple logical combinations
       parts->Where("((QTY > 10) OR (ON_ORDER > 0)) AND ON_HOLD = 0");
       ...
       // This query uses an inner join (requiring a FROM clause also)
       // that joins the PART and LOCATION table on he common field
       // PART_NUMBER.
       parts->Where("PART.ON_HOLD = 0 AND \
                     PART.PART_NUMBER = LOCATION.PART_NUMBER AND \
                     LOCATION.PART_NUMBER > 0");

   See also

   wxDbTable::Where, wxDbTable::GetWhereClause

=head2 Wx::DbTable::Update

   bool Update()

   bool Update(const wxString &pSqlStmt)

   The first form of this function will update the row that the current
   cursor is currently positioned at with the values in the memory
   variables that are bound to the columns. The actual SQL statement to
   perform the update is automatically created by the ODBC class, and
   then executed.

   The second form of the function allows full access through SQL
   statements for updating records in the database. Write any valid SQL
   UPDATE statement and submit it to this function for execution.
   Sophisticated updates can be performed using the full power of the SQL
   dialect. The full SQL statement must have the exact syntax required by
   the driver/datasource for performing the update. This usually is in
   the form of:

       UPDATE tablename SET col1=X, col2=Y, ... where ...

   Parameters

   pSqlStmt

       Pointer to SQL UPDATE statement to be executed.

   Remarks

   A wxDb::CommitTrans or wxDb::RollbackTrans must be called after use of
   this function to commit or rollback the update.

   Example

            wxString sqlStmt;
       sqlStmt = "update PART set QTY = 0 where PART_NUMBER = '32'";

=head2 Wx::DbTable::UpdateWhere

   bool UpdateWhere(const wxString &pWhereClause)

   Performs updates to the base table of the wxDbTable object, updating
   only the rows which match the criteria specified in the pWhereClause.

   All columns that are bound to member variables for this wxDbTable
   instance that were defined with the "updateable" parameter set to true
   will be updated with the information currently held in the memory
   variable.

   Parameters

   pWhereClause

       Pointer to a valid SQL WHERE clause. Do not include the keyword
       'WHERE'.

   Remarks

   Care should be used when updating columns that are part of indexes
   with this function so as not to violate an unique key constraints.

   A wxDb::CommitTrans or wxDb::RollbackTrans must be called after use of
   this function to commit or rollback the update(s).

=head2 Wx::DbTable::Where

   const wxString & Where()

   void Where(const wxString& Where)

   Accessor function for the private class member wxDbTable::where. Can
   be used as a synonym for wxDbTable::GetWhereClause (the first form of
   this function) to return the current where clause or
   wxDbTable::SetWhereClause (the second form of this function) to set
   the where clause for this table instance.

   Parameters

   Where

       A valid SQL WHERE clause. Do not include the keyword 'WHERE'.

   Return value

   The first form of this function returns the current value of the
   wxDbTable member variable ::where.

   The second form of the function has no return value, as it will always
   set the where clause successfully.

   See also

   wxDbTable::GetWhereClause, wxDbTable::SetWhereClause

=head1 Wx::DbTableInf

=head2 Wx::DbTableInf::Initialize

   Simply initializes all member variables to a cleared state. Called by
   the constructor automatically.

=head1 Wx::DbGridColInfo

=head2 Wx::DbGridColInfo::new

   wxDbGridColInfo(int colNumber, wxString type, wxString title,
   wxDbGridColInfo *next)

   Default constructor. See the database grid example in
   wxDbGridTableBase to see two different ways for adding columns.

=head2 Wx::DbGridColInfo::DESTROY

   ~wxDbGridColInfo()

   Destructor.

=head2 Wx::DbGridColInfo::AddColInfo

   void AddColInfo(int colNumber, wxString type, wxString title)

   Use this member function for adding columns. See the database grid
   example in wxDbGridTableBase to see two different ways for adding
   columns.

   It is important to note that this class is merely a specifier to the
   wxDbGridTableBase constructor. Changes made to this datatype after the
   wxDbGridTableBase is called will not have any effect.

   Parameters colNumber

       Column number in the wxDbTable instance to be used (first column
       is 0).

=head1 Wx::DbGridTableBase

=head2 Wx::DbGridTableBase::new

   wxDbGridTableBase(wxDbTable *tab, wxDbGridColInfo *ColInfo, int count
   = wxUSE_QUERY, bool takeOwnership = true)

   Constructor.

   Parameters

   tab 

       The database table you want to display. Must be opened and queried
       before display the grid. See the example above.

=head2 Wx::DbGridTableBase::ValidateRow

   void ValidateRow(int row)

   It ensures that the row data is fetched from the database, and it the
   wxDbTable local buffer, the row number passed should be the grid row.

   Parameters

   row 

       Row where validation must be done.

=head2 Wx::DbGridTableBase::UpdateRow

   bool UpdateRow(int row)

   If row has changed it forces that row to be written back to the
   database, however support for detecting whether insert/update is
   required is currently not in wxDbTable, so this function is currently
   unsupported.

   Parameters

   row 

       Row you want to update.

=head2 Wx::DbGridTableBase::AssignDbTable

   bool AssignDbTable(wxDbTable *tab,int count = wxUSE_QUERY, bool
   takeOwnership = true)

   Resets the grid for using with a new database table, but using the
   same columns definition. This can be useful when re-querying the
   database and want to see the changes.

   Parameters

   tab 

       Database table you want to assign to the grid.

=head1 Wx::DC

=head2 Wx::DC::Blit

   bool Blit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
   wxDC* source, wxCoord xsrc, wxCoord ysrc, int logicalFunc = wxCOPY,
   bool useMask = false, wxCoord xsrcMask = -1, wxCoord ysrcMask = -1)

   Copy from a source DC to this DC, specifying the destination
   coordinates, size of area to copy, source DC, source coordinates,
   logical function, whether to use a bitmap mask, and mask source
   position.

   Parameters

   xdest

       Destination device context x position.

   ydest

       Destination device context y position.

   width

       Width of source area to be copied.

   height

       Height of source area to be copied.

   source

       Source device context.

   xsrc

       Source device context x position.

   ysrc

       Source device context y position.

   logicalFunc

       Logical function to use: see wxDC::SetLogicalFunction.

   useMask

       If true, Blit does a transparent blit using the mask that is
       associated with the bitmap selected into the source device
       context. The Windows implementation does the following if MaskBlt
       cannot be used:

=head2 Wx::DC::CalcBoundingBox

   void CalcBoundingBox(wxCoord x, wxCoord y)

   Adds the specified point to the bounding box which can be retrieved
   with MinX, MaxX and MinY, MaxY functions.

   See also

   ResetBoundingBox

=head2 Wx::DC::Clear

   void Clear()

   Clears the device context using the current background brush.

=head2 Wx::DC::ComputeScaleAndOrigin

   virtual void ComputeScaleAndOrigin()

   Performs all necessary computations for given platform and context
   type after each change of scale and origin parameters. Usually called
   automatically internally after such changes.

=head2 Wx::DC::CrossHair

   void CrossHair(wxCoord x, wxCoord y)

   Displays a cross hair using the current pen. This is a vertical and
   horizontal line the height and width of the window, centred on the
   given point.

=head2 Wx::DC::DestroyClippingRegion

   void DestroyClippingRegion()

   Destroys the current clipping region so that none of the DC is
   clipped. See also wxDC::SetClippingRegion.

=head2 Wx::DC::DeviceToLogicalX

   wxCoord DeviceToLogicalX(wxCoord x)

   Convert device X coordinate to logical coordinate, using the current
   mapping mode.

=head2 Wx::DC::DeviceToLogicalXRel

   wxCoord DeviceToLogicalXRel(wxCoord x)

   Convert device X coordinate to relative logical coordinate, using the
   current mapping mode but ignoring the x axis orientation. Use this
   function for converting a width, for example.

=head2 Wx::DC::DeviceToLogicalY

   wxCoord DeviceToLogicalY(wxCoord y)

   Converts device Y coordinate to logical coordinate, using the current
   mapping mode.

=head2 Wx::DC::DeviceToLogicalYRel

   wxCoord DeviceToLogicalYRel(wxCoord y)

   Convert device Y coordinate to relative logical coordinate, using the
   current mapping mode but ignoring the y axis orientation. Use this
   function for converting a height, for example.

=head2 Wx::DC::DrawArc

   void DrawArc(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord
   xc, wxCoord yc)

   Draws an arc of a circle, centred on (xc, yc), with starting point (x1,
   y1) and ending at (x2, y2). The current pen is used for the outline
   and the current brush for filling the shape.

   The arc is drawn in an anticlockwise direction from the start point to
   the end point.

=head2 Wx::DC::DrawBitmap

   void DrawBitmap(const wxBitmap& bitmap, wxCoord x, wxCoord y, bool
   transparent)

   Draw a bitmap on the device context at the specified point. If
   transparent is true and the bitmap has a transparency mask, the bitmap
   will be drawn transparently.

   When drawing a mono-bitmap, the current text foreground colour will be
   used to draw the foreground of the bitmap (all bits set to 1), and the
   current text background colour to draw the background (all bits set to
   0). See also SetTextForeground, SetTextBackground and wxMemoryDC.

=head2 Wx::DC::DrawCheckMark

   void DrawCheckMark(wxCoord x, wxCoord y, wxCoord width, wxCoord height)

   void DrawCheckMark(const wxRect &rect)

   Draws a check mark inside the given rectangle.

=head2 Wx::DC::DrawCircle

   void DrawCircle(wxCoord x, wxCoord y, wxCoord radius)

   void DrawCircle(const wxPoint& pt, wxCoord radius)

   Draws a circle with the given centre and radius.

   See also

   DrawEllipse

=head2 Wx::DC::DrawEllipse

   void DrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)

   void DrawEllipse(const wxPoint& pt, const wxSize& size)

   void DrawEllipse(const wxRect& rect)

   Draws an ellipse contained in the rectangle specified either with the
   given top left corner and the given size or directly. The current pen
   is used for the outline and the current brush for filling the shape.

   See also

   DrawCircle

=head2 Wx::DC::DrawEllipticArc

   void DrawEllipticArc(wxCoord x, wxCoord y, wxCoord width, wxCoord
   height, double start, double end)

   Draws an arc of an ellipse. The current pen is used for drawing the
   arc and the current brush is used for drawing the pie.

   x and y specify the x and y coordinates of the upper-left corner of
   the rectangle that contains the ellipse.

   width and height specify the width and height of the rectangle that
   contains the ellipse.

   start and end specify the start and end of the arc relative to the
   three-o'clock position from the center of the rectangle. Angles are
   specified in degrees (360 is a complete circle). Positive values mean
   counter-clockwise motion. If start is equal to end, a complete ellipse
   will be drawn.

=head2 Wx::DC::DrawIcon

   void DrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)

   Draw an icon on the display (does nothing if the device context is
   PostScript). This can be the simplest way of drawing bitmaps on a
   window.

=head2 Wx::DC::DrawLabel

   virtual void DrawLabel(const wxString& text, const wxBitmap& image,
   const wxRect& rect, int alignment = wxALIGN_LEFT | wxALIGN_TOP, int
   indexAccel = -1, wxRect *rectBounding = NULL)

   void DrawLabel(const wxString& text, const wxRect& rect, int alignment
   = wxALIGN_LEFT | wxALIGN_TOP, int indexAccel = -1)

   Draw optional bitmap and the text into the given rectangle and aligns
   it as specified by alignment parameter; it also will emphasize the
   character with the given index if it is != -1 and return the bounding
   rectangle if required.

=head2 Wx::DC::DrawLine

   void DrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)

   Draws a line from the first point to the second. The current pen is
   used for drawing the line. Note that the point (x2, y2) is not part of
   the line and is not drawn by this function (this is consistent with
   the behaviour of many other toolkits).

=head2 Wx::DC::DrawLines

   void DrawLines(int n, wxPoint points[], wxCoord xoffset = 0, wxCoord
   yoffset = 0)

   void DrawLines(wxList *points, wxCoord xoffset = 0, wxCoord yoffset =
   0)

   Draws lines using an array of points of size n, or list of pointers to
   points, adding the optional offset coordinate. The current pen is used
   for drawing the lines. The programmer is responsible for deleting the
   list of points.

   wxPython note: The wxPython version of this method accepts a Python
   list of wxPoint objects.

   wxPerl note: The wxPerl version of this method accepts as its first
   parameter a reference to an array of wxPoint objects.

=head2 Wx::DC::DrawPolygon

   void DrawPolygon(int n, wxPoint points[], wxCoord xoffset = 0, wxCoord
   yoffset = 0,

=head2 Wx::DC::DrawPolyPolygon

   void DrawPolyPolygon(int n, int count[], wxPoint points[], wxCoord
   xoffset = 0, wxCoord yoffset = 0,

=head2 Wx::DC::DrawPoint

   void DrawPoint(wxCoord x, wxCoord y)

   Draws a point using the color of the current pen. Note that the other
   properties of the pen are not used, such as width etc..

=head2 Wx::DC::DrawRectangle

   void DrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)

   Draws a rectangle with the given top left corner, and with the given
   size. The current pen is used for the outline and the current brush
   for filling the shape.

=head2 Wx::DC::DrawRotatedText

   void DrawRotatedText(const wxString& text, wxCoord x, wxCoord y,
   double angle)

   Draws the text rotated by angle degrees.

   NB: Under Win9x only TrueType fonts can be drawn by this function. In
   particular, a font different from wxNORMAL_FONT should be used as the
   latter is not a TrueType font. wxSWISS_FONT is an example of a font
   which is.

   See also

   DrawText

=head2 Wx::DC::DrawRoundedRectangle

   void DrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord
   height, double radius)

   Draws a rectangle with the given top left corner, and with the given
   size. The corners are quarter-circles using the given radius. The
   current pen is used for the outline and the current brush for filling
   the shape.

   If radius is positive, the value is assumed to be the radius of the
   rounded corner. If radius is negative, the absolute value is assumed
   to be the proportion of the smallest dimension of the rectangle. This
   means that the corner can be a sensible size relative to the size of
   the rectangle, and also avoids the strange effects X produces when the
   corners are too big for the rectangle.

=head2 Wx::DC::DrawSpline

   void DrawSpline(int n, wxPoint points[])

   Draws a spline between all given control points, using the current
   pen.

   void DrawSpline(wxList *points)

   Draws a spline between all given control points, using the current
   pen. Doesn't delete the wxList and contents.

   void DrawSpline(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2,
   wxCoord x3, wxCoord y3)

   Draws a three-point spline using the current pen.

   wxPython note: The wxPython version of this method accepts a Python
   list of wxPoint objects.

   wxPerl note: The wxPerl version of this method accepts a reference to
   an array of wxPoint objects.

=head2 Wx::DC::DrawText

   void DrawText(const wxString& text, wxCoord x, wxCoord y)

   Draws a text string at the specified point, using the current text
   font, and the current text foreground and background colours.

   The coordinates refer to the top-left corner of the rectangle bounding
   the string. See wxDC::GetTextExtent for how to get the dimensions of a
   text string, which can be used to position the text more precisely.

   NB: under wxGTK the current logical function is used by this function
   but it is ignored by wxMSW. Thus, you should avoid using logical
   functions with this function in portable programs.

=head2 Wx::DC::EndDoc

   void EndDoc()

   Ends a document (only relevant when outputting to a printer).

=head2 Wx::DC::EndPage

   void EndPage()

   Ends a document page (only relevant when outputting to a printer).

=head2 Wx::DC::FloodFill

   bool FloodFill(wxCoord x, wxCoord y, const wxColour& colour, int
   style=wxFLOOD_SURFACE)

   Flood fills the device context starting from the given point, using
   the current brush colour, and using a style:

=head2 Wx::DC::GetBackground

   const wxBrush& GetBackground() const

   Gets the brush used for painting the background (see
   wxDC::SetBackground).

=head2 Wx::DC::GetBackgroundMode

   int GetBackgroundMode() const

   Returns the current background mode: wxSOLID or wxTRANSPARENT.

   See also

   SetBackgroundMode

=head2 Wx::DC::GetBrush

   const wxBrush& GetBrush() const

   Gets the current brush (see wxDC::SetBrush).

=head2 Wx::DC::GetCharHeight

   wxCoord GetCharHeight()

   Gets the character height of the currently set font.

=head2 Wx::DC::GetCharWidth

   wxCoord GetCharWidth()

   Gets the average character width of the currently set font.

=head2 Wx::DC::GetClippingBox

   void GetClippingBox(wxCoord *x, wxCoord *y, wxCoord *width, wxCoord
   *height)

   Gets the rectangle surrounding the current clipping region.

   wxPython note: No arguments are required and the four values defining
   the rectangle are returned as a tuple.

   wxPerl note: This method takes no arguments and returns a four element
   list ( x, y, width, height )

=head2 Wx::DC::GetFont

   const wxFont& GetFont() const

   Gets the current font. Notice that even although each device context
   object has some default font after creation, this method would return
   a wxNullFont initially and only after calling wxDC::SetFont a valid
   font is returned.

=head2 Wx::DC::GetLayoutDirection

   wxLayoutDirection GetLayoutDirection() const

   Gets the current layout direction of the device context. On platforms
   where RTL layout is supported, the return value will either be
   wxLayout_LeftToRight or wxLayout_RightToLeft. If RTL layout is not
   supported, the return value will be wxLayout_Default.

   See also

   SetLayoutDirection

=head2 Wx::DC::GetLogicalFunction

   int GetLogicalFunction()

   Gets the current logical function (see wxDC::SetLogicalFunction).

=head2 Wx::DC::GetMapMode

   int GetMapMode()

   Gets the mapping mode for the device context (see wxDC::SetMapMode).

=head2 Wx::DC::GetMultiLineTextExtent

   void GetMultiLineTextExtent(const wxString& string, wxCoord *w,

=head2 Wx::DC::GetPartialTextExtents

   bool GetPartialTextExtents(const wxString& text, wxArrayInt& widths)
   const

   Fills the widths array with the widths from the beginning of text to
   the corresponding character of text. The generic version simply builds
   a running total of the widths of each character using GetTextExtent,
   however if the various platforms have a native API function that is
   faster or more accurate than the generic implementation then it should
   be used instead.

   See also

   wxDC::GetMultiLineTextExtent, wxDC::GetTextExtent

   wxPython note: This method only takes the text parameter and returns a
   Python list of integers.

=head2 Wx::DC::GetPen

   const wxPen& GetPen() const

   Gets the current pen (see wxDC::SetPen).

=head2 Wx::DC::GetPixel

   bool GetPixel(wxCoord x, wxCoord y, wxColour *colour)

   Gets in colour the colour at the specified location. Not available for
   wxPostScriptDC or wxMetafileDC.

   Note that setting a pixel can be done using DrawPoint.

   wxPython note: For wxPython the wxColour value is returned and is not
   required as a parameter.

   wxPerl note: This method only takes the parameters x and y and returns
   a Wx::Colour value

=head2 Wx::DC::GetPPI

   wxSize GetPPI() const

   Returns the resolution of the device in pixels per inch.

=head2 Wx::DC::GetSize

   void GetSize(wxCoord *width, wxCoord *height) const

   wxSize GetSize() const

   This gets the horizontal and vertical resolution in device units. It
   can be used to scale graphics to fit the page. For example, if maxX
   and maxY represent the maximum horizontal and vertical 'pixel' values
   used in your application, the following code will scale the graphic to
   fit on the printer page:

     wxCoord w, h;
     dc.GetSize(&w, &h);
     double scaleX=(double)(maxX/w);
     double scaleY=(double)(maxY/h);
     dc.SetUserScale(min(scaleX,scaleY),min(scaleX,scaleY));

   wxPython note: In place of a single overloaded method name, wxPython
   implements the following methods:

=head2 Wx::DC::GetSizeMM

   void GetSizeMM(wxCoord *width, wxCoord *height) const

   wxSize GetSizeMM() const

   Returns the horizontal and vertical resolution in millimetres.

=head2 Wx::DC::GetTextBackground

   const wxColour& GetTextBackground() const

   Gets the current text background colour (see wxDC::SetTextBackground).

=head2 Wx::DC::GetTextExtent

   void GetTextExtent(const wxString& string, wxCoord *w, wxCoord *h,

=head2 Wx::DC::GetTextForeground

   const wxColour& GetTextForeground() const

   Gets the current text foreground colour (see wxDC::SetTextForeground).

=head2 Wx::DC::GetUserScale

   void GetUserScale(double *x, double *y)

   Gets the current user scale factor (set by SetUserScale).

   wxPerl note: In wxPerl this method takes no arguments and return a two
   element array ( x, y )

=head2 Wx::DC::GradientFillConcentric

   void GradientFillConcentric(const wxRect& rect, const wxColour&
   initialColour, const wxColour& destColour)

   void GradientFillConcentric(const wxRect& rect, const wxColour&
   initialColour, const wxColour& destColour, const wxPoint& circleCenter)

   Fill the area specified by rect with a radial gradient, starting from
   initialColour at the centre of the circle and fading to destColour on
   the circle outside.

   circleCenter are the relative coordinates of centre of the circle in
   the specified rect. If not specified, the cercle is placed at the
   centre of rect.

   Note: Currently this function is very slow, don't use it for real-time
   drawing.

=head2 Wx::DC::GradientFillLinear

   void GradientFillLinear(const wxRect& rect, const wxColour&
   initialColour, const wxColour& destColour, wxDirection nDirection =
   wxEAST)

   Fill the area specified by rect with a linear gradient, starting from
   initialColour and eventually fading to destColour. The nDirection
   specifies the direction of the colour change, default is to use
   initialColour on the left part of the rectangle and destColour on the
   right one.

=head2 Wx::DC::LogicalToDeviceX

   wxCoord LogicalToDeviceX(wxCoord x)

   Converts logical X coordinate to device coordinate, using the current
   mapping mode.

=head2 Wx::DC::LogicalToDeviceXRel

   wxCoord LogicalToDeviceXRel(wxCoord x)

   Converts logical X coordinate to relative device coordinate, using the
   current mapping mode but ignoring the x axis orientation. Use this for
   converting a width, for example.

=head2 Wx::DC::LogicalToDeviceY

   wxCoord LogicalToDeviceY(wxCoord y)

   Converts logical Y coordinate to device coordinate, using the current
   mapping mode.

=head2 Wx::DC::LogicalToDeviceYRel

   wxCoord LogicalToDeviceYRel(wxCoord y)

   Converts logical Y coordinate to relative device coordinate, using the
   current mapping mode but ignoring the y axis orientation. Use this for
   converting a height, for example.

=head2 Wx::DC::MaxX

   wxCoord MaxX()

   Gets the maximum horizontal extent used in drawing commands so far.

=head2 Wx::DC::MaxY

   wxCoord MaxY()

   Gets the maximum vertical extent used in drawing commands so far.

=head2 Wx::DC::MinX

   wxCoord MinX()

   Gets the minimum horizontal extent used in drawing commands so far.

=head2 Wx::DC::MinY

   wxCoord MinY()

   Gets the minimum vertical extent used in drawing commands so far.

=head2 Wx::DC::IsOk

   bool Ok()

   Returns true if the DC is ok to use.

=head2 Wx::DC::ResetBoundingBox

   void ResetBoundingBox()

   Resets the bounding box: after a call to this function, the bounding
   box doesn't contain anything.

   See also

   CalcBoundingBox

=head2 Wx::DC::SetAxisOrientation

   void SetAxisOrientation(bool xLeftRight, bool yBottomUp)

   Sets the x and y axis orientation (i.e., the direction from lowest to
   highest values on the axis). The default orientation is x axis from
   left to right and y axis from top down.

   Parameters

   xLeftRight

       True to set the x axis orientation to the natural left to right
       orientation, false to invert it.

   yBottomUp

       True to set the y axis orientation to the natural bottom up
       orientation, false to invert it.

=head2 Wx::DC::SetBackground

   void SetBackground(const wxBrush& brush)

   Sets the current background brush for the DC.

=head2 Wx::DC::SetBackgroundMode

   void SetBackgroundMode(int mode)

   mode may be one of wxSOLID and wxTRANSPARENT. This setting determines
   whether text will be drawn with a background colour or not.

=head2 Wx::DC::SetBrush

   void SetBrush(const wxBrush& brush)

   Sets the current brush for the DC.

   If the argument is wxNullBrush, the current brush is selected out of
   the device context, and the original brush restored, allowing the
   current brush to be destroyed safely.

   See also wxBrush.

   See also wxMemoryDC for the interpretation of colours when drawing
   into a monochrome bitmap.

=head2 Wx::DC::SetClippingRegion

   void SetClippingRegion(wxCoord x, wxCoord y, wxCoord width, wxCoord
   height)

   void SetClippingRegion(const wxPoint& pt, const wxSize& sz)

   void SetClippingRegion(const wxRect& rect)

   void SetClippingRegion(const wxRegion& region)

   Sets the clipping region for this device context to the intersection
   of the given region described by the parameters of this method and the
   previously set clipping region. You should call DestroyClippingRegion
   if you want to set the clipping region exactly to the region
   specified.

   The clipping region is an area to which drawing is restricted.
   Possible uses for the clipping region are for clipping text or for
   speeding up window redraws when only a known area of the screen is
   damaged.

   See also

   wxDC::DestroyClippingRegion, wxRegion

=head2 Wx::DC::SetDeviceOrigin

   void SetDeviceOrigin(wxCoord x, wxCoord y)

   Sets the device origin (i.e., the origin in pixels after scaling has
   been applied).

   This function may be useful in Windows printing operations for placing
   a graphic on a page.

=head2 Wx::DC::SetFont

   void SetFont(const wxFont& font)

   Sets the current font for the DC. It must be a valid font, in
   particular you should not pass wxNullFont to this method.

   See also wxFont.

=head2 Wx::DC::SetLayoutDirection

   void SetLayoutDirection(wxLayoutDirection dir)

   Sets the current layout direction for the device context. dir may be
   either wxLayout_Default, wxLayout_LeftToRight or wxLayout_RightToLeft.

   See also

   GetLayoutDirection

=head2 Wx::DC::SetLogicalFunction

   void SetLogicalFunction(int function)

   Sets the current logical function for the device context. This
   determines how a source pixel (from a pen or brush colour, or source
   device context if using wxDC::Blit) combines with a destination pixel
   in the current device context.

   The possible values and their meaning in terms of source and
   destination pixel values are as follows:

   wxAND                 src AND dst
   wxAND_INVERT          (NOT src) AND dst
   wxAND_REVERSE         src AND (NOT dst)
   wxCLEAR               0
   wxCOPY                src
   wxEQUIV               (NOT src) XOR dst
   wxINVERT              NOT dst
   wxNAND                (NOT src) OR (NOT dst)
   wxNOR                 (NOT src) AND (NOT dst)
   wxNO_OP               dst
   wxOR                  src OR dst
   wxOR_INVERT           (NOT src) OR dst
   wxOR_REVERSE          src OR (NOT dst)
   wxSET                 1
   wxSRC_INVERT          NOT src
   wxXOR                 src XOR dst

   The default is wxCOPY, which simply draws with the current colour. The
   others combine the current colour and the background using a logical
   operation. wxINVERT is commonly used for drawing rubber bands or
   moving outlines, since drawing twice reverts to the original colour.

=head2 Wx::DC::SetMapMode

   void SetMapMode(int int)

   The mapping mode of the device context defines the unit of measurement
   used to convert logical units to device units. Note that in X, text
   drawing isn't handled consistently with the mapping mode; a font is
   always specified in point size. However, setting the user scale (see
   wxDC::SetUserScale) scales the text appropriately. In Windows,
   scalable TrueType fonts are always used; in X, results depend on
   availability of fonts, but usually a reasonable match is found.

   The coordinate origin is always at the top left of the screen/printer.

   Drawing to a Windows printer device context uses the current mapping
   mode, but mapping mode is currently ignored for PostScript output.

   The mapping mode can be one of the following:

=head2 Wx::DC::SetPalette

   void SetPalette(const wxPalette& palette)

   If this is a window DC or memory DC, assigns the given palette to the
   window or bitmap associated with the DC. If the argument is
   wxNullPalette, the current palette is selected out of the device
   context, and the original palette restored.

   See wxPalette for further details.

=head2 Wx::DC::SetPen

   void SetPen(const wxPen& pen)

   Sets the current pen for the DC.

   If the argument is wxNullPen, the current pen is selected out of the
   device context, and the original pen restored.

   See also wxMemoryDC for the interpretation of colours when drawing
   into a monochrome bitmap.

=head2 Wx::DC::SetTextBackground

   void SetTextBackground(const wxColour& colour)

   Sets the current text background colour for the DC.

=head2 Wx::DC::SetTextForeground

   void SetTextForeground(const wxColour& colour)

   Sets the current text foreground colour for the DC.

   See also wxMemoryDC for the interpretation of colours when drawing
   into a monochrome bitmap.

=head2 Wx::DC::SetUserScale

   void SetUserScale(double xScale, double yScale)

   Sets the user scaling factor, useful for applications which require
   'zooming'.

=head2 Wx::DC::StartDoc

   bool StartDoc(const wxString& message)

   Starts a document (only relevant when outputting to a printer).
   Message is a message to show while printing.

=head2 Wx::DC::StartPage

   bool StartPage()

   Starts a document page (only relevant when outputting to a printer).

=head1 Wx::DCClipper

=head2 Wx::DCClipper::new

   wxDCClipper(wxDC& dc, const wxRegion& r)

   wxDCClipper(wxDC& dc, const wxRect& rect)

   wxDCClipper(wxDC& dc, int x, int y, int w, int h)

   Sets the clipping region to the specified region r or rectangle
   specified by either a single rect parameter or its position (x and y)
   and size (w ad h).

   The clipping region is automatically unset when this object is
   destroyed.

=head1 Wx::DDEClient

=head2 Wx::DDEClient::new

   wxDDEClient()

   Constructs a client object.

=head2 Wx::DDEClient::MakeConnection

   wxConnectionBase * MakeConnection(const wxString& host, const wxString&
   service, const wxString& topic)

   Tries to make a connection with a server specified by the host
   (machine name under UNIX, ignored under Windows), service name (must
   contain an integer port number under UNIX), and topic string. If the
   server allows a connection, a wxDDEConnection object will be returned.
   The type of wxDDEConnection returned can be altered by overriding the
   wxDDEClient::OnMakeConnection member to return your own derived
   connection object.

=head2 Wx::DDEClient::OnMakeConnection

   wxConnectionBase * OnMakeConnection()

   The type of wxDDEConnection returned from a
   wxDDEClient::MakeConnection call can be altered by deriving the
   OnMakeConnection member to return your own derived connection object.
   By default, a wxDDEConnection object is returned.

   The advantage of deriving your own connection class is that it will
   enable you to intercept messages initiated by the server, such as
   wxDDEConnection::OnAdvise. You may also want to store
   application-specific data in instances of the new class.

=head2 Wx::DDEClient::ValidHost

   bool ValidHost(const wxString& host)

   Returns true if this is a valid host name, false otherwise. This
   always returns true under MS Windows.

=head1 Wx::DDEConnection

=head2 Wx::DDEConnection::new

   wxDDEConnection()

   wxDDEConnection(char* buffer, int size)

   Constructs a connection object. If no user-defined connection object
   is to be derived from wxDDEConnection, then the constructor should not
   be called directly, since the default connection object will be
   provided on requesting (or accepting) a connection. However, if the
   user defines his or her own derived connection object, the
   wxDDEServer::OnAcceptConnection and/or wxDDEClient::OnMakeConnection
   members should be replaced by functions which construct the new
   connection object. If the arguments of the wxDDEConnection constructor
   are void, then a default buffer is associated with the connection.
   Otherwise, the programmer must provide a a buffer and size of the
   buffer for the connection object to use in transactions.

=head2 Wx::DDEConnection::Advise

   bool Advise(const wxString& item, char* data, int size = -1,
   wxIPCFormat format = wxCF_TEXT)

   Called by the server application to advise the client of a change in
   the data associated with the given item. Causes the client
   connection's wxDDEConnection::OnAdvise member to be called. Returns
   true if successful.

=head2 Wx::DDEConnection::Execute

   bool Execute(char* data, int size = -1, wxIPCFormat format = wxCF_TEXT)

   Called by the client application to execute a command on the server.
   Can also be used to transfer arbitrary data to the server (similar to
   wxDDEConnection::Poke in that respect). Causes the server connection's
   wxDDEConnection::OnExecute member to be called. Returns true if
   successful.

=head2 Wx::DDEConnection::Disconnect

   bool Disconnect()

   Called by the client or server application to disconnect from the
   other program; it causes the wxDDEConnection::OnDisconnect message to
   be sent to the corresponding connection object in the other program.
   The default behaviour of OnDisconnect is to delete the connection, but
   the calling application must explicitly delete its side of the
   connection having called Disconnect. Returns true if successful.

=head2 Wx::DDEConnection::OnAdvise

   virtual bool OnAdvise(const wxString& topic, const wxString& item,
   char* data, int size, wxIPCFormat format)

   Message sent to the client application when the server notifies it of
   a change in the data associated with the given item.

=head2 Wx::DDEConnection::OnDisconnect

   virtual bool OnDisconnect()

   Message sent to the client or server application when the other
   application notifies it to delete the connection. Default behaviour is
   to delete the connection object.

=head2 Wx::DDEConnection::OnExecute

   virtual bool OnExecute(const wxString& topic, char* data, int size,
   wxIPCFormat format)

   Message sent to the server application when the client notifies it to
   execute the given data. Note that there is no item associated with
   this message.

=head2 Wx::DDEConnection::OnPoke

   virtual bool OnPoke(const wxString& topic, const wxString& item, char*
   data, int size, wxIPCFormat format)

   Message sent to the server application when the client notifies it to
   accept the given data.

=head2 Wx::DDEConnection::OnRequest

   virtual char* OnRequest(const wxString& topic, const wxString& item,
   int *size, wxIPCFormat format)

   Message sent to the server application when the client calls
   wxDDEConnection::Request. The server should respond by returning a
   character string from OnRequest, or NULL to indicate no data.

=head2 Wx::DDEConnection::OnStartAdvise

   virtual bool OnStartAdvise(const wxString& topic, const wxString& item)

   Message sent to the server application by the client, when the client
   wishes to start an 'advise loop' for the given topic and item. The
   server can refuse to participate by returning false.

=head2 Wx::DDEConnection::OnStopAdvise

   virtual bool OnStopAdvise(const wxString& topic, const wxString& item)

   Message sent to the server application by the client, when the client
   wishes to stop an 'advise loop' for the given topic and item. The
   server can refuse to stop the advise loop by returning false, although
   this doesn't have much meaning in practice.

=head2 Wx::DDEConnection::Poke

   bool Poke(const wxString& item, char* data, int size = -1, wxIPCFormat
   format = wxCF_TEXT)

   Called by the client application to poke data into the server. Can be
   used to transfer arbitrary data to the server. Causes the server
   connection's wxDDEConnection::OnPoke member to be called. Returns true
   if successful.

=head2 Wx::DDEConnection::Request

   char* Request(const wxString& item, int *size, wxIPCFormat format =
   wxIPC_TEXT)

   Called by the client application to request data from the server.
   Causes the server connection's wxDDEConnection::OnRequest member to be
   called. Returns a character string (actually a pointer to the
   connection's buffer) if successful, NULL otherwise.

=head2 Wx::DDEConnection::StartAdvise

   bool StartAdvise(const wxString& item)

   Called by the client application to ask if an advise loop can be
   started with the server. Causes the server connection's
   wxDDEConnection::OnStartAdvise member to be called. Returns true if
   the server okays it, false otherwise.

=head2 Wx::DDEConnection::StopAdvise

   bool StopAdvise(const wxString& item)

   Called by the client application to ask if an advise loop can be
   stopped. Causes the server connection's wxDDEConnection::OnStopAdvise
   member to be called. Returns true if the server okays it, false
   otherwise.

=head1 Wx::DDEServer

=head2 Wx::DDEServer::new

   wxDDEServer()

   Constructs a server object.

=head2 Wx::DDEServer::Create

   bool Create(const wxString& service)

   Registers the server using the given service name. Under UNIX, the
   string must contain an integer id which is used as an Internet port
   number. false is returned if the call failed (for example, the port
   number is already in use).

=head2 Wx::DDEServer::OnAcceptConnection

   virtual wxConnectionBase * OnAcceptConnection(const wxString& topic)

   When a client calls MakeConnection, the server receives the message
   and this member is called. The application should derive a member to
   intercept this message and return a connection object of either the
   standard wxDDEConnection type, or of a user-derived type. If the topic
   is "STDIO'', the application may wish to refuse the connection. Under
   UNIX, when a server is created the OnAcceptConnection message is
   always sent for standard input and output, but in the context of DDE
   messages it doesn't make a lot of sense.

=head1 Wx::DebugContext

=head2 Wx::DebugContext::Check

   int Check()

   Checks the memory blocks for errors, starting from the currently set
   checkpoint.

   Return value

   Returns the number of errors, so a value of zero represents success.
   Returns -1 if an error was detected that prevents further checking.

=head2 Wx::DebugContext::Dump

   bool Dump()

   Performs a memory dump from the currently set checkpoint, writing to
   the current debug stream. Calls the Dump member function for each
   wxObject derived instance.

   Return value

   true if the function succeeded, false otherwise.

=head2 Wx::DebugContext::GetCheckPrevious

   bool GetCheckPrevious()

   Returns true if the memory allocator checks all previous memory blocks
   for errors. By default, this is false since it slows down execution
   considerably.

   See also

   wxDebugContext::SetCheckPrevious

=head2 Wx::DebugContext::GetDebugMode

   bool GetDebugMode()

   Returns true if debug mode is on. If debug mode is on, the wxObject
   new and delete operators store or use information about memory
   allocation. Otherwise, a straight malloc and free will be performed by
   these operators.

   See also

   wxDebugContext::SetDebugMode

=head2 Wx::DebugContext::GetLevel

   int GetLevel()

   Gets the debug level (default 1). The debug level is used by the
   wxTraceLevel function and the WXTRACELEVEL macro to specify how
   detailed the trace information is; setting a different level will only
   have an effect if trace statements in the application specify a value
   other than one.

   This is obsolete, replaced by wxLog functionality.

   See also

   wxDebugContext::SetLevel

=head2 Wx::DebugContext::GetStream

   ostream& GetStream()

   Returns the output stream associated with the debug context.

   This is obsolete, replaced by wxLog functionality.

   See also

   wxDebugContext::SetStream

=head2 Wx::DebugContext::GetStreamBuf

   streambuf* GetStreamBuf()

   Returns a pointer to the output stream buffer associated with the
   debug context. There may not necessarily be a stream buffer if the
   stream has been set by the user.

   This is obsolete, replaced by wxLog functionality.

=head2 Wx::DebugContext::HasStream

   bool HasStream()

   Returns true if there is a stream currently associated with the debug
   context.

   This is obsolete, replaced by wxLog functionality.

   See also

   wxDebugContext::SetStream, wxDebugContext::GetStream

=head2 Wx::DebugContext::PrintClasses

   bool PrintClasses()

   Prints a list of the classes declared in this application, giving
   derivation and whether instances of this class can be dynamically
   created.

   See also

   wxDebugContext::PrintStatistics

=head2 Wx::DebugContext::PrintStatistics

   bool PrintStatistics(bool detailed = true)

   Performs a statistics analysis from the currently set checkpoint,
   writing to the current debug stream. The number of object and
   non-object allocations is printed, together with the total size.

   Parameters

   detailed

       If true, the function will also print how many objects of each
       class have been allocated, and the space taken by these class
       instances.

   See also

   wxDebugContext::PrintStatistics

=head2 Wx::DebugContext::SetCheckpoint

   void SetCheckpoint(bool all = false)

   Sets the current checkpoint: Dump and PrintStatistics operations will
   be performed from this point on. This allows you to ignore allocations
   that have been performed up to this point.

   Parameters

   all 

       If true, the checkpoint is reset to include all memory allocations
       since the program started.

=head2 Wx::DebugContext::SetCheckPrevious

   void SetCheckPrevious(bool check)

   Tells the memory allocator to check all previous memory blocks for
   errors. By default, this is false since it slows down execution
   considerably.

   See also

   wxDebugContext::GetCheckPrevious

=head2 Wx::DebugContext::SetDebugMode

   void SetDebugMode(bool debug)

   Sets the debug mode on or off. If debug mode is on, the wxObject new
   and delete operators store or use information about memory allocation.
   Otherwise, a straight malloc and free will be performed by these
   operators.

   By default, debug mode is on if __WXDEBUG__ is defined. If the
   application uses this function, it should make sure that all object
   memory allocated is deallocated with the same value of debug mode.
   Otherwise, the delete operator might try to look for memory
   information that does not exist.

   See also

   wxDebugContext::GetDebugMode

=head2 Wx::DebugContext::SetFile

   bool SetFile(const wxString& filename)

   Sets the current debug file and creates a stream. This will delete any
   existing stream and stream buffer. By default, the debug context
   stream outputs to the debugger (Windows) or standard error (other
   platforms).

=head2 Wx::DebugContext::SetLevel

   void SetLevel(int level)

   Sets the debug level (default 1). The debug level is used by the
   wxTraceLevel function and the WXTRACELEVEL macro to specify how
   detailed the trace information is; setting a different level will only
   have an effect if trace statements in the application specify a value
   other than one.

   This is obsolete, replaced by wxLog functionality.

   See also

   wxDebugContext::GetLevel

=head2 Wx::DebugContext::SetStandardError

   bool SetStandardError()

   Sets the debugging stream to be the debugger (Windows) or standard
   error (other platforms). This is the default setting. The existing
   stream will be flushed and deleted.

   This is obsolete, replaced by wxLog functionality.

=head2 Wx::DebugContext::SetStream

   void SetStream(ostream* stream, streambuf* streamBuf = NULL)

   Sets the stream and optionally, stream buffer associated with the
   debug context. This operation flushes and deletes the existing stream
   (and stream buffer if any).

   This is obsolete, replaced by wxLog functionality.

   Parameters

   stream

       Stream to associate with the debug context. Do not set this to
       NULL.

   streamBuf

       Stream buffer to associate with the debug context.

   See also

   wxDebugContext::GetStream, wxDebugContext::HasStream

=head1 Wx::DebugReport

=head2 Wx::DebugReport::new

   wxDebugReport()

   The constructor creates a temporary directory where the files that
   will be included in the report are created. Use IsOk() to check for
   errors.

=head2 Wx::DebugReport::DESTROY

   ~wxDebugReport()

   The destructor normally destroys the temporary directory created in
   the constructor with all the files it contains. Call Reset() to
   prevent this from happening.

=head2 Wx::DebugReport::AddAll

   void AddAll(Context context = Context_Exception)

   Adds all available information to the report. Currently this includes
   a text (XML) file describing the process context and, under Win32, a
   minidump file.

=head2 Wx::DebugReport::AddContext

   bool AddContext(Context ctx)

   Add an XML file containing the current or exception context and the
   stack trace.

=head2 Wx::DebugReport::AddCurrentContext

   bool AddCurrentContext()

   The same as AddContext(Context_Current).

=head2 Wx::DebugReport::AddCurrentDump

   bool AddCurrentDump()

   The same as AddDump(Context_Current).

=head2 Wx::DebugReport::AddDump

   bool AddDump(Context ctx)

   Adds the minidump file to the debug report.

   Minidumps are only available under recent Win32 versions (dbghlp32.dll
   can be installed under older systems to make minidumps available).

=head2 Wx::DebugReport::AddExceptionContext

   bool AddExceptionContext()

   The same as AddContext(Context_Exception).

=head2 Wx::DebugReport::AddExceptionDump

   bool AddExceptionDump()

   The same as AddDump(Context_Exception).

=head2 Wx::DebugReport::AddFile

   void AddFile(const wxString& filename, const wxString& description)

   Add another file to the report. If filename is an absolute path, it is
   copied to a file in the debug report directory with the same name.
   Otherwise the file should already exist in this directory

   description only exists to be displayed to the user in the report
   summary shown by wxDebugReportPreview.

   See also

   GetDirectory(),

=head2 Wx::DebugReport::AddText

   bool AddText(const wxString& filename, const wxString& text, const
   wxString& description)

   This is a convenient wrapper around AddFile. It creates the file with
   the given name and writes text to it, then adds the file to the
   report. The filename shouldn't contain the path.

   Returns true if file could be added successfully, false if an IO error
   occurred.

=head2 Wx::DebugReport::DoAddCustomContext

   void DoAddCustomContext(wxXmlNode * nodeRoot)

   This function may be overridden to add arbitrary custom context to the
   XML context file created by AddContext. By default, it does nothing.

=head2 Wx::DebugReport::DoAddExceptionInfo

   bool DoAddExceptionInfo(wxXmlNode* nodeContext)

   This function may be overridden to modify the contents of the
   exception tag in the XML context file.

=head2 Wx::DebugReport::DoAddLoadedModules

   bool DoAddLoadedModules(wxXmlNode* nodeModules)

   This function may be overridden to modify the contents of the modules
   tag in the XML context file.

=head2 Wx::DebugReport::DoAddSystemInfo

   bool DoAddSystemInfo(wxXmlNode* nodeSystemInfo)

   This function may be overridden to modify the contents of the system
   tag in the XML context file.

=head2 Wx::DebugReport::GetDirectory

   const wxString& GetDirectory() const

   Returns the name of the temporary directory used for the files in this
   report.

   This method should be used to construct the full name of the files
   which you wish to add to the report using AddFile.

=head2 Wx::DebugReport::GetFile

   bool GetFile(size_t n, wxString* name, wxString* desc) const

   Retrieves the name (relative to GetDirectory()) and the description of
   the file with the given index. If n is greater than or equal to the
   number of filse, false is returned.

=head2 Wx::DebugReport::GetFilesCount

   size_t GetFilesCount() const

   Gets the current number files in this report.

=head2 Wx::DebugReport::GetReportName

   wxString GetReportName() const

   Gets the name used as a base name for various files, by default
   wxApp::GetAppName() is used.

=head2 Wx::DebugReport::IsOk

   bool IsOk() const

   Returns true if the object was successfully initialized. If this
   method returns false the report can't be used.

=head2 Wx::DebugReport::Process

   bool Process()

   Processes this report: the base class simply notifies the user that
   the report has been generated. This is usually not enough -- instead
   you should override this method to do something more useful to you.

=head2 Wx::DebugReport::RemoveFile

   void RemoveFile(const wxString& name)

   Removes the file from report: this is used by wxDebugReportPreview to
   allow the user to remove files potentially containing private
   information from the report.

=head2 Wx::DebugReport::Reset

   void Reset()

   Resets the directory name we use. The object can't be used any more
   after this as it becomes uninitialized and invalid.

=head1 Wx::DebugReportCompress

=head2 Wx::DebugReportCompress::new

   wxDebugReportCompress()

   Default constructor does nothing special.

=head2 Wx::DebugReportCompress::GetCompressedFileName

   const wxString& GetCompressedFileName() const

   Returns the full path of the compressed file (empty if creation
   failed).

=head1 Wx::DebugReportPreview

=head2 Wx::DebugReportPreview::new

   wxDebugReportPreview()

   Trivial default constructor.

=head2 Wx::DebugReportPreview::DESTROY

   ~wxDebugReportPreview()

   dtor is trivial as well but should be virtual for a base class

=head2 Wx::DebugReportPreview::Show

   bool Show(wxDebugReport& dbgrpt) const

   Present the report to the user and allow him to modify it by removing
   some or all of the files and, potentially, adding some notes. Return
   true if the report should be processed or false if the user chose to
   cancel report generation or removed all files from it.

=head1 Wx::DebugReportPreviewStd

=head2 Wx::DebugReportPreviewStd::new

   wxDebugReportPreviewStd()

   Trivial default constructor.

=head2 Wx::DebugReportPreviewStd::Show

   bool Show(wxDebugReport& dbgrpt) const

   Show the dialog, see wxDebugReportPreview::Show() for more
   information.

=head1 Wx::DebugReportUpload

=head2 Wx::DebugReportUpload::new

   wxDebugReportUpload(const wxString& url, const wxString& input, const
   wxString& action, const wxString& curl = _T("curl"))

   This class will upload the compressed file created by its base class
   to an HTML multipart/form-data form at the specified address. The url
   is the upload page address, input is the name of the "type=file"
   control on the form used for the file name and action is the value of
   the form action field. The report is uploaded using curl program which
   should be available, the curl parameter may be used to specify the
   full path to it.

=head2 Wx::DebugReportUpload::OnServerReply

   bool OnServerReply(const wxArrayString& WXUNUSED(reply))

   This function may be overridden in a derived class to show the output
   from curl: this may be an HTML page or anything else that the server
   returned. Value returned by this function becomes the return value of
   wxDebugReport::Process().

=head1 Wx::DelegateRendererNative

=head2 Wx::DelegateRendererNative::new

   wxDelegateRendererNative()

   wxDelegateRendererNative(wxRendererNative& rendererNative)

   The default constructor does the same thing as the other one except
   that it uses the generic renderer instead of the user-specified
   rendererNative.

   In any case, this sets up the delegate renderer object to follow all
   calls to the specified real renderer.

   Note that this object does not take ownership of (i.e. won't delete)
   rendererNative.

=head2 Wx::DelegateRendererNative::DrawXXX

   DrawXXX(...)

   This class also provides all the virtual methods of wxRendererNative,
   please refer to that class documentation for the details.

=head1 Wx::Dialog

=head2 Wx::Dialog::new

   wxDialog()

   Default constructor.

   wxDialog(wxWindow* parent, wxWindowID id, const wxString& title, const
   wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
   long style = wxDEFAULT_DIALOG_STYLE, const wxString& name =
   "dialogBox")

   Constructor.

   Parameters

   parent

       Can be NULL, a frame or another dialog box.

   id  

       An identifier for the dialog. A value of -1 is taken to mean a
       default.

   title

       The title of the dialog.

   pos 

       The dialog position. A value of (-1, -1) indicates a default
       position, chosen by either the windowing system or wxWidgets,
       depending on platform.

   size

       The dialog size. A value of (-1, -1) indicates a default size,
       chosen by either the windowing system or wxWidgets, depending on
       platform.

   style

       The window style. See wxDialog.

   name

       Used to associate a name with the window, allowing the application
       user to set Motif resource values for individual dialog boxes.

   See also

   wxDialog::Create

=head2 Wx::Dialog::DESTROY

   ~wxDialog()

   Destructor. Deletes any child windows before deleting the physical
   window.

=head2 Wx::Dialog::Centre

   void Centre(int direction = wxBOTH)

   Centres the dialog box on the display.

   Parameters

   direction

       May be wxHORIZONTAL, wxVERTICAL or wxBOTH.

=head2 Wx::Dialog::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxString& title,
   const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = wxDEFAULT_DIALOG_STYLE, const wxString&
   name = "dialogBox")

   Used for two-step dialog box construction. See wxDialog::wxDialog for
   details.

=head2 Wx::Dialog::CreateButtonSizer

   wxSizer* CreateButtonSizer(long flags)

   Creates a sizer with standard buttons. flags is a bit list of the
   following flags: wxOK, wxCANCEL, wxYES, wxNO, wxHELP, wxNO_DEFAULT.

   The sizer lays out the buttons in a manner appropriate to the
   platform.

   This function uses CreateStdDialogButtonSizer internally for most
   platforms but doesn't create the sizer at all for the platforms with
   hardware buttons (such as smartphones) for which it sets up the
   hardware buttons appropriately and returns NULL, so don't forget to
   test that the return value is valid before using it.

=head2 Wx::Dialog::CreateSeparatedButtonSizer

   wxSizer* CreateSeparatedButtonSizer(long flags)

   Creates a sizer with standard buttons using CreateButtonSizer
   separated from the rest of the dialog contents by a horizontal
   wxStaticLine.

   Please notice that just like CreateButtonSizer() this function may
   return NULL if no buttons were created.

=head2 Wx::Dialog::CreateStdDialogButtonSizer

   wxStdDialogButtonSizer* CreateStdDialogButtonSizer(long flags)

   Creates a wxStdDialogButtonSizer with standard buttons. flags is a bit
   list of the following flags: wxOK, wxCANCEL, wxYES, wxNO, wxHELP,
   wxNO_DEFAULT.

   The sizer lays out the buttons in a manner appropriate to the
   platform.

=head2 Wx::Dialog::DoOK

   virtual bool DoOK()

   This function is called when the titlebar OK button is pressed
   (PocketPC only). A command event for the identifier returned by
   GetAffirmativeId is sent by default. You can override this function.
   If the function returns false, wxWidgets will call Close() for the
   dialog.

=head2 Wx::Dialog::EndModal

   void EndModal(int retCode)

   Ends a modal dialog, passing a value to be returned from the
   wxDialog::ShowModal invocation.

   Parameters

   retCode

       The value that should be returned by ShowModal.

   See also

   wxDialog::ShowModal, wxDialog::GetReturnCode, wxDialog::SetReturnCode

=head2 Wx::Dialog::GetAffirmativeId

   int GetAffirmativeId() const

   Gets the identifier of the button which works like standard OK button
   in this dialog.

   See also

   wxDialog::SetAffirmativeId

=head2 Wx::Dialog::GetEscapeId

   int GetEscapeId() const

   Gets the identifier of the button to map presses of ESC button to.

   See also

   wxDialog::SetEscapeId

=head2 Wx::Dialog::GetReturnCode

   int GetReturnCode()

   Gets the return code for this window.

   Remarks

   A return code is normally associated with a modal dialog, where
   wxDialog::ShowModal returns a code to the application.

   See also

   wxDialog::SetReturnCode, wxDialog::ShowModal, wxDialog::EndModal

=head2 Wx::Dialog::GetToolBar

   wxToolBar* GetToolBar() const

   On PocketPC, a dialog is automatically provided with an empty toolbar.
   GetToolBar allows you to access the toolbar and add tools to it.
   Removing tools and adding arbitrary controls are not currently
   supported.

   This function is not available on any other platform.

=head2 Wx::Dialog::Iconize

   void Iconize(const bool iconize)

   Iconizes or restores the dialog. Windows only.

   Parameters

   iconize

       If true, iconizes the dialog box; if false, shows and restores it.

   Remarks

   Note that in Windows, iconization has no effect since dialog boxes
   cannot be iconized. However, applications may need to explicitly
   restore dialog boxes under Motif which have user-iconizable frames,
   and under Windows calling Iconize(false) will bring the window to the
   front, as does Show(true).

=head2 Wx::Dialog::IsIconized

   bool IsIconized() const

   Returns true if the dialog box is iconized. Windows only.

   Remarks

   Always returns false under Windows since dialogs cannot be iconized.

=head2 Wx::Dialog::IsModal

   bool IsModal() const

   Returns true if the dialog box is modal, false otherwise.

=head2 Wx::Dialog::OnSysColourChanged

   void OnSysColourChanged(wxSysColourChangedEvent& event)

   The default handler for wxEVT_SYS_COLOUR_CHANGED.

   Parameters

   event

       The colour change event.

   Remarks

   Changes the dialog's colour to conform to the current settings
   (Windows only). Add an event table entry for your dialog class if you
   wish the behaviour to be different (such as keeping a user-defined
   background colour). If you do override this function, call
   wxEvent::Skip to propagate the notification to child windows and
   controls.

   See also

   wxSysColourChangedEvent

=head2 Wx::Dialog::SetAffirmativeId

   void SetAffirmativeId(int id)

   Sets the identifier to be used as OK button. When the button with this
   identifier is pressed, the dialog calls Validate and
   wxWindow::TransferDataFromWindow and, if they both return true, closes
   the dialog with wxID_OK return code.

   Also, when the user presses a hardware OK button on the devices having
   one or the special OK button in the PocketPC title bar, an event with
   this id is generated.

   By default, the affirmative id is wxID_OK.

   See also

   wxDialog::GetAffirmativeId, wxDialog::SetEscapeId

=head2 Wx::Dialog::SetEscapeId

   void SetEscapeId(int id)

   Sets the identifier of the button which should work like the standard
   CANCEL button in this dialog. When the button with this id is clicked,
   the dialog is closed. Also, when the user presses ESC key in the
   dialog or closes the dialog using the close button in the title bar,
   this is mapped to the click of the button with the specified id.

   By default, the escape id is the special value wxID_ANY meaning that
   wxID_CANCEL button is used if it's present in the dialog and otherwise
   the button with GetAffirmativeId() is used. Another special value for
   id is wxID_NONE meaning that ESC presses should be ignored. If any
   other value is given, it is interpreted as the id of the button to map
   the escape key to.

=head2 Wx::Dialog::SetIcon

   void SetIcon(const wxIcon& icon)

   Sets the icon for this dialog.

   Parameters

   icon

       The icon to associate with this dialog.

   See also wxIcon.

=head2 Wx::Dialog::SetIcons

   void SetIcons(const wxIconBundle& icons)

   Sets the icons for this dialog.

   Parameters

   icons

       The icons to associate with this dialog.

   See also wxIconBundle.

=head2 Wx::Dialog::SetModal

   void SetModal(const bool flag)

   NB: This function is deprecated and doesn't work for all ports, just
   use ShowModal to show a modal dialog instead.

   Allows the programmer to specify whether the dialog box is modal
   (wxDialog::Show blocks control until the dialog is hidden) or modeless
   (control returns immediately).

   Parameters

   flag

       If true, the dialog will be modal, otherwise it will be modeless.

=head2 Wx::Dialog::SetReturnCode

   void SetReturnCode(int retCode)

   Sets the return code for this window.

   Parameters

   retCode

       The integer return code, usually a control identifier.

   Remarks

   A return code is normally associated with a modal dialog, where
   wxDialog::ShowModal returns a code to the application. The function
   wxDialog::EndModal calls SetReturnCode.

   See also

   wxDialog::GetReturnCode, wxDialog::ShowModal, wxDialog::EndModal

=head2 Wx::Dialog::Show

   bool Show(const bool show)

   Hides or shows the dialog.

   Parameters

   show

       If true, the dialog box is shown and brought to the front;
       otherwise the box is hidden. If false and the dialog is modal,
       control is returned to the calling program.

   Remarks

   The preferred way of dismissing a modal dialog is to use
   wxDialog::EndModal.

=head2 Wx::Dialog::ShowModal

   int ShowModal()

   Shows a modal dialog. Program flow does not return until the dialog
   has been dismissed with wxDialog::EndModal.

   Return value

   The return value is the value set with wxDialog::SetReturnCode.

   See also

   wxDialog::EndModal, wxDialog:GetReturnCode, wxDialog::SetReturnCode

=head1 Wx::DialUpEvent

=head2 Wx::DialUpEvent::new

   wxDialUpEvent(bool isConnected, bool isOwnEvent)

   Constructor is only used by wxDialUpManager.

=head2 Wx::DialUpEvent::IsConnectedEvent

   bool IsConnectedEvent() const

   Is this a CONNECTED or DISCONNECTED event? In other words, does it
   notify about transition from offline to online state or vice versa?

=head2 Wx::DialUpEvent::IsOwnEvent

   bool IsOwnEvent() const

   Does this event come from wxDialUpManager::Dial() or from some
   extrenal process (i.e. does it result from our own attempt to
   establish the connection)?

=head1 Wx::DialUpManager

=head2 Wx::DialUpManager::Create

   wxDialUpManager* Create()

   This function should create and return the object of the
   platform-specific class derived from wxDialUpManager. You should
   delete the pointer when you are done with it.

=head2 Wx::DialUpManager::IsOk

   bool IsOk() const

   Returns true if the dialup manager was initialized correctly. If this
   function returns false, no other functions will work neither, so it is
   a good idea to call this function and check its result before calling
   any other wxDialUpManager methods

=head2 Wx::DialUpManager::DESTROY

   ~wxDialUpManager()

   Destructor.

=head2 Wx::DialUpManager::GetISPNames

   size_t GetISPNames(wxArrayString& names) const

   This function is only implemented under Windows.

   Fills the array with the names of all possible values for the first
   parameter to Dial() on this machine and returns their number (may be
   0).

=head2 Wx::DialUpManager::Dial

   bool Dial(const wxString& nameOfISP = wxEmptyString, const wxString&
   username = wxEmptyString, const wxString& password = wxEmptyString,
   bool async = true)

   Dial the given ISP, use username and password to authenticate.

   The parameters are only used under Windows currently, for Unix you
   should use SetConnectCommand to customize this functions behaviour.

   If no nameOfISP is given, the function will select the default one
   (proposing the user to choose among all connections defined on this
   machine) and if no username and/or password are given, the function
   will try to do without them, but will ask the user if really needed.

   If async parameter is false, the function waits until the end of
   dialing and returns true upon successful completion.

   If async is true, the function only initiates the connection and
   returns immediately - the result is reported via events (an event is
   sent anyhow, but if dialing failed it will be a DISCONNECTED one).

=head2 Wx::DialUpManager::IsDialing

   bool IsDialing() const

   Returns true if (async) dialing is in progress.

   See also

   Dial

=head2 Wx::DialUpManager::CancelDialing

   bool CancelDialing()

   Cancel dialing the number initiated with Dial with async parameter
   equal to true.

   Note that this won't result in DISCONNECTED event being sent.

   See also

   IsDialing

=head2 Wx::DialUpManager::HangUp

   bool HangUp()

   Hang up the currently active dial up connection.

=head2 Wx::DialUpManager::IsAlwaysOnline

   bool IsAlwaysOnline() const

   Returns true if the computer has a permanent network connection (i.e.
   is on a LAN) and so there is no need to use Dial() function to go
   online.

   NB: this functions tries to guess the result and it is not always
   guaranteed to be correct, so it is better to ask user for confirmation
   or give him a possibility to override it.

=head2 Wx::DialUpManager::IsOnline

   bool IsOnline() const

   Returns true if the computer is connected to the network: under
   Windows, this just means that a RAS connection exists, under Unix we
   check that the "well-known host" (as specified by SetWellKnownHost) is
   reachable.

=head2 Wx::DialUpManager::SetOnlineStatus

   void SetOnlineStatus(bool isOnline = true)

   Sometimes the built-in logic for determining the online status may
   fail, so, in general, the user should be allowed to override it. This
   function allows to forcefully set the online status - whatever our
   internal algorithm may think about it.

   See also

   IsOnline

=head2 Wx::DialUpManager::EnableAutoCheckOnlineStatus

   bool EnableAutoCheckOnlineStatus(size_t nSeconds = 60)

   Enable automatic checks for the connection status and sending of
   wxEVT_DIALUP_CONNECTED/wxEVT_DIALUP_DISCONNECTED events. The interval
   parameter is only for Unix where we do the check manually and
   specifies how often should we repeat the check (each minute by
   default). Under Windows, the notification about the change of
   connection status is sent by the system and so we don't do any polling
   and this parameter is ignored.

   Returns false if couldn't set up automatic check for online status.

=head2 Wx::DialUpManager::DisableAutoCheckOnlineStatus

   void DisableAutoCheckOnlineStatus()

   Disable automatic check for connection status change - notice that the
   wxEVT_DIALUP_XXX events won't be sent any more neither.

=head2 Wx::DialUpManager::SetWellKnownHost

   void SetWellKnownHost(const wxString& hostname, int portno = 80)

   This method is for Unix only.

   Under Unix, the value of well-known host is used to check whether
   we're connected to the internet. It is unused under Windows, but this
   function is always safe to call. The default value is www.yahoo.com:80.

=head2 Wx::DialUpManager::SetConnectCommand

   void SetConnectCommand(const wxString& commandDial =
   wxT("/usr/bin/pon"), const wxString& commandHangup =
   wxT("/usr/bin/poff"))

   This method is for Unix only.

   Sets the commands to start up the network and to hang up again.

   See also

   Dial

=head1 Wx::Dir

=head2 Wx::Dir::new

   wxDir()

   Default constructor, use Open() afterwards.

   wxDir(const wxString& dir)

   Opens the directory for enumeration, use IsOpened() to test for
   errors.

=head2 Wx::Dir::DESTROY

   ~wxDir()

   Destructor cleans up the associated resources. It is not virtual and
   so this class is not meant to be used polymorphically.

=head2 Wx::Dir::Exists

   static bool Exists(const wxString& dir)

   Test for existence of a directory with the given name

=head2 Wx::Dir::GetAllFiles

   static size_t GetAllFiles(const wxString& dirname, wxArrayString *files,
   const wxString& filespec = wxEmptyString, int flags = wxDIR_DEFAULT)

   The function appends the names of all the files under directory
   dirname to the array files (note that its old content is preserved).
   Only files matching the filespec are taken, with empty spec matching
   all the files.

   The flags parameter should always include wxDIR_FILES or the array
   would be unchanged and should include wxDIR_DIRS flag to recurse into
   subdirectories (both flags are included in the value by default).

   See also: Traverse

=head2 Wx::Dir::FindFirst

   static wxString FindFirst(const wxString& dirname, const wxString&
   filespec, int flags = wxDIR_DEFAULT)

   The function returns the path of the first file matching the given
   filespec or an empty string if there are no files matching it.

   The flags parameter may or may not include wxDIR_FILES, the function
   always behaves as if it were specified. By default, flags includes
   wxDIR_DIRS and so the function recurses into the subdirectories but if
   this flag is not specified, the function restricts the search only to
   the directory dirname itself.

   See also: Traverse

=head2 Wx::Dir::GetFirst

   bool GetFirst(wxString* filename, const wxString& filespec =
   wxEmptyString, int flags = wxDIR_DEFAULT) const

   Start enumerating all files matching filespec (or all files if it is
   empty) and flags, return true on success.

=head2 Wx::Dir::GetName

   wxString GetName() const

   Returns the name of the directory itself. The returned string does not
   have the trailing path separator (slash or backslash).

=head2 Wx::Dir::GetNext

   bool GetNext(wxString* filename) const

   Continue enumerating files which satisfy the criteria specified by the
   last call to GetFirst.

=head2 Wx::Dir::GetTotalSize

   static wxULongLong GetTotalSize(const wxString& dir, wxArrayString*
   filesSkipped = NULL)

   Returns the size (in bytes) of all files recursively found in dir or
   wxInvalidSize in case of error.

   In case it happens that while traversing folders a file's size can not
   be read, that file is added to the filesSkipped array, if not NULL,
   and then skipped. This usually happens with some special folders which
   are locked by the operating system or by another process. Remember
   that when filesSkipped->GetCount() is not zero, then the returned
   value is not 100% accurate and, if the skipped files were big, it
   could be far from real size of the directory.

   See also: wxFileName::GetHumanReadableSize, wxGetDiskSpace

=head2 Wx::Dir::HasFiles

   bool HasFiles(const wxString& filespec = wxEmptyString)

   Returns true if the directory contains any files matching the given
   filespec. If filespec is empty, look for any files at all. In any
   case, even hidden files are taken into account.

=head2 Wx::Dir::HasSubDirs

   bool HasSubDirs(const wxString& dirspec = wxEmptyString)

   Returns true if the directory contains any subdirectories (if a non
   empty filespec is given, only check for directories matching it). The
   hidden subdirectories are taken into account as well.

=head2 Wx::Dir::IsOpened

   bool IsOpened() const

   Returns true if the directory was successfully opened by a previous
   call to Open.

=head2 Wx::Dir::Open

   bool Open(const wxString& dir)

   Open the directory for enumerating, returns true on success or false
   if an error occurred.

=head2 Wx::Dir::Traverse

   size_t Traverse(wxDirTraverser& sink, const wxString& filespec =
   wxEmptyString, int flags = wxDIR_DEFAULT)

   Enumerate all files and directories under the given directory
   recursively calling the element of the provided wxDirTraverser object
   for each of them.

   More precisely, the function will really recurse into subdirectories
   if flags contains wxDIR_DIRS flag. It will ignore the files (but still
   possibly recurse into subdirectories) if wxDIR_FILES flag is given.

   For each found directory, sink.OnDir() is called and sink.OnFile() is
   called for every file. Depending on the return value, the enumeration
   may continue or stop.

   The function returns the total number of files found or (size_t)-1 on
   error.

   See also: GetAllFiles

=head1 Wx::DirDialog

=head2 Wx::DirDialog::new

   wxDirDialog(wxWindow* parent, const wxString& message = "Choose a
   directory", const wxString& defaultPath = "", long style =
   wxDD_DEFAULT_STYLE, const wxPoint& pos = wxDefaultPosition, const
   wxSize& size = wxDefaultSize, const wxString& name = "wxDirCtrl")

   Constructor. Use wxDirDialog::ShowModal to show the dialog.

   Parameters

   parent

       Parent window.

   message

       Message to show on the dialog.

   defaultPath

       The default path, or the empty string.

   style

       The dialog style. See wxDirDialog

   pos 

       Dialog position. Ignored under Windows.

   size

       Dialog size. Ignored under Windows.

   name

       The dialog name, not used.

=head2 Wx::DirDialog::DESTROY

   ~wxDirDialog()

   Destructor.

=head2 Wx::DirDialog::GetPath

   wxString GetPath() const

   Returns the default or user-selected path.

=head2 Wx::DirDialog::GetMessage

   wxString GetMessage() const

   Returns the message that will be displayed on the dialog.

=head2 Wx::DirDialog::SetMessage

   void SetMessage(const wxString& message)

   Sets the message that will be displayed on the dialog.

=head2 Wx::DirDialog::SetPath

   void SetPath(const wxString& path)

   Sets the default path.

=head2 Wx::DirDialog::ShowModal

   int ShowModal()

   Shows the dialog, returning wxID_OK if the user pressed OK, and
   wxID_CANCEL otherwise.

=head1 Wx::DirPickerCtrl

=head2 Wx::DirPickerCtrl::new

   wxDirPickerCtrl(wxWindow *parent, wxWindowID id, const wxString& path
   = wxEmptyString, const wxString& message = "Select a folder", const
   wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
   long style = wxDIRP_DEFAULT_STYLE, const wxValidator& validator =
   wxDefaultValidator, const wxString& name = "dirpickerctrl")

   Initializes the object and calls Create with all the parameters.

=head2 Wx::DirPickerCtrl::Create

   bool Create(wxWindow *parent, wxWindowID id, const wxString& path =
   wxEmptyString, const wxString& message = "Select a folder", const
   wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
   long style = wxDIRP_DEFAULT_STYLE, const wxValidator& validator =
   wxDefaultValidator, const wxString& name = "dirpickerctrl")

   Parameters

   parent

       Parent window, must not be non-NULL.

   id  

       The identifier for the control.

   path

       The initial directory shown in the control. Must be a valid path
       to a directory or the empty string.

   message

       The message shown to the user in the wxDirDialog shown by the
       control.

   pos 

       Initial position.

   size

       Initial size.

   style

       The window style, see wxDIRP_* flags.

   validator

       Validator which can be used for additional date checks.

   name

       Control name.

   Return value

   true if the control was successfully created or false if creation
   failed.

=head2 Wx::DirPickerCtrl::GetPath

   wxString GetPath() const

   Returns the absolute path of the currently selected directory.

=head2 Wx::DirPickerCtrl::SetPath

   void SetPath(const wxString &dirname)

   Sets the absolute path of the currently selected directory. This must
   be a valid directory if wxDIRP_DIR_MUST_EXIST style was given.

=head1 Wx::DirTraverser

=head2 Wx::DirTraverser::OnDir

   virtual wxDirTraverseResult OnDir(const wxString& dirname)

   This function is called for each directory. It may return wxSIR_STOP
   to abort traversing completely, wxDIR_IGNORE to skip this directory
   but continue with others or wxDIR_CONTINUE to enumerate all files and
   subdirectories in this directory.

   This is a pure virtual function and must be implemented in the derived
   class.

=head2 Wx::DirTraverser::OnFile

   virtual wxDirTraverseResult OnFile(const wxString& filename)

   This function is called for each file. It may return wxDIR_STOP to
   abort traversing (for example, if the file being searched is found) or
   wxDIR_CONTINUE to proceed.

   This is a pure virtual function and must be implemented in the derived
   class.

=head2 Wx::DirTraverser::OnOpenError

   virtual wxDirTraverseResult OnOpenError(const wxString& openerrorname)

   This function is called for each directory which we failed to open for
   enumerating. It may return wxSIR_STOP to abort traversing completely,
   wxDIR_IGNORE to skip this directory but continue with others or
   wxDIR_CONTINUE to retry opening this directory once again.

   The base class version always returns wxDIR_IGNORE.

=head1 Wx::Display

=head2 Wx::Display::new

   wxDisplay(unsigned index = 0)

   Constructor, setting up a wxDisplay instance with the specified
   display.

   Parameters

   index

       The index of the display to use. This must be non-negative and
       lower than the value returned by GetCount().

=head2 Wx::Display::DESTROY

   void ~wxDisplay()

   Destructor.

=head2 Wx::Display::ChangeMode

   bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)

   Changes the video mode of this display to the mode specified in the
   mode parameter.

   If wxDefaultVideoMode is passed in as the mode parameter, the defined
   behaviour is that wxDisplay will reset the video mode to the default
   mode used by the display. On Windows, the behavior is normal. However,
   there are differences on other platforms. On Unix variations using X11
   extensions it should behave as defined, but some irregularities may
   occur.

   On wxMac passing in wxDefaultVideoMode as the mode parameter does
   nothing. This happens because carbon no longer has access to
   DMUseScreenPrefs, an undocumented function that changed the video mode
   to the system default by using the system's 'scrn' resource.

=head2 Wx::Display::GetClientArea

   wxRect GetClientArea() const

   Returns the client area of the display. The client area is the part of
   the display available for the normal (non full screen) windows,
   usually it is the same as GetGeometry but it could be less if there is
   a taskbar (or equivalent) on this display.

   See also:

   wxClientDisplayRect

=head2 Wx::Display::GetCount

   static unsigned GetCount()

   Returns the number of connected displays.

=head2 Wx::Display::GetCurrentMode

   wxVideoMode GetCurrentMode() const

   Returns the current video mode that this display is in.

=head2 Wx::Display::GetDepth

   int GetDepth() const

   Returns the bit depth of the display whose index was passed to the
   constructor.

=head2 Wx::Display::GetFromPoint

   static int GetFromPoint(const wxPoint& pt)

   Returns the index of the display on which the given point lies.
   Returns wxNOT_FOUND if the point is not on any connected display.

   Parameters

   pt  

       The point to locate.

=head2 Wx::Display::GetFromWindow

   static int GetFromWindow(wxWindow* win)

   Returns the index of the display on which the given window lies.

   If the window is on more than one display it gets the display that
   overlaps the window the most.

   Returns wxNOT_FOUND if the window is not on any connected display.

   Parameters

   win 

       The window to locate.

=head2 Wx::Display::GetGeometry

   wxRect GetGeometry() const

   Returns the bounding rectangle of the display whose index was passed
   to the constructor.

   See also:

   GetClientArea, wxDisplaySize

=head2 Wx::Display::GetModes

   wxArrayVideoModes GetModes(const wxVideoMode& mode =
   wxDefaultVideoMode) const

   Fills and returns an array with all the video modes that are supported
   by this display, or video modes that are supported by this display and
   match the mode parameter (if mode is not wxDefaultVideoMode).

=head2 Wx::Display::GetName

   wxString GetName() const

   Returns the display's name. A name is not available on all platforms.

=head2 Wx::Display::IsPrimary

   bool IsPrimary()

   Returns true if the display is the primary display. The primary
   display is the one whose index is 0.

=head1 Wx::DllLoader

=head2 Wx::DllLoader::GetDllExt

   static wxString GetDllExt()

   Returns the string containing the usual extension for shared libraries
   for the given systems (including the leading dot if not empty).

   For example, this function will return ".dll" under Windows or
   (usually) ".so" under Unix.

=head2 Wx::DllLoader::GetProgramHandle

   wxDllType GetProgramHandle()

   This function returns a valid handle for the main program itself.
   Notice that the NULL return value is valid for some systems (i.e.
   doesn't mean that the function failed).

   NB: This function is Unix specific. It will always fail under Windows
   or OS/2.

=head2 Wx::DllLoader::GetSymbol

   void * GetSymbol(wxDllType dllHandle, const wxString& name)

   This function resolves a symbol in a loaded DLL, such as a variable or
   function name.

   Returned value will be NULL if the symbol was not found in the DLL or
   if an error occurred.

   Parameters

   dllHandle

       Valid handle previously returned by LoadLibrary

   name

       Name of the symbol.

=head2 Wx::DllLoader::LoadLibrary

   wxDllType LoadLibrary(const wxString & libname, bool* success = NULL)

   This function loads a shared library into memory, with libname being
   the name of the library: it may be either the full name including path
   and (platform-dependent) extension, just the basename (no path and no
   extension) or a basename with extension. In the last two cases, the
   library will be searched in all standard locations.

   Returns a handle to the loaded DLL. Use success parameter to test if
   it is valid. If the handle is valid, the library must be unloaded
   later with UnloadLibrary.

   Parameters

   libname

       Name of the shared object to load.

   success

       May point to a bool variable which will be set to true or false;
       may also be NULL.

=head2 Wx::DllLoader::UnloadLibrary

   void UnloadLibrary(wxDllType dllhandle)

   This function unloads the shared library. The handle dllhandle must
   have been returned by LoadLibrary previously.

=head1 Wx::DocChildFrame

=head2 Wx::DocChildFrame::m_childDocument

   wxDocument* m_childDocument

   The document associated with the frame.

=head2 Wx::DocChildFrame::m_childView

   wxView* m_childView

   The view associated with the frame.

=head2 Wx::DocChildFrame::new

   wxDocChildFrame(wxDocument* doc, wxView* view, wxFrame* parent,
   wxWindowID id, const wxString& title, const wxPoint& pos =
   wxDefaultPosition, const wxSize& size = wxDefaultSize, long style =
   wxDEFAULT_FRAME_STYLE, const wxString& name = "frame")

   Constructor.

=head2 Wx::DocChildFrame::DESTROY

   ~wxDocChildFrame()

   Destructor.

=head2 Wx::DocChildFrame::GetDocument

   wxDocument* GetDocument() const

   Returns the document associated with this frame.

=head2 Wx::DocChildFrame::GetView

   wxView* GetView() const

   Returns the view associated with this frame.

=head2 Wx::DocChildFrame::OnActivate

   void OnActivate(wxActivateEvent event)

   Sets the currently active view to be the frame's view. You may need to
   override (but still call) this function in order to set the keyboard
   focus for your subwindow.

=head2 Wx::DocChildFrame::OnCloseWindow

   void OnCloseWindow(wxCloseEvent& event)

   Closes and deletes the current view and document.

=head2 Wx::DocChildFrame::SetDocument

   void SetDocument(wxDocument *doc)

   Sets the document for this frame.

=head2 Wx::DocChildFrame::SetView

   void SetView(wxView *view)

   Sets the view for this frame.

=head1 Wx::DocManager

=head2 Wx::DocManager::m_currentView

   wxView* m_currentView

   The currently active view.

=head2 Wx::DocManager::m_defaultDocumentNameCounter

   int m_defaultDocumentNameCounter

   Stores the integer to be used for the next default document name.

=head2 Wx::DocManager::m_fileHistory

   wxFileHistory* m_fileHistory

   A pointer to an instance of wxFileHistory, which manages the history
   of recently-visited files on the File menu.

=head2 Wx::DocManager::m_maxDocsOpen

   int m_maxDocsOpen

   Stores the maximum number of documents that can be opened before
   existing documents are closed. By default, this is 10,000.

=head2 Wx::DocManager::m_docs

   wxList m_docs

   A list of all documents.

=head2 Wx::DocManager::m_flags

   long m_flags

   Stores the flags passed to the constructor.

=head2 Wx::DocManager::m_lastDirectory

   The directory last selected by the user when opening a file.

   wxFileHistory* m_fileHistory

=head2 Wx::DocManager::m_templates

   wxList m_templates

   A list of all document templates.

=head2 Wx::DocManager::new

   wxDocManager(long flags = wxDEFAULT_DOCMAN_FLAGS, bool initialize =
   true)

   Constructor. Create a document manager instance dynamically near the
   start of your application before doing any document or view
   operations.

   flags is currently unused.

   If initialize is true, the Initialize function will be called to
   create a default history list object. If you derive from wxDocManager,
   you may wish to call the base constructor with false, and then call
   Initialize in your own constructor, to allow your own Initialize or
   OnCreateFileHistory functions to be called.

=head2 Wx::DocManager::DESTROY

   void ~wxDocManager()

   Destructor.

=head2 Wx::DocManager::ActivateView

   void ActivateView(wxView* doc, bool activate = true)

   Sets the current view.

=head2 Wx::DocManager::AddDocument

   void AddDocument(wxDocument *doc)

   Adds the document to the list of documents.

=head2 Wx::DocManager::AddFileToHistory

   void AddFileToHistory(const wxString& filename)

   Adds a file to the file history list, if we have a pointer to an
   appropriate file menu.

=head2 Wx::DocManager::AssociateTemplate

   void AssociateTemplate(wxDocTemplate *temp)

   Adds the template to the document manager's template list.

=head2 Wx::DocManager::CloseDocuments

   bool CloseDocuments(bool force = true)

   Closes all currently opened documents.

=head2 Wx::DocManager::CreateDocument

   wxDocument* CreateDocument(const wxString& path, long flags)

   Creates a new document in a manner determined by the flags parameter,
   which can be:

=head2 Wx::DocManager::CreateView

   wxView* CreateView(wxDocument*doc, long flags)

   Creates a new view for the given document. If more than one view is
   allowed for the document (by virtue of multiple templates mentioning
   the same document type), a choice of view is presented to the user.

=head2 Wx::DocManager::DisassociateTemplate

   void DisassociateTemplate(wxDocTemplate *temp)

   Removes the template from the list of templates.

=head2 Wx::DocManager::FileHistoryAddFilesToMenu

   void FileHistoryAddFilesToMenu()

   Appends the files in the history list, to all menus managed by the
   file history object.

   void FileHistoryAddFilesToMenu(wxMenu* menu)

   Appends the files in the history list, to the given menu only.

=head2 Wx::DocManager::FileHistoryLoad

   void FileHistoryLoad(wxConfigBase& config)

   Loads the file history from a config object.

   See also

   wxConfig

=head2 Wx::DocManager::FileHistoryRemoveMenu

   void FileHistoryRemoveMenu(wxMenu* menu)

   Removes the given menu from the list of menus managed by the file
   history object.

=head2 Wx::DocManager::FileHistorySave

   void FileHistorySave(wxConfigBase& resourceFile)

   Saves the file history into a config object. This must be called
   explicitly by the application.

   See also

   wxConfig

=head2 Wx::DocManager::FileHistoryUseMenu

   void FileHistoryUseMenu(wxMenu* menu)

   Use this menu for appending recently-visited document filenames, for
   convenient access. Calling this function with a valid menu pointer
   enables the history list functionality.

   Note that you can add multiple menus using this function, to be
   managed by the file history object.

=head2 Wx::DocManager::FindTemplateForPath

   wxDocTemplate * FindTemplateForPath(const wxString& path)

   Given a path, try to find template that matches the extension. This is
   only an approximate method of finding a template for creating a
   document.

=head2 Wx::DocManager::GetCurrentDocument

   wxDocument * GetCurrentDocument()

   Returns the document associated with the currently active view (if
   any).

=head2 Wx::DocManager::GetCurrentView

   wxView * GetCurrentView()

   Returns the currently active view

=head2 Wx::DocManager::GetDocuments

   wxList& GetDocuments()

   Returns a reference to the list of documents.

=head2 Wx::DocManager::GetFileHistory

   wxFileHistory * GetFileHistory()

   Returns a pointer to file history.

=head2 Wx::DocManager::GetLastDirectory

   wxString GetLastDirectory() const

   Returns the directory last selected by the user when opening a file.
   Initially empty.

=head2 Wx::DocManager::GetMaxDocsOpen

   int GetMaxDocsOpen()

   Returns the number of documents that can be open simultaneously.

=head2 Wx::DocManager::GetHistoryFilesCount

   size_t GetHistoryFilesCount()

   Returns the number of files currently stored in the file history.

=head2 Wx::DocManager::GetTemplates

   wxList& GetTemplates()

   Returns a reference to the list of associated templates.

=head2 Wx::DocManager::Initialize

   bool Initialize()

   Initializes data; currently just calls OnCreateFileHistory. Some data
   cannot always be initialized in the constructor because the programmer
   must be given the opportunity to override functionality. If
   OnCreateFileHistory was called from the constructor, an overridden
   virtual OnCreateFileHistory would not be called due to C++'s
   'interesting' constructor semantics. In fact Initialize is called from
   the wxDocManager constructor, but this can be vetoed by passing false
   to the second argument, allowing the derived class's constructor to
   call Initialize, possibly calling a different OnCreateFileHistory from
   the default.

   The bottom line: if you're not deriving from Initialize, forget it and
   construct wxDocManager with no arguments.

=head2 Wx::DocManager::MakeDefaultName

   bool MakeDefaultName(const wxString& buf)

   This method is preserved for backwards compatibility in wxWidgets 2.8
   but is renamed to MakeNewDocumentName in wxWidgets 3.0, please see its
   description for the details.

   This function simply copies the value returned by
   MakeNewDocumentName() into the provided buf and returns true.

   wxPerl note: In wxPerl this function must return the modified name
   rather than just modifying the argument.

=head2 Wx::DocManager::MakeNewDocumentName

   wxString MakeNewDocumentName()

   Returns the name to be used for a new document. The default
   implementation appends an integer counter to the string unnamed and
   increments the counter. To customize this behaviour, you need to
   override the virtual MakeNewDocumentName method but if you only need
   to call this method, an not to override it, please use this method
   which is forward-compatible with wxWidgets 3.0.

   This function is new since wxWidgets version 2.8.8

=head2 Wx::DocManager::OnCreateFileHistory

   wxFileHistory * OnCreateFileHistory()

   A hook to allow a derived class to create a different type of file
   history. Called from Initialize.

=head2 Wx::DocManager::OnFileClose

   void OnFileClose(wxCommandEvent& event)

   Closes and deletes the currently active document.

=head2 Wx::DocManager::OnFileCloseAll

   void OnFileCloseAll(wxCommandEvent& event)

   Closes and deletes all the currently opened documents.

=head2 Wx::DocManager::OnFileNew

   void OnFileNew(wxCommandEvent& event)

   Creates a document from a list of templates (if more than one
   template).

=head2 Wx::DocManager::OnFileOpen

   void OnFileOpen(wxCommandEvent& event)

   Creates a new document and reads in the selected file.

=head2 Wx::DocManager::OnFileRevert

   void OnFileRevert(wxCommandEvent& event)

   Reverts the current document by calling wxDocument::Revert for the
   current document.

=head2 Wx::DocManager::OnFileSave

   void OnFileSave(wxCommandEvent& event)

   Saves the current document by calling wxDocument::Save for the current
   document.

=head2 Wx::DocManager::OnFileSaveAs

   void OnFileSaveAs(wxCommandEvent& event)

   Calls wxDocument::SaveAs for the current document.

=head2 Wx::DocManager::RemoveDocument

   void RemoveDocument(wxDocument *doc)

   Removes the document from the list of documents.

=head2 Wx::DocManager::SelectDocumentPath

   wxDocTemplate * SelectDocumentPath(wxDocTemplate **templates, int
   noTemplates, wxString& path, long flags, bool save)

   Under Windows, pops up a file selector with a list of filters
   corresponding to document templates. The wxDocTemplate corresponding
   to the selected file's extension is returned.

   On other platforms, if there is more than one document template a
   choice list is popped up, followed by a file selector.

   This function is used in wxDocManager::CreateDocument.

   wxPerl note: In wxPerl templates is a reference to a list of
   templates. If you override this method in your document manager it
   must return two values, eg:

=head2 Wx::DocManager::SelectDocumentType

   wxDocTemplate * SelectDocumentType(wxDocTemplate **templates, int
   noTemplates, bool sort=false)

   Returns a document template by asking the user (if there is more than
   one template). This function is used in wxDocManager::CreateDocument.

   Parameters

   templates

       Pointer to an array of templates from which to choose a desired
       template.

=head2 Wx::DocManager::SelectViewType

   wxDocTemplate * SelectViewType(wxDocTemplate **templates, int
   noTemplates, bool sort=false)

   Returns a document template by asking the user (if there is more than
   one template), displaying a list of valid views. This function is used
   in wxDocManager::CreateView. The dialog normally will not appear
   because the array of templates only contains those relevant to the
   document in question, and often there will only be one such.

   Parameters

   templates

       Pointer to an array of templates from which to choose a desired
       template.

=head2 Wx::DocManager::SetLastDirectory

   void SetLastDirectory(const wxString& dir)

   Sets the directory to be displayed to the user when opening a file.
   Initially this is empty.

=head2 Wx::DocManager::SetMaxDocsOpen

   void SetMaxDocsOpen(int n)

   Sets the maximum number of documents that can be open at a time. By
   default, this is 10,000. If you set it to 1, existing documents will
   be saved and deleted when the user tries to open or create a new one
   (similar to the behaviour of Windows Write, for example). Allowing
   multiple documents gives behaviour more akin to MS Word and other
   Multiple Document Interface applications.

=head1 Wx::DocMDIChildFrame

=head2 Wx::DocMDIChildFrame::m_childDocument

   wxDocument* m_childDocument

   The document associated with the frame.

=head2 Wx::DocMDIChildFrame::m_childView

   wxView* m_childView

   The view associated with the frame.

=head2 Wx::DocMDIChildFrame::new

   wxDocMDIChildFrame(wxDocument* doc, wxView* view, wxFrame* parent,
   wxWindowID id, const wxString& title, const wxPoint& pos =
   wxDefaultPosition, const wxSize& size = wxDefaultSize, long style =
   wxDEFAULT_FRAME_STYLE, const wxString& name = "frame")

   Constructor.

=head2 Wx::DocMDIChildFrame::DESTROY

   ~wxDocMDIChildFrame()

   Destructor.

=head2 Wx::DocMDIChildFrame::GetDocument

   wxDocument* GetDocument() const

   Returns the document associated with this frame.

=head2 Wx::DocMDIChildFrame::GetView

   wxView* GetView() const

   Returns the view associated with this frame.

=head2 Wx::DocMDIChildFrame::OnActivate

   void OnActivate(wxActivateEvent event)

   Sets the currently active view to be the frame's view. You may need to
   override (but still call) this function in order to set the keyboard
   focus for your subwindow.

=head2 Wx::DocMDIChildFrame::OnCloseWindow

   void OnCloseWindow(wxCloseEvent& event)

   Closes and deletes the current view and document.

=head2 Wx::DocMDIChildFrame::SetDocument

   void SetDocument(wxDocument *doc)

   Sets the document for this frame.

=head2 Wx::DocMDIChildFrame::SetView

   void SetView(wxView *view)

   Sets the view for this frame.

=head1 Wx::DocMDIParentFrame

=head2 Wx::DocMDIParentFrame::new

   wxDocMDIParentFrame()

   wxDocMDIParentFrame(wxDocManager* manager, wxFrame *parent, wxWindowID
   id, const wxString& title, const wxPoint& pos = wxDefaultPosition,
   const wxSize& size = wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE,
   const wxString& name = "frame")

   Constructor.

=head2 Wx::DocMDIParentFrame::DESTROY

   ~wxDocMDIParentFrame()

   Destructor.

=head2 Wx::DocMDIParentFrame::Create

   bool Create(wxDocManager* manager, wxFrame *parent, wxWindowID id,
   const wxString& title, const wxPoint& pos = wxDefaultPosition, const
   wxSize& size = wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE,
   const wxString& name = "frame")

   Creates the window.

=head2 Wx::DocMDIParentFrame::OnCloseWindow

   void OnCloseWindow(wxCloseEvent& event)

   Deletes all views and documents. If no user input cancelled the
   operation, the frame will be destroyed and the application will exit.

   Since understanding how document/view clean-up takes place can be
   difficult, the implementation of this function is shown below.

   void wxDocParentFrame::OnCloseWindow(wxCloseEvent& event)
   {
     if (m_docManager->Clear(!event.CanVeto()))
     {
       this->Destroy();
     }
     else
       event.Veto();
   }

=head1 Wx::DocParentFrame

=head2 Wx::DocParentFrame::new

   wxDocParentFrame()

   Default constructor.

   wxDocParentFrame(wxDocManager* manager, wxFrame *parent, wxWindowID id,
   const wxString& title, const wxPoint& pos = wxDefaultPosition, const
   wxSize& size = wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE,
   const wxString& name = "frame")

   Constructor.

=head2 Wx::DocParentFrame::DESTROY

   ~wxDocParentFrame()

   Destructor.

=head2 Wx::DocParentFrame::Create

   bool Create(wxDocManager* manager, wxFrame *parent, wxWindowID id,
   const wxString& title, const wxPoint& pos = wxDefaultPosition, const
   wxSize& size = wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE,
   const wxString& name = "frame")

   Used in two-step construction.

=head2 Wx::DocParentFrame::GetDocumentManager

   wxDocManager * GetDocumentManager() const

   Returns the associated document manager object.

=head2 Wx::DocParentFrame::OnCloseWindow

   void OnCloseWindow(wxCloseEvent& event)

   Deletes all views and documents. If no user input cancelled the
   operation, the frame will be destroyed and the application will exit.

   Since understanding how document/view clean-up takes place can be
   difficult, the implementation of this function is shown below.

   void wxDocParentFrame::OnCloseWindow(wxCloseEvent& event)
   {
     if (m_docManager->Clear(!event.CanVeto()))
     {
       this->Destroy();
     }
     else
       event.Veto();
   }

=head1 Wx::DocTemplate

=head2 Wx::DocTemplate::m_defaultExt

   wxString m_defaultExt

   The default extension for files of this type.

=head2 Wx::DocTemplate::m_description

   wxString m_description

   A short description of this template.

=head2 Wx::DocTemplate::m_directory

   wxString m_directory

   The default directory for files of this type.

=head2 Wx::DocTemplate::m_docClassInfo

   wxClassInfo* m_docClassInfo

   Run-time class information that allows document instances to be
   constructed dynamically.

=head2 Wx::DocTemplate::m_docTypeName

   wxString m_docTypeName

   The named type of the document associated with this template.

=head2 Wx::DocTemplate::m_documentManager

   wxDocTemplate* m_documentManager

   A pointer to the document manager for which this template was created.

=head2 Wx::DocTemplate::m_fileFilter

   wxString m_fileFilter

   The file filter (such as *.txt) to be used in file selector dialogs.

=head2 Wx::DocTemplate::m_flags

   long m_flags

   The flags passed to the constructor.

=head2 Wx::DocTemplate::m_viewClassInfo

   wxClassInfo* m_viewClassInfo

   Run-time class information that allows view instances to be
   constructed dynamically.

=head2 Wx::DocTemplate::m_viewTypeName

   wxString m_viewTypeName

   The named type of the view associated with this template.

=head2 Wx::DocTemplate::new

   wxDocTemplate(wxDocManager* manager, const wxString& descr, const
   wxString& filter, const wxString& dir, const wxString& ext, const
   wxString& docTypeName, const wxString& viewTypeName, wxClassInfo*
   docClassInfo = NULL, wxClassInfo* viewClassInfo = NULL, long flags =
   wxDEFAULT_TEMPLATE_FLAGS)

   Constructor. Create instances dynamically near the start of your
   application after creating a wxDocManager instance, and before doing
   any document or view operations.

   manager is the document manager object which manages this template.

   descr is a short description of what the template is for. This string
   will be displayed in the file filter list of Windows file selectors.

   filter is an appropriate file filter such as *.txt.

   dir is the default directory to use for file selectors.

   ext is the default file extension (such as txt).

   docTypeName is a name that should be unique for a given type of
   document, used for gathering a list of views relevant to a particular
   document.

   viewTypeName is a name that should be unique for a given view.

   docClassInfo is a pointer to the run-time document class information
   as returned by the CLASSINFO macro, e.g. CLASSINFO(MyDocumentClass).
   If this is not supplied, you will need to derive a new wxDocTemplate
   class and override the CreateDocument member to return a new document
   instance on demand.

   viewClassInfo is a pointer to the run-time view class information as
   returned by the CLASSINFO macro, e.g. CLASSINFO(MyViewClass). If this
   is not supplied, you will need to derive a new wxDocTemplate class and
   override the CreateView member to return a new view instance on
   demand.

   flags is a bit list of the following:

=head2 Wx::DocTemplate::DESTROY

   void ~wxDocTemplate()

   Destructor.

=head2 Wx::DocTemplate::CreateDocument

   wxDocument * CreateDocument(const wxString& path, long flags = 0)

   Creates a new instance of the associated document class. If you have
   not supplied a wxClassInfo parameter to the template constructor, you
   will need to override this function to return an appropriate document
   instance.

   This function calls wxDocTemplate::InitDocument which in turns calls
   wxDocument::OnCreate.

=head2 Wx::DocTemplate::CreateView

   wxView * CreateView(wxDocument *doc, long flags = 0)

   Creates a new instance of the associated view class. If you have not
   supplied a wxClassInfo parameter to the template constructor, you will
   need to override this function to return an appropriate view instance.

=head2 Wx::DocTemplate::GetDefaultExtension

   wxString GetDefaultExtension()

   Returns the default file extension for the document data, as passed to
   the document template constructor.

=head2 Wx::DocTemplate::GetDescription

   wxString GetDescription()

   Returns the text description of this template, as passed to the
   document template constructor.

=head2 Wx::DocTemplate::GetDirectory

   wxString GetDirectory()

   Returns the default directory, as passed to the document template
   constructor.

=head2 Wx::DocTemplate::GetDocumentManager

   wxDocManager * GetDocumentManager()

   Returns a pointer to the document manager instance for which this
   template was created.

=head2 Wx::DocTemplate::GetDocumentName

   wxString GetDocumentName()

   Returns the document type name, as passed to the document template
   constructor.

=head2 Wx::DocTemplate::GetFileFilter

   wxString GetFileFilter()

   Returns the file filter, as passed to the document template
   constructor.

=head2 Wx::DocTemplate::GetFlags

   long GetFlags()

   Returns the flags, as passed to the document template constructor.

=head2 Wx::DocTemplate::GetViewName

   wxString GetViewName()

   Returns the view type name, as passed to the document template
   constructor.

=head2 Wx::DocTemplate::InitDocument

   bool InitDocument(wxDocument* doc, const wxString& path, long flags =
   0)

   Initialises the document, calling wxDocument::OnCreate. This is called
   from wxDocTemplate::CreateDocument.

=head2 Wx::DocTemplate::IsVisible

   bool IsVisible()

   Returns true if the document template can be shown in user dialogs,
   false otherwise.

=head2 Wx::DocTemplate::SetDefaultExtension

   void SetDefaultExtension(const wxString& ext)

   Sets the default file extension.

=head2 Wx::DocTemplate::SetDescription

   void SetDescription(const wxString& descr)

   Sets the template description.

=head2 Wx::DocTemplate::SetDirectory

   void SetDirectory(const wxString& dir)

   Sets the default directory.

=head2 Wx::DocTemplate::SetDocumentManager

   void SetDocumentManager(wxDocManager *manager)

   Sets the pointer to the document manager instance for which this
   template was created. Should not be called by the application.

=head2 Wx::DocTemplate::SetFileFilter

   void SetFileFilter(const wxString& filter)

   Sets the file filter.

=head2 Wx::DocTemplate::SetFlags

   void SetFlags(long flags)

   Sets the internal document template flags (see the constructor
   description for more details).

=head1 Wx::Document

=head2 Wx::Document::m_commandProcessor

   wxCommandProcessor* m_commandProcessor

   A pointer to the command processor associated with this document.

=head2 Wx::Document::m_documentFile

   wxString m_documentFile

   Filename associated with this document ("" if none).

=head2 Wx::Document::m_documentModified

   bool m_documentModified

   true if the document has been modified, false otherwise.

=head2 Wx::Document::m_documentTemplate

   wxDocTemplate * m_documentTemplate

   A pointer to the template from which this document was created.

=head2 Wx::Document::m_documentTitle

   wxString m_documentTitle

   Document title. The document title is used for an associated frame (if
   any), and is usually constructed by the framework from the filename.

=head2 Wx::Document::m_documentTypeName

   wxString m_documentTypeName

   The document type name given to the wxDocTemplate constructor, copied
   to this variable when the document is created. If several document
   templates are created that use the same document type, this variable
   is used in wxDocManager::CreateView to collate a list of alternative
   view types that can be used on this kind of document. Do not change
   the value of this variable.

=head2 Wx::Document::m_documentViews

   wxList m_documentViews

   List of wxView instances associated with this document.

=head2 Wx::Document::new

   wxDocument()

   Constructor. Define your own default constructor to initialize
   application-specific data.

=head2 Wx::Document::DESTROY

   ~wxDocument()

   Destructor. Removes itself from the document manager.

=head2 Wx::Document::AddView

   virtual bool AddView(wxView *view)

   If the view is not already in the list of views, adds the view and
   calls OnChangedViewList.

=head2 Wx::Document::Close

   virtual bool Close()

   Closes the document, by calling OnSaveModified and then (if this
   returned true) OnCloseDocument. This does not normally delete the
   document object: use DeleteAllViews to do this implicitly.

=head2 Wx::Document::DeleteAllViews

   virtual bool DeleteAllViews()

   Calls wxView::Close and deletes each view. Deleting the final view
   will implicitly delete the document itself, because the wxView
   destructor calls RemoveView. This in turns calls
   wxDocument::OnChangedViewList, whose default implemention is to save
   and delete the document if no views exist.

=head2 Wx::Document::GetCommandProcessor

   wxCommandProcessor* GetCommandProcessor() const

   Returns a pointer to the command processor associated with this
   document.

   See wxCommandProcessor.

=head2 Wx::Document::GetDocumentTemplate

   wxDocTemplate* GetDocumentTemplate() const

   Gets a pointer to the template that created the document.

=head2 Wx::Document::GetDocumentManager

   wxDocManager* GetDocumentManager() const

   Gets a pointer to the associated document manager.

=head2 Wx::Document::GetDocumentName

   wxString GetDocumentName() const

   Gets the document type name for this document. See the comment for
   documentTypeName.

=head2 Wx::Document::GetDocumentWindow

   wxWindow* GetDocumentWindow() const

   Intended to return a suitable window for using as a parent for
   document-related dialog boxes. By default, uses the frame associated
   with the first view.

=head2 Wx::Document::GetFilename

   wxString GetFilename() const

   Gets the filename associated with this document, or "" if none is
   associated.

=head2 Wx::Document::GetFirstView

   wxView * GetFirstView() const

   A convenience function to get the first view for a document, because
   in many cases a document will only have a single view.

   See also: GetViews

=head2 Wx::Document::GetPrintableName

   virtual void GetPrintableName(wxString& name) const

   Copies a suitable document name into the supplied name buffer. The
   default function uses the title, or if there is no title, uses the
   filename; or if no filename, the string unnamed.

   wxPerl note: In wxPerl this function must return the modified name
   rather than just modifying the argument.

=head2 Wx::Document::GetTitle

   wxString GetTitle() const

   Gets the title for this document. The document title is used for an
   associated frame (if any), and is usually constructed by the framework
   from the filename.

=head2 Wx::Document::GetViews

   wxList & GetViews() const

   Returns the list whose elements are the views on the document.

   See also: GetFirstView

=head2 Wx::Document::IsModified

   virtual bool IsModified() const

   Returns true if the document has been modified since the last save,
   false otherwise. You may need to override this if your document view
   maintains its own record of being modified (for example if using
   wxTextWindow to view and edit the document).

   See also Modify.

=head2 Wx::Document::LoadObject

   virtual istream& LoadObject(istream& stream)

   virtual wxInputStream& LoadObject(wxInputStream& stream)

   Override this function and call it from your own LoadObject before
   streaming your own data. LoadObject is called by the framework
   automatically when the document contents need to be loaded.

   Note that only one of these forms exists, depending on how wxWidgets
   was configured.

=head2 Wx::Document::Modify

   virtual void Modify(bool modify)

   Call with true to mark the document as modified since the last save,
   false otherwise. You may need to override this if your document view
   maintains its own record of being modified (for example if using
   wxTextWindow to view and edit the document).

   See also IsModified.

=head2 Wx::Document::OnChangedViewList

   virtual void OnChangedViewList()

   Called when a view is added to or deleted from this document. The
   default implementation saves and deletes the document if no views
   exist (the last one has just been removed).

=head2 Wx::Document::OnCloseDocument

   virtual bool OnCloseDocument()

   The default implementation calls DeleteContents (an empty
   implementation) sets the modified flag to false. Override this to
   supply additional behaviour when the document is closed with Close.

=head2 Wx::Document::OnCreate

   virtual bool OnCreate(const wxString& path, long flags)

   Called just after the document object is created to give it a chance
   to initialize itself. The default implementation uses the template
   associated with the document to create an initial view. If this
   function returns false, the document is deleted.

=head2 Wx::Document::OnCreateCommandProcessor

   virtual wxCommandProcessor* OnCreateCommandProcessor()

   Override this function if you want a different (or no) command
   processor to be created when the document is created. By default, it
   returns an instance of wxCommandProcessor.

   See wxCommandProcessor.

=head2 Wx::Document::OnNewDocument

   virtual bool OnNewDocument()

   The default implementation calls OnSaveModified and DeleteContents,
   makes a default title for the document, and notifies the views that
   the filename (in fact, the title) has changed.

=head2 Wx::Document::OnOpenDocument

   virtual bool OnOpenDocument(const wxString& filename)

   Constructs an input file stream for the given filename (which must not
   be empty), and calls LoadObject. If LoadObject returns true, the
   document is set to unmodified; otherwise, an error message box is
   displayed. The document's views are notified that the filename has
   changed, to give windows an opportunity to update their titles. All of
   the document's views are then updated.

=head2 Wx::Document::OnSaveDocument

   virtual bool OnSaveDocument(const wxString& filename)

   Constructs an output file stream for the given filename (which must
   not be empty), and calls SaveObject. If SaveObject returns true, the
   document is set to unmodified; otherwise, an error message box is
   displayed.

=head2 Wx::Document::OnSaveModified

   virtual bool OnSaveModified()

   If the document has been modified, prompts the user to ask if the
   changes should be changed. If the user replies Yes, the Save function
   is called. If No, the document is marked as unmodified and the
   function succeeds. If Cancel, the function fails.

=head2 Wx::Document::RemoveView

   virtual bool RemoveView(wxView* view)

   Removes the view from the document's list of views, and calls
   OnChangedViewList.

=head2 Wx::Document::Save

   virtual bool Save()

   Saves the document by calling OnSaveDocument if there is an associated
   filename, or SaveAs if there is no filename.

=head2 Wx::Document::SaveAs

   virtual bool SaveAs()

   Prompts the user for a file to save to, and then calls OnSaveDocument.

=head2 Wx::Document::SaveObject

   virtual ostream& SaveObject(ostream& stream)

   virtual wxOutputStream& SaveObject(wxOutputStream& stream)

   Override this function and call it from your own SaveObject before
   streaming your own data. SaveObject is called by the framework
   automatically when the document contents need to be saved.

   Note that only one of these forms exists, depending on how wxWidgets
   was configured.

=head2 Wx::Document::SetCommandProcessor

   virtual void SetCommandProcessor(wxCommandProcessor *processor)

   Sets the command processor to be used for this document. The document
   will then be responsible for its deletion. Normally you should not
   call this; override OnCreateCommandProcessor instead.

   See wxCommandProcessor.

=head2 Wx::Document::SetDocumentName

   void SetDocumentName(const wxString& name)

   Sets the document type name for this document. See the comment for
   documentTypeName.

=head2 Wx::Document::SetDocumentTemplate

   void SetDocumentTemplate(wxDocTemplate* templ)

   Sets the pointer to the template that created the document. Should
   only be called by the framework.

=head2 Wx::Document::SetFilename

   void SetFilename(const wxString& filename, bool notifyViews = false)

   Sets the filename for this document. Usually called by the framework.

   If notifyViews is true, wxView::OnChangeFilename is called for all
   views.

=head2 Wx::Document::SetTitle

   void SetTitle(const wxString& title)

   Sets the title for this document. The document title is used for an
   associated frame (if any), and is usually constructed by the framework
   from the filename.

=head2 Wx::Document::UpdateAllViews

   void UpdateAllViews(wxView* sender = NULL, wxObject* hint = NULL)

   Updates all views. If sender is non-NULL, does not update this view.

   hint represents optional information to allow a view to optimize its
   update.

=head1 Wx::DragImage

=head2 Wx::DragImage::new

   wxDragImage()

   Default constructor.

   wxDragImage(const wxBitmap& image, const wxCursor& cursor =
   wxNullCursor, const wxPoint& cursorHotspot = wxPoint(0, 0))

   Constructs a drag image from a bitmap and optional cursor.

   wxDragImage(const wxIcon& image, const wxCursor& cursor = wxNullCursor,
   const wxPoint& cursorHotspot = wxPoint(0, 0))

   Constructs a drag image from an icon and optional cursor.

   wxPython note: This constructor is called wxDragIcon in wxPython.

   wxDragImage(const wxString& text, const wxCursor& cursor =
   wxNullCursor, const wxPoint& cursorHotspot = wxPoint(0, 0))

   Constructs a drag image from a text string and optional cursor.

   wxPython note: This constructor is called wxDragString in wxPython.

   wxDragImage(const wxTreeCtrl& treeCtrl, wxTreeItemId& id)

   Constructs a drag image from the text in the given tree control item,
   and optional cursor.

   wxPython note: This constructor is called wxDragTreeItem in wxPython.

   wxDragImage(const wxListCtrl& treeCtrl, long id)

   Constructs a drag image from the text in the given tree control item,
   and optional cursor.

   wxPython note: This constructor is called wxDragListItem in wxPython.

   wxDragImage(const wxCursor& cursor = wxNullCursor, const wxPoint&
   cursorHotspot = wxPoint(0, 0))

   Constructs a drag image an optional cursor. This constructor is only
   available for wxGenericDragImage, and can be used when the application
   supplies wxDragImage::DoDrawImage and wxDragImage::GetImageRect.

   Parameters

   image

       Icon or bitmap to be used as the drag image. The bitmap can have a
       mask.

   text

       Text used to construct a drag image.

   cursor

       Optional cursor to combine with the image.

   hotspot

       This parameter is deprecated.

   treeCtrl

       Tree control for constructing a tree drag image.

   listCtrl

       List control for constructing a list drag image.

   id  

       Tree or list control item id.

=head2 Wx::DragImage::BeginDrag

   bool BeginDrag(const wxPoint& hotspot, wxWindow* window, bool
   fullScreen = false, wxRect* rect = NULL)

   Start dragging the image, in a window or full screen.

   bool BeginDrag(const wxPoint& hotspot, wxWindow* window, wxWindow*
   boundingWindow)

   Start dragging the image, using the first window to capture the mouse
   and the second to specify the bounding area. This form is equivalent
   to using the first form, but more convenient than working out the
   bounding rectangle explicitly.

   You need to then call wxDragImage::Show and wxDragImage::Move to show
   the image on the screen.

   Call wxDragImage::EndDrag when the drag has finished.

   Note that this call automatically calls CaptureMouse.

   Parameters

   hotspot

       The location of the drag position relative to the upper-left
       corner of the image.

   window

       The window that captures the mouse, and within which the dragging
       is limited unless fullScreen is true.

   boundingWindow

       In the second form of the function, specifies the area within
       which the drag occurs.

   fullScreen

       If true, specifies that the drag will be visible over the full
       screen, or over as much of the screen as is specified by rect.
       Note that the mouse will still be captured in window.

   rect

       If non-NULL, specifies the rectangle (in screen coordinates) that
       bounds the dragging operation. Specifying this can make the
       operation more efficient by cutting down on the area under
       consideration, and it can also make a visual difference since the
       drag is clipped to this area.

=head2 Wx::DragImage::DoDrawImage

   virtual bool DoDrawImage(wxDC& dc, const wxPoint& pos)

   Draws the image on the device context with top-left corner at the
   given position.

   This function is only available with wxGenericDragImage, to allow
   applications to draw their own image instead of using an actual
   bitmap. If you override this function, you must also override
   wxDragImage::GetImageRect.

=head2 Wx::DragImage::EndDrag

   bool EndDrag()

   Call this when the drag has finished.

   Note that this call automatically calls ReleaseMouse.

=head2 Wx::DragImage::GetImageRect

   virtual wxRect GetImageRect(const wxPoint& pos) const

   Returns the rectangle enclosing the image, assuming that the image is
   drawn with its top-left corner at the given point.

   This function is available in wxGenericDragImage only, and may be
   overridden (together with wxDragImage::DoDrawImage) to provide a
   virtual drawing capability.

=head2 Wx::DragImage::Hide

   bool Hide()

   Hides the image. You may wish to call this before updating the window
   contents (perhaps highlighting an item). Then call wxDragImage::Move
   and wxDragImage::Show.

=head2 Wx::DragImage::Move

   bool Move(const wxPoint& pt)

   Call this to move the image to a new position. The image will only be
   shown if wxDragImage::Show has been called previously (for example at
   the start of the drag).

   pt is the position in client coordinates (relative to the window
   specified in BeginDrag).

   You can move the image either when the image is hidden or shown, but
   in general dragging will be smoother if you move the image when it is
   shown.

=head2 Wx::DragImage::Show

   bool Show()

   Shows the image. Call this at least once when dragging.

=head2 Wx::DragImage::UpdateBackingFromWindow

   bool UpdateBackingFromWindow(wxDC& windowDC, wxMemoryDC& destDC, const
   wxRect& sourceRect, const wxRect& destRect) const

   Override this if you wish to draw the window contents to the backing
   bitmap yourself. This can be desirable if you wish to avoid flicker by
   not having to redraw the updated window itself just before dragging,
   which can cause a flicker just as the drag starts. Instead, paint the
   drag image's backing bitmap to show the appropriate graphic minus the
   objects to be dragged, and leave the window itself to be updated by
   the drag image. This can provide eerily smooth, flicker-free drag
   behaviour.

   The default implementation copies the window contents to the backing
   bitmap. A new implementation will normally copy information from
   another source, such as from its own backing bitmap if it has one, or
   directly from internal data structures.

   This function is available in wxGenericDragImage only.

=head1 Wx::DropFilesEvent

=head2 Wx::DropFilesEvent::new

   wxDropFilesEvent(WXTYPE id = 0, int noFiles = 0, wxString* files =
   NULL)

   Constructor.

=head2 Wx::DropFilesEvent::m_files

   wxString* m_files

   An array of filenames.

=head2 Wx::DropFilesEvent::m_noFiles

   int m_noFiles

   The number of files dropped.

=head2 Wx::DropFilesEvent::m_pos

   wxPoint m_pos

   The point at which the drop took place.

=head2 Wx::DropFilesEvent::GetFiles

   wxString* GetFiles() const

   Returns an array of filenames.

=head2 Wx::DropFilesEvent::GetNumberOfFiles

   int GetNumberOfFiles() const

   Returns the number of files dropped.

=head2 Wx::DropFilesEvent::GetPosition

   wxPoint GetPosition() const

   Returns the position at which the files were dropped.

   Returns an array of filenames.

=head1 Wx::DropSource

=head2 Wx::DropSource::new

   wxDropSource(wxWindow* win = NULL,const wxIconOrCursor& iconCopy =
   wxNullIconOrCursor, const wxIconOrCursor& iconMove =
   wxNullIconOrCursor, const wxIconOrCursor& iconNone =
   wxNullIconOrCursor)

   wxDropSource(wxDataObject& data, wxWindow* win = NULL,const
   wxIconOrCursor& iconCopy = wxNullIconOrCursor, const wxIconOrCursor&
   iconMove = wxNullIconOrCursor, const wxIconOrCursor& iconNone =
   wxNullIconOrCursor)

   The constructors for wxDataObject.

   If you use the constructor without data parameter you must call
   SetData later.

   Note that the exact type of iconCopy and subsequent parameters differs
   between wxMSW and wxGTK: these are cursors under Windows but icons for
   GTK. You should use the macro wxDROP_ICON in portable programs instead
   of directly using either of these types.

   Parameters

   win 

       The window which initiates the drag and drop operation.

   iconCopy

       The icon or cursor used for feedback for copy operation.

   iconMove

       The icon or cursor used for feedback for move operation.

   iconNone

       The icon or cursor used for feedback when operation can't be done.

   win is the window which initiates the drag and drop operation.

=head2 Wx::DropSource::DESTROY

   virtual ~wxDropSource()

=head2 Wx::DropSource::SetData

   void SetData(wxDataObject& data)

   Sets the data wxDataObject associated with the drop source. This will
   not delete any previously associated data.

=head2 Wx::DropSource::DoDragDrop

   virtual wxDragResult DoDragDrop(int flags = wxDrag_CopyOnly)

   Do it (call this in response to a mouse button press, for example).
   This starts the drag-and-drop operation which will terminate when the
   user releases the mouse.

   Parameters

   flags

       If wxDrag_AllowMove is included in the flags, data may be moved
       and not only copied (default). If wxDrag_DefaultMove is specified
       (which includes the previous flag), this is even the default
       operation

   .

   Return value

   Returns the operation requested by the user, may be wxDragCopy,
   wxDragMove, wxDragLink, wxDragCancel or wxDragNone if an error
   occurred.

=head2 Wx::DropSource::GetDataObject

   wxDataObject * GetDataObject()

   Returns the wxDataObject object that has been assigned previously.

=head2 Wx::DropSource::GiveFeedback

   virtual bool GiveFeedback(wxDragResult effect)

   Overridable: you may give some custom UI feedback during the drag and
   drop operation in this function. It is called on each mouse move, so
   your implementation must not be too slow.

   Parameters

   effect

       The effect to implement. One of wxDragCopy, wxDragMove, wxDragLink
       and wxDragNone.

   scrolling

       true if the window is scrolling. MSW only.

   Return value

   Return false if you want default feedback, or true if you implement
   your own feedback. The return values is ignored under GTK.

=head2 Wx::DropSource::SetCursor

   void SetCursor(wxDragResult res, const wxCursor& cursor)

   Set the icon to use for a certain drag result.

   Parameters

   res 

       The drag result to set the icon for.

   cursor

       The ion to show when this drag result occurs.

=head1 Wx::DropTarget

=head2 Wx::DropTarget::new

   wxDropTarget(wxDataObject* data = NULL)

   Constructor. data is the data to be associated with the drop target.

=head2 Wx::DropTarget::DESTROY

   ~wxDropTarget()

   Destructor. Deletes the associated data object, if any.

=head2 Wx::DropTarget::GetData

   virtual void GetData()

   This method may only be called from within OnData. By default, this
   method copies the data from the drop source to the wxDataObject
   associated with this drop target, calling its wxDataObject::SetData
   method.

=head2 Wx::DropTarget::OnData

   virtual wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def)

   Called after OnDrop returns true. By default this will usually GetData
   and will return the suggested default value def.

=head2 Wx::DropTarget::OnDrop

   virtual bool OnDrop(wxCoord x, wxCoord y)

   Called when the user drops a data object on the target. Return false
   to veto the operation.

   Parameters

   x   

       The x coordinate of the mouse.

   y   

       The y coordinate of the mouse.

   Return value

   Return true to accept the data, false to veto the operation.

=head2 Wx::DropTarget::OnEnter

   virtual wxDragResult OnEnter(wxCoord x, wxCoord y, wxDragResult def)

   Called when the mouse enters the drop target. By default, this calls
   OnDragOver.

   Parameters

   x   

       The x coordinate of the mouse.

   y   

       The y coordinate of the mouse.

   def 

       Suggested default for return value. Determined by SHIFT or CONTROL
       key states.

   Return value

   Returns the desired operation or wxDragNone. This is used for optical
   feedback from the side of the drop source, typically in form of
   changing the icon.

=head2 Wx::DropTarget::OnDragOver

   virtual wxDragResult OnDragOver(wxCoord x, wxCoord y, wxDragResult def)

   Called when the mouse is being dragged over the drop target. By
   default, this calls functions return the suggested return value def.

   Parameters

   x   

       The x coordinate of the mouse.

   y   

       The y coordinate of the mouse.

   def 

       Suggested value for return value. Determined by SHIFT or CONTROL
       key states.

   Return value

   Returns the desired operation or wxDragNone. This is used for optical
   feedback from the side of the drop source, typically in form of
   changing the icon.

=head2 Wx::DropTarget::OnLeave

   virtual void OnLeave()

   Called when the mouse leaves the drop target.

=head2 Wx::DropTarget::SetDataObject

   void SetDataObject(wxDataObject* data)

   Sets the data wxDataObject associated with the drop target and deletes
   any previously associated data object.

=head1 Wx::DynamicLibrary

=head2 Wx::DynamicLibrary::new

   wxDynamicLibrary()

   wxDynamicLibrary(const wxString& name, int flags = wxDL_DEFAULT)

   Constructor. Second form calls Load.

=head2 Wx::DynamicLibrary::CanonicalizeName

   static wxString CanonicalizeName(const wxString& name,
   wxDynamicLibraryCategory cat = wxDL_LIBRARY)

   Returns the platform-specific full name for the library called name.
   E.g. it adds a ".dll" extension under Windows and "lib" prefix and
   ".so", ".sl" or maybe ".dylib" extension under Unix.

   The possible values for cat are:

=head2 Wx::DynamicLibrary::CanonicalizePluginName

   static wxString CanonicalizePluginName(const wxString& name,
   wxPluginCategory cat = wxDL_PLUGIN_GUI)

   This function does the same thing as CanonicalizeName but for
   wxWidgets plugins. The only difference is that compiler and version
   information are added to the name to ensure that the plugin which is
   going to be loaded will be compatible with the main program.

   The possible values for cat are:

=head2 Wx::DynamicLibrary::Detach

   wxDllType Detach()

   Detaches this object from its library handle, i.e. the object will not
   unload the library any longer in its destructor but it is now the
   callers responsibility to do this using Unload.

=head2 Wx::DynamicLibrary::GetSymbol

   void * GetSymbol(const wxString& name) const

   Returns pointer to symbol name in the library or NULL if the library
   contains no such symbol.

   See also

   wxDYNLIB_FUNCTION

=head2 Wx::DynamicLibrary::GetSymbolAorW

   void * GetSymbolAorW(const wxString& name) const

   This function is available only under Windows as it is only useful
   when dynamically loading symbols from standard Windows DLLs. Such
   functions have either 'A' (in ANSI build) or 'W' (in Unicode, or wide
   character build) suffix if they take string parameters. Using this
   function you can use just the base name of the function and the
   correct suffix is appende automatically depending on the current
   build. Otherwise, this method is identical to GetSymbol.

=head2 Wx::DynamicLibrary::GetProgramHandle

   static wxDllType GetProgramHandle()

   Return a valid handle for the main program itself or NULL if symbols
   from the main program can't be loaded on this platform.

=head2 Wx::DynamicLibrary::HasSymbol

   bool HasSymbol(const wxString& name) const

   Returns true if the symbol with the given name is present in the
   dynamic library, false otherwise. Unlike GetSymbol, this function
   doesn't log an error message if the symbol is not found.

   This function is new since wxWidgets version 2.5.4

=head2 Wx::DynamicLibrary::IsLoaded

   bool IsLoaded() const

   Returns true if the library was successfully loaded, false otherwise.

=head2 Wx::DynamicLibrary::ListLoaded

   static wxDynamicLibraryDetailsArray ListLoaded()

   This static method returns an array containing the details of all
   modules loaded into the address space of the current project, the
   array elements are object of wxDynamicLibraryDetails class. The array
   will be empty if an error occurred.

   This method is currently implemented only under Win32 and Linux and is
   useful mostly for diagnostics purposes.

=head2 Wx::DynamicLibrary::Load

   bool Load(const wxString& name, int flags = wxDL_DEFAULT)

   Loads DLL with the given name into memory. The flags argument can be a
   combination of the following bits:

=head2 Wx::DynamicLibrary::Unload

   void Unload()

   static void Unload(wxDllType handle)

   Unloads the library from memory. wxDynamicLibrary object automatically
   calls this method from its destructor if it had been successfully
   loaded.

   The second version is only used if you need to keep the library in
   memory during a longer period of time than the scope of the
   wxDynamicLibrary object. In this case you may call Detach and store
   the handle somewhere and call this static method later to unload it.

=head1 Wx::DynamicLibraryDetails

=head2 Wx::DynamicLibraryDetails::GetName

   wxString GetName() const

   Returns the base name of this module, e.g. kernel32.dll or
   libc-2.3.2.so.

=head2 Wx::DynamicLibraryDetails::GetPath

   wxString GetPath() const

   Returns the full path of this module if available, e.g.
   c:\windows\system32\kernel32.dll or /lib/libc-2.3.2.so.

=head2 Wx::DynamicLibraryDetails::GetAddress

   bool GetAddress(void **addr, size_t *len) const

   Retrieves the load address and the size of this module.

   Parameters

   addr

       the pointer to the location to return load address in, may be NULL

   len 

       pointer to the location to return the size of this module in
       memory in, may be NULL

   Return value

   true if the load address and module size were retrieved, false if this
   information is not available.

=head2 Wx::DynamicLibraryDetails::GetVersion

   wxString GetVersion() const

   Returns the version of this module, e.g. 5.2.3790.0 or 2.3.2. The
   returned string is empty if the version information is not available.

=head1 Wx::EncodingConverter

=head2 Wx::EncodingConverter::new

   wxEncodingConverter()

   Constructor.

=head2 Wx::EncodingConverter::Init

   bool Init(wxFontEncoding input_enc, wxFontEncoding output_enc, int
   method = wxCONVERT_STRICT)

   Initialize conversion. Both output or input encoding may be
   wxFONTENCODING_UNICODE, but only if wxUSE_ENCODING is set to 1. All
   subsequent calls to Convert() will interpret its argument as a string
   in input_enc encoding and will output string in output_enc encoding.
   You must call this method before calling Convert. You may call it more
   than once in order to switch to another conversion. Method affects
   behaviour of Convert() in case input character cannot be converted
   because it does not exist in output encoding:

=head2 Wx::EncodingConverter::CanConvert

   static bool CanConvert(wxFontEncoding encIn, wxFontEncoding encOut)

   Return true if (any text in) multibyte encoding encIn can be converted
   to another one (encOut) losslessly.

   Do not call this method with wxFONTENCODING_UNICODE as either
   parameter, it doesn't make sense (always works in one sense and always
   depends on the text to convert in the other).

=head2 Wx::EncodingConverter::Convert

   bool Convert(const char* input, char* output) const

   bool Convert(const wchar_t* input, wchar_t* output) const

   bool Convert(const char* input, wchar_t* output) const

   bool Convert(const wchar_t* input, char* output) const

   Convert input string according to settings passed to Init and writes
   the result to output.

   bool Convert(char* str) const

   bool Convert(wchar_t* str) const

   Convert input string according to settings passed to Init in-place,
   i.e. write the result to the same memory area.

   All of the versions above return true if the conversion was lossless
   and false if at least one of the characters couldn't be converted and
   was replaced with '?' in the output. Note that if wxCONVERT_SUBSTITUTE
   was passed to Init, substitution is considered lossless operation.

   wxString Convert(const wxString& input) const

   Convert wxString and return new wxString object.

   Notes

   You must call Init before using this method!

   wchar_t versions of the method are not available if wxWidgets was
   compiled with wxUSE_WCHAR_T set to 0.

=head2 Wx::EncodingConverter::GetPlatformEquivalents

   static wxFontEncodingArray GetPlatformEquivalents(wxFontEncoding enc,
   int platform = wxPLATFORM_CURRENT)

   Return equivalents for given font that are used under given platform.
   Supported platforms:

=head2 Wx::EncodingConverter::GetAllEquivalents

   static wxFontEncodingArray GetAllEquivalents(wxFontEncoding enc)

   Similar to GetPlatformEquivalents, but this one will return ALL
   equivalent encodings, regardless of the platform, and including
   itself.

   This platform's encodings are before others in the array. And again,
   if enc is in the array, it is the very first item in it.

=head1 Wx::EraseEvent

=head2 Wx::EraseEvent::new

   wxEraseEvent(int id = 0, wxDC* dc = NULL)

   Constructor.

=head2 Wx::EraseEvent::GetDC

   wxDC* GetDC() const

   Returns the device context associated with the erase event to draw on.

=head1 Wx::Event

=head2 Wx::Event::new

   wxEvent(int id = 0, wxEventType eventType = wxEVT_NULL)

   Constructor. Should not need to be used directly by an application.

=head2 Wx::Event::m_propagationLevel



=head2 Wx::Event::Clone

   virtual wxEvent* Clone() const

   Returns a copy of the event.

   Any event that is posted to the wxWidgets event system for later
   action (via wxEvtHandler::AddPendingEvent or wxPostEvent) must
   implement this method. All wxWidgets events fully implement this
   method, but any derived events implemented by the user should also
   implement this method just in case they (or some event derived from
   them) are ever posted.

   All wxWidgets events implement a copy constructor, so the easiest way
   of implementing the Clone function is to implement a copy constructor
   for a new event (call it MyEvent) and then define the Clone function
   like this:

       wxEvent *Clone(void) const { return new MyEvent(*this); }

=head2 Wx::Event::GetEventObject

   wxObject* GetEventObject()

   Returns the object (usually a window) associated with the event, if
   any.

=head2 Wx::Event::GetEventType

   wxEventType GetEventType()

   Returns the identifier of the given event type, such as
   wxEVT_COMMAND_BUTTON_CLICKED.

=head2 Wx::Event::GetId

   int GetId() const

   Returns the identifier associated with this event, such as a button
   command id.

=head2 Wx::Event::GetSkipped

   bool GetSkipped() const

   Returns true if the event handler should be skipped, false otherwise.

=head2 Wx::Event::GetTimestamp

   long GetTimestamp()

   Gets the timestamp for the event. The timestamp is the time in
   milliseconds since some fixed moment (not necessarily the standard
   Unix Epoch, so only differences between the timestamps and not their
   absolute values usually make sense).

=head2 Wx::Event::IsCommandEvent

   bool IsCommandEvent() const

   Returns true if the event is or is derived from wxCommandEvent else it
   returns false. Note: Exists only for optimization purposes.

=head2 Wx::Event::ResumePropagation

   void ResumePropagation(int propagationLevel)

   Sets the propagation level to the given value (for example returned
   from an earlier call to StopPropagation).

=head2 Wx::Event::SetEventObject

   void SetEventObject(wxObject* object)

   Sets the originating object.

=head2 Wx::Event::SetEventType

   void SetEventType(wxEventType type)

   Sets the event type.

=head2 Wx::Event::SetId

   void SetId(int id)

   Sets the identifier associated with this event, such as a button
   command id.

=head2 Wx::Event::SetTimestamp

   void SetTimestamp(long timeStamp)

   Sets the timestamp for the event.

=head2 Wx::Event::ShouldPropagate

   bool ShouldPropagate() const

   Test if this event should be propagated or not, i.e. if the
   propagation level is currently greater than 0.

=head2 Wx::Event::Skip

   void Skip(bool skip = true)

   This method can be used inside an event handler to control whether
   further event handlers bound to this event will be called after the
   current one returns. Without Skip() (or equivalently if Skip(false) is
   used), the event will not be processed any more. If Skip(true) is
   called, the event processing system continues searching for a further
   handler function for this event, even though it has been processed
   already in the current handler.

   In general, it is recommended to skip all non-command events to allow
   the default handling to take place. The command events are, however,
   normally not skipped as usually a single command such as a button
   click or menu item selection must only be processed by one handler.

=head2 Wx::Event::StopPropagation

   int StopPropagation()

   Stop the event from propagating to its parent window.

   Returns the old propagation level value which may be later passed to
   ResumePropagation to allow propagating the event again.

=head1 Wx::EvtHandler

=head2 Wx::EvtHandler::new

   wxEvtHandler()

   Constructor.

=head2 Wx::EvtHandler::DESTROY

   ~wxEvtHandler()

   Destructor. If the handler is part of a chain, the destructor will
   unlink itself and restore the previous and next handlers so that they
   point to each other.

=head2 Wx::EvtHandler::AddPendingEvent

   void AddPendingEvent(wxEvent& event)

   This function posts an event to be processed later.

   Parameters

   event

       Event to add to process queue.

   Remarks

   The difference between sending an event (using the ProcessEvent
   method) and posting it is that in the first case the event is
   processed before the function returns, while in the second case, the
   function returns immediately and the event will be processed sometime
   later (usually during the next event loop iteration).

   A copy of event is made by the function, so the original can be
   deleted as soon as function returns (it is common that the original is
   created on the stack). This requires that the wxEvent::Clone method be
   implemented by event so that it can be duplicated and stored until it
   gets processed.

   This is also the method to call for inter-thread communication---it
   will post events safely between different threads which means that
   this method is thread-safe by using critical sections where needed. In
   a multi-threaded program, you often need to inform the main GUI thread
   about the status of other working threads and such notification should
   be done using this method.

   This method automatically wakes up idle handling if the underlying
   window system is currently idle and thus would not send any idle
   events. (Waking up idle handling is done calling ::wxWakeUpIdle.)

=head2 Wx::EvtHandler::Connect

   void Connect(int id, int lastId, wxEventType eventType,
   wxObjectEventFunction function, wxObject* userData = NULL,
   wxEvtHandler* eventSink = NULL)

   void Connect(int id, wxEventType eventType, wxObjectEventFunction
   function, wxObject* userData = NULL, wxEvtHandler* eventSink = NULL)

   void Connect(wxEventType eventType, wxObjectEventFunction function,
   wxObject* userData = NULL, wxEvtHandler* eventSink = NULL)

   Connects the given function dynamically with the event handler, id and
   event type. This is an alternative to the use of static event tables.
   See the 'event' or the old 'dynamic' sample for usage.

   Parameters

   id  

       The identifier (or first of the identifier range) to be associated
       with the event handler function. For the version not taking this
       argument, it defaults to wxID_ANY.

   lastId

       The second part of the identifier range to be associated with the
       event handler function.

   eventType

       The event type to be associated with this event handler.

   function

       The event handler function. Note that this function should be
       explicitly converted to the correct type which can be done using a
       macro called wxFooHandler for the handler for any wxFooEvent.

   userData

       Data to be associated with the event table entry.

   eventSink

       Object whose member function should be called. If this is NULL,
       this will be used.

   Example

     frame->Connect( wxID_EXIT,
       wxEVT_COMMAND_MENU_SELECTED,
       wxCommandEventHandler(MyFrame::OnQuit) );

   wxPerl note: In wxPerl this function takes 4 arguments: id, lastid,
   type, method; if method is undef, the handler is disconnected.

=head2 Wx::EvtHandler::Disconnect

   bool Disconnect(wxEventType eventType = wxEVT_NULL,
   wxObjectEventFunction function = NULL, wxObject* userData = NULL,
   wxEvtHandler* eventSink = NULL)

   bool Disconnect(int id = wxID_ANY, wxEventType eventType = wxEVT_NULL,
   wxObjectEventFunction function = NULL, wxObject* userData = NULL,
   wxEvtHandler* eventSink = NULL)

   bool Disconnect(int id, int lastId = wxID_ANY, wxEventType eventType =
   wxEVT_NULL, wxObjectEventFunction function = NULL, wxObject* userData
   = NULL, wxEvtHandler* eventSink = NULL)

   Disconnects the given function dynamically from the event handler,
   using the specified parameters as search criteria and returning true
   if a matching function has been found and removed. This method can
   only disconnect functions which have been added using the
   wxEvtHandler::Connect method. There is no way to disconnect functions
   connected using the (static) event tables.

   Parameters

   id  

       The identifier (or first of the identifier range) associated with
       the event handler function.

   lastId

       The second part of the identifier range associated with the event
       handler function.

   eventType

       The event type associated with this event handler.

   function

       The event handler function.

   userData

       Data associated with the event table entry.

   eventSink

       Object whose member function should be called.

   wxPerl note: In wxPerl this function takes 3 arguments: id, lastid,
   type.

=head2 Wx::EvtHandler::GetClientData

   void* GetClientData()

   Gets user-supplied client data.

   Remarks

   Normally, any extra data the programmer wishes to associate with the
   object should be made available by deriving a new class with new data
   members.

   See also

   wxEvtHandler::SetClientData

=head2 Wx::EvtHandler::GetClientObject

   wxClientData* GetClientObject() const

   Get a pointer to the user-supplied client data object.

   See also

   wxEvtHandler::SetClientObject, wxClientData

=head2 Wx::EvtHandler::GetEvtHandlerEnabled

   bool GetEvtHandlerEnabled()

   Returns true if the event handler is enabled, false otherwise.

   See also

   wxEvtHandler::SetEvtHandlerEnabled

=head2 Wx::EvtHandler::GetNextHandler

   wxEvtHandler* GetNextHandler()

   Gets the pointer to the next handler in the chain.

   See also

   wxEvtHandler::SetNextHandler, wxEvtHandler::GetPreviousHandler,
   wxEvtHandler::SetPreviousHandler, wxWindow::PushEventHandler,
   wxWindow::PopEventHandler

=head2 Wx::EvtHandler::GetPreviousHandler

   wxEvtHandler* GetPreviousHandler()

   Gets the pointer to the previous handler in the chain.

   See also

   wxEvtHandler::SetPreviousHandler, wxEvtHandler::GetNextHandler,
   wxEvtHandler::SetNextHandler, wxWindow::PushEventHandler,
   wxWindow::PopEventHandler

=head2 Wx::EvtHandler::ProcessEvent

   virtual bool ProcessEvent(wxEvent& event)

   Processes an event, searching event tables and calling zero or more
   suitable event handler function(s).

   Parameters

   event

       Event to process.

   Return value

   true if a suitable event handler function was found and executed, and
   the function did not call wxEvent::Skip.

   Remarks

   Normally, your application would not call this function: it is called
   in the wxWidgets implementation to dispatch incoming user interface
   events to the framework (and application).

   However, you might need to call it if implementing new functionality
   (such as a new control) where you define new event types, as opposed
   to allowing the user to override virtual functions.

   An instance where you might actually override the ProcessEvent
   function is where you want to direct event processing to event
   handlers not normally noticed by wxWidgets. For example, in the
   document/view architecture, documents and views are potential event
   handlers. When an event reaches a frame, ProcessEvent will need to be
   called on the associated document and view in case event handler
   functions are associated with these objects. The property classes
   library (wxProperty) also overrides ProcessEvent for similar reasons.

   The normal order of event table searching is as follows:

=head2 Wx::EvtHandler::SearchEventTable

   virtual bool SearchEventTable(wxEventTable& table, wxEvent& event)

   Searches the event table, executing an event handler function if an
   appropriate one is found.

   Parameters

   table

       Event table to be searched.

   event

       Event to be matched against an event table entry.

   Return value

   true if a suitable event handler function was found and executed, and
   the function did not call wxEvent::Skip.

   Remarks

   This function looks through the object's event table and tries to find
   an entry that will match the event.

   An entry will match if:

=head2 Wx::EvtHandler::SetClientData

   void SetClientData(void* data)

   Sets user-supplied client data.

   Parameters

   data

       Data to be associated with the event handler.

   Remarks

   Normally, any extra data the programmer wishes to associate with the
   object should be made available by deriving a new class with new data
   members. You must not call this method and SetClientObject on the same
   class - only one of them.

   See also

   wxEvtHandler::GetClientData

=head2 Wx::EvtHandler::SetClientObject

   void SetClientObject(wxClientData* data)

   Set the client data object. Any previous object will be deleted.

   See also

   wxEvtHandler::GetClientObject, wxClientData

=head2 Wx::EvtHandler::SetEvtHandlerEnabled

   void SetEvtHandlerEnabled(bool enabled)

   Enables or disables the event handler.

   Parameters

   enabled

       true if the event handler is to be enabled, false if it is to be
       disabled.

   Remarks

   You can use this function to avoid having to remove the event handler
   from the chain, for example when implementing a dialog editor and
   changing from edit to test mode.

   See also

   wxEvtHandler::GetEvtHandlerEnabled

=head2 Wx::EvtHandler::SetNextHandler

   void SetNextHandler(wxEvtHandler* handler)

   Sets the pointer to the next handler.

   Parameters

   handler

       Event handler to be set as the next handler.

   See also

   wxEvtHandler::GetNextHandler, wxEvtHandler::SetPreviousHandler,
   wxEvtHandler::GetPreviousHandler, wxWindow::PushEventHandler,
   wxWindow::PopEventHandler

=head2 Wx::EvtHandler::SetPreviousHandler

   void SetPreviousHandler(wxEvtHandler* handler)

   Sets the pointer to the previous handler.

   Parameters

   handler

       Event handler to be set as the previous handler.

   See also

   wxEvtHandler::GetPreviousHandler, wxEvtHandler::SetNextHandler,
   wxEvtHandler::GetNextHandler, wxWindow::PushEventHandler,
   wxWindow::PopEventHandler

=head1 Wx::FFile

=head2 Wx::FFile::new

   wxFFile()

   Default constructor.

   wxFFile(const char* filename, const char* mode = "r")

   Opens a file with the given mode. As there is no way to return whether
   the operation was successful or not from the constructor you should
   test the return value of IsOpened to check that it didn't fail.

   wxFFile(FILE* fp)

   Opens a file with the given file pointer, which has already been
   opened.

   Parameters

   filename

       The filename.

   mode

       The mode in which to open the file using standard C strings. Note
       that you should use "b" flag if you use binary files under Windows
       or the results might be unexpected due to automatic newline
       conversion done for the text files.

   fp  

       An existing file descriptor, such as stderr.

=head2 Wx::FFile::DESTROY

   ~wxFFile()

   Destructor will close the file.

   NB: it is not virtual so you should not derive from wxFFile!

=head2 Wx::FFile::Attach

   void Attach(FILE* fp)

   Attaches an existing file pointer to the wxFFile object.

   The descriptor should be already opened and it will be closed by
   wxFFile object.

=head2 Wx::FFile::Close

   bool Close()

   Closes the file and returns true on success.

=head2 Wx::FFile::Detach

   void Detach()

   Get back a file pointer from wxFFile object -- the caller is
   responsible for closing the file if this descriptor is opened.
   IsOpened() will return false after call to Detach().

=head2 Wx::FFile::fp

   FILE * fp() const

   Returns the file pointer associated with the file.

=head2 Wx::FFile::Eof

   bool Eof() const

   Returns true if the an attempt has been made to read past the end of
   the file.

   Note that the behaviour of the file descriptor based class wxFile is
   different as wxFile::Eof will return true here as soon as the last
   byte of the file has been read.

   Also note that this method may only be called for opened files and may
   crash if the file is not opened.

   See also

   IsOpened

=head2 Wx::FFile::Error

   Returns true if an error has occurred on this file, similar to the
   standard ferror() function.

   Please note that this method may only be called for opened files and
   may crash if the file is not opened.

   See also

   IsOpened

=head2 Wx::FFile::Flush

   bool Flush()

   Flushes the file and returns true on success.

=head2 Wx::FFile::GetKind

   wxFileKind GetKind() const

   Returns the type of the file. Possible return values are:

   enum wxFileKind
   {
     wxFILE_KIND_UNKNOWN,
     wxFILE_KIND_DISK,     // a file supporting seeking to arbitrary offsets
     wxFILE_KIND_TERMINAL, // a tty
     wxFILE_KIND_PIPE      // a pipe
   };

=head2 Wx::FFile::IsOpened

   bool IsOpened() const

   Returns true if the file is opened. Most of the methods of this class
   may only be used for an opened file.

=head2 Wx::FFile::Length

   wxFileOffset Length() const

   Returns the length of the file.

=head2 Wx::FFile::Open

   bool Open(const char* filename, const char* mode = "r")

   Opens the file, returning true if successful.

   Parameters

   filename

       The filename.

   mode

       The mode in which to open the file.

=head2 Wx::FFile::Read

   size_t Read(void* buffer, size_t count)

   Reads the specified number of bytes into a buffer, returning the
   actual number read.

   Parameters

   buffer

       A buffer to receive the data.

   count

       The number of bytes to read.

   Return value

   The number of bytes read.

=head2 Wx::FFile::ReadAll

   bool ReadAll(wxString * str, wxMBConv& conv = wxConvUTF8)

   Reads the entire contents of the file into a string.

   Parameters

   str 

       String to read data into.

   conv

       Conversion object to use in Unicode build; by default supposes
       that file contents is encoded in UTF-8.

   Return value

   true if file was read successfully, false otherwise.

=head2 Wx::FFile::Seek

   bool Seek(wxFileOffset ofs, wxSeekMode mode = wxFromStart)

   Seeks to the specified position and returns true on success.

   Parameters

   ofs 

       Offset to seek to.

   mode

       One of wxFromStart, wxFromEnd, wxFromCurrent.

=head2 Wx::FFile::SeekEnd

   bool SeekEnd(wxFileOffset ofs = 0)

   Moves the file pointer to the specified number of bytes before the end
   of the file and returns true on success.

   Parameters

   ofs 

       Number of bytes before the end of the file.

=head2 Wx::FFile::Tell

   wxFileOffset Tell() const

   Returns the current position.

=head2 Wx::FFile::Write

   size_t Write(const void* buffer, size_t count)

   Writes the specified number of bytes from a buffer.

   Parameters

   buffer

       A buffer containing the data.

   count

       The number of bytes to write.

   Return value

   Number of bytes written.

=head2 Wx::FFile::Write

   bool Write(const wxString& s, wxMBConv& conv = wxConvUTF8)

   Writes the contents of the string to the file, returns true on
   success.

   The second argument is only meaningful in Unicode build of wxWidgets
   when conv is used to convert s to multibyte representation.

=head1 Wx::FFileInputStream

=head2 Wx::FFileInputStream::new

   wxFFileInputStream(const wxString& filename, const wxChar * mode =
   "rb")

   Opens the specified file using its filename name using the specified
   mode.

   wxFFileInputStream(wxFFile& file)

   Initializes a file stream in read-only mode using the file I/O object
   file.

   wxFFileInputStream(FILE * fp)

   Initializes a file stream in read-only mode using the specified file
   pointer fp.

=head2 Wx::FFileInputStream::DESTROY

   ~wxFFileInputStream()

   Destructor.

=head2 Wx::FFileInputStream::IsOk

   bool IsOk() const

   Returns true if the stream is initialized and ready.

=head1 Wx::FFileOutputStream

=head2 Wx::FFileOutputStream::new

   wxFFileOutputStream(const wxString& filename, const wxChar *
   mode="w+b")

   Opens the file with the given filename name in the specified mode.

   wxFFileOutputStream(wxFFile& file)

   Initializes a file stream in write-only mode using the file I/O object
   file.

   wxFFileOutputStream(FILE * fp)

   Initializes a file stream in write-only mode using the file descriptor
   fp.

=head2 Wx::FFileOutputStream::DESTROY

   ~wxFFileOutputStream()

   Destructor.

=head2 Wx::FFileOutputStream::IsOk

   bool IsOk() const

   Returns true if the stream is initialized and ready.

=head1 Wx::FFileStream

=head2 Wx::FFileStream::new

   wxFFileStream(const wxString& iofileName)

   Initializes a new file stream in read-write mode using the specified
   iofilename name.

=head1 Wx::File

=head2 Wx::File::new

   wxFile()

   Default constructor.

   wxFile(const char* filename, wxFile::OpenMode mode = wxFile::read)

   Opens a file with the given mode. As there is no way to return whether
   the operation was successful or not from the constructor you should
   test the return value of IsOpened to check that it didn't fail.

   wxFile(int fd)

   Associates the file with the given file descriptor, which has already
   been opened.

   Parameters

   filename

       The filename.

   mode

       The mode in which to open the file. May be one of wxFile::read,
       wxFile::write and wxFile::read_write.

   fd  

       An existing file descriptor (see Attach() for the list of
       predefined descriptors)

=head2 Wx::File::DESTROY

   ~wxFile()

   Destructor will close the file.

   NB: it is not virtual so you should not use wxFile polymorphically.

=head2 Wx::File::Access

   static bool Access(const char * name, OpenMode mode)

   This function verifies if we may access the given file in specified
   mode. Only values of wxFile::read or wxFile::write really make sense
   here.

=head2 Wx::File::Attach

   void Attach(int fd)

   Attaches an existing file descriptor to the wxFile object. Example of
   predefined file descriptors are 0, 1 and 2 which correspond to stdin,
   stdout and stderr (and have symbolic names of wxFile::fd_stdin,
   wxFile::fd_stdout and wxFile::fd_stderr).

   The descriptor should be already opened and it will be closed by
   wxFile object.

=head2 Wx::File::Close

   void Close()

   Closes the file.

=head2 Wx::File::Create

   bool Create(const char* filename, bool overwrite = false, int access =
   wxS_DEFAULT)

   Creates a file for writing. If the file already exists, setting
   overwrite to true will ensure it is overwritten.

=head2 Wx::File::Detach

   void Detach()

   Get back a file descriptor from wxFile object - the caller is
   responsible for closing the file if this descriptor is opened.
   IsOpened() will return false after call to Detach().

=head2 Wx::File::fd

   int fd() const

   Returns the file descriptor associated with the file.

=head2 Wx::File::Eof

   bool Eof() const

   Returns true if the end of the file has been reached.

   Note that the behaviour of the file pointer based class wxFFile is
   different as wxFFile::Eof will return true here only if an attempt has
   been made to read past the last byte of the file, while wxFile::Eof()
   will return true even before such attempt is made if the file pointer
   is at the last position in the file.

   Note also that this function doesn't work on unseekable file
   descriptors (examples include pipes, terminals and sockets under Unix)
   and an attempt to use it will result in an error message in such case.
   So, to read the entire file into memory, you should write a loop which
   uses Read repeatedly and tests its return condition instead of using
   Eof() as this will not work for special files under Unix.

=head2 Wx::File::Exists

   static bool Exists(const char* filename)

   Returns true if the given name specifies an existing regular file (not
   a directory or a link)

=head2 Wx::File::Flush

   bool Flush()

   Flushes the file descriptor.

   Note that wxFile::Flush is not implemented on some Windows compilers
   due to a missing fsync function, which reduces the usefulness of this
   function (it can still be called but it will do nothing on unsupported
   compilers).

=head2 Wx::File::GetKind

   wxFileKind GetKind() const

   Returns the type of the file. Possible return values are:

   enum wxFileKind
   {
     wxFILE_KIND_UNKNOWN,
     wxFILE_KIND_DISK,     // a file supporting seeking to arbitrary offsets
     wxFILE_KIND_TERMINAL, // a tty
     wxFILE_KIND_PIPE      // a pipe
   };

=head2 Wx::File::IsOpened

   bool IsOpened() const

   Returns true if the file has been opened.

=head2 Wx::File::Length

   wxFileOffset Length() const

   Returns the length of the file.

=head2 Wx::File::Open

   bool Open(const char* filename, wxFile::OpenMode mode = wxFile::read)

   Opens the file, returning true if successful.

   Parameters

   filename

       The filename.

   mode

       The mode in which to open the file. May be one of wxFile::read,
       wxFile::write and wxFile::read_write.

=head2 Wx::File::Read

   size_t Read(void* buffer, size_t count)

   Reads the specified number of bytes into a buffer, returning the
   actual number read.

   Parameters

   buffer

       A buffer to receive the data.

   count

       The number of bytes to read.

   Return value

   The number of bytes read, or the symbol wxInvalidOffset (-1) if there
   was an error.

=head2 Wx::File::Seek

   wxFileOffset Seek(wxFileOffset ofs, wxSeekMode mode = wxFromStart)

   Seeks to the specified position.

   Parameters

   ofs 

       Offset to seek to.

   mode

       One of wxFromStart, wxFromEnd, wxFromCurrent.

   Return value

   The actual offset position achieved, or wxInvalidOffset on failure.

=head2 Wx::File::SeekEnd

   wxFileOffset SeekEnd(wxFileOffset ofs = 0)

   Moves the file pointer to the specified number of bytes relative to
   the end of the file. For example, SeekEnd(-5) would position the
   pointer 5 bytes before the end.

   Parameters

   ofs 

       Number of bytes before the end of the file.

   Return value

   The actual offset position achieved, or wxInvalidOffset on failure.

=head2 Wx::File::Tell

   wxFileOffset Tell() const

   Returns the current position or wxInvalidOffset if file is not opened
   or if another error occurred.

=head2 Wx::File::Write

   size_t Write(const void* buffer, size_t count)

   Writes the specified number of bytes from a buffer.

   Parameters

   buffer

       A buffer containing the data.

   count

       The number of bytes to write.

   Return value

   the number of bytes actually written

=head2 Wx::File::Write

   bool Write(const wxString& s, wxMBConv& conv = wxConvUTF8)

   Writes the contents of the string to the file, returns true on
   success.

   The second argument is only meaningful in Unicode build of wxWidgets
   when conv is used to convert s to multibyte representation.

   Note that this method only works with NUL-terminated strings, if you
   want to write data with embedded NULs to the file you should use the
   other Write() overload.

=head1 Wx::FileConfig

=head2 Wx::FileConfig::new

   wxFileConfig(wxInputStream& is, wxMBConv& conv = wxConvUTF8)

   Read the config data from the specified stream instead of the
   associated file, as usual.

   See also

   Save

=head2 Wx::FileConfig::Save

   bool Save(wxOutputStream& os, wxMBConv& conv = wxConvUTF8)

   Saves all config data to the given stream, returns true if data was
   saved successfully or false on error.

   Note the interaction of this function with the internal "dirty flag'':
   the data is saved unconditionally, i.e. even if the object is not
   dirty. However after saving it successfully, the dirty flag is reset
   so no changes will be written back to the file this object is
   associated with until you change its contents again.

   See also

   Flush

=head2 Wx::FileConfig::SetUmask

   void SetUmask(int mode)

   Allows to set the mode to be used for the config file creation. For
   example, to create a config file which is not readable by other users
   (useful if it stores some sensitive information, such as passwords),
   you could use SetUmask(0077).

   This function doesn't do anything on non-Unix platforms.

   See also

   wxCHANGE_UMASK

=head1 Wx::FileDataObject

=head2 Wx::FileDataObject

   wxFileDataObject()

   Constructor.

=head2 Wx::FileDataObject::AddFile

   virtual void AddFile(const wxString& file)

   MSW only: adds a file to the file list represented by this data
   object.

=head2 Wx::FileDataObject::GetFilenames

   const wxArrayString& GetFilenames() const

   Returns the array of file names.

=head1 Wx::FileDialog

=head2 Wx::FileDialog::new

   wxFileDialog(wxWindow* parent, const wxString& message = "Choose a
   file", const wxString& defaultDir = "", const wxString& defaultFile =
   "", const wxString& wildcard = "*.*", long style = wxFD_DEFAULT_STYLE,
   const wxPoint& pos = wxDefaultPosition, const wxSize& sz =
   wxDefaultSize, const wxString& name = "filedlg")

   Constructor. Use wxFileDialog::ShowModal to show the dialog.

   Parameters

   parent

       Parent window.

   message

       Message to show on the dialog.

   defaultDir

       The default directory, or the empty string.

   defaultFile

       The default filename, or the empty string.

   wildcard

       A wildcard, such as "*.*" or "BMP files (*.bmp)|*.bmp|GIF files
       (*.gif)|*.gif".

       Note that the native Motif dialog has some limitations with
       respect to wildcards; see the Remarks section above.

   style

       A dialog style. See wxFD_* styles for more info.

   pos 

       Dialog position. Not implemented.

   size

       Dialog size. Not implemented.

   name

       Dialog name. Not implemented.

=head2 Wx::FileDialog::DESTROY

   ~wxFileDialog()

   Destructor.

=head2 Wx::FileDialog::GetDirectory

   wxString GetDirectory() const

   Returns the default directory.

=head2 Wx::FileDialog::GetFilename

   wxString GetFilename() const

   Returns the default filename.

=head2 Wx::FileDialog::GetFilenames

   void GetFilenames(wxArrayString& filenames) const

   Fills the array filenames with the names of the files chosen. This
   function should only be used with the dialogs which have wxFD_MULTIPLE
   style, use GetFilename for the others.

   Note that under Windows, if the user selects shortcuts, the filenames
   include paths, since the application cannot determine the full path of
   each referenced file by appending the directory containing the
   shortcuts to the filename.

=head2 Wx::FileDialog::GetFilterIndex

   int GetFilterIndex() const

   Returns the index into the list of filters supplied, optionally, in
   the wildcard parameter. Before the dialog is shown, this is the index
   which will be used when the dialog is first displayed. After the
   dialog is shown, this is the index selected by the user.

=head2 Wx::FileDialog::GetMessage

   wxString GetMessage() const

   Returns the message that will be displayed on the dialog.

=head2 Wx::FileDialog::GetPath

   wxString GetPath() const

   Returns the full path (directory and filename) of the selected file.

=head2 Wx::FileDialog::GetPaths

   void GetPaths(wxArrayString& paths) const

   Fills the array paths with the full paths of the files chosen. This
   function should only be used with the dialogs which have wxFD_MULTIPLE
   style, use GetPath for the others.

=head2 Wx::FileDialog::GetWildcard

   wxString GetWildcard() const

   Returns the file dialog wildcard.

=head2 Wx::FileDialog::SetDirectory

   void SetDirectory(const wxString& directory)

   Sets the default directory.

=head2 Wx::FileDialog::SetFilename

   void SetFilename(const wxString& setfilename)

   Sets the default filename.

=head2 Wx::FileDialog::SetFilterIndex

   void SetFilterIndex(int filterIndex)

   Sets the default filter index, starting from zero.

=head2 Wx::FileDialog::SetMessage

   void SetMessage(const wxString& message)

   Sets the message that will be displayed on the dialog.

=head2 Wx::FileDialog::SetPath

   void SetPath(const wxString& path)

   Sets the path (the combined directory and filename that will be
   returned when the dialog is dismissed).

=head2 Wx::FileDialog::SetWildcard

   void SetWildcard(const wxString& wildCard)

   Sets the wildcard, which can contain multiple file types, for example:

   "BMP files (*.bmp)|*.bmp|GIF files (*.gif)|*.gif"

   Note that the native Motif dialog has some limitations with respect to
   wildcards; see the Remarks section above.

=head2 Wx::FileDialog::ShowModal

   int ShowModal()

   Shows the dialog, returning wxID_OK if the user pressed OK, and
   wxID_CANCEL otherwise.

=head1 Wx::FileDropTarget

=head2 Wx::FileDropTarget::new

   wxFileDropTarget()

   Constructor.

=head2 Wx::FileDropTarget::OnDrop

   virtual bool OnDrop(long x, long y, const void *data, size_t size)

   See wxDropTarget::OnDrop. This function is implemented appropriately
   for files, and calls wxFileDropTarget::OnDropFiles.

=head2 Wx::FileDropTarget::OnDropFiles

   virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString&
   filenames)

   Override this function to receive dropped files.

   Parameters

   x   

       The x coordinate of the mouse.

   y   

       The y coordinate of the mouse.

   filenames

       An array of filenames.

   Return value

   Return true to accept the data, false to veto the operation.

=head1 Wx::FileHistory

=head2 Wx::FileHistory::m_fileHistory

   char** m_fileHistory

   A character array of strings corresponding to the most recently opened
   files.

=head2 Wx::FileHistory::m_fileHistoryN

   size_t m_fileHistoryN

   The number of files stored in the history array.

=head2 Wx::FileHistory::m_fileMaxFiles

   size_t m_fileMaxFiles

   The maximum number of files to be stored and displayed on the menu.

=head2 Wx::FileHistory::m_fileMenu

   wxMenu* m_fileMenu

   The file menu used to display the file history list (if enabled).

=head2 Wx::FileHistory::new

   wxFileHistory(size_t maxFiles = 9, wxWindowID idBase = wxID_FILE1)

   Constructor. Pass the maximum number of files that should be stored
   and displayed.

   idBase defaults to wxID_FILE1 and represents the id given to the first
   history menu item. Since menu items can't share the same ID you should
   change idBase (To one of your own defined IDs) when using more than
   one wxFileHistory in your application.

=head2 Wx::FileHistory::DESTROY

   ~wxFileHistory()

   Destructor.

=head2 Wx::FileHistory::AddFileToHistory

   void AddFileToHistory(const wxString& filename)

   Adds a file to the file history list, if the object has a pointer to
   an appropriate file menu.

=head2 Wx::FileHistory::AddFilesToMenu

   void AddFilesToMenu()

   Appends the files in the history list, to all menus managed by the
   file history object.

   void AddFilesToMenu(wxMenu* menu)

   Appends the files in the history list, to the given menu only.

=head2 Wx::FileHistory::GetBaseId

   wxWindowID GetBaseId() const

   Returns the base identifier for the range used for appending items.

=head2 Wx::FileHistory::GetCount

   size_t GetCount() const

   Returns the number of files currently stored in the file history.

=head2 Wx::FileHistory::GetHistoryFile

   wxString GetHistoryFile(size_t index) const

   Returns the file at this index (zero-based).

=head2 Wx::FileHistory::GetMaxFiles

   int GetMaxFiles() const

   Returns the maximum number of files that can be stored.

=head2 Wx::FileHistory::GetMenus

   const wxList& GetMenus() const

   Returns the list of menus that are managed by this file history
   object.

   See also

   wxFileHistory::UseMenu

=head2 Wx::FileHistory::Load

   void Load(wxConfigBase& config)

   Loads the file history from the given config object. This function
   should be called explicitly by the application.

   See also

   wxConfig

=head2 Wx::FileHistory::RemoveFileFromHistory

   void RemoveFileFromHistory(size_t i)

   Removes the specified file from the history.

=head2 Wx::FileHistory::RemoveMenu

   void RemoveMenu(wxMenu* menu)

   Removes this menu from the list of those managed by this object.

=head2 Wx::FileHistory::Save

   void Save(wxConfigBase& config)

   Saves the file history into the given config object. This must be
   called explicitly by the application.

   See also

   wxConfig

=head2 Wx::FileHistory::SetBaseId

   void SetBaseId(wxWindowID baseId)

   Sets the base identifier for the range used for appending items.

=head2 Wx::FileHistory::UseMenu

   void UseMenu(wxMenu* menu)

   Adds this menu to the list of those menus that are managed by this
   file history object. Also see AddFilesToMenu() for initializing the
   menu with filenames that are already in the history when this function
   is called, as this is not done automatically.

=head1 Wx::FileInputStream

=head2 Wx::FileInputStream::new

   wxFileInputStream(const wxString& ifileName)

   Opens the specified file using its ifilename name in read-only mode.

   wxFileInputStream(wxFile& file)

   Initializes a file stream in read-only mode using the file I/O object
   file.

   wxFileInputStream(int fd)

   Initializes a file stream in read-only mode using the specified file
   descriptor.

=head2 Wx::FileInputStream::DESTROY

   ~wxFileInputStream()

   Destructor.

=head2 Wx::FileInputStream::IsOk

   bool IsOk() const

   Returns true if the stream is initialized and ready.

=head1 Wx::FileName

=head2 File name format

   wxFileName currently supports the file names in the Unix, DOS/Windows,
   Mac OS and VMS formats. Although these formats are quite different,
   wxFileName tries to treat them all in the same generic way. It
   supposes that all file names consist of the following parts: the
   volume (also known as drive under Windows or device under VMS), the
   path which is a sequence of directory names separated by the path
   separators and the full filename itself which, in turn, is composed
   from the base file name and the extension. All of the individual
   components of the file name may be empty and, for example, the volume
   name is always empty under Unix, but if they are all empty
   simultaneously, the filename object is considered to be in an invalid
   state and IsOk returns false for it.

   File names can be case-sensitive or not, the function IsCaseSensitive
   allows to determine this.

   The rules for determining whether the file name is absolute or
   relative also depend on the file name format and the only portable way
   to answer this question is to use IsAbsolute or IsRelative method.
   Note that on Windows, "X:" refers to the current working directory on
   drive X. Therefore, a wxFileName instance constructed from for example
   "X:dir/file.ext" treats the portion beyond drive separator as being
   relative to that directory.

   To ensure that the filename is absolute, you may use MakeAbsolute.
   There is also an inverse function MakeRelativeTo which undoes what
   Normalize(wxPATH_NORM_DOTS) does.

   Other functions returning information about the file format provided
   by this class are GetVolumeSeparator, IsPathSeparator.

=head2 File name construction

   You can initialize a wxFileName instance using one of the following
   functions:

   wxFileName constructors

=head2 File tests

   Before doing other tests, you should use IsOk to verify that the
   filename is well defined. If it is, FileExists can be used to test
   whether a file with such name exists and DirExists can be used to test
   for directory existence.

   File names should be compared using SameAs method or operator ==.

   For testing basic access modes, you can use:

   IsDirWritable

=head2 File name components

   These functions allow to examine and modify the individual directories
   of the path:

   AppendDir

=head2 Operations

   These methods allow to work with the file creation, access and
   modification times. Note that not all filesystems under all platforms
   implement these times in the same way. For example, the access time
   under Windows has a resolution of one day (so it is really the access
   date and not time). The access time may be updated when the file is
   executed or not depending on the platform.

   GetModificationTime

=head2 Wx::FileName::new

   wxFileName()

   Default constructor.

   wxFileName(const wxFileName& filename)

   Copy constructor.

   wxFileName(const wxString& fullpath, wxPathFormat format =
   wxPATH_NATIVE)

   Constructor taking a full filename. If it terminates with a '/', a
   directory path is constructed (the name will be empty), otherwise a
   file name and extension are extracted from it.

   wxFileName(const wxString& path, const wxString& name, wxPathFormat
   format = wxPATH_NATIVE)

   Constructor from a directory name and a file name.

   wxFileName(const wxString& path, const wxString& name, const wxString&
   ext, wxPathFormat format = wxPATH_NATIVE)

   Constructor from a directory name, base file name and extension.

   wxFileName(const wxString& volume, const wxString& path, const
   wxString& name, const wxString& ext, wxPathFormat format =
   wxPATH_NATIVE)

   Constructor from a volume name, a directory name, base file name and
   extension.

=head2 Wx::FileName::AppendDir

   void AppendDir(const wxString& dir)

   Appends a directory component to the path. This component should
   contain a single directory name level, i.e. not contain any path or
   volume separators nor should it be empty, otherwise the function does
   nothing (and generates an assert failure in debug build).

=head2 Wx::FileName::Assign

   void Assign(const wxFileName& filepath)

   void Assign(const wxString& fullpath, wxPathFormat format =
   wxPATH_NATIVE)

   void Assign(const wxString& volume, const wxString& path, const
   wxString& name, const wxString& ext, bool hasExt, wxPathFormat format
   = wxPATH_NATIVE)

   void Assign(const wxString& volume, const wxString& path, const
   wxString& name, const wxString& ext, wxPathFormat format =
   wxPATH_NATIVE)

   void Assign(const wxString& path, const wxString& name, wxPathFormat
   format = wxPATH_NATIVE)

   void Assign(const wxString& path, const wxString& name, const wxString&
   ext, wxPathFormat format = wxPATH_NATIVE)

   Creates the file name from various combinations of data.

=head2 Wx::FileName::AssignCwd

   static void AssignCwd(const wxString& volume = wxEmptyString)

   Makes this object refer to the current working directory on the
   specified volume (or current volume if volume is empty).

   See also

   GetCwd

=head2 Wx::FileName::AssignDir

   void AssignDir(const wxString& dir, wxPathFormat format =
   wxPATH_NATIVE)

   Sets this file name object to the given directory name. The name and
   extension will be empty.

=head2 Wx::FileName::AssignHomeDir

   void AssignHomeDir()

   Sets this file name object to the home directory.

=head2 Wx::FileName::AssignTempFileName

   void AssignTempFileName(const wxString& prefix, wxFile *fileTemp =
   NULL)

   The function calls CreateTempFileName to create a temporary file and
   sets this object to the name of the file. If a temporary file couldn't
   be created, the object is put into the invalid state.

=head2 Wx::FileName::Clear

   void Clear()

   Reset all components to default, uninitialized state.

=head2 Wx::FileName::ClearExt

   void SetClearExt()

   Removes the extension from the file name resulting in a file name with
   no trailing dot.

   See also

   SetExt SetEmptyExt

=head2 Wx::FileName::CreateTempFileName

   static wxString CreateTempFileName(const wxString& prefix, wxFile *fileTemp
   = NULL)

   Returns a temporary file name starting with the given prefix. If the
   prefix is an absolute path, the temporary file is created in this
   directory, otherwise it is created in the default system directory for
   the temporary files or in the current directory.

   If the function succeeds, the temporary file is actually created. If
   fileTemp is not NULL, this file will be opened using the name of the
   temporary file. When possible, this is done in an atomic way ensuring
   that no race condition occurs between the temporary file name
   generation and opening it which could often lead to security
   compromise on the multiuser systems. If fileTemp is NULL, the file is
   only created, but not opened.

   Under Unix, the temporary file will have read and write permissions
   for the owner only to minimize the security problems.

   Parameters

   prefix

       Prefix to use for the temporary file name construction

   fileTemp

       The file to open or NULL to just get the name

   Return value

   The full temporary file name or an empty string on error.

=head2 Wx::FileName::DirExists

   bool DirExists() const

   static bool DirExists(const wxString& dir)

   Returns true if the directory with this name exists.

=head2 Wx::FileName::DirName

   static wxFileName DirName(const wxString& dir, wxPathFormat format =
   wxPATH_NATIVE)

   Returns the object corresponding to the directory with the given name.
   The dir parameter may have trailing path separator or not.

=head2 Wx::FileName::FileExists

   bool FileExists() const

   static bool FileExists(const wxString& file)

   Returns true if the file with this name exists.

   See also

   DirExists

=head2 Wx::FileName::FileName

   static wxFileName FileName(const wxString& file, wxPathFormat format =
   wxPATH_NATIVE)

   Returns the file name object corresponding to the given file. This
   function exists mainly for symmetry with DirName.

=head2 Wx::FileName::GetCwd

   static wxString GetCwd(const wxString& volume = "")

   Retrieves the value of the current working directory on the specified
   volume. If the volume is empty, the program's current working
   directory is returned for the current volume.

   Return value

   The string containing the current working directory or an empty string
   on error.

   See also

   AssignCwd

=head2 Wx::FileName::GetDirCount

   size_t GetDirCount() const

   Returns the number of directories in the file name.

=head2 Wx::FileName::GetDirs

   const wxArrayString& GetDirs() const

   Returns the directories in string array form.

=head2 Wx::FileName::GetExt

   wxString GetExt() const

   Returns the file name extension.

=head2 Wx::FileName::GetForbiddenChars

   static wxString GetForbiddenChars(wxPathFormat format = wxPATH_NATIVE)

   Returns the characters that can't be used in filenames and directory
   names for the specified format.

=head2 Wx::FileName::GetFormat

   static wxPathFormat GetFormat(wxPathFormat format = wxPATH_NATIVE)

   Returns the canonical path format for this platform.

=head2 Wx::FileName::GetFullName

   wxString GetFullName() const

   Returns the full name (including extension but excluding directories).

=head2 Wx::FileName::GetFullPath

   wxString GetFullPath(wxPathFormat format = wxPATH_NATIVE) const

   Returns the full path with name and extension.

=head2 Wx::FileName::GetHomeDir

   static wxString GetHomeDir()

   Returns the home directory.

=head2 Wx::FileName::GetLongPath

   wxString GetLongPath() const

   Return the long form of the path (returns identity on non-Windows
   platforms)

=head2 Wx::FileName::GetModificationTime

   wxDateTime GetModificationTime() const

   Returns the last time the file was last modified.

=head2 Wx::FileName::GetName

   wxString GetName() const

   Returns the name part of the filename (without extension).

   See also

   GetFullName

=head2 Wx::FileName::GetPath

   wxString GetPath(int flags = wxPATH_GET_VOLUME, wxPathFormat format =
   wxPATH_NATIVE) const

   Returns the path part of the filename (without the name or extension).
   The possible flags values are:

=head2 Wx::FileName::GetPathSeparator

   static wxChar GetPathSeparator(wxPathFormat format = wxPATH_NATIVE)

   Returns the usually used path separator for this format. For all
   formats but wxPATH_DOS there is only one path separator anyhow, but
   for DOS there are two of them and the native one, i.e. the backslash
   is returned by this method.

   See also

   GetPathSeparators

=head2 Wx::FileName::GetPathSeparators

   static wxString GetPathSeparators(wxPathFormat format = wxPATH_NATIVE)

   Returns the string containing all the path separators for this format.
   For all formats but wxPATH_DOS this string contains only one character
   but for DOS and Windows both '/' and '\' may be used as separators.

   See also

   GetPathSeparator

=head2 Wx::FileName::GetPathTerminators

   static wxString GetPathTerminators(wxPathFormat format = wxPATH_NATIVE)

   Returns the string of characters which may terminate the path part.
   This is the same as GetPathSeparators except for VMS path format where
   ] is used at the end of the path part.

=head2 Wx::FileName::GetPathWithSep

   wxString GetPathWithSep(wxPathFormat format = wxPATH_NATIVE) const

   Returns the path with the trailing separator, useful for appending the
   name to the given path.

   This is the same as calling GetPath (wxPATH_GET_VOLUME |
   wxPATH_GET_SEPARATOR, format).

=head2 Wx::FileName::GetShortPath

   wxString GetShortPath() const

   Return the short form of the path (returns identity on non-Windows
   platforms).

=head2 Wx::FileName::GetSize

   wxULongLong GetSize() const

   static wxULongLong GetSize(const wxString& filename)

   Returns the size of this file (first form) or the size of the given
   file (second form). If the file does not exist or its size could not
   be read (because e.g. the file is locked by another process) the
   returned value is wxInvalidSize.

=head2 Wx::FileName::GetHumanReadableSize

   wxString GetHumanReadableSize(const wxString& failmsg = "Not
   available", int precision = 1) const

   static wxString GetHumanReadableSize(const wxULongLong& bytes, const
   wxString& nullsize = "Not available", int precision = 1)

   Returns the size of this file (first form) or the given number of
   bytes (second form) in a human-readable form.

   If the size could not be retrieved the failmsg string is returned
   (first form). If bytes is wxInvalidSize or zero, then nullsize is
   returned (second form).

   In case of success, the returned string is a floating-point number
   with precision decimal digits followed by the size unit (B, kB, MB,
   GB, TB: respectively bytes, kilobytes, megabytes, gigabytes,
   terabytes).

=head2 Wx::FileName::GetTempDir

   static wxString GetTempDir()

   Returns the directory used for temporary files.

=head2 Wx::FileName::GetTimes

   bool GetTimes(wxDateTime* dtAccess, wxDateTime* dtMod, wxDateTime*
   dtCreate) const

   Returns the last access, last modification and creation times. The
   last access time is updated whenever the file is read or written (or
   executed in the case of Windows), last modification time is only
   changed when the file is written to. Finally, the creation time is
   indeed the time when the file was created under Windows and the inode
   change time under Unix (as it is impossible to retrieve the real file
   creation time there anyhow) which can also be changed by many
   operations after the file creation.

   If no filename or extension is specified in this instance of
   wxFileName (and therefore IsDir returns true) then this function will
   return the directory times of the path specified by GetPath, otherwise
   the file times of the file specified by GetFullPath.

   Any of the pointers may be NULL if the corresponding time is not
   needed.

   Return value

   true on success, false if we failed to retrieve the times.

=head2 Wx::FileName::GetVolume

   wxString GetVolume() const

   Returns the string containing the volume for this file name, empty if
   it doesn't have one or if the file system doesn't support volumes at
   all (for example, Unix).

=head2 Wx::FileName::GetVolumeSeparator

   static wxString GetVolumeSeparator(wxPathFormat format = wxPATH_NATIVE)

   Returns the string separating the volume from the path for this
   format.

=head2 Wx::FileName::HasExt

   bool HasExt() const

   Returns true if an extension is present.

=head2 Wx::FileName::HasName

   bool HasName() const

   Returns true if a name is present.

=head2 Wx::FileName::HasVolume

   bool HasVolume() const

   Returns true if a volume specifier is present.

=head2 Wx::FileName::InsertDir

   void InsertDir(size_t before, const wxString& dir)

   Inserts a directory component before the zero-based position in the
   directory list. Please see AppendDir for important notes.

=head2 Wx::FileName::IsAbsolute

   bool IsAbsolute(wxPathFormat format = wxPATH_NATIVE)

   Returns true if this filename is absolute.

=head2 Wx::FileName::IsCaseSensitive

   static bool IsCaseSensitive(wxPathFormat format = wxPATH_NATIVE)

   Returns true if the file names of this type are case-sensitive.

=head2 Wx::FileName::IsDirReadable

   bool IsDirReadable() const

   static bool IsDirReadable(const wxString& dir)

   Returns true if the directory component of this instance (or given dir)
   is an existing directory and this process has read permissions on it.
   Read permissions on a directory mean that you can list the directory
   contents but it doesn't imply that you have read permissions on the
   files contained.

=head2 Wx::FileName::IsDirWritable

   bool IsDirWritable() const

   static bool IsDirWritable(const wxString& dir)

   Returns true if the directory component of this instance (or given dir)
   is an existing directory and this process has write permissions on it.
   Write permissions on a directory mean that you can create new files in
   the directory.

=head2 Wx::FileName::IsFileExecutable

   bool IsFileExecutable() const

   static bool IsFileExecutable(const wxString& file)

   Returns true if a file with this name exists and if this process has
   execute permissions on it.

=head2 Wx::FileName::IsFileReadable

   bool IsFileReadable() const

   static bool IsFileReadable(const wxString& file)

   Returns true if a file with this name exists and if this process has
   read permissions on it.

=head2 Wx::FileName::IsFileWritable

   bool IsFileWritable() const

   static bool IsFileWritable(const wxString& file)

   Returns true if a file with this name exists and if this process has
   write permissions on it.

=head2 Wx::FileName::IsOk

   bool IsOk() const

   Returns true if the filename is valid, false if it is not initialized
   yet. The assignment functions and Clear may reset the object to the
   uninitialized, invalid state (the former only do it on failure).

=head2 Wx::FileName::IsPathSeparator

   static bool IsPathSeparator(wxChar ch, wxPathFormat format =
   wxPATH_NATIVE)

   Returns true if the char is a path separator for this format.

=head2 Wx::FileName::IsRelative

   bool IsRelative(wxPathFormat format = wxPATH_NATIVE)

   Returns true if this filename is not absolute.

=head2 Wx::FileName::IsDir

   bool IsDir() const

   Returns true if this object represents a directory, false otherwise
   (i.e. if it is a file). Note that this method doesn't test whether the
   directory or file really exists, you should use DirExists or
   FileExists for this.

=head2 Wx::FileName::MacFindDefaultTypeAndCreator

   static bool MacFindDefaultTypeAndCreator(const wxString& ext,
   wxUint32* type, wxUint32* creator)

   On Mac OS, gets the common type and creator for the given extension.

=head2 Wx::FileName::MacRegisterDefaultTypeAndCreator

   static void MacRegisterDefaultTypeAndCreator(const wxString& ext,
   wxUint32 type, wxUint32 creator)

   On Mac OS, registers application defined extensions and their default
   type and creator.

=head2 Wx::FileName::MacSetDefaultTypeAndCreator

   bool MacSetDefaultTypeAndCreator()

   On Mac OS, looks up the appropriate type and creator from the
   registration and then sets it.

=head2 Wx::FileName::MakeAbsolute

   bool MakeAbsolute(const wxString& cwd = wxEmptyString, wxPathFormat
   format = wxPATH_NATIVE)

   Make the file name absolute. This is a shortcut for Normalize(wxPATH_NORM_DOTS
   | wxPATH_NORM_ABSOLUTE | wxPATH_NORM_TILDE, cwd, format).

   See also

   MakeRelativeTo, Normalize, IsAbsolute

=head2 Wx::FileName::MakeRelativeTo

   bool MakeRelativeTo(const wxString& pathBase = wxEmptyString,
   wxPathFormat format = wxPATH_NATIVE)

   This function tries to put this file name in a form relative to
   pathBase. In other words, it returns the file name which should be
   used to access this file if the current directory were pathBase.

   pathBase

       the directory to use as root, current directory is used by default

   format

       the file name format, native by default

   Return value

   true if the file name has been changed, false if we failed to do
   anything with it (currently this only happens if the file name is on a
   volume different from the volume specified by pathBase).

   See also

   Normalize

=head2 Wx::FileName::Mkdir

   bool Mkdir(int perm = 0777, int flags = 0)

   static bool Mkdir(const wxString& dir, int perm = 0777, int flags = 0)

   dir 

       the directory to create

   parm

       the permissions for the newly created directory

   flags

       if the flags contain wxPATH_MKDIR_FULL flag, try to create each
       directory in the path and also don't return an error if the target
       directory already exists.

   Return value

   Returns true if the directory was successfully created, false
   otherwise.

=head2 Wx::FileName::Normalize

   bool Normalize(int flags = wxPATH_NORM_ALL, const wxString& cwd =
   wxEmptyString, wxPathFormat format = wxPATH_NATIVE)

   Normalize the path. With the default flags value, the path will be
   made absolute, without any ".." and "." and all environment variables
   will be expanded in it.

   flags

       The kind of normalization to do with the file name. It can be any
       or-combination of the following constants:

=head2 Wx::FileName::PrependDir

   void PrependDir(const wxString& dir)

   Prepends a directory to the file path. Please see AppendDir for
   important notes.

=head2 Wx::FileName::RemoveDir

   void RemoveDir(size_t pos)

   Removes the specified directory component from the path.

   See also

   GetDirCount

=head2 Wx::FileName::RemoveLastDir

   void RemoveLastDir()

   Removes last directory component from the path.

=head2 Wx::FileName::Rmdir

   bool Rmdir()

   static bool Rmdir(const wxString& dir)

   Deletes the specified directory from the file system.

=head2 Wx::FileName::SameAs

   bool SameAs(const wxFileName& filepath, wxPathFormat format =
   wxPATH_NATIVE) const

   Compares the filename using the rules of this platform.

=head2 Wx::FileName::SetCwd

   bool SetCwd()

   static bool SetCwd(const wxString& cwd)

   Changes the current working directory.

=head2 Wx::FileName::SetExt

   void SetExt(const wxString& ext)

   Sets the extension of the file name. Setting an empty string as the
   extension will remove the extension resulting in a file name without a
   trailing dot, unlike a call to SetEmptyExt.

   See also

   SetEmptyExt ClearExt

=head2 Wx::FileName::SetEmptyExt

   void SetEmptyExt()

   Sets the extension of the file name to be an empty extension. This is
   different from having no extension at all as the file name will have a
   trailing dot after a call to this method.

   See also

   SetExt ClearExt

=head2 Wx::FileName::SetFullName

   void SetFullName(const wxString& fullname)

   The full name is the file name and extension (but without the path).

=head2 Wx::FileName::SetName

   void SetName(const wxString& name)

   Sets the name part (without extension).

   See also

   SetFullName

=head2 Wx::FileName::SetTimes

   bool SetTimes(const wxDateTime* dtAccess, const wxDateTime* dtMod,
   const wxDateTime* dtCreate)

   Sets the file creation and last access/modification times (any of the
   pointers may be NULL).

=head2 Wx::FileName::SetVolume

   void SetVolume(const wxString& volume)

   Sets the volume specifier.

=head2 Wx::FileName::SplitPath

   static void SplitPath(const wxString& fullpath, wxString* volume,
   wxString* path, wxString* name, wxString* ext, bool *hasExt = NULL,
   wxPathFormat format = wxPATH_NATIVE)

   static void SplitPath(const wxString& fullpath, wxString* volume,
   wxString* path, wxString* name, wxString* ext, wxPathFormat format =
   wxPATH_NATIVE)

   static void SplitPath(const wxString& fullpath, wxString* path,
   wxString* name, wxString* ext, wxPathFormat format = wxPATH_NATIVE)

   This function splits a full file name into components: the volume
   (with the first version) path (including the volume in the second
   version), the base name and the extension. Any of the output
   parameters (volume, path, name or ext) may be NULL if you are not
   interested in the value of a particular component. Also, fullpath may
   be empty on entry.

   On return, path contains the file path (without the trailing
   separator), name contains the file name and ext contains the file
   extension without leading dot. All three of them may be empty if the
   corresponding component is. The old contents of the strings pointed to
   by these parameters will be overwritten in any case (if the pointers
   are not NULL).

   Note that for a filename "foo.'' the extension is present, as
   indicated by the trailing dot, but empty. If you need to cope with
   such cases, you should use hasExt instead of relying on testing
   whether ext is empty or not.

=head2 Wx::FileName::SplitVolume

   static void SplitVolume(const wxString& fullpath, wxString* volume,
   wxString* path, wxPathFormat format = wxPATH_NATIVE)

   Splits the given fullpath into the volume part (which may be empty)
   and the pure path part, not containing any volume.

   See also

   SplitPath

=head2 Wx::FileName::Touch

   bool Touch()

   Sets the access and modification times to the current moment.

=head1 Wx::FileOutputStream

=head2 Wx::FileOutputStream::new

   wxFileOutputStream(const wxString& ofileName)

   Creates a new file with ofilename name and initializes the stream in
   write-only mode.

   wxFileOutputStream(wxFile& file)

   Initializes a file stream in write-only mode using the file I/O object
   file.

   wxFileOutputStream(int fd)

   Initializes a file stream in write-only mode using the file descriptor
   fd.

=head2 Wx::FileOutputStream::DESTROY

   ~wxFileOutputStream()

   Destructor.

=head2 Wx::FileOutputStream::IsOk

   bool IsOk() const

   Returns true if the stream is initialized and ready.

=head1 Wx::FilePickerCtrl

=head2 Wx::FilePickerCtrl::new

   wxFilePickerCtrl(wxWindow *parent, wxWindowID id, const wxString& path
   = wxEmptyString, const wxString& message = "Select a file", const
   wxString& wildcard = "*.*", const wxPoint& pos = wxDefaultPosition,
   const wxSize& size = wxDefaultSize, long style = wxFLP_DEFAULT_STYLE,
   const wxValidator& validator = wxDefaultValidator, const wxString&
   name = "filepickerctrl")

   Initializes the object and calls Create with all the parameters.

=head2 Wx::FilePickerCtrl::Create

   bool Create(wxWindow *parent, wxWindowID id, const wxString& path =
   wxEmptyString, const wxString& message = "Select a file", const
   wxString& wildcard = "*.*", const wxPoint& pos = wxDefaultPosition,
   const wxSize& size = wxDefaultSize, long style = wxFLP_DEFAULT_STYLE,
   const wxValidator& validator = wxDefaultValidator, const wxString&
   name = "filepickerctrl")

   Parameters

   parent

       Parent window, must not be non-NULL.

   id  

       The identifier for the control.

   path

       The initial file shown in the control. Must be a valid path to a
       file or the empty string.

   message

       The message shown to the user in the wxFileDialog shown by the
       control.

   wildcard

       A wildcard which defines user-selectable files (use the same
       syntax as for wxFileDialog's wildcards).

   pos 

       Initial position.

   size

       Initial size.

   style

       The window style, see wxFLP_* flags.

   validator

       Validator which can be used for additional date checks.

   name

       Control name.

   Return value

   true if the control was successfully created or false if creation
   failed.

=head2 Wx::FilePickerCtrl::GetPath

   wxString GetPath() const

   Returns the absolute path of the currently selected file.

=head2 Wx::FilePickerCtrl::SetPath

   void SetPath(const wxString &filename)

   Sets the absolute path of the currently selected file. This must be a
   valid file if the wxFLP_FILE_MUST_EXIST style was given.

=head1 Wx::FileDirPickerEvent

=head2 Wx::FileDirPickerEvent::new

   wxFileDirPickerEvent(wxEventType type, wxObject * generator, int id,
   const wxString path)

   The constructor is not normally used by the user code.

=head2 Wx::FileDirPickerEvent::GetPath

   wxString GetPath() const

   Retrieve the absolute path of the file/directory the user has just
   selected.

=head2 Wx::FileDirPickerEvent::SetPath

   void SetPath(const wxString &path)

   Set the absolute path of the file/directory associated with the event.

=head1 Wx::FileStream

=head2 Wx::FileStream::new

   wxFileStream(const wxString& iofileName)

   Initializes a new file stream in read-write mode using the specified
   iofilename name.

=head1 Wx::FileSystem

=head2 Wx::FileSystem::new

   wxFileSystem()

   Constructor.

=head2 Wx::FileSystem::AddHandler

   static void AddHandler(wxFileSystemHandler *handler)

   This static function adds new handler into the list of handlers which
   provide access to virtual FS. Note that if two handlers for the same
   protocol are added, the last one added takes precedence.

   Note

   You can call:

   wxFileSystem::AddHandler(new My_FS_Handler);

   This is because (a) AddHandler is a static method, and (b) the
   handlers are deleted in wxFileSystem's destructor so that you don't
   have to care about it.

=head2 Wx::FileSystem::HasHandlerForPath

   static bool HasHandlerForPath(const wxString & location)

   This static function returns true if there is a registered handler
   which can open the given location.

=head2 Wx::FileSystem::ChangePathTo

   void ChangePathTo(const wxString& location, bool is_dir = false)

   Sets the current location. location parameter passed to OpenFile is
   relative to this path.

   Caution! Unless is_dir is true the location parameter is not the
   directory name but the name of the file in this directory. All these
   commands change the path to "dir/subdir/":

     ChangePathTo("dir/subdir/xh.htm");
     ChangePathTo("dir/subdir", true);
     ChangePathTo("dir/subdir/", true);

   Parameters

   location

       the new location. Its meaning depends on the value of is_dir

   is_dir

       if true location is new directory. If false (default) location is
       file in the new directory.

   Example

     f = fs -> OpenFile("hello.htm"); // opens file 'hello.htm'
     fs -> ChangePathTo("subdir/folder", true);
     f = fs -> OpenFile("hello.htm"); // opens file 'subdir/folder/hello.htm' !!

=head2 Wx::FileSystem::GetPath

   wxString GetPath()

   Returns actual path (set by ChangePathTo).

=head2 Wx::FileSystem::FileNameToURL

   static wxString FileNameToURL(wxFileName filename)

   Converts filename into URL.

   See also

   wxFileSystem::URLToFileName, wxFileName

=head2 Wx::FileSystem::FindFileInPath

   bool FindFileInPath(wxString *str, const wxChar *path, const wxChar
   *file)

   Looks for the file with the given name file in a colon or semi-colon
   (depending on the current platform) separated list of directories in
   path. If the file is found in any directory, returns true and the full
   path of the file in str, otherwise returns false and doesn't modify
   str.

   Parameters

   str 

       Receives the full path of the file, must not be NULL

   path

       wxPATH_SEP-separated list of directories

   file

       the name of the file to look for

=head2 Wx::FileSystem::FindFirst

   wxString FindFirst(const wxString& wildcard, int flags = 0)

   Works like wxFindFirstFile. Returns name of the first filename (within
   filesystem's current path) that matches wildcard. flags may be one of
   wxFILE (only files), wxDIR (only directories) or 0 (both).

=head2 Wx::FileSystem::FindNext

   wxString FindNext()

   Returns the next filename that matches parameters passed to FindFirst.

=head2 Wx::FileSystem::OpenFile

   wxFSFile* OpenFile(const wxString& location, int flags = wxFS_READ)

   Opens the file and returns a pointer to a wxFSFile object or NULL if
   failed. It first tries to open the file in relative scope (based on
   value passed to ChangePathTo() method) and then as an absolute path.
   Note that the user is responsible for deleting the returned wxFSFile.

   flags can be one or more of the following bit values ored together:

   // Open Bit Flags
   enum {
       wxFS_READ = 1,      // Open for reading
       wxFS_SEEKABLE = 4   // Returned stream will be seekable
   };

   A stream opened with just the default wxFS_READ flag may or may not be
   seekable depending on the underlying source. Passing wxFS_READ |
   wxFS_SEEKABLE for flags will back a stream that is not natively
   seekable with memory or a file and return a stream that is always
   seekable.

=head2 Wx::FileSystem::URLToFileName

   static wxFileName URLToFileName(const wxString& url)

   Converts URL into a well-formed filename. The URL must use the file
   protocol.

   See also

   wxFileSystem::FileNameToURL, wxFileName

=head1 Wx::FileSystemHandler

=head2 Wx::FileSystemHandler::new

   wxFileSystemHandler()

   Constructor.

=head2 Wx::FileSystemHandler::CanOpen

   virtual bool CanOpen(const wxString& location)

   Returns true if the handler is able to open this file. This function
   doesn't check whether the file exists or not, it only checks if it
   knows the protocol. Example:

   bool MyHand::CanOpen(const wxString& location) 
   {
       return (GetProtocol(location) == "http");
   }

   Must be overridden in derived handlers.

=head2 Wx::FileSystemHandler::GetAnchor

   wxString GetAnchor(const wxString& location) const

   Returns the anchor if present in the location. See wxFSFile for
   details.

   Example: GetAnchor("index.htm#chapter2") == "chapter2"

   Note: the anchor is NOT part of the left location.

=head2 Wx::FileSystemHandler::GetLeftLocation

   wxString GetLeftLocation(const wxString& location) const

   Returns the left location string extracted from location.

   Example: GetLeftLocation("file:myzipfile.zip#zip:index.htm") ==
   "file:myzipfile.zip"

=head2 Wx::FileSystemHandler::GetMimeTypeFromExt

   wxString GetMimeTypeFromExt(const wxString& location)

   Returns the MIME type based on extension of location. (While
   wxFSFile::GetMimeType returns real MIME type - either extension-based
   or queried from HTTP.)

   Example : GetMimeTypeFromExt("index.htm") == "text/html"

=head2 Wx::FileSystemHandler::GetProtocol

   wxString GetProtocol(const wxString& location) const

   Returns the protocol string extracted from location.

   Example: GetProtocol("file:myzipfile.zip#zip:index.htm") == "zip"

=head2 Wx::FileSystemHandler::GetRightLocation

   wxString GetRightLocation(const wxString& location) const

   Returns the right location string extracted from location.

   Example : GetRightLocation("file:myzipfile.zip#zip:index.htm") ==
   "index.htm"

=head2 Wx::FileSystemHandler::FindFirst

   virtual wxString FindFirst(const wxString& wildcard, int flags = 0)

   Works like wxFindFirstFile. Returns name of the first filename (within
   filesystem's current path) that matches wildcard. flags may be one of
   wxFILE (only files), wxDIR (only directories) or 0 (both).

   This method is only called if CanOpen returns true.

=head2 Wx::FileSystemHandler::FindNext

   virtual wxString FindNext()

   Returns next filename that matches parameters passed to FindFirst.

   This method is only called if CanOpen returns true and FindFirst
   returned a non-empty string.

=head2 Wx::FileSystemHandler::OpenFile

   virtual wxFSFile* OpenFile(wxFileSystem& fs, const wxString& location)

   Opens the file and returns wxFSFile pointer or NULL if failed.

   Must be overridden in derived handlers.

   Parameters

   fs  

       Parent FS (the FS from that OpenFile was called). See ZIP handler
       for details of how to use it.

   location

       The absolute location of file.

=head1 Wx::FileType

=head2 MessageParameters class

   One of the most common usages of MIME is to encode an e-mail message.
   The MIME type of the encoded message is an example of a message
   parameter. These parameters are found in the message headers
   ("Content-XXX"). At the very least, they must specify the MIME type
   and the version of MIME used, but almost always they provide
   additional information about the message such as the original file
   name or the charset (for the text documents).

   These parameters may be useful to the program used to open, edit, view
   or print the message, so, for example, an e-mail client program will
   have to pass them to this program. Because wxFileType itself can not
   know about these parameters, it uses MessageParameters class to query
   them. The default implementation only requires the caller to provide
   the file name (always used by the program to be called - it must know
   which file to open) and the MIME type and supposes that there are no
   other parameters. If you wish to supply additional parameters, you
   must derive your own class from MessageParameters and override
   GetParamValue() function, for example:

   // provide the message parameters for the MIME type manager
   class MailMessageParameters : public wxFileType::MessageParameters
   {
   public:
      MailMessageParameters(const wxString& filename,
                            const wxString& mimetype)
         : wxFileType::MessageParameters(filename, mimetype)
      {
      }

=head2 Wx::FileType::new

   wxFileType()

   The default constructor is private because you should never create
   objects of this type: they are only returned by wxMimeTypesManager
   methods.

=head2 Wx::FileType::DESTROY

   ~wxFileType()

   The destructor of this class is not virtual, so it should not be
   derived from.

=head2 Wx::FileType::GetMimeType

   bool GetMimeType(wxString* mimeType)

   If the function returns true, the string pointed to by mimeType is
   filled with full MIME type specification for this file type: for
   example, "text/plain".

=head2 Wx::FileType::GetMimeTypes

   bool GetMimeType(wxArrayString& mimeTypes)

   Same as GetMimeType but returns array of MIME types. This array will
   contain only one item in most cases but sometimes, notably under Unix
   with KDE, may contain more MIME types. This happens when one file
   extension is mapped to different MIME types by KDE, mailcap and
   mime.types.

=head2 Wx::FileType::GetExtensions

   bool GetExtensions(wxArrayString& extensions)

   If the function returns true, the array extensions is filled with all
   extensions associated with this file type: for example, it may contain
   the following two elements for the MIME type "text/html" (notice the
   absence of the leading dot): "html" and "htm".

   Windows: This function is currently not implemented: there is no
   (efficient) way to retrieve associated extensions from the given MIME
   type on this platform, so it will only return true if the wxFileType
   object was created by GetFileTypeFromExtension function in the first
   place.

=head2 Wx::FileType::GetIcon

   bool GetIcon(wxIconLocation * iconLoc)

   If the function returns true, the iconLoc is filled with the location
   of the icon for this MIME type. A wxIcon may be created from iconLoc
   later.

   Windows: The function returns the icon shown by Explorer for the files
   of the specified type.

   Mac: This function is not implemented and always returns false.

   Unix: MIME manager gathers information about icons from GNOME and KDE
   settings and thus GetIcon's success depends on availability of these
   desktop environments.

=head2 Wx::FileType::GetDescription

   bool GetDescription(wxString* desc)

   If the function returns true, the string pointed to by desc is filled
   with a brief description for this file type: for example, "text
   document" for the "text/plain" MIME type.

=head2 Wx::FileType::GetOpenCommand

   bool GetOpenCommand(wxString* command, MessageParameters& params)

   wxString GetOpenCommand(const wxString& filename)

   With the first version of this method, if the true is returned, the
   string pointed to by command is filled with the command which must be
   executed (see wxExecute) in order to open the file of the given type.
   In this case, the name of the file as well as any other parameters is
   retrieved from MessageParameters class.

   In the second case, only the filename is specified and the command to
   be used to open this kind of file is returned directly. An empty
   string is returned to indicate that an error occurred (typically
   meaning that there is no standard way to open this kind of files).

=head2 Wx::FileType::GetPrintCommand

   bool GetPrintCommand(wxString* command,MessageParameters& params)

   If the function returns true, the string pointed to by command is
   filled with the command which must be executed (see wxExecute) in
   order to print the file of the given type. The name of the file is
   retrieved from MessageParameters class.

=head2 Wx::FileType::ExpandCommand

   static wxString ExpandCommand(const wxString& command,
   MessageParameters& params)

   This function is primarily intended for GetOpenCommand and
   GetPrintCommand usage but may be also used by the application directly
   if, for example, you want to use some non-default command to open the
   file.

   The function replaces all occurrences of

=head1 Wx::FilterClassFactory

=head2 Wx::FilterClassFactory::CanHandle

   bool CanHandle(const wxChar* protocol, wxStreamProtocolType type =
   wxSTREAM_PROTOCOL) const

   Returns true if this factory can handle the given protocol, MIME type,
   HTTP encoding or file extension.

   When using wxSTREAM_FILEEXT for the second parameter, the first
   parameter can be a complete filename rather than just an extension.

=head2 Wx::FilterClassFactory::Find

   static const wxFilterClassFactory* Find(const wxChar* protocol,
   wxStreamProtocolType type = wxSTREAM_PROTOCOL)

   A static member that finds a factory that can handle a given protocol,
   MIME type, HTTP encoding or file extension. Returns a pointer to the
   class factory if found, or NULL otherwise. It does not give away
   ownership of the factory.

   When using wxSTREAM_FILEEXT for the second parameter, the first
   parameter can be a complete filename rather than just an extension.

=head2 Wx::FilterClassFactory::GetFirst/GetNext

   static const wxFilterClassFactory* GetFirst()

   const wxFilterClassFactory* GetNext() const

   GetFirst and GetNext can be used to enumerate the available factories.

   For example, to list them:

       wxString list;
       const wxFilterClassFactory *factory = wxFilterClassFactory::GetFirst();

=head2 Wx::FilterClassFactory::GetProtocol

   wxString GetProtocol() const

   Returns the wxFileSystem protocol supported by this factory.
   Equivalent to wxString(*GetProtcols()).

=head2 Wx::FilterClassFactory::GetProtocols

   const wxChar * const* GetProtocols(wxStreamProtocolType type =
   wxSTREAM_PROTOCOL) const

   Returns the protocols, MIME types, HTTP encodings or file extensions
   supported by this factory, as an array of null terminated strings. It
   does not give away ownership of the array or strings.

   For example, to list the file extensions a factory supports:

       wxString list;
       const wxChar *const *p;

=head2 Wx::FilterClassFactory::NewStream

   wxFilterInputStream* NewStream(wxInputStream& stream) const

   wxFilterOutputStream* NewStream(wxOutputStream& stream) const

   wxFilterInputStream* NewStream(wxInputStream* stream) const

   wxFilterOutputStream* NewStream(wxOutputStream* stream) const

   Create a new input or output stream to decompress or compress a given
   stream.

   If the parent stream is passed as a pointer then the new filter stream
   takes ownership of it. If it is passed by reference then it does not.

=head2 Wx::FilterClassFactory::PopExtension

   wxString PopExtension(const wxString& location) const

   Remove the file extension of location if it is one of the file
   extensions handled by this factory.

=head2 Wx::FilterClassFactory::PushFront

   void PushFront()

   Adds this class factory to the list returned by GetFirst()/GetNext().

   It is not necessary to do this to use the filter streams. It is
   usually used when implementing streams, typically the implementation
   will add a static instance of its factory class.

   It can also be used to change the order of a factory already in the
   list, bringing it to the front. This isn't a thread safe operation so
   can't be done when other threads are running that will be using the
   list.

   The list does not take ownership of the factory.

=head2 Wx::FilterClassFactory::Remove

   void Remove()

   Removes this class factory from the list returned by
   GetFirst()/GetNext().

   Removing from the list isn't a thread safe operation so can't be done
   when other threads are running that will be using the list.

   The list does not own the factories, so removing a factory does not
   delete it.

=head1 Wx::FilterInputStream

=head2 Wx::FilterInputStream::new

   wxFilterInputStream(wxInputStream& stream)

   wxFilterInputStream(wxInputStream* stream)

   Initializes a "filter" stream.

   If the parent stream is passed as a pointer then the new filter stream
   takes ownership of it. If it is passed by reference then it does not.

=head1 Wx::FilterOutputStream

=head2 Wx::FilterOutputStream::new

   wxFilterOutputStream(wxOutputStream& stream)

   wxFilterOutputStream(wxOutputStream* stream)

   Initializes a "filter" stream.

   If the parent stream is passed as a pointer then the new filter stream
   takes ownership of it. If it is passed by reference then it does not.

=head1 Wx::FindDialogEvent

=head2 Wx::FindDialogEvent::new

   wxFindDialogEvent(wxEventType commandType = wxEVT_NULL, int id = 0)

   Constuctor used by wxWidgets only.

=head2 Wx::FindDialogEvent::GetFlags

   int GetFlags() const

   Get the currently selected flags: this is the combination of wxFR_DOWN,
   wxFR_WHOLEWORD and wxFR_MATCHCASE flags.

=head2 Wx::FindDialogEvent::GetFindString

   wxString GetFindString() const

   Return the string to find (never empty).

=head2 Wx::FindDialogEvent::GetReplaceString

   const wxString& GetReplaceString() const

   Return the string to replace the search string with (only for replace
   and replace all events).

=head2 Wx::FindDialogEvent::GetDialog

   wxFindReplaceDialog* GetDialog() const

   Return the pointer to the dialog which generated this event.

=head1 Wx::FindReplaceData

=head2 Wx::FindReplaceData::new

   wxFindReplaceData(wxUint32 flags = 0)

   Constuctor initializes the flags to default value (0).

=head2 Wx::FindReplaceData::GetFindString

   const wxString& GetFindString()

   Get the string to find.

=head2 Wx::FindReplaceData::GetReplaceString

   const wxString& GetReplaceString()

   Get the replacement string.

=head2 Wx::FindReplaceData::GetFlags

   int GetFlags() const

   Get the combination of wxFindReplaceFlags values.

=head2 Wx::FindReplaceData::SetFlags

   void SetFlags(wxUint32 flags)

   Set the flags to use to initialize the controls of the dialog.

=head2 Wx::FindReplaceData::SetFindString

   void SetFindString(const wxString& str)

   Set the string to find (used as initial value by the dialog).

=head2 Wx::FindReplaceData::SetReplaceString

   void SetReplaceString(const wxString& str)

   Set the replacement string (used as initial value by the dialog).

=head1 Wx::FindReplaceDialog

=head2 Wx::FindReplaceDialog::new

   wxFindReplaceDialog()

   wxFindReplaceDialog(wxWindow * parent, wxFindReplaceData* data, const
   wxString& title, int style = 0)

   After using default constructor Create() must be called.

   The parent and data parameters must be non-NULL.

=head2 Wx::FindReplaceDialog::DESTROY

   ~wxFindReplaceDialog()

   Destructor.

=head2 Wx::FindReplaceDialog::Create

   bool Create(wxWindow * parent, wxFindReplaceData* data, const wxString&
   title, int style = 0)

   Creates the dialog; use Show to show it on screen.

   The parent and data parameters must be non-NULL.

=head2 Wx::FindReplaceDialog::GetData

   const wxFindReplaceData* GetData() const

   Get the wxFindReplaceData object used by this dialog.

=head1 Wx::FlexGridSizer

=head2 Wx::FlexGridSizer::new

   wxFlexGridSizer(int rows, int cols, int vgap, int hgap)

   wxFlexGridSizer(int cols, int vgap = 0, int hgap = 0)

   Constructor for a wxGridSizer. rows and cols determine the number of
   columns and rows in the sizer - if either of the parameters is zero,
   it will be calculated to form the total number of children in the
   sizer, thus making the sizer grow dynamically. vgap and hgap define
   extra space between all children.

=head2 Wx::FlexGridSizer::AddGrowableCol

   void AddGrowableCol(size_t idx, int proportion = 0)

   Specifies that column idx (starting from zero) should be grown if
   there is extra space available to the sizer.

   The proportion parameter has the same meaning as the stretch factor
   for the sizers except that if all proportions are 0, then all columns
   are resized equally (instead of not being resized at all).

=head2 Wx::FlexGridSizer::AddGrowableRow

   void AddGrowableRow(size_t idx, int proportion = 0)

   Specifies that row idx (starting from zero) should be grown if there
   is extra space available to the sizer.

   See AddGrowableCol for the description of proportion parameter.

=head2 Wx::FlexGridSizer::GetFlexibleDirection

   int GetFlexibleDirection() const

   Returns a wxOrientation value that specifies whether the sizer
   flexibly resizes its columns, rows, or both (default).

   Return value

   One of the following values:

=head2 Wx::FlexGridSizer::GetNonFlexibleGrowMode

   int GetNonFlexibleGrowMode() const

   Returns the value that specifies how the sizer grows in the
   "non-flexible" direction if there is one.

   Return value

   One of the following values:

=head2 Wx::FlexGridSizer::RemoveGrowableCol

   void RemoveGrowableCol(size_t idx)

   Specifies that column idx is no longer growable.

=head2 Wx::FlexGridSizer::RemoveGrowableRow

   void RemoveGrowableRow(size_t idx)

   Specifies that row idx is no longer growable.

=head2 Wx::FlexGridSizer::SetFlexibleDirection

   void SetFlexibleDirection(int direction)

   Specifies whether the sizer should flexibly resize its columns, rows,
   or both. Argument direction can be wxVERTICAL, wxHORIZONTAL or wxBOTH
   (which is the default value). Any other value is ignored. See
   GetFlexibleDirection() for the explanation of these values.

   Note that this method does not trigger relayout.

=head2 Wx::FlexGridSizer::SetNonFlexibleGrowMode

   void SetNonFlexibleGrowMode(wxFlexSizerGrowMode mode)

   Specifies how the sizer should grow in the non-flexible direction if
   there is one (so SetFlexibleDirection() must have been called
   previously). Argument mode can be one of those documented in
   GetNonFlexibleGrowMode, please see there for their explanation.

   Note that this method does not trigger relayout.

=head1 Wx::FocusEvent

=head2 Wx::FocusEvent::new

   wxFocusEvent(WXTYPE eventType = 0, int id = 0)

   Constructor.

=head2 Wx::FocusEvent::GetWindow

   Returns the window associated with this event, that is the window
   which had the focus before for the wxEVT_SET_FOCUS event and the
   window which is going to receive focus for the wxEVT_KILL_FOCUS one.

   Warning: the window pointer may be NULL!

=head1 Wx::Font

=head2 Wx::Font::new

   wxFont()

   Default constructor.

   wxFont(const wxFont& font)

   Copy constructor, uses reference counting.

   wxFont(int pointSize, wxFontFamily family, int style, wxFontWeight
   weight, const bool underline = false, const wxString& faceName = "",
   wxFontEncoding encoding = wxFONTENCODING_DEFAULT)

   wxFont(const wxSize& pixelSize, wxFontFamily family, int style,
   wxFontWeight weight, const bool underline = false, const wxString&
   faceName = "", wxFontEncoding encoding = wxFONTENCODING_DEFAULT)

   Creates a font object with the specified attributes.

   Parameters

   pointSize

       Size in points.

   pixelSize

       Size in pixels: this is directly supported only under MSW
       currently where this constructor can be used directly, under other
       platforms a font with the closest size to the given one is found
       using binary search and the static New method must be used.

   family

       Font family, a generic way of referring to fonts without
       specifying actual facename. One of:

=head2 Wx::Font::DESTROY

   ~wxFont()

   Destructor. See reference-counted object destruction for more info.

   Remarks

   Although all remaining fonts are deleted when the application exits,
   the application should try to clean up all fonts itself. This is
   because wxWidgets cannot know if a pointer to the font object is
   stored in an application data structure, and there is a risk of double
   deletion.

=head2 Wx::Font::IsFixedWidth

   bool IsFixedWidth() const

   Returns true if the font is a fixed width (or monospaced) font, false
   if it is a proportional one or font is invalid.

=head2 Wx::Font::GetDefaultEncoding

   static wxFontEncoding GetDefaultEncoding()

   Returns the current application's default encoding.

   See also

   Font encoding overview, SetDefaultEncoding

=head2 Wx::Font::GetFaceName

   wxString GetFaceName() const

   Returns the typeface name associated with the font, or the empty
   string if there is no typeface information.

   See also

   wxFont::SetFaceName

=head2 Wx::Font::GetFamily

   wxFontFamily GetFamily() const

   Gets the font family. See wxFont::SetFamily for a list of valid family
   identifiers.

   See also

   wxFont::SetFamily

=head2 Wx::Font::GetNativeFontInfoDesc

   wxString GetNativeFontInfoDesc() const

   Returns the platform-dependent string completely describing this font.
   Returned string is always non-empty. Note that the returned string is
   not meant to be shown or edited by the user: a typical use of this
   function is for serializing in string-form a wxFont object.

   See also

   wxFont::SetNativeFontInfo,wxFont::GetNativeFontInfoUserDesc

=head2 Wx::Font::GetNativeFontInfoUserDesc

   wxString GetNativeFontInfoUserDesc()

   Returns a user-friendly string for this font object. Returned string
   is always non-empty. Some examples of the formats of returned strings
   (which are platform-dependent) are in SetNativeFontInfoUserDesc.

   See also

   wxFont::GetNativeFontInfoDesc

=head2 Wx::Font::GetPointSize

   int GetPointSize() const

   Gets the point size.

   See also

   wxFont::SetPointSize

=head2 Wx::Font::GetStyle

   int GetStyle() const

   Gets the font style. See wxFont::wxFont for a list of valid styles.

   See also

   wxFont::SetStyle

=head2 Wx::Font::GetUnderlined

   bool GetUnderlined() const

   Returns true if the font is underlined, false otherwise.

   See also

   wxFont::SetUnderlined

=head2 Wx::Font::GetWeight

   wxFontWeight GetWeight() const

   Gets the font weight. See wxFont::wxFont for a list of valid weight
   identifiers.

   See also

   wxFont::SetWeight

=head2 Wx::Font::New

   static wxFont * New(int pointSize, wxFontFamily family, int style,
   wxFontWeight weight, const bool underline = false, const wxString&
   faceName = "", wxFontEncoding encoding = wxFONTENCODING_DEFAULT)

   static wxFont * New(int pointSize, wxFontFamily family, int flags =
   wxFONTFLAG_DEFAULT, const wxString& faceName = "", wxFontEncoding
   encoding = wxFONTENCODING_DEFAULT)

   static wxFont * New(const wxSize& pixelSize, wxFontFamily family, int
   style, wxFontWeight weight, const bool underline = false, const
   wxString& faceName = "", wxFontEncoding encoding =
   wxFONTENCODING_DEFAULT)

   static wxFont * New(const wxSize& pixelSize, wxFontFamily family, int
   flags = wxFONTFLAG_DEFAULT, const wxString& faceName = "",
   wxFontEncoding encoding = wxFONTENCODING_DEFAULT)

   These functions take the same parameters as wxFont constructor and
   return a new font object allocated on the heap.

   Using New() is currently the only way to directly create a font with
   the given size in pixels on platforms other than wxMSW.

=head2 Wx::Font::IsOk

   bool IsOk() const

   Returns true if this object is a valid font, false otherwise.

=head2 Wx::Font::SetDefaultEncoding

   static void SetDefaultEncoding(wxFontEncoding encoding)

   Sets the default font encoding.

   See also

   Font encoding overview, GetDefaultEncoding

=head2 Wx::Font::SetFaceName

   bool SetFaceName(const wxString& faceName)

   Sets the facename for the font. Returns true if the given face name
   exists; false otherwise.

   Parameters

   faceName

       A valid facename, which should be on the end-user's system.

   Remarks

   To avoid portability problems, don't rely on a specific face, but
   specify the font family instead or as well. A suitable font will be
   found on the end-user's system. If both the family and the facename
   are specified, wxWidgets will first search for the specific face, and
   then for a font belonging to the same family.

   See also

   wxFont::GetFaceName, wxFont::SetFamily

=head2 Wx::Font::SetFamily

   void SetFamily(wxFontFamily family)

   Sets the font family.

   Parameters

   family

       One of:

=head2 Wx::Font::SetNativeFontInfo

   bool SetNativeFontInfo(const wxString& info)

   Creates the font corresponding to the given native font description
   string and returns true if the creation was successful. which must
   have been previously returned by GetNativeFontInfoDesc. If the string
   is invalid, font state is undefined (it becomes invalid in 2.8 but
   this shouldn't be relied on as the next wxWidgets version leaves it
   unchanged instead). This function is typically used for de-serializing
   a wxFont object previously saved in a string-form.

   See also

   wxFont::SetNativeFontInfoUserDesc

=head2 Wx::Font::SetNativeFontInfoUserDesc

   bool SetNativeFontInfoUserDesc(const wxString& info)

   Creates the font corresponding to the given native font description
   string and returns true if the creation was successful. Unlike
   SetNativeFontInfo, this function accepts strings which are
   user-friendly. Examples of accepted string formats are:

=head2 Wx::Font::SetPointSize

   void SetPointSize(int pointSize)

   Sets the point size.

   Parameters

   pointSize

       Size in points.

   See also

   wxFont::GetPointSize

=head2 Wx::Font::SetStyle

   void SetStyle(int style)

   Sets the font style.

   Parameters

   style

       One of wxFONTSTYLE_NORMAL, wxFONTSTYLE_SLANT and
       wxFONTSTYLE_ITALIC.

   See also

   wxFont::GetStyle

=head2 Wx::Font::SetUnderlined

   void SetUnderlined(const bool underlined)

   Sets underlining.

   Parameters

   underlining

       true to underline, false otherwise.

   See also

   wxFont::GetUnderlined

=head2 Wx::Font::SetWeight

   void SetWeight(wxFontWeight weight)

   Sets the font weight.

   Parameters

   weight

       One of:

=head1 Wx::FontData

=head2 Wx::FontData::new

   wxFontData()

   Constructor. Initializes fontColour to black, showHelp to black,
   allowSymbols to true, enableEffects to true, minSize to 0 and maxSize
   to 0.

=head2 Wx::FontData::EnableEffects

   void EnableEffects(bool enable)

   Enables or disables 'effects' under MS Windows or generic only. This
   refers to the controls for manipulating colour, strikeout and
   underline properties.

   The default value is true.

=head2 Wx::FontData::GetAllowSymbols

   bool GetAllowSymbols()

   Under MS Windows, returns a flag determining whether symbol fonts can
   be selected. Has no effect on other platforms.

   The default value is true.

=head2 Wx::FontData::GetColour

   wxColour& GetColour()

   Gets the colour associated with the font dialog.

   The default value is black.

=head2 Wx::FontData::GetChosenFont

   wxFont GetChosenFont()

   Gets the font chosen by the user if the user pressed OK
   (wxFontDialog::ShowModal returned wxID_OK).

=head2 Wx::FontData::GetEnableEffects

   bool GetEnableEffects()

   Determines whether 'effects' are enabled under Windows. This refers to
   the controls for manipulating colour, strikeout and underline
   properties.

   The default value is true.

=head2 Wx::FontData::GetInitialFont

   wxFont GetInitialFont()

   Gets the font that will be initially used by the font dialog. This
   should have previously been set by the application.

=head2 Wx::FontData::GetShowHelp

   bool GetShowHelp()

   Returns true if the Help button will be shown (Windows only).

   The default value is false.

=head2 Wx::FontData::SetAllowSymbols

   void SetAllowSymbols(bool allowSymbols)

   Under MS Windows, determines whether symbol fonts can be selected. Has
   no effect on other platforms.

   The default value is true.

=head2 Wx::FontData::SetChosenFont

   void SetChosenFont(const wxFont& font)

   Sets the font that will be returned to the user (for internal use
   only).

=head2 Wx::FontData::SetColour

   void SetColour(const wxColour& colour)

   Sets the colour that will be used for the font foreground colour.

   The default colour is black.

=head2 Wx::FontData::SetInitialFont

   void SetInitialFont(const wxFont&font)

   Sets the font that will be initially used by the font dialog.

=head2 Wx::FontData::SetRange

   void SetRange(int min, int max)

   Sets the valid range for the font point size (Windows only).

   The default is 0, 0 (unrestricted range).

=head2 Wx::FontData::SetShowHelp

   void SetShowHelp(bool showHelp)

   Determines whether the Help button will be displayed in the font
   dialog (Windows only).

   The default value is false.

=head1 Wx::FontDialog

=head2 Wx::FontDialog::new

   wxFontDialog()

   wxFontDialog(wxWindow* parent)

   wxFontDialog(wxWindow* parent, const wxFontData& data)

   Constructor. Pass a parent window, and optionally the font data object
   to be used to initialize the dialog controls. If the default
   constructor is used, Create() must be called before the dialog can be
   shown.

=head2 Wx::FontDialog::Create

   bool Create(wxWindow* parent)

   bool Create(wxWindow* parent, const wxFontData& data)

   Creates the dialog if it the wxFontDialog object had been initialized
   using the default constructor. Returns true on success and false if an
   error occurred.

=head2 Wx::FontDialog::GetFontData

   const wxFontData& GetFontData() const

   wxFontData& GetFontData()

   Returns the font data associated with the font dialog.

=head2 Wx::FontDialog::ShowModal

   int ShowModal()

   Shows the dialog, returning wxID_OK if the user pressed Ok, and
   wxID_CANCEL otherwise.

   If the user cancels the dialog (ShowModal returns wxID_CANCEL), no
   font will be created. If the user presses OK, a new wxFont will be
   created and stored in the font dialog's wxFontData structure.

=head1 Wx::FontEnumerator

=head2 Wx::FontEnumerator::EnumerateFacenames

   virtual bool EnumerateFacenames( wxFontEncoding encoding =
   wxFONTENCODING_SYSTEM, bool fixedWidthOnly = false)

   Call OnFacename for each font which supports given encoding (only if
   it is not wxFONTENCODING_SYSTEM) and is of fixed width (if
   fixedWidthOnly is true).

   Calling this function with default arguments will result in
   enumerating all fonts available on the system.

=head2 Wx::FontEnumerator::EnumerateEncodings

   virtual bool EnumerateEncodings(const wxString& font = "")

   Call OnFontEncoding for each encoding supported by the given font - or
   for each encoding supported by at least some font if font is not
   specified.

=head2 Wx::FontEnumerator::GetEncodings

   static wxArrayString GetEncodings(const wxString& facename = "")

   Return array of strings containing all encodings found by
   EnumerateEncodings.

=head2 Wx::FontEnumerator::GetFacenames

   static wxArrayString GetFacenames(wxFontEncoding encoding =
   wxFONTENCODING_SYSTEM, bool fixedWidthOnly = false)

   Return array of strings containing all facenames found by
   EnumerateFacenames.

=head2 Wx::FontEnumerator::IsValidFacename

   static bool IsValidFacename(const wxString & facename)

   Returns true if the given string is valid face name, i.e. it's the
   face name of an installed font and it can safely be used with
   wxFont::SetFaceName.

=head2 Wx::FontEnumerator::OnFacename

   virtual bool OnFacename(const wxString& font)

   Called by EnumerateFacenames for each match. Return true to continue
   enumeration or false to stop it.

=head2 Wx::FontEnumerator::OnFontEncoding

   virtual bool OnFontEncoding(const wxString& font, const wxString&
   encoding)

   Called by EnumerateEncodings for each match. Return true to continue
   enumeration or false to stop it.

=head1 Wx::FontList

=head2 Wx::FontList::new

   wxFontList()

   Constructor. The application should not construct its own font list:
   use the object pointer wxTheFontList.

=head2 Wx::FontList::FindOrCreateFont

   wxFont * FindOrCreateFont(int point_size, int family, int style, int
   weight, bool underline = false, const wxString& facename = NULL,
   wxFontEncoding encoding = wxFONTENCODING_DEFAULT)

   Finds a font of the given specification, or creates one and adds it to
   the list. See the wxFont constructor for details of the arguments.

=head1 Wx::FontMapper

=head2 Wx::FontMapper::new

   wxFontMapper()

   Default ctor.

   Note

   The preferred way of creating a wxFontMapper instance is to call
   wxFontMapper::Get.

=head2 Wx::FontMapper::DESTROY

   ~wxFontMapper()

   Virtual dtor for a base class.

=head2 Wx::FontMapper::CharsetToEncoding

   wxFontEncoding CharsetToEncoding(const wxString& charset, bool
   interactive = true)

   Returns the encoding for the given charset (in the form of RFC 2046)
   or wxFONTENCODING_SYSTEM if couldn't decode it.

   Be careful when using this function with interactive set to true
   (default value) as the function then may show a dialog box to the user
   which may lead to unexpected reentrancies and may also take a
   significantly longer time than a simple function call. For these
   reasons, it is almost always a bad idea to call this function from the
   event handlers for repeatedly generated events such as EVT_PAINT.

=head2 Wx::FontMapper::Get

   static wxFontMapper * Get()

   Get the current font mapper object. If there is no current object,
   creates one.

   See also

   wxFontMapper::Set

=head2 Wx::FontMapper::GetAllEncodingNames

   static const wxChar** GetAllEncodingNames(wxFontEncoding encoding)

   Returns the array of all possible names for the given encoding. The
   array is NULL-terminated. IF it isn't empty, the first name in it is
   the canonical encoding name, i.e. the same string as returned by
   GetEncodingName().

=head2 Wx::FontMapper::GetAltForEncoding

   bool GetAltForEncoding(wxFontEncoding encoding, wxNativeEncodingInfo*
   info, const wxString& facename = wxEmptyString, bool interactive =
   true)

   bool GetAltForEncoding(wxFontEncoding encoding, wxFontEncoding*
   alt_encoding, const wxString& facename = wxEmptyString, bool
   interactive = true)

   Find an alternative for the given encoding (which is supposed to not
   be available on this system). If successful, return true and fill info
   structure with the parameters required to create the font, otherwise
   return false.

   The first form is for wxWidgets' internal use while the second one is
   better suitable for general use -- it returns wxFontEncoding which can
   consequently be passed to wxFont constructor.

=head2 Wx::FontMapper::GetEncoding

   static wxFontEncoding GetEncoding(size_t n)

   Returns the n-th supported encoding. Together with
   GetSupportedEncodingsCount() this method may be used to get all
   supported encodings.

=head2 Wx::FontMapper::GetEncodingDescription

   static wxString GetEncodingDescription(wxFontEncoding encoding)

   Return user-readable string describing the given encoding.

=head2 Wx::FontMapper::GetEncodingFromName

   static wxFontEncoding GetEncodingFromName(const wxString& encoding)

   Return the encoding corresponding to the given internal name. This
   function is the inverse of GetEncodingName and is intentionally less
   general than CharsetToEncoding, i.e. it doesn't try to make any
   guesses nor ever asks the user. It is meant just as a way of restoring
   objects previously serialized using GetEncodingName.

=head2 Wx::FontMapper::GetEncodingName

   static wxString GetEncodingName(wxFontEncoding encoding)

   Return internal string identifier for the encoding (see also
   GetEncodingDescription())

   See also

   GetEncodingFromName

=head2 Wx::FontMapper::GetSupportedEncodingsCount

   static size_t GetSupportedEncodingsCount()

   Returns the number of the font encodings supported by this class.
   Together with GetEncoding this method may be used to get all supported
   encodings.

=head2 Wx::FontMapper::IsEncodingAvailable

   bool IsEncodingAvailable(wxFontEncoding encoding, const wxString&
   facename = wxEmptyString)

   Check whether given encoding is available in given face or not. If no
   facename is given, find any font in this encoding.

=head2 Wx::FontMapper::SetDialogParent

   void SetDialogParent(wxWindow* parent)

   The parent window for modal dialogs.

=head2 Wx::FontMapper::SetDialogTitle

   void SetDialogTitle(const wxString& title)

   The title for the dialogs (note that default is quite reasonable).

=head2 Wx::FontMapper::Set

   static wxFontMapper * Set(wxFontMapper *mapper)

   Set the current font mapper object and return previous one (may be
   NULL). This method is only useful if you want to plug-in an
   alternative font mapper into wxWidgets.

   See also

   wxFontMapper::Get

=head2 Wx::FontMapper::SetConfig

   void SetConfig(wxConfigBase* config)

   Set the config object to use (may be NULL to use default).

   By default, the global one (from wxConfigBase::Get() will be used) and
   the default root path for the config settings is the string returned
   by GetDefaultConfigPath().

=head2 Wx::FontMapper::SetConfigPath

   void SetConfigPath(const wxString& prefix)

   Set the root config path to use (should be an absolute path).

=head1 Wx::FontPickerCtrl

=head2 Wx::FontPickerCtrl::new

   wxFontPickerCtrl(wxWindow *parent, wxWindowID id, const wxFont& font =
   wxNullFont, const wxPoint& pos = wxDefaultPosition, const wxSize& size
   = wxDefaultSize, long style = wxFNTP_DEFAULT_STYLE, const wxValidator&
   validator = wxDefaultValidator, const wxString& name =
   "fontpickerctrl")

   Initializes the object and calls Create with all the parameters.

=head2 Wx::FontPickerCtrl::Create

   bool Create(wxWindow *parent, wxWindowID id, const wxFont& font =
   wxNullFont, const wxPoint& pos = wxDefaultPosition, const wxSize& size
   = wxDefaultSize, long style = wxFNTP_DEFAULT_STYLE, const wxValidator&
   validator = wxDefaultValidator, const wxString& name =
   "fontpickerctrl")

   Parameters

   parent

       Parent window, must not be non-NULL.

   id  

       The identifier for the control.

   font

       The initial font shown in the control. If wxNullFont is given, the
       default font is used.

   pos 

       Initial position.

   size

       Initial size.

   style

       The window style, see wxFNTP_* flags.

   validator

       Validator which can be used for additional date checks.

   name

       Control name.

   Return value

   true if the control was successfully created or false if creation
   failed.

=head2 Wx::FontPickerCtrl::GetSelectedFont

   wxFont GetSelectedFont() const

   Returns the currently selected font. Note that this function is
   completely different from wxWindow::GetFont.

=head2 Wx::FontPickerCtrl::SetSelectedFont

   void SetSelectedFont(const wxFont &font)

   Sets the currently selected font. Note that this function is
   completely different from wxWindow::SetFont.

=head2 Wx::FontPickerCtrl::GetMaxPointSize

   unsigned int GetMaxPointSize() const

   Returns the maximum point size value allowed for the user-chosen font.

=head2 Wx::FontPickerCtrl::SetMaxPointSize

   void GetMaxPointSize(unsigned int max)

   Sets the maximum point size value allowed for the user-chosen font.
   The default value is 100. Note that big fonts can require a lot of
   memory and CPU time both for creation and for rendering; thus,
   specially because the user has the option to specify the fontsize
   through a text control (see wxFNTP_USE_TEXTCTRL), it's a good idea to
   put a limit to the maximum font size when huge fonts do not make much
   sense.

=head1 Wx::FontPickerEvent

=head2 Wx::FontPickerEvent::new

   wxFontPickerEvent(wxObject * generator, int id, const wxFont& font)

   The constructor is not normally used by the user code.

=head2 Wx::FontPickerEvent::GetFont

   wxFont GetFont() const

   Retrieve the font the user has just selected.

=head2 Wx::FontPickerEvent::SetFont

   void SetFont(const wxFont & f)

   Set the font associated with the event.

=head1 Wx::Frame

=head2 Wx::Frame::new

   wxFrame()

   Default constructor.

   wxFrame(wxWindow* parent, wxWindowID id, const wxString& title, const
   wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
   long style = wxDEFAULT_FRAME_STYLE, const wxString& name = "frame")

   Constructor, creating the window.

   Parameters

   parent

       The window parent. This may be NULL. If it is non-NULL, the frame
       will always be displayed on top of the parent window on Windows.

   id  

       The window identifier. It may take a value of -1 to indicate a
       default value.

   title

       The caption to be displayed on the frame's title bar.

   pos 

       The window position. A value of (-1, -1) indicates a default
       position, chosen by either the windowing system or wxWidgets,
       depending on platform.

   size

       The window size. A value of (-1, -1) indicates a default size,
       chosen by either the windowing system or wxWidgets, depending on
       platform.

   style

       The window style. See wxFrame.

   name

       The name of the window. This parameter is used to associate a name
       with the item, allowing the application user to set Motif resource
       values for individual windows.

   Remarks

   For Motif, MWM (the Motif Window Manager) should be running for any
   window styles to work (otherwise all styles take effect).

   See also

   wxFrame::Create

=head2 Wx::Frame::DESTROY

   void ~wxFrame()

   Destructor. Destroys all child windows and menu bar if present.

=head2 Wx::Frame::Centre

   void Centre(int direction = wxBOTH)

   Centres the frame on the display.

   Parameters

   direction

       The parameter may be wxHORIZONTAL, wxVERTICAL or wxBOTH.

=head2 Wx::Frame::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxString& title,
   const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE, const wxString&
   name = "frame")

   Used in two-step frame construction. See wxFrame::wxFrame for further
   details.

=head2 Wx::Frame::CreateStatusBar

   virtual wxStatusBar* CreateStatusBar(int number = 1, long style =
   wxST_SIZEGRIP | wxFULL_REPAINT_ON_RESIZE, wxWindowID id = 0, const
   wxString& name = "statusBar")

   Creates a status bar at the bottom of the frame.

   Parameters

   number

       The number of fields to create. Specify a value greater than 1 to
       create a multi-field status bar.

   style

       The status bar style. See wxStatusBar for a list of valid styles.

   id  

       The status bar window identifier. If -1, an identifier will be
       chosen by wxWidgets.

   name

       The status bar window name.

   Return value

   A pointer to the status bar if it was created successfully, NULL
   otherwise.

   Remarks

   The width of the status bar is the whole width of the frame (adjusted
   automatically when resizing), and the height and text size are chosen
   by the host windowing system.

   By default, the status bar is an instance of wxStatusBar. To use a
   different class, override wxFrame::OnCreateStatusBar.

   Note that you can put controls and other windows on the status bar if
   you wish.

   See also

   wxFrame::SetStatusText, wxFrame::OnCreateStatusBar,
   wxFrame::GetStatusBar

=head2 Wx::Frame::CreateToolBar

   virtual wxToolBar* CreateToolBar(long style = wxNO_BORDER |
   wxTB_HORIZONTAL, wxWindowID id = -1, const wxString& name = "toolBar")

   Creates a toolbar at the top or left of the frame.

   Parameters

   style

       The toolbar style. See wxToolBar for a list of valid styles.

   id  

       The toolbar window identifier. If -1, an identifier will be chosen
       by wxWidgets.

   name

       The toolbar window name.

   Return value

   A pointer to the toolbar if it was created successfully, NULL
   otherwise.

   Remarks

   By default, the toolbar is an instance of wxToolBar (which is defined
   to be a suitable toolbar class on each platform, such as wxToolBar95).
   To use a different class, override wxFrame::OnCreateToolBar.

   When a toolbar has been created with this function, or made known to
   the frame with wxFrame::SetToolBar, the frame will manage the toolbar
   position and adjust the return value from wxWindow::GetClientSize to
   reflect the available space for application windows.

   Under Pocket PC, you should always use this function for creating the
   toolbar to be managed by the frame, so that wxWidgets can use a
   combined menubar and toolbar. Where you manage your own toolbars,
   create a wxToolBar as usual.

   See also

   wxFrame::CreateStatusBar, wxFrame::OnCreateToolBar,
   wxFrame::SetToolBar, wxFrame::GetToolBar

=head2 Wx::Frame::GetClientAreaOrigin

   wxPoint GetClientAreaOrigin() const

   Returns the origin of the frame client area (in client coordinates).
   It may be different from (0, 0) if the frame has a toolbar.

=head2 Wx::Frame::GetMenuBar

   wxMenuBar* GetMenuBar() const

   Returns a pointer to the menubar currently associated with the frame
   (if any).

   See also

   wxFrame::SetMenuBar, wxMenuBar, wxMenu

=head2 Wx::Frame::GetStatusBar

   wxStatusBar* GetStatusBar() const

   Returns a pointer to the status bar currently associated with the
   frame (if any).

   See also

   wxFrame::CreateStatusBar, wxStatusBar

=head2 Wx::Frame::GetStatusBarPane

   int GetStatusBarPane()

   Returns the status bar pane used to display menu and toolbar help.

   See also

   wxFrame::SetStatusBarPane

=head2 Wx::Frame::GetToolBar

   wxToolBar* GetToolBar() const

   Returns a pointer to the toolbar currently associated with the frame
   (if any).

   See also

   wxFrame::CreateToolBar, wxToolBar, wxFrame::SetToolBar

=head2 Wx::Frame::OnCreateStatusBar

   virtual wxStatusBar* OnCreateStatusBar(int number, long style,
   wxWindowID id, const wxString& name)

   Virtual function called when a status bar is requested by
   wxFrame::CreateStatusBar.

   Parameters

   number

       The number of fields to create.

   style

       The window style. See wxStatusBar for a list of valid styles.

   id  

       The window identifier. If -1, an identifier will be chosen by
       wxWidgets.

   name

       The window name.

   Return value

   A status bar object.

   Remarks

   An application can override this function to return a different kind
   of status bar. The default implementation returns an instance of
   wxStatusBar.

   See also

   wxFrame::CreateStatusBar, wxStatusBar.

=head2 Wx::Frame::OnCreateToolBar

   virtual wxToolBar* OnCreateToolBar(long style, wxWindowID id, const
   wxString& name)

   Virtual function called when a toolbar is requested by
   wxFrame::CreateToolBar.

   Parameters

   style

       The toolbar style. See wxToolBar for a list of valid styles.

   id  

       The toolbar window identifier. If -1, an identifier will be chosen
       by wxWidgets.

   name

       The toolbar window name.

   Return value

   A toolbar object.

   Remarks

   An application can override this function to return a different kind
   of toolbar. The default implementation returns an instance of
   wxToolBar.

   See also

   wxFrame::CreateToolBar, wxToolBar.

=head2 Wx::Frame::ProcessCommand

   void ProcessCommand(int id)

   Simulate a menu command.

   Parameters

   id  

       The identifier for a menu item.

=head2 Wx::Frame::SendSizeEvent

   void SendSizeEvent()

   This function sends a dummy size event to the frame forcing it to
   reevaluate its children positions. It is sometimes useful to call this
   function after adding or deleting a children after the frame creation
   or if a child size changes.

   Note that if the frame is using either sizers or constraints for the
   children layout, it is enough to call Layout() directly and this
   function should not be used in this case.

=head2 Wx::Frame::SetMenuBar

   void SetMenuBar(wxMenuBar* menuBar)

   Tells the frame to show the given menu bar.

   Parameters

   menuBar

       The menu bar to associate with the frame.

   Remarks

   If the frame is destroyed, the menu bar and its menus will be
   destroyed also, so do not delete the menu bar explicitly (except by
   resetting the frame's menu bar to another frame or NULL).

   Under Windows, a size event is generated, so be sure to initialize
   data members properly before calling SetMenuBar.

   Note that on some platforms, it is not possible to call this function
   twice for the same frame object.

   See also

   wxFrame::GetMenuBar, wxMenuBar, wxMenu.

=head2 Wx::Frame::SetStatusBar

   void SetStatusBar(wxStatusBar* statusBar)

   Associates a status bar with the frame.

   See also

   wxFrame::CreateStatusBar, wxStatusBar, wxFrame::GetStatusBar

=head2 Wx::Frame::SetStatusBarPane

   void SetStatusBarPane(int n)

   Set the status bar pane used to display menu and toolbar help. Using
   -1 disables help display.

=head2 Wx::Frame::SetStatusText

   virtual void SetStatusText(const wxString& text, int number = 0)

   Sets the status bar text and redraws the status bar.

   Parameters

   text

       The text for the status field.

   number

       The status field (starting from zero).

   Remarks

   Use an empty string to clear the status bar.

   See also

   wxFrame::CreateStatusBar, wxStatusBar

=head2 Wx::Frame::SetStatusWidths

   virtual void SetStatusWidths(int n, int *widths)

   Sets the widths of the fields in the status bar.

   Parameters

   n   

       The number of fields in the status bar. It must be the same used
       in CreateStatusBar.

   widths

       Must contain an array of n integers, each of which is a status
       field width in pixels. A value of -1 indicates that the field is
       variable width; at least one field must be -1. You should delete
       this array after calling SetStatusWidths.

   Remarks

   The widths of the variable fields are calculated from the total width
   of all fields, minus the sum of widths of the non-variable fields,
   divided by the number of variable fields.

   wxPython note: Only a single parameter is required, a Python list of
   integers.

   wxPerl note: In wxPerl this method takes the field widths as
   parameters.

=head2 Wx::Frame::SetToolBar

   void SetToolBar(wxToolBar* toolBar)

   Associates a toolbar with the frame.

   See also

   wxFrame::CreateToolBar, wxToolBar, wxFrame::GetToolBar

=head1 Wx::FSFile

=head2 Wx::FSFile::new

   wxFSFile(wxInputStream *stream, const wxString& loc, const wxString&
   mimetype, const wxString& anchor, wxDateTime modif)

   Constructor. You probably won't use it. See Notes for details.

   Parameters

   stream

       The input stream that will be used to access data

   location

       The full location (aka filename) of the file

   mimetype

       MIME type of this file. Mime type is either extension-based or
       HTTP Content-Type

   anchor

       Anchor. See GetAnchor() for details.

   If you are not sure of the meaning of these params, see the
   description of the GetXXXX() functions.

   Notes

   It is seldom used by the application programmer but you will need it
   if you are writing your own virtual FS. For example you may need
   something similar to wxMemoryInputStream, but because
   wxMemoryInputStream doesn't free the memory when destroyed and thus
   passing a memory stream pointer into wxFSFile constructor would lead
   to memory leaks, you can write your own class derived from wxFSFile:

   class wxMyFSFile : public wxFSFile
   {
       private:
           void *m_Mem;
       public:
           wxMyFSFile(.....)
           ~wxMyFSFile() {free(m_Mem);}
               // of course dtor is virtual ;-)
   };

=head2 Wx::FSFile::DetachStream

   void DetachStream()

   Detaches the stream from the wxFSFile object. That is, the stream
   obtained with GetStream() will continue its existance after the
   wxFSFile object is deleted. You will have to delete the stream
   yourself.

=head2 Wx::FSFile::GetAnchor

   const wxString& GetAnchor() const

   Returns anchor (if present). The term of anchor can be easily
   explained using few examples:

   index.htm#anchor                      /* 'anchor' is anchor */
   index/wx001.htm                       /* NO anchor here!    */
   archive/main.zip#zip:index.htm#global /* 'global'           */
   archive/main.zip#zip:index.htm        /* NO anchor here!    */

   Usually an anchor is presented only if the MIME type is 'text/html'.
   But it may have some meaning with other files; for example
   myanim.avi#200 may refer to position in animation or
   reality.wrl#MyView may refer to a predefined view in VRML.

=head2 Wx::FSFile::GetLocation

   const wxString& GetLocation() const

   Returns full location of the file, including path and protocol.
   Examples :

   http://www.wxwidgets.org
   http://www.ms.mff.cuni.cz/~vsla8348/wxhtml/archive.zip#zip:info.txt
   file:/home/vasek/index.htm
   relative-file.htm

=head2 Wx::FSFile::GetMimeType

   const wxString& GetMimeType() const

   Returns the MIME type of the content of this file. It is either
   extension-based (see wxMimeTypesManager) or extracted from HTTP
   protocol Content-Type header.

=head2 Wx::FSFile::GetModificationTime

   wxDateTime GetModificationTime() const

   Returns time when this file was modified.

=head2 Wx::FSFile::GetStream

   wxInputStream* GetStream() const

   Returns pointer to the stream. You can use the returned stream to
   directly access data. You may suppose that the stream provide Seek and
   GetSize functionality (even in the case of the HTTP protocol which
   doesn't provide this by default. wxHtml uses local cache to work
   around this and to speed up the connection).

=head1 Wx::FTP

=head2 Wx::FTP::new

   wxFTP()

   Default constructor.

=head2 Wx::FTP::DESTROY

   ~wxFTP()

   Destructor will close the connection if connected.

=head2 Wx::FTP::Abort

   bool Abort()

   Aborts the download currently in process, returns true if ok, false if
   an error occurred.

=head2 Wx::FTP::CheckCommand

   bool CheckCommand(const wxString& command, char ret)

   Send the specified command to the FTP server. ret specifies the
   expected result.

   Return value

   true if the command has been sent successfully, else false.

=head2 Wx::FTP::SendCommand

   char SendCommand(const wxString& command)

   Send the specified command to the FTP server and return the first
   character of the return code.

=head2 Wx::FTP::GetLastResult

   const wxString& GetLastResult()

   Returns the last command result, i.e. the full server reply for the
   last command.

=head2 Wx::FTP::ChDir

   bool ChDir(const wxString& dir)

   Change the current FTP working directory. Returns true if successful.

=head2 Wx::FTP::MkDir

   bool MkDir(const wxString& dir)

   Create the specified directory in the current FTP working directory.
   Returns true if successful.

=head2 Wx::FTP::RmDir

   bool RmDir(const wxString& dir)

   Remove the specified directory from the current FTP working directory.
   Returns true if successful.

=head2 Wx::FTP::Pwd

   wxString Pwd()

   Returns the current FTP working directory.

=head2 Wx::FTP::Rename

   bool Rename(const wxString& src, const wxString& dst)

   Rename the specified src element to dst. Returns true if successful.

=head2 Wx::FTP::RmFile

   bool RmFile(const wxString& path)

   Delete the file specified by path. Returns true if successful.

=head2 Wx::FTP::SetAscii

   bool SetAscii()

   Sets the transfer mode to ASCII. It will be used for the next
   transfer.

=head2 Wx::FTP::SetBinary

   bool SetBinary()

   Sets the transfer mode to binary (IMAGE). It will be used for the next
   transfer.

=head2 Wx::FTP::SetPassive

   void SetPassive(bool pasv)

   If pasv is true, passive connection to the FTP server is used. This is
   the default as it works with practically all firewalls. If the server
   doesn't support passive move, you may call this function with false
   argument to use active connection.

=head2 Wx::FTP::SetTransferMode

   bool SetTransferMode(TransferMode mode)

   Sets the transfer mode to the specified one. It will be used for the
   next transfer.

   If this function is never called, binary transfer mode is used by
   default.

=head2 Wx::FTP::SetUser

   void SetUser(const wxString& user)

   Sets the user name to be sent to the FTP server to be allowed to log
   in.

   Default value

   The default value of the user name is "anonymous".

   Remark

   This parameter can be included in a URL if you want to use the URL
   manager. For example, you can use:
   "ftp://a_user:a_password@a.host:service/a_directory/a_file" to specify
   a user and a password.

=head2 Wx::FTP::SetPassword

   void SetPassword(const wxString& passwd)

   Sets the password to be sent to the FTP server to be allowed to log
   in.

   Default value

   The default value of the user name is your email address. For example,
   it could be "username@userhost.domain". This password is built by
   getting the current user name and the host name of the local machine
   from the system.

   Remark

   This parameter can be included in a URL if you want to use the URL
   manager. For example, you can use:
   "ftp://a_user:a_password@a.host:service/a_directory/a_file" to specify
   a user and a password.

=head2 Wx::FTP::FileExists

   bool FileExists(const wxString& filename)

   Returns true if the given remote file exists, false otherwise.

=head2 Wx::FTP::GetFileSize

   int GetFileSize(const wxString& filename)

   Returns the file size in bytes or -1 if the file doesn't exist or the
   size couldn't be determined. Notice that this size can be
   approximative size only and shouldn't be used for allocating the
   buffer in which the remote file is copied, for example.

=head2 Wx::FTP::GetDirList

   bool GetDirList(wxArrayString& files, const wxString& wildcard = "")

   The GetList function is quite low-level. It returns the list of the
   files in the current directory. The list can be filtered using the
   wildcard string. If wildcard is empty (default), it will return all
   files in directory.

   The form of the list can change from one peer system to another. For
   example, for a UNIX peer system, it will look like this:

   -r--r--r--   1 guilhem  lavaux      12738 Jan 16 20:17 cmndata.cpp
   -r--r--r--   1 guilhem  lavaux      10866 Jan 24 16:41 config.cpp
   -rw-rw-rw-   1 guilhem  lavaux      29967 Dec 21 19:17 cwlex_yy.c
   -rw-rw-rw-   1 guilhem  lavaux      14342 Jan 22 19:51 cwy_tab.c
   -r--r--r--   1 guilhem  lavaux      13890 Jan 29 19:18 date.cpp
   -r--r--r--   1 guilhem  lavaux       3989 Feb  8 19:18 datstrm.cpp

   But on Windows system, it will look like this:

   winamp~1 exe    520196 02-25-1999  19:28  winamp204.exe
           1 file(s)           520 196 bytes

   Return value: true if the file list was successfully retrieved, false
   otherwise.

   See also

   GetFilesList

=head2 Wx::FTP::GetFilesList

   bool GetFilesList(wxArrayString& files, const wxString& wildcard = "")

   This function returns the computer-parsable list of the files in the
   current directory (optionally only of the files matching the wildcard,
   all files by default). This list always has the same format and
   contains one full (including the directory path) file name per line.

   Return value: true if the file list was successfully retrieved, false
   otherwise.

=head2 Wx::FTP::GetOutputStream

   wxOutputStream * GetOutputStream(const wxString& file)

   Initializes an output stream to the specified file. The returned
   stream has all but the seek functionality of wxStreams. When the user
   finishes writing data, he has to delete the stream to close it.

   Return value

   An initialized write-only stream.

   See also

   wxOutputStream

=head2 Wx::FTP::GetInputStream

   wxInputStream * GetInputStream(const wxString& path)

   Creates a new input stream on the specified path. You can use all but
   the seek functionality of wxStream. Seek isn't available on all
   streams. For example, HTTP or FTP streams do not deal with it. Other
   functions like Tell are not available for this sort of stream, at
   present. You will be notified when the EOF is reached by an error.

   Return value

   Returns NULL if an error occurred (it could be a network failure or
   the fact that the file doesn't exist).

   Returns the initialized stream. You will have to delete it yourself
   when you don't need it anymore. The destructor closes the DATA stream
   connection but will leave the COMMAND stream connection opened. It
   means that you can still send new commands without reconnecting.

   Example of a standalone connection (without wxURL)

     wxFTP ftp;
     wxInputStream *in_stream;
     char *data;

=head1 Wx::Gauge

=head2 Wx::Gauge::new

   wxGauge()

   Default constructor.

   wxGauge(wxWindow* parent, wxWindowID id, int range, const wxPoint& pos
   = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style =
   wxGA_HORIZONTAL, const wxValidator& validator = wxDefaultValidator,
   const wxString& name = "gauge")

   Constructor, creating and showing a gauge.

   Parameters

   parent

       Window parent.

   id  

       Window identifier.

   range

       Integer range (maximum value) of the gauge. It is ignored when the
       gauge is used in indeterminate mode.

   pos 

       Window position.

   size

       Window size.

   style

       Gauge style. See wxGauge.

   name

       Window name.

   See also

   wxGauge::Create

=head2 Wx::Gauge::DESTROY

   ~wxGauge()

   Destructor, destroying the gauge.

=head2 Wx::Gauge::Create

   bool Create(wxWindow* parent, wxWindowID id, int range, const wxPoint&
   pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long
   style = wxGA_HORIZONTAL, const wxValidator& validator =
   wxDefaultValidator, const wxString& name = "gauge")

   Creates the gauge for two-step construction. See wxGauge::wxGauge for
   further details.

=head2 Wx::Gauge::GetBezelFace

   int GetBezelFace() const

   Returns the width of the 3D bezel face.

   Remarks

   This method is not implemented (returns 0) for most platforms.

   See also

   wxGauge::SetBezelFace

=head2 Wx::Gauge::GetRange

   int GetRange() const

   Returns the maximum position of the gauge.

   See also

   wxGauge::SetRange

=head2 Wx::Gauge::GetShadowWidth

   int GetShadowWidth() const

   Returns the 3D shadow margin width.

   Remarks

   This method is not implemented (returns 0) for most platforms.

   See also

   wxGauge::SetShadowWidth

=head2 Wx::Gauge::GetValue

   int GetValue() const

   Returns the current position of the gauge.

   See also

   wxGauge::SetValue

=head2 Wx::Gauge::IsVertical

   bool IsVertical() const

   Returns true if the gauge is vertical (has wxGA_VERTICAL style) and
   false otherwise.

=head2 Wx::Gauge::SetBezelFace

   void SetBezelFace(int width)

   Sets the 3D bezel face width.

   Remarks

   This method is not implemented (doesn't do anything) for most
   platforms.

   See also

   wxGauge::GetBezelFace

=head2 Wx::Gauge::SetRange

   void SetRange(int range)

   Sets the range (maximum value) of the gauge. This function makes the
   gauge switch to determinate mode, if it's not already.

   See also

   wxGauge::GetRange

=head2 Wx::Gauge::SetShadowWidth

   void SetShadowWidth(int width)

   Sets the 3D shadow width.

   Remarks

   This method is not implemented (doesn't do anything) for most
   platforms.

=head2 Wx::Gauge::SetValue

   void SetValue(int pos)

   Sets the position of the gauge. This function makes the gauge switch
   to determinate mode, if it's not already.

   Parameters

   pos 

       Position for the gauge level.

   See also

   wxGauge::GetValue

=head2 Wx::Gauge::Pulse

   void Pulse()

   Switch the gauge to indeterminate mode (if required) and makes the
   gauge move a bit to indicate the user that some progress has been
   made.

   Note that after calling this function the value returned by GetValue
   is undefined and thus you need to explicitely call SetValue if you
   want to restore the determinate mode.

=head1 Wx::GBPosition

=head2 Wx::GBPosition::new

   wxGBPosition()

   wxGBPosition(int row, int col)

   Construct a new wxGBPosition, optionally setting the row and column.
   The default is (0,0).

=head2 Wx::GBPosition::GetCol

   int GetCol() const

   Get the current column value.

=head2 Wx::GBPosition::GetRow

   int GetRow() const

   Get the current row value.

=head2 Wx::GBPosition::SetCol

   void SetCol(int col)

   Set a new column value.

=head2 Wx::GBPosition::SetRow

   void SetRow(int row)

   Set a new row value.

=head1 Wx::GBSizerItem

=head2 Wx::GBSizerItem::new

   wxGBSizerItem(int width, int height, const wxGBPosition& pos, const
   wxGBSpan& span, int flag, int border, wxObject* userData)

   Construct a sizer item for tracking a spacer.

   wxGBSizerItem(wxWindow* window, const wxGBPosition& pos, const
   wxGBSpan& span, int flag, int border, wxObject* userData)

   Construct a sizer item for tracking a window.

   wxGBSizerItem(wxSizer* sizer, const wxGBPosition& pos, const wxGBSpan&
   span, int flag, int border, wxObject* userData)

   Construct a sizer item for tracking a subsizer.

=head2 Wx::GBSizerItem::GetEndPos

   void GetEndPos(int& row, int& col)

   Get the row and column of the endpoint of this item

=head2 Wx::GBSizerItem::GetPos

   wxGBPosition GetPos() const

   void GetPos(int& row, int& col) const

   Get the grid position of the item.

=head2 Wx::GBSizerItem::GetSpan

   wxGBSpan GetSpan() const

   void GetSpan(int& rowspan, int& colspan) const

   Get the row and column spanning of the item.

=head2 Wx::GBSizerItem::Intersects

   bool Intersects(const wxGBSizerItem& other)

   Returns true if this item and the other item instersect

   bool Intersects(const wxGBPosition& pos, const wxGBSpan& span)

   Returns true if the given pos/span would intersect with this item.

=head2 Wx::GBSizerItem::SetPos

   bool SetPos(const wxGBPosition& pos)

   If the item is already a member of a sizer then first ensure that
   there is no other item that would intersect with this one at the new
   position, then set the new position. Returns true if the change is
   successful and after the next Layout the item will be moved.

=head2 Wx::GBSizerItem::SetSpan

   bool SetSpan(const wxGBSpan& span)

   If the item is already a member of a sizer then first ensure that
   there is no other item that would intersect with this one with its new
   spanning size, then set the new spanning. Returns true if the change
   is successful and after the next Layout the item will be resized.

=head1 Wx::GBSpan

=head2 Wx::GBSpan::new

   wxGBSpan()

   wxGBSpan(int rowspan, int colspan)

   Construct a new wxGBSpan, optionally setting the rowspan and colspan.
   The default is (1,1). (Meaning that the item occupies one cell in each
   direction.

=head2 Wx::GBSpan::GetColspan

   int GetColspan() const

   Get the current colspan value.

=head2 Wx::GBSpan::GetRowspan

   int GetRowspan() const

   Get the current rowspan value.

=head2 Wx::GBSpan::SetColspan

   void SetColspan(int colspan)

   Set a new colspan value.

=head2 Wx::GBSpan::SetRowspan

   void SetRowspan(int rowspan)

   Set a new rowspan value.

=head1 Wx::GDIObject

=head2 Wx::GDIObject::new

   wxGDIObject()

   Default constructor.

=head1 Wx::GenericDirCtrl

=head2 Wx::GenericDirCtrl::new

   wxGenericDirCtrl()

   Default constructor.

   wxGenericDirCtrl(wxWindow* parent, const wxWindowID id = -1, const
   wxString& dir = wxDirDialogDefaultFolderStr, const wxPoint& pos =
   wxDefaultPosition, const wxSize& size = wxDefaultSize, long style =
   wxDIRCTRL_3D_INTERNAL|wxSUNKEN_BORDER, const wxString& filter =
   wxEmptyString, int defaultFilter = 0, const wxString& name =
   wxTreeCtrlNameStr)

   Main constructor.

   Parameters

   parent

       Parent window.

   id  

       Window identifier.

   dir 

       Initial folder.

   pos 

       Position.

   size

       Size.

   style

       Window style. Please see wxGenericDirCtrl for a list of possible
       styles.

   filter

       A filter string, using the same syntax as that for wxFileDialog.
       This may be empty if filters are not being used.

       Example: "All files (*.*)|*.*|JPEG files (*.jpg)|*.jpg"

   defaultFilter

       The zero-indexed default filter setting.

   name

       The window name.

=head2 Wx::GenericDirCtrl::DESTROY

   ~wxGenericDirCtrl()

   Destructor.

=head2 Wx::GenericDirCtrl::Create

   bool Create(wxWindow* parent, const wxWindowID id = -1, const wxString&
   dir = wxDirDialogDefaultFolderStr, const wxPoint& pos =
   wxDefaultPosition, const wxSize& size = wxDefaultSize, long style =
   wxDIRCTRL_3D_INTERNAL|wxSUNKEN_BORDER, const wxString& filter =
   wxEmptyString, int defaultFilter = 0, const wxString& name =
   wxTreeCtrlNameStr)

   Create function for two-step construction. See
   wxGenericDirCtrl::wxGenericDirCtrl for details.

=head2 Wx::GenericDirCtrl::Init

   void Init()

   Initializes variables.

=head2 Wx::GenericDirCtrl::CollapseTree

   void CollapseTree()

   Collapses the entire tree.

=head2 Wx::GenericDirCtrl::ExpandPath

   bool ExpandPath(const wxString& path)

   Tries to expand as much of the given path as possible, so that the
   filename or directory is visible in the tree control.

=head2 Wx::GenericDirCtrl::CollapsePath

   bool CollapsePath(const wxString& path)

   Collapse the given path.

=head2 Wx::GenericDirCtrl::GetDefaultPath

   wxString GetDefaultPath() const

   Gets the default path.

=head2 Wx::GenericDirCtrl::GetPath

   wxString GetPath() const

   Gets the currently-selected directory or filename.

=head2 Wx::GenericDirCtrl::GetFilePath

   wxString GetFilePath() const

   Gets selected filename path only (else empty string).

   This function doesn't count a directory as a selection.

=head2 Wx::GenericDirCtrl::GetFilter

   wxString GetFilter() const

   Returns the filter string.

=head2 Wx::GenericDirCtrl::GetFilterIndex

   int GetFilterIndex() const

   Returns the current filter index (zero-based).

=head2 Wx::GenericDirCtrl::GetFilterListCtrl

   wxDirFilterListCtrl* GetFilterListCtrl() const

   Returns a pointer to the filter list control (if present).

=head2 Wx::GenericDirCtrl::GetRootId

   wxTreeItemId GetRootId()

   Returns the root id for the tree control.

=head2 Wx::GenericDirCtrl::GetTreeCtrl

   wxTreeCtrl* GetTreeCtrl() const

   Returns a pointer to the tree control.

=head2 Wx::GenericDirCtrl::ReCreateTree

   void ReCreateTree()

   Collapse and expand the tree, thus re-creating it from scratch. May be
   used to update the displayed directory content.

=head2 Wx::GenericDirCtrl::SetDefaultPath

   void SetDefaultPath(const wxString& path)

   Sets the default path.

=head2 Wx::GenericDirCtrl::SetFilter

   void SetFilter(const wxString& filter)

   Sets the filter string.

=head2 Wx::GenericDirCtrl::SetFilterIndex

   void SetFilterIndex(int n)

   Sets the current filter index (zero-based).

=head2 Wx::GenericDirCtrl::SetPath

   void SetPath(const wxString& path)

   Sets the current path.

=head2 Wx::GenericDirCtrl::ShowHidden

   void ShowHidden(bool show)

   Parameters

   show

       If true, hidden folders and files will be displayed by the
       control. If false, they will not be displayed.

=head1 Wx::GenericValidator

=head2 Wx::GenericValidator::new

   wxGenericValidator(const wxGenericValidator& validator)

   Copy constructor.

   wxGenericValidator(bool* valPtr)

   Constructor taking a bool pointer. This will be used for wxCheckBox
   and wxRadioButton.

   wxGenericValidator(wxString* valPtr)

   Constructor taking a wxString pointer. This will be used for wxButton,
   wxComboBox, wxStaticText, wxTextCtrl.

   wxGenericValidator(int* valPtr)

   Constructor taking an integer pointer. This will be used for wxGauge,
   wxScrollBar, wxRadioBox, wxSpinButton, wxChoice.

   wxGenericValidator(wxArrayInt* valPtr)

   Constructor taking a wxArrayInt pointer. This will be used for
   wxListBox, wxCheckListBox.

   Parameters

   validator

       Validator to copy.

   valPtr

       A pointer to a variable that contains the value. This variable
       should have a lifetime equal to or longer than the validator
       lifetime (which is usually determined by the lifetime of the
       window).

=head2 Wx::GenericValidator::DESTROY

   ~wxGenericValidator()

   Destructor.

=head2 Wx::GenericValidator::Clone

   virtual wxValidator* Clone() const

   Clones the generic validator using the copy constructor.

=head2 Wx::GenericValidator::TransferFromWindow

   virtual bool TransferFromWindow()

   Transfers the value from the window to the appropriate data type.

=head2 Wx::GenericValidator::TransferToWindow

   virtual bool TransferToWindow()

   Transfers the value to the window.

=head1 Wx::GLCanvas

=head2 Wx::GLCanvas::new

   void wxGLCanvas(wxWindow* parent, wxWindowID id = -1, const wxPoint&
   pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long
   style=0, const wxString& name="GLCanvas", int* attribList = 0, const
   wxPalette& palette = wxNullPalette)

   void wxGLCanvas(wxWindow* parent, wxGLContext* sharedContext,
   wxWindowID id = -1, const wxPoint& pos = wxDefaultPosition, const
   wxSize& size = wxDefaultSize, long style=0, const wxString&
   name="GLCanvas", int* attribList = 0, const wxPalette& palette =
   wxNullPalette)

   void wxGLCanvas(wxWindow* parent, wxGLCanvas* sharedCanvas, wxWindowID
   id = -1, const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style=0, const wxString& name="GLCanvas", int*
   attribList = 0, const wxPalette& palette = wxNullPalette)

   void wxGLCanvas(wxWindow* parent, wxWindowID id = wxID_ANY, int*
   attribList = 0, const wxPoint& pos = wxDefaultPosition, const wxSize&
   size = wxDefaultSize, long style=0, const wxString& name="GLCanvas",
   const wxPalette& palette = wxNullPalette)

   Constructors. The first three constructors implicitly create an
   instance of wxGLContext. The fourth constructur is identical to the
   first, except for the fact that it does not create such an implicit
   rendering context, which means that you have to create an explicit
   instance of wxGLContext yourself (highly recommended for future
   compatibility with wxWidgets and the flexibility of your own
   program!).

   Note that if you used one of the first three constructors,
   wxGLCanvas::GetContext returns the pointer to the implicitly created
   instance, and the wxGLCanvas::SetCurrent method without the parameter
   should be used. If however you used the fourth constructor,
   wxGLCanvas::GetContext always returns NULL and the
   wxGLCanvas::SetCurrent method with the parameter must be used!

   parent

       Pointer to a parent window.

   sharedContext

       Context to share object resources with.

   id  

       Window identifier. If -1, will automatically create an identifier.

   pos 

       Window position. wxDefaultPosition is (-1, -1) which indicates
       that wxWidgets should generate a default position for the window.

   size

       Window size. wxDefaultSize is (-1, -1) which indicates that
       wxWidgets should generate a default size for the window. If no
       suitable size can be found, the window will be sized to 20x20
       pixels so that the window is visible but obviously not correctly
       sized.

   style

       Window style.

   name

       Window name.

   attribList

       Array of int. With this parameter you can set the device context
       attributes associated to this window. This array is
       zero-terminated: it should be set up with constants described in
       the table above. If a constant should be followed by a value, put
       it in the next array position. For example, the WX_GL_DEPTH_SIZE
       should be followed by the value that indicates the number of bits
       for the depth buffer, so:

   attribList[index]= WX_GL_DEPTH_SIZE;
   attribList[index+1]=32;
   and so on.

   palette

       If the window has the palette, it should by pass this value. Note:
       palette and WX_GL_RGBA are mutually exclusive.

=head2 Wx::GLCanvas::GetContext

   wxGLContext* GetContext()

   Obtains the context that is associated with this canvas if one was
   implicitly created (by use of one of the first three constructors).
   Always returns NULL if the canvas was constructed with the fourth
   constructor.

=head2 Wx::GLCanvas::SetCurrent

   void SetCurrent()

   If this canvas was created with one of the first three constructors, a
   call to this method makes the implicit rendering context of this
   canvas current with this canvas, so that subsequent OpenGL calls
   modify the OpenGL state of the implicit rendering context.

   If this canvas was created with the fourth constructor, this method
   should not be called (use the SetCurrent method below with the
   parameter instead)!

   Note that this function may only be called after the window has been
   shown.

=head2 Wx::GLCanvas::SetCurrent

   void SetCurrent( const wxGLContext RC )

   If this canvas was created with one of the first three constructors,
   this method should not be called (use the SetCurrent above without the
   parameter instead)!

   If this canvas was created with the fourth constructor, a call to this
   method makes the OpenGL state that is represented by the OpenGL
   rendering context RC current with this canvas, and if win is an object
   of type wxGLCanvas, the statements win.SetCurrent(RC); and
   RC.SetCurrent(win); are equivalent, see wxGLContext::SetCurrent.

   Note that this function may only be called after the window has been
   shown.

=head2 Wx::GLCanvas::SetColour

   void SetColour(const char* colour)

   Sets the current colour for this window, using the wxWidgets colour
   database to find a named colour.

=head2 Wx::GLCanvas::SwapBuffers

   void SwapBuffers()

   Swaps the double-buffer of this window, making the back-buffer the
   front-buffer and vice versa, so that the output of the previous OpenGL
   commands is displayed on the window.

=head1 Wx::GLContext

=head2 Wx::GLContext::new

   wxGLContext( wxGLCanvas* win, const wxGLContext* other=NULL )

   Constructor.

   win 

       The canvas that is used to initialize this context. This parameter
       is needed only temporarily, and the caller may do anything with it
       (e.g. destroy the window) after the constructor returned.

       It will be possible to bind (make current) this context to any
       other wxGLCanvas that has been created with equivalent attributes
       as win.

   other

       Context to share display lists with or NULL (the default) for no
       sharing.

=head2 Wx::GLContext::SetCurrent

   void SetCurrent(const wxGLCanvas& win)

   Makes the OpenGL state that is represented by this rendering context
   current with the wxGLCanvas win. Note that win can be a different
   wxGLCanvas window than the one that was passed to the constructor of
   this rendering context. If RC is an object of type wxGLContext, the
   statements RC.SetCurrent(win); and win.SetCurrent(RC); are equivalent,
   see wxGLCanvas::SetCurrent.

=head1 Wx::GraphicsContext

=head2 Wx::GraphicsContext::Create

   wxGraphicsContext* Create(const wxWindowDC& dc)

   Creates a wxGraphicsContext from a wxWindowDC (eg a wxPaintDC).

   wxGraphicsContext* Create(wxWindow* window)

   Creates a wxGraphicsContext from a wxWindow.

   See also

   wxGraphicsRenderer:: CreateContext

=head2 Wx::GraphicsContext::CreateFromNative

   Creates a wxGraphicsContext from a native context. This native context
   must be eg a CGContextRef for Core Graphics, a Graphics pointer for
   GDIPlus or a cairo_t pointer for cairo.

   wxGraphicsContext* CreateFromNative(void * context)

   Creates a wxGraphicsContext from a native window.

   See also

   wxGraphicsRenderer:: CreateContextFromNativeContext

=head2 Wx::GraphicsContext::CreateFromNativeWindow

   wxGraphicsContext* CreateFromNativeWindow(void * window)

   See also

   wxGraphicsRenderer:: CreateContextFromNativeWindow

=head2 Wx::GraphicsContext::CreatePen

   wxGraphicsPen CreatePen(const wxPen& pen) const

   Creates a native pen from a wxPen.

=head2 Wx::GraphicsContext::CreateBrush

   wxGraphicsBrush CreateBrush(const wxBrush& brush) const

   Creates a native brush from a wxBrush.

=head2 Wx::GraphicsContext::CreateRadialGradientBrush

   wxGraphicsBrush CreateRadialGradientBrush(wxDouble xo, wxDouble yo,
   wxDouble xc, wxDouble yc, wxDouble radius, const wxColour& oColor,
   const wxColour& cColor) const

   Creates a native brush, having a radial gradient originating at
   (xo,yc) with color oColour and ends on a circle around (xc,yc) with
   radius r and color cColour

=head2 Wx::GraphicsContext::CreateLinearGradientBrush

   wxGraphicsBrush CreateLinearGradientBrush(wxDouble x1, wxDouble y1,
   wxDouble x2, wxDouble y2, const wxColour&c1, const wxColour&c2) const

   Creates a native brush, having a linear gradient, starting at (x1,y1)
   with color c1 to (x2,y2) with color c2

=head2 Wx::GraphicsContext::CreateFont

   wxGraphicsFont CreateFont(const wxFont& font, const wxColour& col =
   *wxBLACK) const

   Creates a native graphics font from a wxFont and a text colour.

=head2 Wx::GraphicsContext::CreateMatrix

   wxGraphicsMatrix CreateMatrix(wxDouble a = 1.0, wxDouble b = 0.0,
   wxDouble c = 0.0, wxDouble d = 1.0, wxDouble tx = 0.0, wxDouble ty =
   0.0) const

   Creates a native affine transformation matrix from the passed in
   values. The defaults result in an identity matrix.

=head2 Wx::GraphicsContext::CreatePath

   wxGraphicsPath CreatePath() const

   Creates a native graphics path which is initially empty.

=head2 Wx::GraphicsContext::Clip

   void Clip(const wxRegion& region)

   Clips drawings to the region, combined to current clipping region

   void Clip(wxDouble x, wxDouble y, wxDouble w, wxDouble h)

   Clips drawings to the rectangle.

=head2 Wx::GraphicsContext::ResetClip

   void ResetClip()

   Resets the clipping to original shape.

=head2 Wx::GraphicsContext::DrawBitmap

   void DrawBitmap(const wxBitmap& bmp, wxDouble x, wxDouble y, wxDouble
   w, wxDouble h)

   Draws the bitmap. In case of a mono bitmap, this is treated as a mask
   and the current brushed is used for filling.

=head2 Wx::GraphicsContext::DrawEllipse

   void DrawEllipse(wxDouble x, wxDouble y, wxDouble w, wxDouble h)

   Draws an ellipse.

=head2 Wx::GraphicsContext::DrawIcon

   void DrawIcon(const wxIcon& icon, wxDouble x, wxDouble y, wxDouble w,
   wxDouble h)

   Draws the icon.

=head2 Wx::GraphicsContext::DrawLines

   void DrawLines(size_t n, const wxPoint2DDouble* points, int fillStyle
   = wxODDEVEN_RULE)

   Draws a polygon.

=head2 Wx::GraphicsContext::DrawPath

   void DrawPath(const wxGraphicsPath& path, int fillStyle =
   wxODDEVEN_RULE)

   Draws the path by first filling and then stroking.

=head2 Wx::GraphicsContext::DrawRectangle

   void DrawRectangle(wxDouble x, wxDouble y, wxDouble w, wxDouble h)

   Draws a rectangle.

=head2 Wx::GraphicsContext::DrawRoundedRectangle

   void DrawRoundedRectangle(wxDouble x, wxDouble y, wxDouble w, wxDouble
   h, wxDouble radius)

   Draws a rounded rectangle.

=head2 Wx::GraphicsContext::DrawText

   void DrawText(const wxString& str, wxDouble x, wxDouble y, wxDouble
   angle)

   void DrawText(const wxString& str, wxDouble x, wxDouble y)

   Draws a text at the defined position, at the given angle.

=head2 Wx::GraphicsContext::FillPath

   void FillPath(const wxGraphicsPath& path, int fillStyle =
   wxODDEVEN_RULE)

   Fills the path with the current brush.

=head2 Wx::GraphicsContext::StrokePath

   void StrokePath(const wxGraphicsPath& path)

   Strokes along a path with the current pen.

=head2 Wx::GraphicsContext::GetNativeContext

   void * GetNativeContext()

   Returns the native context (CGContextRef for Core Graphics, Graphics
   pointer for GDIPlus and cairo_t pointer for cairo).

=head2 Wx::GraphicsContext::GetPartialTextExtents

   void GetPartialTextExtents(const wxString& text, wxArrayDouble& widths)
   const

   Fills the widths array with the widths from the beginning of text to
   the corresponding character of text.

=head2 Wx::GraphicsContext::GetTextExtent

   void GetTextExtent(const wxString& text, wxDouble* width, wxDouble*
   height, wxDouble* descent, wxDouble* externalLeading) const

   Gets the dimensions of the string using the currently selected font.
   string is the text string to measure, w and h are the total width and
   height respectively, descent is the dimension from the baseline of the
   font to the bottom of the descender, and externalLeading is any extra
   vertical space added to the font by the font designer (usually is
   zero).

=head2 Wx::GraphicsContext::Rotate

   void Rotate(wxDouble angle)

   Rotates the current transformation matrix (radians),

=head2 Wx::GraphicsContext::Scale

   void Scale(wxDouble xScale, wxDouble yScale)

   Scales the current transformation matrix.

=head2 Wx::GraphicsContext::Translate

   void Translate(wxDouble dx, wxDouble dy)

   Translates the current transformation matrix.

=head2 Wx::GraphicsContext::GetTransform

   wxGraphicsMatrix GetTransform() const

   Gets the current transformation matrix of this context.

=head2 Wx::GraphicsContext::SetTransform

   void SetTransform(const wxGraphicsMatrix& matrix)

   Sets the current transformation matrix of this context

=head2 Wx::GraphicsContext::ConcatTransform

   void ConcatTransform(const wxGraphicsMatrix& matrix)

   Concatenates the passed in transform with the current transform of
   this context

=head2 Wx::GraphicsContext::SetBrush

   void SetBrush(const wxBrush& brush)

   void SetBrush(const wxGraphicsBrush& brush)

   Sets the brush for filling paths.

=head2 Wx::GraphicsContext::SetFont

   void SetFont(const wxFont& font, const wxColour& colour)

=head2 Wx::GraphicsContext::SetPen

   void SetPen(const wxGraphicsPen& pen)

   void SetPen(const wxPen& pen)

   Sets the pen used for stroking.

=head2 Wx::GraphicsContext::StrokeLine

   void StrokeLine(wxDouble x1, wxDouble y1, wxDouble x2, wxDouble y2)

   Strokes a single line.

=head2 Wx::GraphicsContext::StrokeLines

   void StrokeLines(size_t n, const wxPoint2DDouble* beginPoints, const
   wxPoint2DDouble* endPoints)

   void StrokeLines(size_t n, const wxPoint2DDouble* points)

   Stroke disconnected lines from begin to end points, fastest method
   available for this purpose.

=head1 Wx::GraphicsMatrix

=head2 Wx::GraphicsMatrix::Concat

   void Concat(const wxGraphicsMatrix* t)

   Concatenates the matrix passed with the current matrix.

   void Concat(const wxGraphicsMatrix& t)

=head2 Wx::GraphicsMatrix::Get

   void Get(wxDouble* a=NULL, wxDouble* b=NULL, wxDouble* c=NULL,
   wxDouble* d=NULL, wxDouble* tx=NULL, wxDouble* ty=NULL) const

   Returns the component values of the matrix via the argument pointers.

=head2 Wx::GraphicsMatrix::GetNativeMatrix

   void * GetNativeMatrix() const

   Returns the native representation of the matrix. For CoreGraphics this
   is a CFAffineMatrix pointer. For GDIPlus a Matrix Pointer and for
   Cairo a cairo_matrix_t pointer.

=head2 Wx::GraphicsMatrix::Invert

   void Invert()

   Inverts the matrix.

=head2 Wx::GraphicsMatrix::IsEqual

   bool IsEqual(const wxGraphicsMatrix& t) const

   Returns true if the elements of the transformation matrix are equal.

=head2 Wx::GraphicsMatrix::IsIdentity

   bool IsIdentity() const

   Return true if this is the identity matrix.

=head2 Wx::GraphicsMatrix::Rotate

   void Rotate(wxDouble angle)

   Rotates this matrix (radians).

=head2 Wx::GraphicsMatrix::Scale

   void Scale(wxDouble xScale, wxDouble yScale)

   Scales this matrix.

=head2 Wx::GraphicsMatrix::Translate

   void Translate(wxDouble dx, wxDouble dy)

   Translates this matrix.

=head2 Wx::GraphicsMatrix::Set

   void Set(wxDouble a = 1.0, wxDouble b = 0.0, wxDouble c = 0.0,
   wxDouble d = 1.0, wxDouble tx = 0.0, wxDouble ty = 0.0)

   Sets the matrix to the respective values (default values are the
   identity matrix)

=head2 Wx::GraphicsMatrix::TransformPoint

   void TransformPoint(wxDouble* x, wxDouble* y) const

   Applies this matrix to a point.

=head2 Wx::GraphicsMatrix::TransformDistance

   void TransformDistance(wxDouble* dx, wxDouble* dy) const

   Applies this matrix to a distance (ie. performs all transforms except
   translations)

=head1 Wx::GraphicsObject

=head2 Wx::GraphicsObject::GetRenderer

   wxGraphicsRenderer* GetRenderer() const

   Returns the renderer that was used to create this instance, or NULL if
   it has not been initialized yet

=head2 Wx::GraphicsObject::IsNull

   bool IsNull() const

   Is this object valid (false) or still empty (true)?

=head1 Wx::GraphicsPath

=head2 Wx::GraphicsPath::MoveToPoint

   void MoveToPoint(wxDouble x, wxDouble y)

   void MoveToPoint(const wxPoint2DDouble& p)

   Begins a new subpath at (x,y)

=head2 Wx::GraphicsPath::AddArc

   void AddArc(wxDouble x, wxDouble y, wxDouble r, wxDouble startAngle,
   wxDouble endAngle, bool clockwise)

   Adds an arc of a circle centering at (x,y) with radius (r) from
   startAngle to endAngle.

   void AddArc(const wxPoint2DDouble& c, wxDouble r, wxDouble startAngle,
   wxDouble endAngle, bool clockwise)

=head2 Wx::GraphicsPath::AddArcToPoint

   void AddArcToPoint(wxDouble x1, wxDouble y1, wxDouble x2, wxDouble y2,
   wxDouble r)

   Appends a an arc to two tangents connecting (current) to (x1,y1) and
   (x1,y1) to (x2,y2), also a straight line from (current) to (x1,y1).

=head2 Wx::GraphicsPath::AddCircle

   void AddCircle(wxDouble x, wxDouble y, wxDouble r)

   Appends a circle around (x,y) with radius r as a new closed subpath.

=head2 Wx::GraphicsPath::AddCurveToPoint

   void AddCurveToPoint(wxDouble cx1, wxDouble cy1, wxDouble cx2,
   wxDouble cy2, wxDouble x, wxDouble y)

   Adds a cubic Bezier curve from the current point, using two control
   points and an end point.

   void AddCurveToPoint(const wxPoint2DDouble& c1, const wxPoint2DDouble&
   c2, const wxPoint2DDouble& e)

=head2 Wx::GraphicsPath::AddEllipse

   void AddEllipse(wxDouble x, wxDouble y, wxDouble w, wxDouble h)

   Appends an ellipse fitting into the passed in rectangle.

=head2 Wx::GraphicsPath::AddLineToPoint

   void AddLineToPoint(wxDouble x, wxDouble y)

   Adds a straight line from the current point to (x,y).

   void AddLineToPoint(const wxPoint2DDouble& p)

=head2 Wx::GraphicsPath::AddPath

   void AddPath(const wxGraphicsPath& path)

   Adds another path.

=head2 Wx::GraphicsPath::AddQuadCurveToPoint

   void AddQuadCurveToPoint(wxDouble cx, wxDouble cy, wxDouble x,
   wxDouble y)

   Adds a quadratic Bezier curve from the current point, using a control
   point and an end point.

=head2 Wx::GraphicsPath::AddRectangle

   void AddRectangle(wxDouble x, wxDouble y, wxDouble w, wxDouble h)

   Appends a rectangle as a new closed subpath.

=head2 Wx::GraphicsPath::AddRoundedRectangle

   void AddRoundedRectangle(wxDouble x, wxDouble y, wxDouble w, wxDouble
   h, wxDouble radius)

   Appends a rounded rectangle as a new closed subpath.

=head2 Wx::GraphicsPath::CloseSubpath

   void CloseSubpath()

   Closes the current sub-path.

=head2 Wx::GraphicsPath::Contains

   bool Contains(const wxPoint2DDouble& c, int fillStyle = wxODDEVEN_RULE)
   const

   bool Contains(wxDouble x, wxDouble y, int fillStyle = wxODDEVEN_RULE)
   const

   Returns true if the point is within the path.

=head2 Wx::GraphicsPath::GetBox

   wxRect2DDouble GetBox() const

   void GetBox(wxDouble* x, wxDouble* y, wxDouble* w, wxDouble* h) const

   Gets the bounding box enclosing all points (possibly including control
   points).

=head2 Wx::GraphicsPath::GetCurrentPoint

   void GetCurrentPoint(wxDouble* x, wxDouble* y) const

   wxPoint2DDouble GetCurrentPoint() const

   Gets the last point of the current path, (0,0) if not yet set.

=head2 Wx::GraphicsPath::Transform

   void Transform(const wxGraphicsMatrix& matrix)

   Transforms each point of this path by the matrix.

=head2 Wx::GraphicsPath::GetNativePath

   void * GetNativePath() const

   Returns the native path (CGPathRef for Core Graphics, Path pointer for
   GDIPlus and a cairo_path_t pointer for cairo).

=head2 Wx::GraphicsPath::UnGetNativePath

   void UnGetNativePath(void* p) const

   Gives back the native path returned by GetNativePath() because there
   might be some deallocations necessary (eg on cairo the native path
   returned by GetNativePath is newly allocated each time).

=head1 Wx::GraphicsRenderer

=head2 Wx::GraphicsRenderer::GetDefaultRenderer

   wxGraphicsRenderer* GetDefaultRenderer()

   Returns the default renderer on this platform. On OS X this is the
   Core Graphics (a.k.a. Quartz 2D) renderer, on MSW the GDIPlus
   renderer, and on GTK we currently default to the cairo renderer.

=head2 Wx::GraphicsRenderer::CreateContext

   wxGraphicsContext * CreateContext(const wxWindowDC& dc)

   Creates a wxGraphicsContext from a wxWindowDC (eg a wxPaintDC).

   wxGraphicsContext * CreateContext(wxWindow* window)

   Creates a wxGraphicsContext from a wxWindow.

=head2 Wx::GraphicsRenderer::CreateContextFromNativeContext

   wxGraphicsContext * CreateContextFromNativeContext(void * context)

   Creates a wxGraphicsContext from a native context. This native context
   must be eg a CGContextRef for Core Graphics, a Graphics pointer for
   GDIPlus or a cairo_t pointer for cairo.

=head2 Wx::GraphicsRenderer::CreateContextFromNativeWindow

   wxGraphicsContext * CreateContextFromNativeWindow(void * window)

   Creates a wxGraphicsContext from a native window.

=head2 Wx::GraphicsRenderer::CreatePen

   wxGraphicsPen CreatePen(const wxPen& pen)

   Creates a native pen from a wxPen.

=head2 Wx::GraphicsRenderer::CreateBrush

   wxGraphicsBrush CreateBrush(const wxBrush& brush)

   Creates a native brush from a wxBrush.

=head2 Wx::GraphicsRenderer::CreateLinearGradientBrush

   wxGraphicsBrush CreateLinearGradientBrush(wxDouble x1, wxDouble y1,
   wxDouble x2, wxDouble y2, const wxColour&c1, const wxColour&c2)

   Creates a native brush, having a linear gradient, starting at (x1,y1)
   with color c1 to (x2,y2) with color c2

=head2 Wx::GraphicsRenderer::CreateRadialGradientBrush

   wxGraphicsBrush CreateRadialGradientBrush(wxDouble xo, wxDouble yo,
   wxDouble xc, wxDouble yc, wxDouble radius, const wxColour& oColour,
   const wxColour& cColour)

   Creates a native brush, having a radial gradient originating at
   (xo,yc) with color oColour and ends on a circle around (xc,yc) with
   radius r and color cColour

=head2 Wx::GraphicsRenderer::CreateFont

   wxGraphicsFont CreateFont(const wxFont& font, const wxColour& col =
   *wxBLACK)

   Creates a native graphics font from a wxFont and a text colour.

=head2 Wx::GraphicsRenderer::CreateMatrix

   wxGraphicsMatrix CreateMatrix(wxDouble a = 1.0, wxDouble b = 0.0,
   wxDouble c = 0.0, wxDouble d = 1.0, wxDouble tx = 0.0, wxDouble ty =
   0.0)

   Creates a native affine transformation matrix from the passed in
   values. The defaults result in an identity matrix.

=head2 Wx::GraphicsRenderer::CreatePath

   wxGraphicsPath CreatePath()

   Creates a native graphics path which is initially empty.

=head1 Wx::Grid

=head2 Constructors and initialization

   wxGrid

=head2 Display format



=head2 Selection functions

   wxGrid::ClearSelection

=head2 Wx::Grid::new

   wxGrid()

   Default constructor

   wxGrid(wxWindow* parent, wxWindowID id, const wxPoint& pos =
   wxDefaultPosition, const wxSize& size = wxDefaultSize, long style =
   wxWANTS_CHARS, const wxString& name = wxPanelNameStr)

   Constructor to create a grid object. Call either wxGrid::CreateGrid or
   wxGrid::SetTable directly after this to initialize the grid before
   using it.

=head2 Wx::Grid::DESTROY

   ~wxGrid()

   Destructor. This will also destroy the associated grid table unless
   you passed a table object to the grid and specified that the grid
   should not take ownership of the table (see wxGrid::SetTable).

=head2 Wx::Grid::AppendCols

   bool AppendCols(int numCols = 1, bool updateLabels = true)

   Appends one or more new columns to the right of the grid and returns
   true if successful. The updateLabels argument is not used at present.

   If you are using a derived grid table class you will need to override
   wxGridTableBase::AppendCols. See wxGrid::InsertCols for further
   information.

=head2 Wx::Grid::AppendRows

   bool AppendRows(int numRows = 1, bool updateLabels = true)

   Appends one or more new rows to the bottom of the grid and returns
   true if successful. The updateLabels argument is not used at present.

   If you are using a derived grid table class you will need to override
   wxGridTableBase::AppendRows. See wxGrid::InsertRows for further
   information.

=head2 Wx::Grid::AutoSize

   void AutoSize()

   Automatically sets the height and width of all rows and columns to fit
   their contents.

   Note

=head2 Wx::Grid::AutoSizeColumn

   void AutoSizeColumn(int col, bool setAsMin = true)

   Automatically sizes the column to fit its contents. If setAsMin is
   true the calculated width will also be set as the minimal width for
   the column.

   Note

=head2 Wx::Grid::AutoSizeColumns

   void AutoSizeColumns(bool setAsMin = true)

   Automatically sizes all columns to fit their contents. If setAsMin is
   true the calculated widths will also be set as the minimal widths for
   the columns.

   Note

=head2 Wx::Grid::AutoSizeRow

   void AutoSizeRow(int row, bool setAsMin = true)

   Automatically sizes the row to fit its contents. If setAsMin is true
   the calculated height will also be set as the minimal height for the
   row.

   Note

=head2 Wx::Grid::AutoSizeRows

   void AutoSizeRows(bool setAsMin = true)

   Automatically sizes all rows to fit their contents. If setAsMin is
   true the calculated heights will also be set as the minimal heights
   for the rows.

   Note

=head2 Wx::Grid::BeginBatch

   void BeginBatch()

   Increments the grid's batch count. When the count is greater than zero
   repainting of the grid is suppressed. Each call to BeginBatch must be
   matched by a later call to wxGrid::EndBatch. Code that does a lot of
   grid modification can be enclosed between BeginBatch and EndBatch
   calls to avoid screen flicker. The final EndBatch will cause the grid
   to be repainted.

=head2 Wx::Grid::BlockToDeviceRect

   wxRect BlockToDeviceRect(const wxGridCellCoords & topLeft, const
   wxGridCellCoords & bottomRight)

   This function returns the rectangle that encloses the block of cells
   limited by TopLeft and BottomRight cell in device coords and clipped
   to the client size of the grid window.

=head2 Wx::Grid::CanDragColMove

   bool CanDragColMove()

   Returns true if columns can be moved by dragging with the mouse.
   Columns can be moved by dragging on their labels.

=head2 Wx::Grid::CanDragColSize

   bool CanDragColSize()

   Returns true if columns can be resized by dragging with the mouse.
   Columns can be resized by dragging the edges of their labels. If grid
   line dragging is enabled they can also be resized by dragging the
   right edge of the column in the grid cell area (see
   wxGrid::EnableDragGridSize).

=head2 Wx::Grid::CanDragRowSize

   bool CanDragRowSize()

   Returns true if rows can be resized by dragging with the mouse. Rows
   can be resized by dragging the edges of their labels. If grid line
   dragging is enabled they can also be resized by dragging the lower
   edge of the row in the grid cell area (see wxGrid::EnableDragGridSize).

=head2 Wx::Grid::CanDragGridSize

   bool CanDragGridSize()

   Return true if the dragging of grid lines to resize rows and columns
   is enabled or false otherwise.

=head2 Wx::Grid::CanEnableCellControl

   bool CanEnableCellControl() const

   Returns true if the in-place edit control for the current grid cell
   can be used and false otherwise (e.g. if the current cell is
   read-only).

=head2 Wx::Grid::CanHaveAttributes

   bool CanHaveAttributes()

   Do we have some place to store attributes in?

=head2 Wx::Grid::CellToRect

   wxRect CellToRect(int row, int col)

   wxRect CellToRect(const wxGridCellCoords& coords)

   Return the rectangle corresponding to the grid cell's size and
   position in logical coordinates.

=head2 Wx::Grid::ClearGrid

   void ClearGrid()

   Clears all data in the underlying grid table and repaints the grid.
   The table is not deleted by this function. If you are using a derived
   table class then you need to override wxGridTableBase::Clear for this
   function to have any effect.

=head2 Wx::Grid::ClearSelection

   void ClearSelection()

   Deselects all cells that are currently selected.

=head2 Wx::Grid::CreateGrid

   bool CreateGrid(int numRows, int numCols, wxGrid::wxGridSelectionModes
   selmode = wxGrid::wxGridSelectCells)

   Creates a grid with the specified initial number of rows and columns.
   Call this directly after the grid constructor. When you use this
   function wxGrid will create and manage a simple table of string values
   for you. All of the grid data will be stored in memory.

   For applications with more complex data types or relationships, or for
   dealing with very large datasets, you should derive your own grid
   table class and pass a table object to the grid with wxGrid::SetTable.

=head2 Wx::Grid::DeleteCols

   bool DeleteCols(int pos = 0, int numCols = 1, bool updateLabels = true)

   Deletes one or more columns from a grid starting at the specified
   position and returns true if successful. The updateLabels argument is
   not used at present.

   If you are using a derived grid table class you will need to override
   wxGridTableBase::DeleteCols. See wxGrid::InsertCols for further
   information.

=head2 Wx::Grid::DeleteRows

   bool DeleteRows(int pos = 0, int numRows = 1, bool updateLabels = true)

   Deletes one or more rows from a grid starting at the specified
   position and returns true if successful. The updateLabels argument is
   not used at present.

   If you are using a derived grid table class you will need to override
   wxGridTableBase::DeleteRows. See wxGrid::InsertRows for further
   information.

=head2 Wx::Grid::DisableCellEditControl

   void DisableCellEditControl()

   Disables in-place editing of grid cells. Equivalent to calling
   EnableCellEditControl(false).

=head2 Wx::Grid::DisableDragColMove

   void DisableDragColMove()

   Disables column moving by dragging with the mouse. Equivalent to
   passing false to wxGrid::EnableDragColMove.

=head2 Wx::Grid::DisableDragColSize

   void DisableDragColSize()

   Disables column sizing by dragging with the mouse. Equivalent to
   passing false to wxGrid::EnableDragColSize.

=head2 Wx::Grid::DisableDragGridSize

   void DisableDragGridSize()

   Disable mouse dragging of grid lines to resize rows and columns.
   Equivalent to passing false to wxGrid::EnableDragGridSize

=head2 Wx::Grid::DisableDragRowSize

   void DisableDragRowSize()

   Disables row sizing by dragging with the mouse. Equivalent to passing
   false to wxGrid::EnableDragRowSize.

=head2 Wx::Grid::EnableCellEditControl

   void EnableCellEditControl(bool enable = true)

   Enables or disables in-place editing of grid cell data. The grid will
   issue either a wxEVT_GRID_EDITOR_SHOWN or wxEVT_GRID_EDITOR_HIDDEN
   event.

=head2 Wx::Grid::EnableDragColSize

   void EnableDragColSize(bool enable = true)

   Enables or disables column sizing by dragging with the mouse.

=head2 Wx::Grid::EnableDragColMove

   void EnableDragColMove(bool enable = true)

   Enables or disables column moving by dragging with the mouse.

=head2 Wx::Grid::EnableDragGridSize

   void EnableDragGridSize(bool enable = true)

   Enables or disables row and column resizing by dragging gridlines with
   the mouse.

=head2 Wx::Grid::EnableDragRowSize

   void EnableDragRowSize(bool enable = true)

   Enables or disables row sizing by dragging with the mouse.

=head2 Wx::Grid::EnableEditing

   void EnableEditing(bool edit)

   If the edit argument is false this function sets the whole grid as
   read-only. If the argument is true the grid is set to the default
   state where cells may be editable. In the default state you can set
   single grid cells and whole rows and columns to be editable or
   read-only via wxGridCellAttribute::SetReadOnly. For single cells you
   can also use the shortcut function wxGrid::SetReadOnly.

   For more information about controlling grid cell attributes see the
   wxGridCellAttr cell attribute class and the wxGrid classes overview.

=head2 Wx::Grid::EnableGridLines

   void EnableGridLines(bool enable = true)

   Turns the drawing of grid lines on or off.

=head2 Wx::Grid::EndBatch

   void EndBatch()

   Decrements the grid's batch count. When the count is greater than zero
   repainting of the grid is suppressed. Each previous call to
   wxGrid::BeginBatch must be matched by a later call to EndBatch. Code
   that does a lot of grid modification can be enclosed between
   BeginBatch and EndBatch calls to avoid screen flicker. The final
   EndBatch will cause the grid to be repainted.

=head2 Wx::Grid::Fit

   void Fit()

   Overridden wxWindow method.

=head2 Wx::Grid::ForceRefresh

   void ForceRefresh()

   Causes immediate repainting of the grid. Use this instead of the usual
   wxWindow::Refresh.

=head2 Wx::Grid::GetBatchCount

   int GetBatchCount()

   Returns the number of times that wxGrid::BeginBatch has been called
   without (yet) matching calls to wxGrid::EndBatch. While the grid's
   batch count is greater than zero the display will not be updated.

=head2 Wx::Grid::GetCellAlignment

   void GetCellAlignment(int row, int col, int* horiz, int* vert)

   Sets the arguments to the horizontal and vertical text alignment
   values for the grid cell at the specified location.

   Horizontal alignment will be one of wxALIGN_LEFT, wxALIGN_CENTRE or
   wxALIGN_RIGHT.

=head2 Wx::Grid::GetCellBackgroundColour

   wxColour GetCellBackgroundColour(int row, int col)

   Returns the background colour of the cell at the specified location.

=head2 Wx::Grid::GetCellEditor

   wxGridCellEditor* GetCellEditor(int row, int col)

   Returns a pointer to the editor for the cell at the specified
   location.

   See wxGridCellEditor and the wxGrid overview for more information
   about cell editors and renderers.

=head2 Wx::Grid::GetCellFont

   wxFont GetCellFont(int row, int col)

   Returns the font for text in the grid cell at the specified location.

=head2 Wx::Grid::GetCellRenderer

   wxGridCellRenderer* GetCellRenderer(int row, int col)

   Returns a pointer to the renderer for the grid cell at the specified
   location.

   See wxGridCellRenderer and the wxGrid overview for more information
   about cell editors and renderers.

=head2 Wx::Grid::GetCellTextColour

   wxColour GetCellTextColour(int row, int col)

   Returns the text colour for the grid cell at the specified location.

=head2 Wx::Grid::GetCellValue

   wxString GetCellValue(int row, int col)

   wxString GetCellValue(const wxGridCellCoords&coords)

   Returns the string contained in the cell at the specified location.
   For simple applications where a grid object automatically uses a
   default grid table of string values you use this function together
   with wxGrid::SetCellValue to access cell values.

   For more complex applications where you have derived your own grid
   table class that contains various data types (e.g. numeric, boolean or
   user-defined custom types) then you only use this function for those
   cells that contain string values.

   See wxGridTableBase::CanGetValueAs and the wxGrid overview for more
   information.

=head2 Wx::Grid::GetColAt

   int GetColAt(int colPos) const

   Returns the column ID of the specified column position.

=head2 Wx::Grid::GetColLeft

   int GetColLeft(int col) const

=head2 Wx::Grid::GetColLabelAlignment

   void GetColLabelAlignment(int* horiz, int* vert)

   Sets the arguments to the current column label alignment values.

   Horizontal alignment will be one of wxALIGN_LEFT, wxALIGN_CENTRE or
   wxALIGN_RIGHT.

=head2 Wx::Grid::GetColLabelSize

   int GetColLabelSize()

   Returns the current height of the column labels.

=head2 Wx::Grid::GetColLabelValue

   wxString GetColLabelValue(int col)

   Returns the specified column label. The default grid table class
   provides column labels of the form A,B...Z,AA,AB...ZZ,AAA... If you
   are using a custom grid table you can override
   wxGridTableBase::GetColLabelValue to provide your own labels.

=head2 Wx::Grid::GetColMinimalAcceptableWidth

   int GetColMinimalAcceptableWidth()

   This returns the value of the lowest column width that can be handled
   correctly. See member SetColMinimalAcceptableWidth for details.

=head2 Wx::Grid::GetColMinimalWidth

   int GetColMinimalWidth(int col) const

   Get the minimal width of the given column/row.

=head2 Wx::Grid::GetColPos

   int GetColPos(int colID) const

   Returns the position of the specified column.

=head2 Wx::Grid::GetColRight

   int GetColRight(int col) const

=head2 Wx::Grid::GetColSize

   int GetColSize(int col)

   Returns the width of the specified column.

=head2 Wx::Grid::GetDefaultCellAlignment

   void GetDefaultCellAlignment(int* horiz, int* vert)

   Sets the arguments to the current default horizontal and vertical text
   alignment values.

   Horizontal alignment will be one of wxALIGN_LEFT, wxALIGN_CENTRE or
   wxALIGN_RIGHT.

=head2 Wx::Grid::GetDefaultCellBackgroundColour

   wxColour GetDefaultCellBackgroundColour()

   Returns the current default background colour for grid cells.

=head2 Wx::Grid::GetDefaultCellFont

   wxFont GetDefaultCellFont()

   Returns the current default font for grid cell text.

=head2 Wx::Grid::GetDefaultCellTextColour

   wxColour GetDefaultCellTextColour()

   Returns the current default colour for grid cell text.

=head2 Wx::Grid::GetDefaultColLabelSize

   int GetDefaultColLabelSize()

   Returns the default height for column labels.

=head2 Wx::Grid::GetDefaultColSize

   int GetDefaultColSize()

   Returns the current default width for grid columns.

=head2 Wx::Grid::GetDefaultEditor

   wxGridCellEditor* GetDefaultEditor() const

   Returns a pointer to the current default grid cell editor.

   See wxGridCellEditor and the wxGrid overview for more information
   about cell editors and renderers.

=head2 Wx::Grid::GetDefaultEditorForCell

   wxGridCellEditor* GetDefaultEditorForCell(int row, int col) const

   wxGridCellEditor* GetDefaultEditorForCell(const wxGridCellCoords& c)
   const

=head2 Wx::Grid::GetDefaultEditorForType

   wxGridCellEditor* GetDefaultEditorForType(const wxString& typeName)
   const

=head2 Wx::Grid::GetDefaultRenderer

   wxGridCellRenderer* GetDefaultRenderer() const

   Returns a pointer to the current default grid cell renderer.

   See wxGridCellRenderer and the wxGrid overview for more information
   about cell editors and renderers.

=head2 Wx::Grid::GetDefaultRendererForCell

   wxGridCellRenderer* GetDefaultRendererForCell(int row, int col) const

=head2 Wx::Grid::GetDefaultRendererForType

   wxGridCellRenderer* GetDefaultRendererForType(const wxString& typeName)
   const

=head2 Wx::Grid::GetDefaultRowLabelSize

   int GetDefaultRowLabelSize()

   Returns the default width for the row labels.

=head2 Wx::Grid::GetDefaultRowSize

   int GetDefaultRowSize()

   Returns the current default height for grid rows.

=head2 Wx::Grid::GetGridCursorCol

   int GetGridCursorCol()

   Returns the current grid cell column position.

=head2 Wx::Grid::GetGridCursorRow

   int GetGridCursorRow()

   Returns the current grid cell row position.

=head2 Wx::Grid::GetGridLineColour

   wxColour GetGridLineColour()

   Returns the colour used for grid lines.

   See also

   GetDefaultGridLinePen()

=head2 Wx::Grid::GetDefaultGridLinePen

   wxPen GetDefaultGridLinePen()

   Returns the pen used for grid lines. This virtual function may be
   overridden in derived classes in order to change the appearance of
   grid lines. Note that currently the pen width must be 1.

   See also

   GetColGridLinePen(),

=head2 Wx::Grid::GetRowGridLinePen

   wxPen GetRowGridLinePen(int row)

   Returns the pen used for horizontal grid lines. This virtual function
   may be overridden in derived classes in order to change the appearance
   of individual grid line for the given row row.

   Example:

=head2 Wx::Grid::GetColGridLinePen

   wxPen GetColGridLinePen(int col)

   Returns the pen used for vertical grid lines. This virtual function
   may be overridden in derived classes in order to change the appearance
   of individual grid lines for the given column col.

   See GetRowGridLinePen() for an example.

=head2 Wx::Grid::GridLinesEnabled

   bool GridLinesEnabled()

   Returns true if drawing of grid lines is turned on, false otherwise.

=head2 Wx::Grid::GetLabelBackgroundColour

   wxColour GetLabelBackgroundColour()

   Returns the colour used for the background of row and column labels.

=head2 Wx::Grid::GetLabelFont

   wxFont GetLabelFont()

   Returns the font used for row and column labels.

=head2 Wx::Grid::GetLabelTextColour

   wxColour GetLabelTextColour()

   Returns the colour used for row and column label text.

=head2 Wx::Grid::GetNumberCols

   int GetNumberCols()

   Returns the total number of grid columns (actually the number of
   columns in the underlying grid table).

=head2 Wx::Grid::GetNumberRows

   int GetNumberRows()

   Returns the total number of grid rows (actually the number of rows in
   the underlying grid table).

=head2 Wx::Grid::GetOrCreateCellAttr

   wxGridCellAttr* GetOrCreateCellAttr(int row, int col) const

=head2 Wx::Grid::GetRowMinimalAcceptableHeight

   int GetRowMinimalAcceptableHeight()

   This returns the value of the lowest row width that can be handled
   correctly. See member SetRowMinimalAcceptableHeight for details.

=head2 Wx::Grid::GetRowMinimalHeight

   int GetRowMinimalHeight(int col) const

=head2 Wx::Grid::GetRowLabelAlignment

   void GetRowLabelAlignment(int* horiz, int* vert)

   Sets the arguments to the current row label alignment values.

   Horizontal alignment will be one of wxLEFT, wxCENTRE or wxRIGHT.

=head2 Wx::Grid::GetRowLabelSize

   int GetRowLabelSize()

   Returns the current width of the row labels.

=head2 Wx::Grid::GetRowLabelValue

   wxString GetRowLabelValue(int row)

   Returns the specified row label. The default grid table class provides
   numeric row labels. If you are using a custom grid table you can
   override wxGridTableBase::GetRowLabelValue to provide your own labels.

=head2 Wx::Grid::GetRowSize

   int GetRowSize(int row)

   Returns the height of the specified row.

=head2 Wx::Grid::GetScrollLineX

   int GetScrollLineX() const

   Returns the number of pixels per horizontal scroll increment. The
   default is 15.

   See also

   wxGrid::GetScrollLineY, wxGrid::SetScrollLineX, wxGrid::SetScrollLineY

=head2 Wx::Grid::GetScrollLineY

   int GetScrollLineY() const

   Returns the number of pixels per vertical scroll increment. The
   default is 15.

   See also

   wxGrid::GetScrollLineX, wxGrid::SetScrollLineX, wxGrid::SetScrollLineY

=head2 Wx::Grid::GetSelectionMode

   wxGrid::wxGridSelectionModes GetSelectionMode() const

   Returns the current selection mode, see wxGrid::SetSelectionMode.

=head2 Wx::Grid::GetSelectedCells

   wxGridCellCoordsArray GetSelectedCells() const

   Returns an array of singly selected cells.

=head2 Wx::Grid::GetSelectedCols

   wxArrayInt GetSelectedCols() const

   Returns an array of selected cols.

=head2 Wx::Grid::GetSelectedRows

   wxArrayInt GetSelectedRows() const

   Returns an array of selected rows.

=head2 Wx::Grid::GetSelectionBackground

   wxColour GetSelectionBackground() const

   Access or update the selection fore/back colours

=head2 Wx::Grid::GetSelectionBlockTopLeft

   wxGridCellCoordsArray GetSelectionBlockTopLeft() const

   Returns an array of the top left corners of blocks of selected cells,
   see wxGrid::GetSelectionBlockBottomRight.

=head2 Wx::Grid::GetSelectionBlockBottomRight

   wxGridCellCoordsArray GetSelectionBlockBottomRight() const

   Returns an array of the bottom right corners of blocks of selected
   cells, see wxGrid::GetSelectionBlockTopLeft.

=head2 Wx::Grid::GetSelectionForeground

   wxColour GetSelectionForeground() const

=head2 Wx::Grid::GetTable

   wxGridTableBase * GetTable() const

   Returns a base pointer to the current table object.

=head2 Wx::Grid::GetViewWidth

   int GetViewWidth()

   Returned number of whole cols visible.

=head2 Wx::Grid::HideCellEditControl

   void HideCellEditControl()

   Hides the in-place cell edit control.

=head2 Wx::Grid::InitColWidths

   void InitColWidths()

   Init the m_colWidths/Rights arrays

=head2 Wx::Grid::InitRowHeights

   void InitRowHeights()

   NB: never access m_row/col arrays directly because they are created on
   demand, always use accessor functions instead!

   Init the m_rowHeights/Bottoms arrays with default values.

=head2 Wx::Grid::InsertCols

   bool InsertCols(int pos = 0, int numCols = 1, bool updateLabels = true)

   Inserts one or more new columns into a grid with the first new column
   at the specified position and returns true if successful. The
   updateLabels argument is not used at present.

   The sequence of actions begins with the grid object requesting the
   underlying grid table to insert new columns. If this is successful the
   table notifies the grid and the grid updates the display. For a
   default grid (one where you have called wxGrid::CreateGrid) this
   process is automatic. If you are using a custom grid table (specified
   with wxGrid::SetTable) then you must override
   wxGridTableBase::InsertCols in your derived table class.

=head2 Wx::Grid::InsertRows

   bool InsertRows(int pos = 0, int numRows = 1, bool updateLabels = true)

   Inserts one or more new rows into a grid with the first new row at the
   specified position and returns true if successful. The updateLabels
   argument is not used at present.

   The sequence of actions begins with the grid object requesting the
   underlying grid table to insert new rows. If this is successful the
   table notifies the grid and the grid updates the display. For a
   default grid (one where you have called wxGrid::CreateGrid) this
   process is automatic. If you are using a custom grid table (specified
   with wxGrid::SetTable) then you must override
   wxGridTableBase::InsertRows in your derived table class.

=head2 Wx::Grid::IsCellEditControlEnabled

   bool IsCellEditControlEnabled() const

   Returns true if the in-place edit control is currently enabled.

=head2 Wx::Grid::IsCurrentCellReadOnly

   bool IsCurrentCellReadOnly() const

   Returns true if the current cell has been set to read-only (see
   wxGrid::SetReadOnly).

=head2 Wx::Grid::IsEditable

   bool IsEditable()

   Returns false if the whole grid has been set as read-only or true
   otherwise. See wxGrid::EnableEditing for more information about
   controlling the editing status of grid cells.

=head2 Wx::Grid::IsInSelection

   bool IsInSelection(int row, int col) const

   bool IsInSelection(const wxGridCellCoords& coords) const

   Is this cell currently selected.

=head2 Wx::Grid::IsReadOnly

   bool IsReadOnly(int row, int col) const

   Returns true if the cell at the specified location can't be edited.
   See also wxGrid::IsReadOnly.

=head2 Wx::Grid::IsSelection

   bool IsSelection()

   Returns true if there are currently rows, columns or blocks of cells
   selected.

=head2 Wx::Grid::IsVisible

   bool IsVisible(int row, int col, bool wholeCellVisible = true)

   bool IsVisible(const wxGridCellCoords& coords, bool wholeCellVisible =
   true)

   Returns true if a cell is either wholly visible (the default) or at
   least partially visible in the grid window.

=head2 Wx::Grid::MakeCellVisible

   void MakeCellVisible(int row, int col)

   void MakeCellVisible(const wxGridCellCoords& coords)

   Brings the specified cell into the visible grid cell area with minimal
   scrolling. Does nothing if the cell is already visible.

=head2 Wx::Grid::MoveCursorDown

   bool MoveCursorDown(bool expandSelection)

   Moves the grid cursor down by one row. If a block of cells was
   previously selected it will expand if the argument is true or be
   cleared if the argument is false.

   Keyboard

=head2 Wx::Grid::MoveCursorLeft

   bool MoveCursorLeft(bool expandSelection)

   Moves the grid cursor left by one column. If a block of cells was
   previously selected it will expand if the argument is true or be
   cleared if the argument is false.

   Keyboard

=head2 Wx::Grid::MoveCursorRight

   bool MoveCursorRight(bool expandSelection)

   Moves the grid cursor right by one column. If a block of cells was
   previously selected it will expand if the argument is true or be
   cleared if the argument is false.

   Keyboard

=head2 Wx::Grid::MoveCursorUp

   bool MoveCursorUp(bool expandSelection)

   Moves the grid cursor up by one row. If a block of cells was
   previously selected it will expand if the argument is true or be
   cleared if the argument is false.

   Keyboard

=head2 Wx::Grid::MoveCursorDownBlock

   bool MoveCursorDownBlock(bool expandSelection)

   Moves the grid cursor down in the current column such that it skips to
   the beginning or end of a block of non-empty cells. If a block of
   cells was previously selected it will expand if the argument is true
   or be cleared if the argument is false.

   Keyboard

=head2 Wx::Grid::MoveCursorLeftBlock

   bool MoveCursorLeftBlock(bool expandSelection)

   Moves the grid cursor left in the current row such that it skips to
   the beginning or end of a block of non-empty cells. If a block of
   cells was previously selected it will expand if the argument is true
   or be cleared if the argument is false.

   Keyboard

=head2 Wx::Grid::MoveCursorRightBlock

   bool MoveCursorRightBlock(bool expandSelection)

   Moves the grid cursor right in the current row such that it skips to
   the beginning or end of a block of non-empty cells. If a block of
   cells was previously selected it will expand if the argument is true
   or be cleared if the argument is false.

   Keyboard

=head2 Wx::Grid::MoveCursorUpBlock

   bool MoveCursorUpBlock(bool expandSelection)

   Moves the grid cursor up in the current column such that it skips to
   the beginning or end of a block of non-empty cells. If a block of
   cells was previously selected it will expand if the argument is true
   or be cleared if the argument is false.

   Keyboard

=head2 Wx::Grid::MovePageDown

   bool MovePageDown()

   Moves the grid cursor down by some number of rows so that the previous
   bottom visible row becomes the top visible row.

   Keyboard

=head2 Wx::Grid::MovePageUp

   bool MovePageUp()

   Moves the grid cursor up by some number of rows so that the previous
   top visible row becomes the bottom visible row.

   Keyboard

=head2 Wx::Grid::RegisterDataType

   void RegisterDataType(const wxString& typeName, wxGridCellRenderer*
   renderer, wxGridCellEditor* editor)

   Methods for a registry for mapping data types to Renderers/Editors

=head2 Wx::Grid::SaveEditControlValue

   void SaveEditControlValue()

   Sets the value of the current grid cell to the current in-place edit
   control value. This is called automatically when the grid cursor moves
   from the current cell to a new cell. It is also a good idea to call
   this function when closing a grid since any edits to the final cell
   location will not be saved otherwise.

=head2 Wx::Grid::SelectAll

   void SelectAll()

   Selects all cells in the grid.

=head2 Wx::Grid::SelectBlock

   void SelectBlock(int topRow, int leftCol, int bottomRow, int rightCol,
   bool addToSelected = false)

   void SelectBlock(const wxGridCellCoords& topLeft, const
   wxGridCellCoords& bottomRight, bool addToSelected = false)

   Selects a rectangular block of cells. If addToSelected is false then
   any existing selection will be deselected; if true the column will be
   added to the existing selection.

=head2 Wx::Grid::SelectCol

   void SelectCol(int col, bool addToSelected = false)

   Selects the specified column. If addToSelected is false then any
   existing selection will be deselected; if true the column will be
   added to the existing selection.

=head2 Wx::Grid::SelectionToDeviceRect

   wxRect SelectionToDeviceRect()

   This function returns the rectangle that encloses the selected cells
   in device coords and clipped to the client size of the grid window.

=head2 Wx::Grid::SelectRow

   void SelectRow(int row, bool addToSelected = false)

   Selects the specified row. If addToSelected is false then any existing
   selection will be deselected; if true the row will be added to the
   existing selection.

=head2 Wx::Grid::SetCellAlignment

   void SetCellAlignment(int row, int col, int horiz, int vert)

   void SetCellAlignment(int align, int row, int col)

   Sets the horizontal and vertical alignment for grid cell text at the
   specified location.

   Horizontal alignment should be one of wxALIGN_LEFT, wxALIGN_CENTRE or
   wxALIGN_RIGHT.

=head2 Wx::Grid::SetCellBackgroundColour

   void SetCellBackgroundColour(int row, int col, const wxColour& colour)

=head2 Wx::Grid::SetCellEditor

   void SetCellEditor(int row, int col, wxGridCellEditor* editor)

   Sets the editor for the grid cell at the specified location. The grid
   will take ownership of the pointer.

   See wxGridCellEditor and the wxGrid overview for more information
   about cell editors and renderers.

=head2 Wx::Grid::SetCellFont

   void SetCellFont(int row, int col, const wxFont& font)

   Sets the font for text in the grid cell at the specified location.

=head2 Wx::Grid::SetCellRenderer

   void SetCellRenderer(int row, int col, wxGridCellRenderer* renderer)

   Sets the renderer for the grid cell at the specified location. The
   grid will take ownership of the pointer.

   See wxGridCellRenderer and the wxGrid overview for more information
   about cell editors and renderers.

=head2 Wx::Grid::SetCellTextColour

   void SetCellTextColour(int row, int col, const wxColour& colour)

   void SetCellTextColour(const wxColour& val, int row, int col)

   void SetCellTextColour(const wxColour& colour)

   Sets the text colour for the grid cell at the specified location.

=head2 Wx::Grid::SetCellValue

   void SetCellValue(int row, int col, const wxString& s)

   void SetCellValue(const wxGridCellCoords& coords, const wxString& s)

   void SetCellValue(const wxString& val, int row, int col)

   Sets the string value for the cell at the specified location. For
   simple applications where a grid object automatically uses a default
   grid table of string values you use this function together with
   wxGrid::GetCellValue to access cell values.

   For more complex applications where you have derived your own grid
   table class that contains various data types (e.g. numeric, boolean or
   user-defined custom types) then you only use this function for those
   cells that contain string values.

   The last form is for backward compatibility only.

   See wxGridTableBase::CanSetValueAs and the wxGrid overview for more
   information.

=head2 Wx::Grid::SetColAttr

   void SetColAttr(int col, wxGridCellAttr* attr)

   Sets the cell attributes for all cells in the specified column.

   For more information about controlling grid cell attributes see the
   wxGridCellAttr cell attribute class and the wxGrid classes overview.

=head2 Wx::Grid::SetColFormatBool

   void SetColFormatBool(int col)

   Sets the specified column to display boolean values. wxGrid displays
   boolean values with a checkbox.

=head2 Wx::Grid::SetColFormatNumber

   void SetColFormatNumber(int col)

   Sets the specified column to display integer values.

=head2 Wx::Grid::SetColFormatFloat

   void SetColFormatFloat(int col, int width = -1, int precision = -1)

   Sets the specified column to display floating point values with the
   given width and precision.

=head2 Wx::Grid::SetColFormatCustom

   void SetColFormatCustom(int col, const wxString& typeName)

   Sets the specified column to display data in a custom format. See the
   wxGrid overview for more information on working with custom data
   types.

=head2 Wx::Grid::SetColLabelAlignment

   void SetColLabelAlignment(int horiz, int vert)

   Sets the horizontal and vertical alignment of column label text.

   Horizontal alignment should be one of wxALIGN_LEFT, wxALIGN_CENTRE or
   wxALIGN_RIGHT.

   Vertical alignment should be one of wxALIGN_TOP, wxALIGN_CENTRE or
   wxALIGN_BOTTOM.

=head2 Wx::Grid::SetColLabelSize

   void SetColLabelSize(int height)

   Sets the height of the column labels.

   If height equals to wxGRID_AUTOSIZE then height is calculated
   automatically so that no label is truncated. Note that this could be
   slow for a large table. This flag is new since wxWidgets version
   2.8.8.

=head2 Wx::Grid::SetColLabelValue

   void SetColLabelValue(int col, const wxString& value)

   Set the value for the given column label. If you are using a derived
   grid table you must override wxGridTableBase::SetColLabelValue for
   this to have any effect.

=head2 Wx::Grid::SetColMinimalWidth

   void SetColMinimalWidth(int col, int width)

   Sets the minimal width for the specified column. This should normally
   be called when creating the grid because it will not resize a column
   that is already narrower than the minimal width. The width argument
   must be higher than the minimimal acceptable column width, see
   wxGrid::GetColMinimalAcceptableWidth.

=head2 Wx::Grid::SetColMinimalAcceptableWidth

   void SetColMinimalAcceptableWidth(int width)

   This modifies the minimum column width that can be handled correctly.
   Specifying a low value here allows smaller grid cells to be dealt with
   correctly. Specifying a value here which is much smaller than the
   actual minimum size will incur a performance penalty in the functions
   which perform grid cell index lookup on the basis of screen
   coordinates. This should normally be called when creating the grid
   because it will not resize existing columns with sizes smaller than
   the value specified here.

=head2 Wx::Grid::SetColPos

   void SetColPos(int colID, int newPos)

   Sets the position of the specified column.

=head2 Wx::Grid::SetColSize

   void SetColSize(int col, int width)

   Sets the width of the specified column.

   This function does not refresh the grid. If you are calling it outside
   of a BeginBatch / EndBatch block you can use wxGrid::ForceRefresh to
   see the changes.

   Automatically sizes the column to fit its contents. If setAsMin is
   true the calculated width will also be set as the minimal width for
   the column.

   Note

=head2 Wx::Grid::SetDefaultCellAlignment

   void SetDefaultCellAlignment(int horiz, int vert)

   Sets the default horizontal and vertical alignment for grid cell text.

   Horizontal alignment should be one of wxALIGN_LEFT, wxALIGN_CENTRE or
   wxALIGN_RIGHT.

   Vertical alignment should be one of wxALIGN_TOP, wxALIGN_CENTRE or
   wxALIGN_BOTTOM.

=head2 Wx::Grid::SetDefaultCellBackgroundColour

   void SetDefaultCellBackgroundColour(const wxColour& colour)

   Sets the default background colour for grid cells.

=head2 Wx::Grid::SetDefaultCellFont

   void SetDefaultCellFont(const wxFont& font)

   Sets the default font to be used for grid cell text.

=head2 Wx::Grid::SetDefaultCellTextColour

   void SetDefaultCellTextColour(const wxColour& colour)

   Sets the current default colour for grid cell text.

=head2 Wx::Grid::SetDefaultEditor

   void SetDefaultEditor(wxGridCellEditor* editor)

   Sets the default editor for grid cells. The grid will take ownership
   of the pointer.

   See wxGridCellEditor and the wxGrid overview for more information
   about cell editors and renderers.

=head2 Wx::Grid::SetDefaultRenderer

   void SetDefaultRenderer(wxGridCellRenderer* renderer)

   Sets the default renderer for grid cells. The grid will take ownership
   of the pointer.

   See wxGridCellRenderer and the wxGrid overview for more information
   about cell editors and renderers.

=head2 Wx::Grid::SetDefaultColSize

   void SetDefaultColSize(int width, bool resizeExistingCols = false)

   Sets the default width for columns in the grid. This will only affect
   columns subsequently added to the grid unless resizeExistingCols is
   true.

=head2 Wx::Grid::SetDefaultRowSize

   void SetDefaultRowSize(int height, bool resizeExistingRows = false)

   Sets the default height for rows in the grid. This will only affect
   rows subsequently added to the grid unless resizeExistingRows is true.

=head2 Wx::Grid::SetGridCursor

   void SetGridCursor(int row, int col)

   Set the grid cursor to the specified cell. This function calls
   wxGrid::MakeCellVisible.

=head2 Wx::Grid::SetGridLineColour

   void SetGridLineColour(const wxColour&colour)

   Sets the colour used to draw grid lines.

=head2 Wx::Grid::SetLabelBackgroundColour

   void SetLabelBackgroundColour(const wxColour& colour)

   Sets the background colour for row and column labels.

=head2 Wx::Grid::SetLabelFont

   void SetLabelFont(const wxFont& font)

   Sets the font for row and column labels.

=head2 Wx::Grid::SetLabelTextColour

   void SetLabelTextColour(const wxColour& colour)

   Sets the colour for row and column label text.

=head2 Wx::Grid::SetMargins

   void SetMargins(int extraWidth, int extraHeight)

   A grid may occupy more space than needed for its rows/columns. This
   function allows to set how big this extra space is

=head2 Wx::Grid::SetOrCalcColumnSizes

   int SetOrCalcColumnSizes(bool calcOnly, bool setAsMin = true)

   Common part of AutoSizeColumn/Row() and GetBestSize()

=head2 Wx::Grid::SetOrCalcRowSizes

   int SetOrCalcRowSizes(bool calcOnly, bool setAsMin = true)

=head2 Wx::Grid::SetReadOnly

   void SetReadOnly(int row, int col, bool isReadOnly = true)

   Makes the cell at the specified location read-only or editable. See
   also wxGrid::IsReadOnly.

=head2 Wx::Grid::SetRowAttr

   void SetRowAttr(int row, wxGridCellAttr* attr)

   Sets the cell attributes for all cells in the specified row. See the
   wxGridCellAttr class for more information about controlling cell
   attributes.

=head2 Wx::Grid::SetRowLabelAlignment

   void SetRowLabelAlignment(int horiz, int vert)

   Sets the horizontal and vertical alignment of row label text.

   Horizontal alignment should be one of wxALIGN_LEFT, wxALIGN_CENTRE or
   wxALIGN_RIGHT.

   Vertical alignment should be one of wxALIGN_TOP, wxALIGN_CENTRE or
   wxALIGN_BOTTOM.

=head2 Wx::Grid::SetRowLabelSize

   void SetRowLabelSize(int width)

   Sets the width of the row labels.

   If width equals wxGRID_AUTOSIZE then width is calculated automatically
   so that no label is truncated. Note that this could be slow for a
   large table. This flag is new since wxWidgets version 2.8.8.

=head2 Wx::Grid::SetRowLabelValue

   void SetRowLabelValue(int row, const wxString& value)

   Set the value for the given row label. If you are using a derived grid
   table you must override wxGridTableBase::SetRowLabelValue for this to
   have any effect.

=head2 Wx::Grid::SetRowMinimalHeight

   void SetRowMinimalHeight(int row, int height)

   Sets the minimal height for the specified row. This should normally be
   called when creating the grid because it will not resize a row that is
   already shorter than the minimal height. The height argument must be
   higher than the minimimal acceptable row height, see
   wxGrid::GetRowMinimalAcceptableHeight.

=head2 Wx::Grid::SetRowMinimalAcceptableHeight

   void SetRowMinimalAcceptableHeight(int height)

   This modifies the minimum row width that can be handled correctly.
   Specifying a low value here allows smaller grid cells to be dealt with
   correctly. Specifying a value here which is much smaller than the
   actual minimum size will incur a performance penalty in the functions
   which perform grid cell index lookup on the basis of screen
   coordinates. This should normally be called when creating the grid
   because it will not resize existing rows with sizes smaller than the
   value specified here.

=head2 Wx::Grid::SetRowSize

   void SetRowSize(int row, int height)

   Sets the height of the specified row.

   This function does not refresh the grid. If you are calling it outside
   of a BeginBatch / EndBatch block you can use wxGrid::ForceRefresh to
   see the changes.

   Automatically sizes the column to fit its contents. If setAsMin is
   true the calculated width will also be set as the minimal width for
   the column.

   Note

   wxGrid sets up arrays to store individual row and column sizes when
   non-default sizes are used. The memory requirements for this could
   become prohibitive if your grid is very large.

=head2 Wx::Grid::SetScrollLineX

   void SetScrollLineX(int x)

   Sets the number of pixels per horizontal scroll increment. The default
   is 15. Sometimes wxGrid has trouble setting the scrollbars correctly
   due to rounding errors: setting this to 1 can help.

   See also

   wxGrid::GetScrollLineX, wxGrid::GetScrollLineY, wxGrid::SetScrollLineY

=head2 Wx::Grid::SetScrollLineY

   void SetScrollLineY(int y)

   Sets the number of pixels per vertical scroll increment. The default
   is 15. Sometimes wxGrid has trouble setting the scrollbars correctly
   due to rounding errors: setting this to 1 can help.

   See also

   wxGrid::GetScrollLineX, wxGrid::GetScrollLineY, wxGrid::SetScrollLineX

=head2 Wx::Grid::SetSelectionBackground

   void SetSelectionBackground(const wxColour& c)

=head2 Wx::Grid::SetSelectionForeground

   void SetSelectionForeground(const wxColour& c)

=head2 Wx::Grid::SetSelectionMode

   void SetSelectionMode(wxGrid::wxGridSelectionModes selmode)

   Set the selection behaviour of the grid.

   Parameters

   wxGrid::wxGridSelectCells

       The default mode where individual cells are selected.

   wxGrid::wxGridSelectRows

       Selections will consist of whole rows.

   wxGrid::wxGridSelectColumns

       Selections will consist of whole columns.

=head2 Wx::Grid::SetTable

   bool SetTable(wxGridTableBase* table, bool takeOwnership = false,
   wxGrid::wxGridSelectionModes selmode = wxGrid::wxGridSelectCells)

   Passes a pointer to a custom grid table to be used by the grid. This
   should be called after the grid constructor and before using the grid
   object. If takeOwnership is set to true then the table will be deleted
   by the wxGrid destructor.

   Use this function instead of wxGrid::CreateGrid when your application
   involves complex or non-string data or data sets that are too large to
   fit wholly in memory.

=head2 Wx::Grid::ShowCellEditControl

   void ShowCellEditControl()

   Displays the in-place cell edit control for the current cell.

=head2 Wx::Grid::XToCol

   int XToCol(int x, bool clipToMinMax = false)

   Parameters x

       The x position to evaluate.

=head2 Wx::Grid::XToEdgeOfCol

   int XToEdgeOfCol(int x)

   Returns the column whose right hand edge is close to the given logical
   x position. If no column edge is near to this position wxNOT_FOUND is
   returned.

=head2 Wx::Grid::YToEdgeOfRow

   int YToEdgeOfRow(int y)

   Returns the row whose bottom edge is close to the given logical y
   position. If no row edge is near to this position wxNOT_FOUND is
   returned.

=head2 Wx::Grid::YToRow

   int YToRow(int y)

   Returns the grid row that corresponds to the logical y coordinate.
   Returns wxNOT_FOUND if there is no row at the y position.

=head1 Wx::GridCellAttr

=head2 Wx::GridCellAttr::new

   wxGridCellAttr()

   Default constructor.

   wxGridCellAttr(const wxColour& colText, const wxColour& colBack, const
   wxFont& font, int hAlign, int vAlign)

   Constructor specifying some of the often used attributes.

=head2 Wx::GridCellAttr::Clone

   wxGridCellAttr* Clone() const

   Creates a new copy of this object.

=head2 Wx::GridCellAttr::IncRef

   void IncRef()

   This class is ref counted: it is created with ref count of 1, so
   calling DecRef() once will delete it. Calling IncRef() allows to lock
   it until the matching DecRef() is called

=head2 Wx::GridCellAttr::DecRef

   void DecRef()

=head2 Wx::GridCellAttr::SetTextColour

   void SetTextColour(const wxColour& colText)

   Sets the text colour.

=head2 Wx::GridCellAttr::SetBackgroundColour

   void SetBackgroundColour(const wxColour& colBack)

   Sets the background colour.

=head2 Wx::GridCellAttr::SetFont

   void SetFont(const wxFont& font)

   Sets the font.

=head2 Wx::GridCellAttr::SetAlignment

   void SetAlignment(int hAlign, int vAlign)

   Sets the alignment. hAlign can be one of wxALIGN_LEFT, wxALIGN_CENTRE
   or wxALIGN_RIGHT and vAlign can be one of wxALIGN_TOP, wxALIGN_CENTRE
   or wxALIGN_BOTTOM.

=head2 Wx::GridCellAttr::SetReadOnly

   void SetReadOnly(bool isReadOnly = true)

=head2 Wx::GridCellAttr::SetRenderer

   void SetRenderer(wxGridCellRenderer* renderer)

   takes ownership of the pointer

=head2 Wx::GridCellAttr::SetEditor

   void SetEditor(wxGridCellEditor* editor)

=head2 Wx::GridCellAttr::HasTextColour

   bool HasTextColour() const

   accessors

=head2 Wx::GridCellAttr::HasBackgroundColour

   bool HasBackgroundColour() const

=head2 Wx::GridCellAttr::HasFont

   bool HasFont() const

=head2 Wx::GridCellAttr::HasAlignment

   bool HasAlignment() const

=head2 Wx::GridCellAttr::HasRenderer

   bool HasRenderer() const

=head2 Wx::GridCellAttr::HasEditor

   bool HasEditor() const

=head2 Wx::GridCellAttr::GetTextColour

   const wxColour& GetTextColour() const

=head2 Wx::GridCellAttr::GetBackgroundColour

   const wxColour& GetBackgroundColour() const

=head2 Wx::GridCellAttr::GetFont

   const wxFont& GetFont() const

=head2 Wx::GridCellAttr::GetAlignment

   void GetAlignment(int* hAlign, int* vAlign) const

   wxPerl note: This method takes no parameters and returns a 2-element
   list ( hAlign, vAlign ).

   See SetAlignment for the returned values.

=head2 Wx::GridCellAttr::GetRenderer

   wxGridCellRenderer* GetRenderer(wxGrid* grid, int row, int col) const

=head2 Wx::GridCellAttr::GetEditor

   wxGridCellEditor* GetEditor(wxGrid* grid, int row, int col) const

=head2 Wx::GridCellAttr::IsReadOnly

   bool IsReadOnly() const

=head2 Wx::GridCellAttr::SetDefAttr

   void SetDefAttr(wxGridCellAttr* defAttr)

=head1 Wx::GridBagSizer

=head2 Wx::GridBagSizer::new

   wxGridBagSizer(int vgap = 0, int hgap = 0)

   Constructor, with optional parameters to specify the gap between the
   rows and columns.

=head2 Wx::GridBagSizer::Add

   wxSizerItem* Add(wxWindow* window, const wxGBPosition& pos, const
   wxGBSpan& span = wxDefaultSpan, int flag = 0, int border = 0, wxObject*
   userData = NULL)

   wxSizerItem* Add(wxSizer* sizer, const wxGBPosition& pos, const
   wxGBSpan& span = wxDefaultSpan, int flag = 0, int border = 0, wxObject*
   userData = NULL)

   wxSizerItem* Add(int width, int height, const wxGBPosition& pos, const
   wxGBSpan& span = wxDefaultSpan, int flag = 0, int border = 0, wxObject*
   userData = NULL)

   wxSizerItem* Add(wxGBSizerItem* item)

   The Add methods return a valid pointer if the item was successfully
   placed at the given position, NULL if something was already there.

=head2 Wx::GridBagSizer::CalcMin

   wxSize CalcMin()

   Called when the managed size of the sizer is needed or when layout
   needs done.

=head2 Wx::GridBagSizer::CheckForIntersection

   bool CheckForIntersection(wxGBSizerItem* item, wxGBSizerItem*
   excludeItem = NULL)

   bool CheckForIntersection(const wxGBPosition& pos, const wxGBSpan&
   span, wxGBSizerItem* excludeItem = NULL)

   Look at all items and see if any intersect (or would overlap) the
   given item. Returns true if so, false if there would be no overlap. If
   an excludeItem is given then it will not be checked for intersection,
   for example it may be the item we are checking the position of.

=head2 Wx::GridBagSizer::FindItem

   wxGBSizerItem* FindItem(wxWindow* window)

   wxGBSizerItem* FindItem(wxSizer* sizer)

   Find the sizer item for the given window or subsizer, returns NULL if
   not found. (non-recursive)

=head2 Wx::GridBagSizer::FindItemAtPoint

   wxGBSizerItem* FindItemAtPoint(const wxPoint& pt)

   Return the sizer item located at the point given in pt, or NULL if
   there is no item at that point. The (x,y) coordinates in pt correspond
   to the client coordinates of the window using the sizer for layout.
   (non-recursive)

=head2 Wx::GridBagSizer::FindItemAtPosition

   wxGBSizerItem* FindItemAtPosition(const wxGBPosition& pos)

   Return the sizer item for the given grid cell, or NULL if there is no
   item at that position. (non-recursive)

=head2 Wx::GridBagSizer::FindItemWithData

   wxGBSizerItem* FindItemWithData(const wxObject* userData)

   Return the sizer item that has a matching user data (it only compares
   pointer values) or NULL if not found. (non-recursive)

=head2 Wx::GridBagSizer::GetCellSize

   wxSize GetCellSize(int row, int col) const

   Get the size of the specified cell, including hgap and vgap. Only
   valid after a Layout.

=head2 Wx::GridBagSizer::GetEmptyCellSize

   wxSize GetEmptyCellSize() const

   Get the size used for cells in the grid with no item.

=head2 Wx::GridBagSizer::GetItemPosition

   wxGBPosition GetItemPosition(wxWindow* window)

   wxGBPosition GetItemPosition(wxSizer* sizer)

   wxGBPosition GetItemPosition(size_t index)

   Get the grid position of the specified item.

=head2 Wx::GridBagSizer::GetItemSpan

   wxGBSpan GetItemSpan(wxWindow* window)

   wxGBSpan GetItemSpan(wxSizer* sizer)

   wxGBSpan GetItemSpan(size_t index)

   Get the row/col spanning of the specified item

=head2 Wx::GridBagSizer::RecalcSizes

   void RecalcSizes()

   Called when the managed size of the sizer is needed or when layout
   needs done.

=head2 Wx::GridBagSizer::SetEmptyCellSize

   void SetEmptyCellSize(const wxSize& sz)

   Set the size used for cells in the grid with no item.

=head2 Wx::GridBagSizer::SetItemPosition

   bool SetItemPosition(wxWindow* window, const wxGBPosition& pos)

   bool SetItemPosition(wxSizer* sizer, const wxGBPosition& pos)

   bool SetItemPosition(size_t index, const wxGBPosition& pos)

   Set the grid position of the specified item. Returns true on success.
   If the move is not allowed (because an item is already there) then
   false is returned.

=head2 Wx::GridBagSizer::SetItemSpan

   bool SetItemSpan(wxWindow* window, const wxGBSpan& span)

   bool SetItemSpan(wxSizer* sizer, const wxGBSpan& span)

   bool SetItemSpan(size_t index, const wxGBSpan& span)

   Set the row/col spanning of the specified item. Returns true on
   success. If the move is not allowed (because an item is already there)
   then false is returned.

=head1 Wx::GridCellBoolEditor

=head2 Wx::GridCellBoolEditor::new

   wxGridCellBoolEditor()

   Default constructor.

=head2 Wx::GridCellBoolEditor::IsTrueValue

   static bool IsTrueValue(const wxString& value)

   Returns true if the given value is equal to the string representation
   of the truth value we currently use (see UseStringValues).

=head2 Wx::GridCellBoolEditor::UseStringValues

   static void UseStringValues(const wxString& valueTrue = _T("1"), const
   wxString& valueFalse = _T(""))

   This method allows to customize the values returned by GetValue()
   method for the cell using this editor. By default, the default values
   of the arguments are used, i.e. "1" is returned if the cell is checked
   and an empty string otherwise, using this method allows to change
   this.

=head1 Wx::GridCellChoiceEditor

=head2 Wx::GridCellChoiceEditor::new

   wxGridCellChoiceEditor(size_t count = 0, const wxString choices[] =
   NULL, bool allowOthers = false)

   wxGridCellChoiceEditor(const wxArrayString& choices, bool allowOthers
   = false)

   count

       Number of strings from which the user can choose.

=head2 Wx::GridCellChoiceEditor::SetParameters

   void SetParameters(const wxString& params)

   Parameters string format is "item1[,item2[...,itemN]]"

=head1 Wx::GridCellEditor

=head2 Wx::GridCellEditor::new

   wxGridCellEditor()

=head2 Wx::GridCellEditor::IsCreated

   bool IsCreated()

=head2 Wx::GridCellEditor::Create

   void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler)

   Creates the actual edit control.

=head2 Wx::GridCellEditor::SetSize

   void SetSize(const wxRect& rect)

   Size and position the edit control.

=head2 Wx::GridCellEditor::Show

   void Show(bool show, wxGridCellAttr* attr = NULL)

   Show or hide the edit control, use the specified attributes to set
   colours/fonts for it.

=head2 Wx::GridCellEditor::PaintBackground

   void PaintBackground(const wxRect& rectCell, wxGridCellAttr* attr)

   Draws the part of the cell not occupied by the control: the base class
   version just fills it with background colour from the attribute.

=head2 Wx::GridCellEditor::BeginEdit

   void BeginEdit(int row, int col, wxGrid* grid)

   Fetch the value from the table and prepare the edit control to begin
   editing. Set the focus to the edit control.

=head2 Wx::GridCellEditor::EndEdit

   bool EndEdit(int row, int col, wxGrid* grid)

   Complete the editing of the current cell. Returns true if the value
   has changed. If necessary, the control may be destroyed.

=head2 Wx::GridCellEditor::Reset

   void Reset()

   Reset the value in the control back to its starting value.

=head2 Wx::GridCellEditor::StartingKey

   void StartingKey(wxKeyEvent& event)

   If the editor is enabled by pressing keys on the grid, this will be
   called to let the editor do something about that first key if desired.

=head2 Wx::GridCellEditor::StartingClick

   void StartingClick()

   If the editor is enabled by clicking on the cell, this method will be
   called.

=head2 Wx::GridCellEditor::HandleReturn

   void HandleReturn(wxKeyEvent& event)

   Some types of controls on some platforms may need some help with the
   Return key.

=head2 Wx::GridCellEditor::Destroy

   void Destroy()

   Final cleanup.

=head2 Wx::GridCellEditor::Clone

   wxGridCellEditor* Clone() const

   Create a new object which is the copy of this one.

=head2 Wx::GridCellEditor::DESTROY

   ~wxGridCellEditor()

   The dtor is private because only DecRef() can delete us.

=head1 Wx::GridCellFloatEditor

=head2 Wx::GridCellFloatEditor::new

   wxGridCellFloatEditor(int width = -1, int precision = -1)

   width

       Minimum number of characters to be shown.

=head2 Wx::GridCellFloatEditor::SetParameters

   void SetParameters(const wxString& params)

   Parameters string format is "width,precision"

=head1 Wx::GridCellNumberEditor

=head2 Wx::GridCellNumberEditor::new

   wxGridCellNumberEditor(int min = -1, int max = -1)

   Allows to specify the range for acceptable data; if min == max == -1,
   no range checking is done

=head2 Wx::GridCellNumberEditor::GetString

   wxString GetString() const

   String representation of the value.

=head2 Wx::GridCellNumberEditor::HasRange

   bool HasRange() const

   If the return value is true, the editor uses a wxSpinCtrl to get user
   input, otherwise it uses a wxTextCtrl.

=head2 Wx::GridCellNumberEditor::SetParameters

   void SetParameters(const wxString& params)

   Parameters string format is "min,max".

=head1 Wx::GridCellTextEditor

=head2 Wx::GridCellTextEditor::new

   wxGridCellTextEditor()

   Default constructor.

=head2 Wx::GridCellTextEditor::SetParameters

   void SetParameters(const wxString& params)

   The parameters string format is "n" where n is a number representing
   the maximum width.

=head1 Wx::GridEditorCreatedEvent

=head2 Wx::GridEditorCreatedEvent::new

   wxGridEditorCreatedEvent()

   Default constructor.

   wxGridEditorCreatedEvent(int id, wxEventType type, wxObject* obj, int
   row, int col, wxControl* ctrl)

=head2 Wx::GridEditorCreatedEvent::GetCol

   int GetCol()

   Returns the column at which the event occurred.

=head2 Wx::GridEditorCreatedEvent::GetControl

   wxControl* GetControl()

   Returns the edit control.

=head2 Wx::GridEditorCreatedEvent::GetRow

   int GetRow()

   Returns the row at which the event occurred.

=head2 Wx::GridEditorCreatedEvent::SetCol

   void SetCol(int col)

   Sets the column at which the event occurred.

=head2 Wx::GridEditorCreatedEvent::SetControl

   void SetControl(wxControl* ctrl)

   Sets the edit control.

=head2 Wx::GridEditorCreatedEvent::SetRow

   void SetRow(int row)

   Sets the row at which the event occurred.

=head1 Wx::GridEvent

=head2 Wx::GridEvent::new

   wxGridEvent()

   Default constructor.

   wxGridEvent(int id, wxEventType type, wxObject* obj, int row = -1, int
   col = -1, int x = -1, int y = -1, bool sel = true, bool control =
   false, bool shift = false, bool alt = false, bool meta = false)

   Parameters

=head2 Wx::GridEvent::AltDown

   bool AltDown()

   Returns true if the Alt key was down at the time of the event.

=head2 Wx::GridEvent::ControlDown

   bool ControlDown()

   Returns true if the Control key was down at the time of the event.

=head2 Wx::GridEvent::GetCol

   int GetCol()

   Column at which the event occurred.

=head2 Wx::GridEvent::GetPosition

   wxPoint GetPosition()

   Position in pixels at which the event occurred.

=head2 Wx::GridEvent::GetRow

   int GetRow()

   Row at which the event occurred.

=head2 Wx::GridEvent::MetaDown

   bool MetaDown()

   Returns true if the Meta key was down at the time of the event.

=head2 Wx::GridEvent::Selecting

   bool Selecting()

   Returns true if the user deselected a cell, false if the user
   deselected a cell.

=head2 Wx::GridEvent::ShiftDown

   bool ShiftDown()

   Returns true if the Shift key was down at the time of the event.

=head1 Wx::GridRangeSelectEvent

=head2 Wx::GridRangeSelectEvent::new

   wxGridRangeSelectEvent()

   Default constructor.

   wxGridRangeSelectEvent(int id, wxEventType type, wxObject* obj, const
   wxGridCellCoords& topLeft, const wxGridCellCoords& bottomRight, bool
   sel = true, bool control = false, bool shift = false, bool alt = false,
   bool meta = false)

=head2 Wx::GridRangeSelectEvent::AltDown

   bool AltDown()

   Returns true if the Alt key was down at the time of the event.

=head2 Wx::GridRangeSelectEvent::ControlDown

   bool ControlDown()

   Returns true if the Control key was down at the time of the event.

=head2 Wx::GridRangeSelectEvent::GetBottomRightCoords

   wxGridCellCoords GetBottomRightCoords()

   Top left corner of the rectangular area that was (de)selected.

=head2 Wx::GridRangeSelectEvent::GetBottomRow

   int GetBottomRow()

   Bottom row of the rectangular area that was (de)selected.

=head2 Wx::GridRangeSelectEvent::GetLeftCol

   int GetLeftCol()

   Left column of the rectangular area that was (de)selected.

=head2 Wx::GridRangeSelectEvent::GetRightCol

   int GetRightCol()

   Right column of the rectangular area that was (de)selected.

=head2 Wx::GridRangeSelectEvent::GetTopLeftCoords

   wxGridCellCoords GetTopLeftCoords()

   Top left corner of the rectangular area that was (de)selected.

=head2 Wx::GridRangeSelectEvent::GetTopRow

   int GetTopRow()

   Top row of the rectangular area that was (de)selected.

=head2 Wx::GridRangeSelectEvent::MetaDown

   bool MetaDown()

   Returns true if the Meta key was down at the time of the event.

=head2 Wx::GridRangeSelectEvent::Selecting

   bool Selecting()

   Returns true if the area was selected, false otherwise.

=head2 Wx::GridRangeSelectEvent::ShiftDown

   bool ShiftDown()

   Returns true if the Shift key was down at the time of the event.

=head1 Wx::GridSizeEvent

=head2 Wx::GridSizeEvent::new

   wxGridSizeEvent()

   Default constructor.

   wxGridSizeEvent(int id, wxEventType type, wxObject* obj, int rowOrCol
   = -1, int x = -1, int y = -1, bool control = false, bool shift = false,
   bool alt = false, bool meta = false)

=head2 Wx::GridSizeEvent::AltDown

   bool AltDown()

   Returns true if the Alt key was down at the time of the event.

=head2 Wx::GridSizeEvent::ControlDown

   bool ControlDown()

   Returns true if the Control key was down at the time of the event.

=head2 Wx::GridSizeEvent::GetPosition

   wxPoint GetPosition()

   Position in pixels at which the event occurred.

=head2 Wx::GridSizeEvent::GetRowOrCol

   int GetRowOrCol()

   Row or column at that was resized.

=head2 Wx::GridSizeEvent::MetaDown

   bool MetaDown()

   Returns true if the Meta key was down at the time of the event.

=head2 Wx::GridSizeEvent::ShiftDown

   bool ShiftDown()

   Returns true if the Shift key was down at the time of the event.

=head1 Wx::GridCellBoolRenderer

=head2 Wx::GridCellBoolRenderer::new

   wxGridCellBoolRenderer()

   Default constructor

=head1 Wx::GridCellFloatRenderer

=head2 Wx::GridCellFloatRenderer::new

   wxGridCellFloatRenderer(int width = -1, int precision = -1)

   width

       Minimum number of characters to be shown.

=head2 Wx::GridCellFloatRenderer::GetPrecision

   int GetPrecision() const

   Returns the precision ( see wxGridCellFloatRenderer ).

=head2 Wx::GridCellFloatRenderer::GetWidth

   int GetWidth() const

   Returns the width ( see wxGridCellFloatRenderer ).

=head2 Wx::GridCellFloatRenderer::SetParameters

   void SetParameters(const wxString& params)

   Parameters string format is "width[,precision]".

=head2 Wx::GridCellFloatRenderer::SetPrecision

   void SetPrecision(int precision)

   Sets the precision ( see wxGridCellFloatRenderer ).

=head2 Wx::GridCellFloatRenderer::SetWidth

   void SetWidth(int width)

   Sets the width ( see wxGridCellFloatRenderer )

=head1 Wx::GridCellNumberRenderer

=head2 Wx::GridCellNumberRenderer::new

   wxGridCellNumberRenderer()

   Default constructor

=head1 Wx::GridCellRenderer

=head2 Wx::GridCellRenderer::Draw

   void Draw(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc, const wxRect&
   rect, int row, int col, bool isSelected)

   Draw the given cell on the provided DC inside the given rectangle
   using the style specified by the attribute and the default or selected
   state corresponding to the isSelected value.

   This pure virtual function has a default implementation which will
   prepare the DC using the given attribute: it will draw the rectangle
   with the background colour from attr and set the text colour and font.

=head2 Wx::GridCellRenderer::GetBestSize

   wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc, int
   row, int col)

   Get the preferred size of the cell for its contents.

=head2 Wx::GridCellRenderer::Clone

   wxGridCellRenderer* Clone() const

=head1 Wx::GridCellStringRenderer

=head2 Wx::GridCellStringRenderer::new

   wxGridCellStringRenderer()

   Default constructor

=head1 Wx::GridTableBase

=head2 Wx::GridTableBase::new

   wxGridTableBase()

=head2 Wx::GridTableBase::DESTROY

   ~wxGridTableBase()

=head2 Wx::GridTableBase::GetNumberRows

   int GetNumberRows()

   You must override these functions in a derived table class.

=head2 Wx::GridTableBase::GetNumberCols

   int GetNumberCols()

=head2 Wx::GridTableBase::IsEmptyCell

   bool IsEmptyCell(int row, int col)

=head2 Wx::GridTableBase::GetValue

   wxString GetValue(int row, int col)

=head2 Wx::GridTableBase::SetValue

   void SetValue(int row, int col, const wxString& value)

=head2 Wx::GridTableBase::GetTypeName

   wxString GetTypeName(int row, int col)

   Data type determination and value access.

=head2 Wx::GridTableBase::CanGetValueAs

   bool CanGetValueAs(int row, int col, const wxString& typeName)

=head2 Wx::GridTableBase::CanSetValueAs

   bool CanSetValueAs(int row, int col, const wxString& typeName)

=head2 Wx::GridTableBase::GetValueAsLong

   long GetValueAsLong(int row, int col)

=head2 Wx::GridTableBase::GetValueAsDouble

   double GetValueAsDouble(int row, int col)

=head2 Wx::GridTableBase::GetValueAsBool

   bool GetValueAsBool(int row, int col)

=head2 Wx::GridTableBase::SetValueAsLong

   void SetValueAsLong(int row, int col, long value)

=head2 Wx::GridTableBase::SetValueAsDouble

   void SetValueAsDouble(int row, int col, double value)

=head2 Wx::GridTableBase::SetValueAsBool

   void SetValueAsBool(int row, int col, bool value)

=head2 Wx::GridTableBase::GetValueAsCustom

   void* GetValueAsCustom(int row, int col, const wxString& typeName)

   For user defined types

=head2 Wx::GridTableBase::SetValueAsCustom

   void SetValueAsCustom(int row, int col, const wxString& typeName,
   void* value)

=head2 Wx::GridTableBase::SetView

   void SetView(wxGrid* grid)

   Overriding these is optional

=head2 Wx::GridTableBase::GetView

   wxGrid * GetView() const

=head2 Wx::GridTableBase::Clear

   void Clear()

=head2 Wx::GridTableBase::InsertRows

   bool InsertRows(size_t pos = 0, size_t numRows = 1)

=head2 Wx::GridTableBase::AppendRows

   bool AppendRows(size_t numRows = 1)

=head2 Wx::GridTableBase::DeleteRows

   bool DeleteRows(size_t pos = 0, size_t numRows = 1)

=head2 Wx::GridTableBase::InsertCols

   bool InsertCols(size_t pos = 0, size_t numCols = 1)

=head2 Wx::GridTableBase::AppendCols

   bool AppendCols(size_t numCols = 1)

=head2 Wx::GridTableBase::DeleteCols

   bool DeleteCols(size_t pos = 0, size_t numCols = 1)

=head2 Wx::GridTableBase::GetRowLabelValue

   wxString GetRowLabelValue(int row)

=head2 Wx::GridTableBase::GetColLabelValue

   wxString GetColLabelValue(int col)

=head2 Wx::GridTableBase::SetRowLabelValue

   void SetRowLabelValue(int WXUNUSED(row), const wxString&)

=head2 Wx::GridTableBase::SetColLabelValue

   void SetColLabelValue(int WXUNUSED(col), const wxString&)

=head2 Wx::GridTableBase::SetAttrProvider

   void SetAttrProvider(wxGridCellAttrProvider* attrProvider)

   Attribute handling give us the attr provider to use - we take
   ownership of the pointer

=head2 Wx::GridTableBase::GetAttrProvider

   wxGridCellAttrProvider* GetAttrProvider() const

   get the currently used attr provider (may be NULL)

=head2 Wx::GridTableBase::CanHaveAttributes

   bool CanHaveAttributes()

   Does this table allow attributes? Default implementation creates a
   wxGridCellAttrProvider if necessary.

=head2 Wx::GridTableBase::UpdateAttrRows

   void UpdateAttrRows(size_t pos, int numRows)

   change row/col number in attribute if needed

=head2 Wx::GridTableBase::UpdateAttrCols

   void UpdateAttrCols(size_t pos, int numCols)

=head2 Wx::GridTableBase::GetAttr

   wxGridCellAttr* GetAttr(int row, int col)

   by default forwarded to wxGridCellAttrProvider if any. May be
   overridden to handle attributes directly in the table.

=head2 Wx::GridTableBase::SetAttr

   void SetAttr(wxGridCellAttr* attr, int row, int col)

   these functions take ownership of the pointer

=head2 Wx::GridTableBase::SetRowAttr

   void SetRowAttr(wxGridCellAttr* attr, int row)

=head2 Wx::GridTableBase::SetColAttr

   void SetColAttr(wxGridCellAttr* attr, int col)

=head1 Wx::GridSizer

=head2 Wx::GridSizer::new

   wxGridSizer(int rows, int cols, int vgap, int hgap)

   wxGridSizer(int cols, int vgap = 0, int hgap = 0)

   Constructor for a wxGridSizer. rows and cols determine the number of
   columns and rows in the sizer - if either of the parameters is zero,
   it will be calculated to form the total number of children in the
   sizer, thus making the sizer grow dynamically. vgap and hgap define
   extra space between all children.

=head2 Wx::GridSizer::GetCols

   int GetCols()

   Returns the number of columns in the sizer.

=head2 Wx::GridSizer::GetHGap

   int GetHGap()

   Returns the horizontal gap (in pixels) between cells in the sizer.

=head2 Wx::GridSizer::GetRows

   int GetRows()

   Returns the number of rows in the sizer.

=head2 Wx::GridSizer::GetVGap

   int GetVGap()

   Returns the vertical gap (in pixels) between the cells in the sizer.

=head2 Wx::GridSizer::SetCols

   void SetCols(int cols)

   Sets the number of columns in the sizer.

=head2 Wx::GridSizer::SetHGap

   void SetHGap(int gap)

   Sets the horizontal gap (in pixels) between cells in the sizer.

=head2 Wx::GridSizer::SetRows

   void SetRows(int rows)

   Sets the number of rows in the sizer.

=head2 Wx::GridSizer::SetVGap

   void SetVGap(int gap)

   Sets the vertical gap (in pixels) between the cells in the sizer.

=head1 Wx::HashMap

=head2 Wx::HashMap::new

   wxHashMap(size_type size = 10)

   The size parameter is just a hint, the table will resize automatically
   to preserve performance.

   wxHashMap(const wxHashMap& map)

   Copy constructor.

=head2 Wx::HashMap::begin

   const_iterator begin() const

   iterator begin()

   Returns an iterator pointing at the first element of the hash map.
   Please remember that hash maps do not guarantee ordering.

=head2 Wx::HashMap::clear

   void clear()

   Removes all elements from the hash map.

=head2 Wx::HashMap::count

   size_type count(const key_type& key) const

   Counts the number of elements with the given key present in the map.
   This function returns only 0 or 1.

=head2 Wx::HashMap::empty

   bool empty() const

   Returns true if the hash map does not contain any elements, false
   otherwise.

=head2 Wx::HashMap::end

   const_iterator end() const

   iterator end()

   Returns an iterator pointing at the one-after-the-last element of the
   hash map. Please remember that hash maps do not guarantee ordering.

=head2 Wx::HashMap::erase

   size_type erase(const key_type& key)

   Erases the element with the given key, and returns the number of
   elements erased (either 0 or 1).

   void erase(iterator it)

   void erase(const_iterator it)

   Erases the element pointed to by the iterator. After the deletion the
   iterator is no longer valid and must not be used.

=head2 Wx::HashMap::find

   iterator find(const key_type& key)

   const_iterator find(const key_type& key) const

   If an element with the given key is present, the functions returns an
   iterator pointing at that element, otherwise an invalid iterator is
   returned (i.e. hashmap.find( non_existent_key ) == hashmap.end()).

=head2 Wx::HashMap::insert

   Insert_Result insert(const value_type& v)

   Inserts the given value in the hash map. The return value is
   equivalent to a std::pair<wxHashMap::iterator, bool>; the iterator
   points to the inserted element, the boolean value is true if v was
   actually inserted.

=head2 Wx::HashMap::size

   size_type size() const

   Returns the number of elements in the map.

=head1 Wx::HashSet

=head2 Wx::HashSet::new

   wxHashSet(size_type size = 10)

   The size parameter is just a hint, the table will resize automatically
   to preserve performance.

   wxHashSet(const wxHashSet& set)

   Copy constructor.

=head2 Wx::HashSet::begin

   const_iterator begin() const

   iterator begin()

   Returns an iterator pointing at the first element of the hash set.
   Please remember that hash sets do not guarantee ordering.

=head2 Wx::HashSet::clear

   void clear()

   Removes all elements from the hash set.

=head2 Wx::HashSet::count

   size_type count(const key_type& key) const

   Counts the number of elements with the given key present in the set.
   This function returns only 0 or 1.

=head2 Wx::HashSet::empty

   bool empty() const

   Returns true if the hash set does not contain any elements, false
   otherwise.

=head2 Wx::HashSet::end

   const_iterator end() const

   iterator end()

   Returns an iterator pointing at the one-after-the-last element of the
   hash set. Please remember that hash sets do not guarantee ordering.

=head2 Wx::HashSet::erase

   size_type erase(const key_type& key)

   Erases the element with the given key, and returns the number of
   elements erased (either 0 or 1).

   void erase(iterator it)

   void erase(const_iterator it)

   Erases the element pointed to by the iterator. After the deletion the
   iterator is no longer valid and must not be used.

=head2 Wx::HashSet::find

   iterator find(const key_type& key)

   const_iterator find(const key_type& key) const

   If an element with the given key is present, the functions returns an
   iterator pointing at that element, otherwise an invalid iterator is
   returned (i.e. hashset.find( non_existent_key ) == hashset.end()).

=head2 Wx::HashSet::insert

   Insert_Result insert(const value_type& v)

   Inserts the given value in the hash set. The return value is
   equivalent to a std::pair<wxHashMap::iterator, bool>; the iterator
   points to the inserted element, the boolean value is true if v was
   actually inserted.

=head2 Wx::HashSet::size

   size_type size() const

   Returns the number of elements in the set.

=head1 Wx::HashTable

=head2 Wx::HashTable::new

   wxHashTable(unsigned int key_type, int size = 1000)

   Constructor. key_type is one of wxKEY_INTEGER, or wxKEY_STRING, and
   indicates what sort of keying is required. size is optional.

=head2 Wx::HashTable::DESTROY

   ~wxHashTable()

   Destroys the hash table.

=head2 Wx::HashTable::BeginFind

   void BeginFind()

   The counterpart of Next. If the application wishes to iterate through
   all the data in the hash table, it can call BeginFind and then loop on
   Next.

=head2 Wx::HashTable::Clear

   void Clear()

   Clears the hash table of all nodes (but as usual, doesn't delete user
   data).

=head2 Wx::HashTable::Delete

   wxObject * Delete(long key)

   wxObject * Delete(const wxString& key)

   Deletes entry in hash table and returns the user's data (if found).

=head2 Wx::HashTable::DeleteContents

   void DeleteContents(bool flag)

   If set to true data stored in hash table will be deleted when hash
   table object is destroyed.

=head2 Wx::HashTable::Get

   wxObject * Get(long key)

   wxObject * Get(const char* key)

   Gets data from the hash table, using an integer or string key
   (depending on which has table constructor was used).

=head2 Wx::HashTable::MakeKey

   long MakeKey(const wxString& string)

   Makes an integer key out of a string. An application may wish to make
   a key explicitly (for instance when combining two data values to form
   a key).

=head2 Wx::HashTable::Next

   wxHashTable::Node * Next()

   If the application wishes to iterate through all the data in the hash
   table, it can call BeginFind and then loop on Next. This function
   returns a wxHashTable::Node pointer (or NULL if there are no more
   nodes). The return value is functionally equivalent to wxNode but
   might not be implemented as a wxNode. The user will probably only wish
   to use the GetData method to retrieve the data; the node may also be
   deleted.

=head2 Wx::HashTable::Put

   void Put(long key, wxObject *object)

   void Put(const char* key, wxObject *object)

   Inserts data into the hash table, using an integer or string key
   (depending on which has table constructor was used). The key string is
   copied and stored by the hash table implementation.

=head2 Wx::HashTable::GetCount

   size_t GetCount() const

   Returns the number of elements in the hash table.

=head1 Wx::HelpController

=head2 Wx::HelpController::new

   wxHelpController(wxWindow* parentWindow = NULL)

   Constructs a help instance object, but does not invoke the help
   viewer.

   If you provide a window, it will be used by some help controller
   classes, such as wxCHMHelpController, wxWinHelpController and
   wxHtmlHelpController, as the parent for the help window instead of the
   value of wxApp::GetTopWindow. You can also change the parent window
   later with wxHelpController::SetParentWindow.

=head2 Wx::HelpController::DESTROY

   ~wxHelpController()

   Destroys the help instance, closing down the viewer if it is running.

=head2 Wx::HelpController::Initialize

   virtual bool Initialize(const wxString& file)

   virtual bool Initialize(const wxString& file, int server)

   Initializes the help instance with a help filename, and optionally a
   server socket number if using wxHelp (now obsolete). Does not invoke
   the help viewer. This must be called directly after the help instance
   object is created and before any attempts to communicate with the
   viewer.

   You may omit the file extension and a suitable one will be chosen. For
   wxHtmlHelpController, the extensions zip, htb and hhp will be appended
   while searching for a suitable file. For WinHelp, the hlp extension is
   appended.

=head2 Wx::HelpController::DisplayBlock

   virtual bool DisplayBlock(long blockNo)

   If the help viewer is not running, runs it and displays the file at
   the given block number.

   WinHelp: Refers to the context number.

   MS HTML Help: Refers to the context number.

   External HTML help: the same as for wxHelpController::DisplaySection.

   wxHtmlHelpController: sectionNo is an identifier as specified in the
   .hhc file. See Help files format.

   This function is for backward compatibility only, and applications
   should use wxHelpController instead.

=head2 Wx::HelpController::DisplayContents

   virtual bool DisplayContents()

   If the help viewer is not running, runs it and displays the contents.

=head2 Wx::HelpController::DisplayContextPopup

   virtual bool DisplayContextPopup(int contextId)

   Displays the section as a popup window using a context id.

   Returns false if unsuccessful or not implemented.

=head2 Wx::HelpController::DisplaySection

   virtual bool DisplaySection(const wxString& section)

   If the help viewer is not running, runs it and displays the given
   section.

   The interpretation of section differs between help viewers. For most
   viewers, this call is equivalent to KeywordSearch. For MS HTML Help,
   wxHTML help and external HTML help, if section has a .htm or .html
   extension, that HTML file will be displayed; otherwise a keyword
   search is done.

   virtual bool DisplaySection(int sectionNo)

   If the help viewer is not running, runs it and displays the given
   section.

   WinHelp, MS HTML Help sectionNo is a context id.

   External HTML help: wxExtHelpController implements sectionNo as an id
   in a map file, which is of the form:

   0  wx.html             ; Index
   1  wx34.html#classref  ; Class reference
   2  wx204.html          ; Function reference

   wxHtmlHelpController: sectionNo is an identifier as specified in the
   .hhc file. See Help files format.

   See also the help sample for notes on how to specify section numbers
   for various help file formats.

=head2 Wx::HelpController::DisplayTextPopup

   virtual bool DisplayTextPopup(const wxString& text, const wxPoint& pos)

   Displays the text in a popup window, if possible.

   Returns false if unsuccessful or not implemented.

=head2 Wx::HelpController::GetFrameParameters

   virtual wxFrame * GetFrameParameters(const wxSize * size = NULL, const
   wxPoint * pos = NULL, bool *newFrameEachTime = NULL)

   wxHtmlHelpController returns the frame, size and position.

   For all other help controllers, this function does nothing and just
   returns NULL.

   Parameters

   viewer

       This defaults to "netscape" for wxExtHelpController.

   flags

       This defaults to wxHELP_NETSCAPE for wxExtHelpController,
       indicating that the viewer is a variant of Netscape Navigator.

=head2 Wx::HelpController::GetParentWindow

   virtual wxWindow* GetParentWindow() const

   Returns the window to be used as the parent for the help window. This
   window is used by wxCHMHelpController, wxWinHelpController and
   wxHtmlHelpController.

=head2 Wx::HelpController::KeywordSearch

   virtual bool KeywordSearch(const wxString& keyWord, wxHelpSearchMode
   mode = wxHELP_SEARCH_ALL)

   If the help viewer is not running, runs it, and searches for sections
   matching the given keyword. If one match is found, the file is
   displayed at this section. The optional parameter allows the search
   the index (wxHELP_SEARCH_INDEX) but this currently only supported by
   the wxHtmlHelpController.

   WinHelp, MS HTML Help: If more than one match is found, the first
   topic is displayed.

   External HTML help, simple wxHTML help: If more than one match is
   found, a choice of topics is displayed.

   wxHtmlHelpController: see wxHtmlHelpController::KeywordSearch.

=head2 Wx::HelpController::LoadFile

   virtual bool LoadFile(const wxString& file = "")

   If the help viewer is not running, runs it and loads the given file.
   If the filename is not supplied or is empty, the file specified in
   Initialize is used. If the viewer is already displaying the specified
   file, it will not be reloaded. This member function may be used before
   each display call in case the user has opened another file.

   wxHtmlHelpController ignores this call.

=head2 Wx::HelpController::OnQuit

   virtual bool OnQuit()

   Overridable member called when this application's viewer is quit by
   the user.

   This does not work for all help controllers.

=head2 Wx::HelpController::SetFrameParameters

   virtual void SetFrameParameters(const wxString & title, const wxSize &
   size, const wxPoint & pos = wxDefaultPosition, bool newFrameEachTime =
   false)

   For wxHtmlHelpController, the title is set (again with %s indicating
   the page title) and also the size and position of the frame if the
   frame is already open. newFrameEachTime is ignored.

   For all other help controllers this function has no effect.

=head2 Wx::HelpController::SetParentWindow

   virtual void SetParentWindow(wxWindow* parentWindow)

   Sets the window to be used as the parent for the help window. This is
   used by wxCHMHelpController, wxWinHelpController and
   wxHtmlHelpController.

=head2 Wx::HelpController::SetViewer

   virtual void SetViewer(const wxString& viewer, long flags)

   Sets detailed viewer information. So far this is only relevant to
   wxExtHelpController.

   Some examples of usage:

     m_help.SetViewer("kdehelp");
     m_help.SetViewer("gnome-help-browser");
     m_help.SetViewer("netscape", wxHELP_NETSCAPE);

=head2 Wx::HelpController::Quit

   virtual bool Quit()

   If the viewer is running, quits it by disconnecting.

   For Windows Help, the viewer will only close if no other application
   is using it.

=head1 Wx::HelpControllerHelpProvider

=head2 Wx::HelpControllerHelpProvider::new

   wxHelpControllerHelpProvider(wxHelpControllerBase* hc = NULL)

   Note that the instance doesn't own the help controller. The help
   controller should be deleted separately.

=head2 Wx::HelpControllerHelpProvider::SetHelpController

   void SetHelpController(wxHelpControllerBase* hc)

   Sets the help controller associated with this help provider.

=head2 Wx::HelpControllerHelpProvider::GetHelpController

   wxHelpControllerBase* GetHelpController() const

   Returns the help controller associated with this help provider.

=head1 Wx::HelpEvent

=head2 Wx::HelpEvent::new

   wxHelpEvent(WXTYPE eventType = 0, wxWindowID id = 0, const wxPoint&
   point)

   Constructor.

=head2 Wx::HelpEvent::GetOrigin

   wxHelpEvent::Origin GetOrigin() const

   Returns the origin of the help event which is one of the following
   values:

=head2 Wx::HelpEvent::GetPosition

   const wxPoint& GetPosition() const

   Returns the left-click position of the mouse, in screen coordinates.
   This allows the application to position the help appropriately.

=head2 Wx::HelpEvent::SetOrigin

   void SetOrigin(wxHelpEvent::Origin origin)

   Set the help event origin, only used internally by wxWidgets normally.

   See also

   wxHelpEvent::GetOrigin

=head2 Wx::HelpEvent::SetPosition

   void SetPosition(const wxPoint& pt)

   Sets the left-click position of the mouse, in screen coordinates.

=head1 Wx::HelpProvider

=head2 Wx::HelpProvider::DESTROY

   ~wxHelpProvider()

   Virtual destructor for any base class.

=head2 Wx::HelpProvider::AddHelp

   virtual void AddHelp(wxWindowBase* window, const wxString& text)

   Associates the text with the given window or id. Although all help
   providers have these functions to allow making wxWindow::SetHelpText
   work, not all of them implement the functions.

   virtual void AddHelp(wxWindowID id, const wxString& text)

   This version associates the given text with all windows with this id.
   May be used to set the same help string for all Cancel buttons in the
   application, for example.

=head2 Wx::HelpProvider::Get

   static wxHelpProvider* Get()

   Returns pointer to help provider instance.

   Unlike some other classes, the help provider is not created on demand.
   This must be explicitly done by the application using Set.

=head2 Wx::HelpProvider::GetHelp

   virtual wxString GetHelp(const wxWindowBase* window)

   Gets the help string for this window. Its interpretation is dependent
   on the help provider except that empty string always means that no
   help is associated with the window.

=head2 Wx::HelpProvider::RemoveHelp

   virtual void RemoveHelp(wxWindowBase* window)

   Removes the association between the window pointer and the help text,
   if it was previously set using AddHelp. This is called by the wxWindow
   destructor. Without this, the table of help strings will fill up and
   when window pointers are reused, the wrong help string will be found.

   Note that this method may be called even for windows that don't have
   any associated help text. If that happens, its implementation should
   simply do nothing.

=head2 Wx::HelpProvider::Set

   static wxHelpProvider* Set(wxHelpProvider* helpProvider)

   Get/set the current, application-wide help provider. Returns the
   previous one.

=head2 Wx::HelpProvider::ShowHelpAtPoint

   virtual bool ShowHelpAtPoint(wxWindowBase* window, const wxPointpoint,
   wxHelpEvent::Origin origin)

   This function may be overridden to show help for the window when it
   should depend on the position inside the window, By default this
   method forwards to ShowHelp, so it is enough to only implement the
   latter if the help doesn't depend on the position.

   Returns true if help was shown, or false if no help was available for
   this window.

   Parameters

   window

       Window to show help text for.

   point

       Coordinates of the mouse at the moment of help event emission.

   origin

       Help event origin, see wxHelpEvent::GetOrigin.

   This function is new since wxWidgets version 2.7.0

=head2 Wx::HelpProvider::ShowHelp

   virtual bool ShowHelp(wxWindowBase* window)

   Shows help for the given window. Override this function if the help
   doesn't depend on the exact position inside the window, otherwise you
   need to override ShowHelpAtPoint.

   Returns true if help was shown, or false if no help was available for
   this window.

=head1 Wx::HtmlCell

=head2 Wx::HtmlCell::new

   wxHtmlCell()

   Constructor.

=head2 Wx::HtmlCell::AdjustPagebreak

   virtual bool AdjustPagebreak(int * pagebreak)

   This method is used to adjust pagebreak position. The parameter is
   variable that contains y-coordinate of page break (= horizontal line
   that should not be crossed by words, images etc.). If this cell cannot
   be divided into two pieces (each one on another page) then it moves
   the pagebreak few pixels up.

   Returns true if pagebreak was modified, false otherwise

   Usage:

   while (container->AdjustPagebreak(&p)) {}

=head2 Wx::HtmlCell::Draw

   virtual void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2)

   Renders the cell.

   Parameters

   dc  

       Device context to which the cell is to be drawn

   x,y 

       Coordinates of parent's upper left corner (origin). You must add
       this to m_PosX,m_PosY when passing coordinates to dc's methods
       Example : dc -> DrawText("hello", x + m_PosX, y + m_PosY)

   view_y1

       y-coord of the first line visible in window. This is used to
       optimize rendering speed

   view_y2

       y-coord of the last line visible in window. This is used to
       optimize rendering speed

=head2 Wx::HtmlCell::DrawInvisible

   virtual void DrawInvisible(wxDC& dc, int x, int y)

   This method is called instead of Draw when the cell is certainly out
   of the screen (and thus invisible). This is not nonsense - some tags
   (like wxHtmlColourCell or font setter) must be drawn even if they are
   invisible!

   Parameters

   dc  

       Device context to which the cell is to be drawn

   x,y 

       Coordinates of parent's upper left corner. You must add this to
       m_PosX,m_PosY when passing coordinates to dc's methods Example :
       dc -> DrawText("hello", x + m_PosX, y + m_PosY)

=head2 Wx::HtmlCell::Find

   virtual const wxHtmlCell* Find(int condition, const void* param)

   Returns pointer to itself if this cell matches condition (or if any of
   the cells following in the list matches), NULL otherwise. (In other
   words if you call top-level container's Find it will return pointer to
   the first cell that matches the condition)

   It is recommended way how to obtain pointer to particular cell or to
   cell of some type (e.g. wxHtmlAnchorCell reacts on
   wxHTML_COND_ISANCHOR condition)

   Parameters

   condition

       Unique integer identifier of condition

   param

       Optional parameters

   Defined conditions

=head2 Wx::HtmlCell::GetDescent

   int GetDescent() const

   Returns descent value of the cell (m_Descent member). See explanation:

   [IMAGE]

=head2 Wx::HtmlCell::GetFirstChild

   wxHtmlCell* GetFirstChild()

   Returns pointer to the first cell in the list. You can then use
   child's GetNext method to obtain pointer to the next cell in list.

   Note: This shouldn't be used by the end user. If you need some way of
   finding particular cell in the list, try Find method instead.

=head2 Wx::HtmlCell::GetHeight

   int GetHeight() const

   Returns height of the cell (m_Height member).

=head2 Wx::HtmlCell::GetId

   virtual wxString GetId() const

   Returns unique cell identifier if there is any, empty string
   otherwise.

=head2 Wx::HtmlCell::GetLink

   virtual wxHtmlLinkInfo* GetLink(int x = 0, int y = 0) const

   Returns hypertext link if associated with this cell or NULL otherwise.
   See wxHtmlLinkInfo. (Note: this makes sense only for visible tags).

   Parameters

   x,y 

       Coordinates of position where the user pressed mouse button. These
       coordinates are used e.g. by COLORMAP. Values are relative to the
       upper left corner of THIS cell (i.e. from 0 to m_Width or
       m_Height)

=head2 Wx::HtmlCell::GetMouseCursor

   virtual wxCursor GetMouseCursor(wxHtmlWindowInterface* window)

   Returns cursor to show when mouse pointer is over the cell.

   Parameters

   window

       interface to the parent HTML window

   This function is new since wxWidgets version 2.7.0 (before GetCursor
   method served a similar purpose, which is now deprecated).

=head2 Wx::HtmlCell::GetNext

   wxHtmlCell* GetNext() const

   Returns pointer to the next cell in list (see htmlcell.h if you're
   interested in details).

=head2 Wx::HtmlCell::GetParent

   wxHtmlContainerCell* GetParent() const

   Returns pointer to parent container.

=head2 Wx::HtmlCell::GetPosX

   int GetPosX() const

   Returns X position within parent (the value is relative to parent's
   upper left corner). The returned value is meaningful only if parent's
   Layout was called before!

=head2 Wx::HtmlCell::GetPosY

   int GetPosY() const

   Returns Y position within parent (the value is relative to parent's
   upper left corner). The returned value is meaningful only if parent's
   Layout was called before!

=head2 Wx::HtmlCell::GetWidth

   int GetWidth() const

   Returns width of the cell (m_Width member).

=head2 Wx::HtmlCell::Layout

   virtual void Layout(int w)

   This method performs two actions:

=head2 Wx::HtmlCell::ProcessMouseClick

   virtual bool ProcessMouseClick(wxHtmlWindowInterface* window, const
   wxPoint& pos, const wxMouseEvent& event)

   This function is simple event handler. Each time the user clicks mouse
   button over a cell within wxHtmlWindow this method of that cell is
   called. Default behavior is to call wxHtmlWindow::LoadPage.

   Note

   If you need more "advanced" event handling you should use
   wxHtmlBinderCell instead.

   Parameters

   window

       interface to the parent HTML window

   pos 

       coordinates of mouse click (this is relative to cell's origin

   event

       mouse event that triggered the call

   Return value

   true if a link was clicked, false otherwise.

   This function is new since wxWidgets version 2.7.0 (before
   OnMouseClick method served a similar purpose).

=head2 Wx::HtmlCell::SetId

   void SetId(const wxString& id)

   Sets unique cell identifier. Default value is no identifier, i.e.
   empty string.

=head2 Wx::HtmlCell::SetLink

   void SetLink(const wxHtmlLinkInfo& link)

   Sets the hypertext link associated with this cell. (Default value is
   wxHtmlLinkInfo("", "") (no link))

=head2 Wx::HtmlCell::SetNext

   void SetNext(wxHtmlCell *cell)

   Sets the next cell in the list. This shouldn't be called by user - it
   is to be used only by wxHtmlContainerCell::InsertCell.

=head2 Wx::HtmlCell::SetParent

   void SetParent(wxHtmlContainerCell *p)

   Sets parent container of this cell. This is called from
   wxHtmlContainerCell::InsertCell.

=head2 Wx::HtmlCell::SetPos

   void SetPos(int x, int y)

   Sets the cell's position within parent container.

=head1 Wx::HtmlColourCell

=head2 Wx::HtmlColourCell::new

   wxHtmlColourCell(wxColour clr, int flags = wxHTML_CLR_FOREGROUND)

   Constructor.

   Parameters

   clr 

       The color

   flags

       Can be one of following:

=head1 Wx::HtmlContainerCell

=head2 Wx::HtmlContainerCell::new

   wxHtmlContainerCell(wxHtmlContainerCell *parent)

   Constructor. parent is pointer to parent container or NULL.

=head2 Wx::HtmlContainerCell::GetAlignHor

   int GetAlignHor() const

   Returns container's horizontal alignment.

=head2 Wx::HtmlContainerCell::GetAlignVer

   int GetAlignVer() const

   Returns container's vertical alignment.

=head2 Wx::HtmlContainerCell::GetBackgroundColour

   wxColour GetBackgroundColour()

   Returns the background colour of the container or wxNullColour if no
   background colour is set.

=head2 Wx::HtmlContainerCell::GetIndent

   int GetIndent(int ind) const

   Returns the indentation. ind is one of the wxHTML_INDENT_* constants.

   Note: You must call GetIndentUnits with same ind parameter in order to
   correctly interpret the returned integer value. It is NOT always in
   pixels!

=head2 Wx::HtmlContainerCell::GetIndentUnits

   int GetIndentUnits(int ind) const

   Returns the units of indentation for ind where ind is one of the
   wxHTML_INDENT_* constants.

=head2 Wx::HtmlContainerCell::InsertCell

   void InsertCell(wxHtmlCell *cell)

   Inserts new cell into the container.

=head2 Wx::HtmlContainerCell::SetAlign

   void SetAlign(const wxHtmlTag& tag)

   Sets the container's alignment (both horizontal and vertical)
   according to the values stored in tag. (Tags ALIGN parameter is
   extracted.) In fact it is only a front-end to SetAlignHor and
   SetAlignVer.

=head2 Wx::HtmlContainerCell::SetAlignHor

   void SetAlignHor(int al)

   Sets the container's horizontal alignment. During Layout each line is
   aligned according to al value.

   Parameters

   al  

       new horizontal alignment. May be one of these values:

=head2 Wx::HtmlContainerCell::SetAlignVer

   void SetAlignVer(int al)

   Sets the container's vertical alignment. This is per-line alignment!

   Parameters

   al  

       new vertical alignment. May be one of these values:

=head2 Wx::HtmlContainerCell::SetBackgroundColour

   void SetBackgroundColour(const wxColour& clr)

   Sets the background colour for this container.

=head2 Wx::HtmlContainerCell::SetBorder

   void SetBorder(const wxColour& clr1, const wxColour& clr2)

   Sets the border (frame) colours. A border is a rectangle around the
   container.

   Parameters

   clr1

       Colour of top and left lines

   clr2

       Colour of bottom and right lines

=head2 Wx::HtmlContainerCell::SetIndent

   void SetIndent(int i, int what, int units = wxHTML_UNITS_PIXELS)

   Sets the indentation (free space between borders of container and
   subcells).

   Parameters

   i   

       Indentation value.

   what

       Determines which of the four borders we're setting. It is OR
       combination of following constants:

=head2 Wx::HtmlContainerCell::SetMinHeight

   void SetMinHeight(int h, int align = wxHTML_ALIGN_TOP)

   Sets minimal height of the container.

   When container's Layout is called, m_Height is set depending on layout
   of subcells to the height of area covered by layed-out subcells.
   Calling this method guarantees you that the height of container is
   never smaller than h - even if the subcells cover much smaller area.

   Parameters

   h   

       The minimal height.

   align

       If height of the container is lower than the minimum height, empty
       space must be inserted somewhere in order to ensure minimal
       height. This parameter is one of wxHTML_ALIGN_TOP,
       wxHTML_ALIGN_BOTTOM, wxHTML_ALIGN_CENTER. It refers to the
       contents, not to the empty place.

=head2 Wx::HtmlContainerCell::SetWidthFloat

   void SetWidthFloat(int w, int units)

   void SetWidthFloat(const wxHtmlTag& tag, double pixel_scale = 1.0)

   Sets floating width adjustment.

   The normal behaviour of container is that its width is the same as the
   width of parent container (and thus you can have only one
   sub-container per line). You can change this by setting FWA.

   pixel_scale is number of real pixels that equals to 1 HTML pixel.

   Parameters

   w   

       Width of the container. If the value is negative it means
       complement to full width of parent container (e.g.
       SetWidthFloat(-50, wxHTML_UNITS_PIXELS) sets the width of
       container to parent's width minus 50 pixels. This is useful when
       creating tables - you can call SetWidthFloat(50) and
       SetWidthFloat(-50))

   units

       Units of w This parameter affects the interpretation of value.

=head1 Wx::HtmlDCRenderer

=head2 Wx::HtmlDCRenderer::new

   wxHtmlDCRenderer()

   Constructor.

=head2 Wx::HtmlDCRenderer::SetDC

   void SetDC(wxDC* dc, double pixel_scale = 1.0)

   Assign DC instance to the renderer.

   pixel_scale can be used when rendering to high-resolution DCs (e.g.
   printer) to adjust size of pixel metrics. (Many dimensions in HTML are
   given in pixels -- e.g. image sizes. 300x300 image would be only one
   inch wide on typical printer. With pixel_scale = 3.0 it would be 3
   inches.)

=head2 Wx::HtmlDCRenderer::SetFonts

   void SetFonts(const wxString& normal_face, const wxString& fixed_face,
   const int *sizes = NULL)

   Sets fonts. See wxHtmlWindow::SetFonts for detailed description.

   See also SetSize.

=head2 Wx::HtmlDCRenderer::SetSize

   void SetSize(int width, int height)

   Set size of output rectangle, in pixels. Note that you can't change
   width of the rectangle between calls to Render! (You can freely change
   height.)

=head2 Wx::HtmlDCRenderer::SetHtmlText

   void SetHtmlText(const wxString& html, const wxString& basepath =
   wxEmptyString, bool isdir = true)

   Assign text to the renderer. Render then draws the text onto DC.

   Parameters

   html

       HTML text. This is not a filename.

   basepath

       base directory (html string would be stored there if it was in
       file). It is used to determine path for loading images, for
       example.

   isdir

       false if basepath is filename, true if it is directory name (see
       wxFileSystem for detailed explanation)

=head2 Wx::HtmlDCRenderer::Render

   int Render(int x, int y, int from = 0, int dont_render = false)

   Renders HTML text to the DC.

   Parameters

   x,y 

       position of upper-left corner of printing rectangle (see SetSize)

   from

       y-coordinate of the very first visible cell

   dont_render

       if true then this method only returns y coordinate of the next
       page and does not output anything

   Returned value is y coordinate of first cell than didn't fit onto
   page. Use this value as from in next call to Render in order to print
   multipages document.

   Caution!

   The Following three methods must always be called before any call to
   Render (preferably in this order):

=head2 Wx::HtmlDCRenderer::GetTotalHeight

   int GetTotalHeight()

   Returns the height of the HTML text. This is important if area height
   (see SetSize) is smaller that total height and thus the page cannot
   fit into it. In that case you're supposed to call Render as long as
   its return value is smaller than GetTotalHeight's.

=head1 Wx::HtmlEasyPrinting

=head2 Wx::HtmlEasyPrinting::new

   wxHtmlEasyPrinting(const wxString& name = "Printing", wxWindow*
   parentWindow = NULL)

   Constructor.

   Parameters

   name

       Name of the printing object. Used by preview frames and setup
       dialogs.

   parentWindow

       pointer to the window that will own the preview frame and setup
       dialogs. May be NULL.

=head2 Wx::HtmlEasyPrinting::GetParentWindow

   wxWindow* GetParentWindow() const

   Gets the parent window for dialogs.

=head2 Wx::HtmlEasyPrinting::GetPrintData

   wxPrintData* GetPrintData()

   Returns pointer to wxPrintData instance used by this class. You can
   set its parameters (via SetXXXX methods).

=head2 Wx::HtmlEasyPrinting::GetPageSetupData

   wxPageSetupDialogData* GetPageSetupData()

   Returns a pointer to wxPageSetupDialogData instance used by this
   class. You can set its parameters (via SetXXXX methods).

=head2 Wx::HtmlEasyPrinting::PreviewFile

   bool PreviewFile(const wxString& htmlfile)

   Preview HTML file.

   Returns false in case of error -- call wxPrinter::GetLastError to get
   detailed information about the kind of the error.

=head2 Wx::HtmlEasyPrinting::PreviewText

   bool PreviewText(const wxString& htmltext, const wxString& basepath =
   wxEmptyString)

   Preview HTML text (not file!).

   Returns false in case of error -- call wxPrinter::GetLastError to get
   detailed information about the kind of the error.

   Parameters

   htmltext

       HTML text.

   basepath

       base directory (html string would be stored there if it was in
       file). It is used to determine path for loading images, for
       example.

=head2 Wx::HtmlEasyPrinting::PrintFile

   bool PrintFile(const wxString& htmlfile)

   Print HTML file.

   Returns false in case of error -- call wxPrinter::GetLastError to get
   detailed information about the kind of the error.

=head2 Wx::HtmlEasyPrinting::PrintText

   bool PrintText(const wxString& htmltext, const wxString& basepath =
   wxEmptyString)

   Print HTML text (not file!).

   Returns false in case of error -- call wxPrinter::GetLastError to get
   detailed information about the kind of the error.

   Parameters

   htmltext

       HTML text.

   basepath

       base directory (html string would be stored there if it was in
       file). It is used to determine path for loading images, for
       example.

=head2 Wx::HtmlEasyPrinting::PageSetup

   void PageSetup()

   Display page setup dialog and allows the user to modify settings.

=head2 Wx::HtmlEasyPrinting::SetFonts

   void SetFonts(const wxString& normal_face, const wxString& fixed_face,
   const int *sizes = NULL)

   Sets fonts. See wxHtmlWindow::SetFonts for detailed description.

=head2 Wx::HtmlEasyPrinting::SetHeader

   void SetHeader(const wxString& header, int pg = wxPAGE_ALL)

   Set page header. The following macros can be used inside it:

=head2 Wx::HtmlEasyPrinting::SetFooter

   void SetFooter(const wxString& footer, int pg = wxPAGE_ALL)

   Set page footer. The following macros can be used inside it:

=head2 Wx::HtmlEasyPrinting::SetParentWindow

   void SetParentWindow(wxWindow* window)

   Sets the parent window for dialogs.

=head1 Wx::HtmlFilter

=head2 Wx::HtmlFilter::new

   wxHtmlFilter()

   Constructor.

=head2 Wx::HtmlFilter::CanRead

   bool CanRead(const wxFSFile& file)

   Returns true if this filter is capable of reading file file.

   Example:

   bool MyFilter::CanRead(const wxFSFile& file)
   {
       return (file.GetMimeType() == "application/x-ugh");
   }

=head2 Wx::HtmlFilter::ReadFile

   wxString ReadFile(const wxFSFile& file)

   Reads the file and returns string with HTML document.

   Example:

   wxString MyImgFilter::ReadFile(const wxFSFile& file)
   {
       return "<html><body><img src=\"" +
              file.GetLocation() +
              "\"></body></html>";
   }

=head1 Wx::HtmlHelpController

=head2 Wx::HtmlHelpController::new

   wxHtmlHelpController(int style = wxHF_DEFAULT_STYLE, wxWindow*
   parentWindow = NULL)

   Constructor.

   Parameters

   style is a combination of these flags:

=head2 Wx::HtmlHelpController::AddBook

   bool AddBook(const wxFileName& bookFile, bool showWaitMsg)

   bool AddBook(const wxString& bookUrl, bool showWaitMsg)

   Adds book (.hhp file - HTML Help Workshop project file) into the list
   of loaded books. This must be called at least once before displaying
   any help.

   bookFile or bookUrl may be either .hhp file or ZIP archive that
   contains arbitrary number of .hhp files in top-level directory. This
   ZIP archive must have .zip or .htb extension (the latter stands for
   "HTML book"). In other words, AddBook(wxFileName("help.zip")) is
   possible and is the recommended way.

   Parameters

   showWaitMsg

       If true then a decoration-less window with progress message is
       displayed.

=head2 Wx::HtmlHelpController::CreateHelpDialog

   virtual wxHtmlHelpDialog* CreateHelpDialog(wxHtmlHelpData * data)

   This protected virtual method may be overridden so that when
   specifying the wxHF_DIALOG style, the controller uses a different
   dialog.

=head2 Wx::HtmlHelpController::CreateHelpFrame

   virtual wxHtmlHelpFrame* CreateHelpFrame(wxHtmlHelpData * data)

   This protected virtual method may be overridden so that the controller
   uses a different frame.

=head2 Wx::HtmlHelpController::Display

   void Display(const wxString& x)

   Displays page x. This is THE important function - it is used to
   display the help in application.

   You can specify the page in many ways:

=head2 Wx::HtmlHelpController::DisplayContents

   void DisplayContents()

   Displays help window and focuses contents panel.

=head2 Wx::HtmlHelpController::DisplayIndex

   void DisplayIndex()

   Displays help window and focuses index panel.

=head2 Wx::HtmlHelpController::KeywordSearch

   bool KeywordSearch(const wxString& keyword, wxHelpSearchMode mode =
   wxHELP_SEARCH_ALL)

   Displays help window, focuses search panel and starts searching.
   Returns true if the keyword was found. Optionally it searches through
   the index (mode = wxHELP_SEARCH_INDEX), default the content (mode =
   wxHELP_SEARCH_ALL).

   Important: KeywordSearch searches only pages listed in .hhc file(s).
   You should list all pages in the contents file.

=head2 Wx::HtmlHelpController::ReadCustomization

   void ReadCustomization(wxConfigBase* cfg, wxString path =
   wxEmptyString)

   Reads the controller's setting (position of window, etc.)

=head2 Wx::HtmlHelpController::SetTempDir

   void SetTempDir(const wxString& path)

   Sets the path for storing temporary files - cached binary versions of
   index and contents files. These binary forms are much faster to read.
   Default value is empty string (empty string means that no cached data
   are stored). Note that these files are not deleted when program exits.

   Once created these cached files will be used in all subsequent
   executions of your application. If cached files become older than
   corresponding .hhp file (e.g. if you regenerate documentation) it will
   be refreshed.

=head2 Wx::HtmlHelpController::SetTitleFormat

   void SetTitleFormat(const wxString& format)

   Sets format of title of the frame. Must contain exactly one "%s" (for
   title of displayed HTML page).

=head2 Wx::HtmlHelpController::UseConfig

   void UseConfig(wxConfigBase* config, const wxString& rootpath =
   wxEmptyString)

   Associates config object with the controller.

   If there is associated config object, wxHtmlHelpController
   automatically reads and writes settings (including wxHtmlWindow's
   settings) when needed.

   The only thing you must do is create wxConfig object and call
   UseConfig.

   If you do not use UseConfig, wxHtmlHelpController will use default
   wxConfig object if available (for details see wxConfigBase::Get and
   wxConfigBase::Set).

=head2 Wx::HtmlHelpController::WriteCustomization

   void WriteCustomization(wxConfigBase* cfg, wxString path =
   wxEmptyString)

   Stores controllers setting (position of window etc.)

=head1 Wx::HtmlHelpData

=head2 Wx::HtmlHelpData::new

   wxHtmlHelpData()

   Constructor.

=head2 Wx::HtmlHelpData::AddBook

   bool AddBook(const wxString& book_url)

   Adds new book. book is URL (not filename!) of HTML help project (hhp)
   or ZIP file that contains arbitrary number of .hhp projects (this zip
   file can have either .zip or .htb extension, htb stands for "html
   book"). Returns success.

=head2 Wx::HtmlHelpData::FindPageById

   wxString FindPageById(int id)

   Returns page's URL based on integer ID stored in project.

=head2 Wx::HtmlHelpData::FindPageByName

   wxString FindPageByName(const wxString& page)

   Returns page's URL based on its (file)name.

=head2 Wx::HtmlHelpData::GetBookRecArray

   const wxHtmlBookRecArray& GetBookRecArray()

   Returns array with help books info.

=head2 Wx::HtmlHelpData::GetContentsArray

   const wxHtmlHelpDataItems& GetContentsArray()

   Returns reference to array with contents entries.

=head2 Wx::HtmlHelpData::GetIndexArray

   const wxHtmlHelpDataItems& GetIndexArray()

   Returns reference to array with index entries.

=head2 Wx::HtmlHelpData::SetTempDir

   void SetTempDir(const wxString& path)

   Sets temporary directory where binary cached versions of MS HTML
   Workshop files will be stored. (This is turned off by default and you
   can enable this feature by setting non-empty temp dir.)

=head1 Wx::HtmlHelpDialog

=head2 Wx::HtmlHelpDialog::new

   wxHtmlHelpDialog(wxHtmlHelpData* data = NULL)

   wxHtmlHelpDialog(wxWindow* parent, int wxWindowID, const wxString&
   title = wxEmptyString, int style = wxHF_DEFAULT_STYLE, wxHtmlHelpData*
   data = NULL)

   Constructor. For the values of style, please see the documentation for
   wxHtmlHelpController.

=head2 Wx::HtmlHelpDialog::AddToolbarButtons

   virtual void AddToolbarButtons(wxToolBar *toolBar, int style)

   You may override this virtual method to add more buttons to the help
   window's toolbar. toolBar is a pointer to the toolbar and style is the
   style flag as passed to the Create method.

   wxToolBar::Realize is called immediately after returning from this
   function.

=head2 Wx::HtmlHelpDialog::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxString& title =
   wxEmptyString, int style = wxHF_DEFAULT_STYLE)

   Creates the dialog. See the constructor for a description of the
   parameters.

=head2 Wx::HtmlHelpDialog::GetController

   wxHtmlHelpController* GetController() const

   Returns the help controller associated with the dialog.

=head2 Wx::HtmlHelpDialog::ReadCustomization

   void ReadCustomization(wxConfigBase* cfg, const wxString& path =
   wxEmptyString)

   Reads the user's settings for this dialog see
   wxHtmlHelpController::ReadCustomization)

=head2 Wx::HtmlHelpDialog::SetController

   void SetController(wxHtmlHelpController* contoller)

   Sets the help controller associated with the dialog.

=head2 Wx::HtmlHelpDialog::SetTitleFormat

   void SetTitleFormat(const wxString& format)

   Sets the dialog's title format. format must contain exactly one "%s"
   (it will be replaced by the page title).

=head2 Wx::HtmlHelpDialog::WriteCustomization

   void WriteCustomization(wxConfigBase* cfg, const wxString& path =
   wxEmptyString)

   Saves the user's settings for this dialog (see
   wxHtmlHelpController::WriteCustomization).

=head1 Wx::HtmlHelpFrame

=head2 Wx::HtmlHelpFrame::new

   wxHtmlHelpFrame(wxHtmlHelpData* data = NULL)

   wxHtmlHelpFrame(wxWindow* parent, int wxWindowID, const wxString&
   title = wxEmptyString, int style = wxHF_DEFAULT_STYLE, wxHtmlHelpData*
   data = NULL)

   Constructor. For the values of style, please see the documentation for
   wxHtmlHelpController.

=head2 Wx::HtmlHelpFrame::AddToolbarButtons

   virtual void AddToolbarButtons(wxToolBar *toolBar, int style)

   You may override this virtual method to add more buttons to the help
   window's toolbar. toolBar is a pointer to the toolbar and style is the
   style flag as passed to the Create method.

   wxToolBar::Realize is called immediately after returning from this
   function.

=head2 Wx::HtmlHelpFrame::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxString& title =
   wxEmptyString, int style = wxHF_DEFAULT_STYLE)

   Creates the frame. See the constructor for a description of the
   parameters.

=head2 Wx::HtmlHelpFrame::GetController

   wxHtmlHelpController* GetController() const

   Returns the help controller associated with the frame.

=head2 Wx::HtmlHelpFrame::ReadCustomization

   void ReadCustomization(wxConfigBase* cfg, const wxString& path =
   wxEmptyString)

   Reads the user's settings for this frame see
   wxHtmlHelpController::ReadCustomization)

=head2 Wx::HtmlHelpFrame::SetController

   void SetController(wxHtmlHelpController* contoller)

   Sets the help controller associated with the frame.

=head2 Wx::HtmlHelpFrame::SetTitleFormat

   void SetTitleFormat(const wxString& format)

   Sets the frame's title format. format must contain exactly one "%s"
   (it will be replaced by the page title).

=head2 Wx::HtmlHelpFrame::WriteCustomization

   void WriteCustomization(wxConfigBase* cfg, const wxString& path =
   wxEmptyString)

   Saves the user's settings for this frame (see
   wxHtmlHelpController::WriteCustomization).

=head1 Wx::HtmlHelpWindow

=head2 Wx::HtmlHelpWindow::new

   wxHtmlHelpWindow(wxHtmlHelpData* data = NULL)

   wxHtmlHelpWindow(wxWindow* parent, int wxWindowID, const wxPoint& pos
   = wxDefaultPosition, const wxSize& pos = wxDefaultSize, int style =
   wxTAB_TRAVERSAL|wxTAB_wxNO_BORDER, int helpStyle = wxHF_DEFAULT_STYLE,
   wxHtmlHelpData* data = NULL)

   Constructor.

   Constructor. For the values of helpStyle, please see the documentation
   for wxHtmlHelpController.

=head2 Wx::HtmlHelpWindow::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxPoint& pos =
   wxDefaultPosition, const wxSize& pos = wxDefaultSize, int style =
   wxTAB_TRAVERSAL|wxTAB_wxNO_BORDER, int helpStyle = wxHF_DEFAULT_STYLE,
   wxHtmlHelpData* data = NULL)

   Creates the help window. See the constructor for a description of the
   parameters.

=head2 Wx::HtmlHelpWindow::CreateContents

   void CreateContents()

   Creates contents panel. (May take some time.)

   Protected.

=head2 Wx::HtmlHelpWindow::CreateIndex

   void CreateIndex()

   Creates index panel. (May take some time.)

   Protected.

=head2 Wx::HtmlHelpWindow::CreateSearch

   void CreateSearch()

   Creates search panel.

=head2 Wx::HtmlHelpWindow::Display

   bool Display(const wxString& x)

   bool Display(const int id)

   Displays page x. If not found it will give the user the choice of
   searching books. Looking for the page runs in these steps:

=head2 Wx::HtmlHelpWindow::DisplayContents

   bool DisplayContents()

   Displays contents panel.

=head2 Wx::HtmlHelpWindow::DisplayIndex

   bool DisplayIndex()

   Displays index panel.

=head2 Wx::HtmlHelpWindow::GetData

   wxHtmlHelpData* GetData()

   Returns the wxHtmlHelpData object, which is usually a pointer to the
   controller's data.

=head2 Wx::HtmlHelpWindow::KeywordSearch

   bool KeywordSearch(const wxString& keyword, wxHelpSearchMode mode =
   wxHELP_SEARCH_ALL)

   Search for given keyword. Optionally it searches through the index
   (mode = wxHELP_SEARCH_INDEX), default the content (mode =
   wxHELP_SEARCH_ALL).

=head2 Wx::HtmlHelpWindow::ReadCustomization

   void ReadCustomization(wxConfigBase* cfg, const wxString& path =
   wxEmptyString)

   Reads the user's settings for this window (see
   wxHtmlHelpController::ReadCustomization)

=head2 Wx::HtmlHelpWindow::RefreshLists

   void RefreshLists()

   Refresh all panels. This is necessary if a new book was added.

   Protected.

=head2 Wx::HtmlHelpWindow::SetTitleFormat

   void SetTitleFormat(const wxString& format)

   Sets the frame's title format. format must contain exactly one "%s"
   (it will be replaced by the page title).

=head2 Wx::HtmlHelpWindow::UseConfig

   void UseConfig(wxConfigBase* config, const wxString& rootpath =
   wxEmptyString)

   Associates a wxConfig object with the help window. It is recommended
   that you use wxHtmlHelpController::UseConfig instead.

=head2 Wx::HtmlHelpWindow::WriteCustomization

   void WriteCustomization(wxConfigBase* cfg, const wxString& path =
   wxEmptyString)

   Saves the user's settings for this window(see
   wxHtmlHelpController::WriteCustomization).

=head2 Wx::HtmlHelpWindow::AddToolbarButtons

   virtual void AddToolbarButtons(wxToolBar *toolBar, int style)

   You may override this virtual method to add more buttons to the help
   window's toolbar. toolBar is a pointer to the toolbar and style is the
   style flag as passed to the Create method.

   wxToolBar::Realize is called immediately after returning from this
   function.

   See samples/html/helpview for an example.

=head1 Wx::HtmlModalHelp

=head2 Wx::HtmlModalHelp::new

   wxHtmlModalHelp(wxWindow* parent, const wxString& helpFile, const
   wxString& topic = wxEmptyString, int style = wxHF_DEFAULT_STYLE |
   wxHF_DIALOG | wxHF_MODAL)

   Parameters

   parent is the parent of the dialog.

   helpFile is the HTML help file to show.

   topic is an optional topic. If this is empty, the help contents will
   be shown.

   style is a combination of the flags described in the
   wxHtmlHelpController documentation.

=head1 Wx::HtmlLinkInfo

=head2 Wx::HtmlLinkInfo::new

   wxHtmlLinkInfo()

   Default ctor.

   wxHtmlLinkInfo(const wxString& href, const wxString& target =
   wxEmptyString)

   Construct hypertext link from HREF (aka URL) and TARGET (name of
   target frame).

=head2 Wx::HtmlLinkInfo::GetEvent

   const wxMouseEvent * GetEvent()

   Return pointer to event that generated OnLinkClicked event. Valid only
   within wxHtmlWindow::OnLinkClicked, NULL otherwise.

=head2 Wx::HtmlLinkInfo::GetHtmlCell

   const wxHtmlCell * GetHtmlCell()

   Return pointer to the cell that was clicked. Valid only within
   wxHtmlWindow::OnLinkClicked, NULL otherwise.

=head2 Wx::HtmlLinkInfo::GetHref

   wxString GetHref()

   Return HREF value of the <A> tag.

=head2 Wx::HtmlLinkInfo::GetTarget

   wxString GetTarget()

   Return TARGET value of the <A> tag (this value is used to specify in
   which frame should be the page pointed by Href opened).

=head1 Wx::HtmlListBox

=head2 Wx::HtmlListBox::new

   wxHtmlListBox(wxWindow* parent, wxWindowID id = wxID_ANY, const
   wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
   long style = 0, const wxString& name = wxHtmlListBoxNameStr)

   Normal constructor which calls Create() internally.

   wxHtmlListBox()

   Default constructor, you must call Create() later.

=head2 Wx::HtmlListBox::DESTROY

   ~wxHtmlListBox()

   Destructor cleans up whatever resources we use.

=head2 Wx::HtmlListBox::Create

   bool Create(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint&
   pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long
   style = 0, const wxString& name = wxHtmlListBoxNameStr)

   Creates the control and optionally sets the initial number of items in
   it (it may also be set or changed later with SetItemCount()).

   There are no special styles defined for wxHtmlListBox, in particular
   the wxListBox styles (with the exception of wxLB_MULTIPLE) can not be
   used here.

   Returns true on success or false if the control couldn't be created

=head2 Wx::HtmlListBox::GetFileSystem

   wxFileSystem& GetFileSystem()

   const wxFileSystem& GetFileSystem() const

   Returns the wxFileSystem used by the HTML parser of this object. The
   file system object is used to resolve the paths in HTML fragments
   displayed in the control and you should use wxFileSystem::ChangePathTo
   if you use relative paths for the images or other resources embedded
   in your HTML.

=head2 Wx::HtmlListBox::GetSelectedTextBgColour

   wxColour GetSelectedTextBgColour(const wxColour& colBg) const

   This virtual function may be overridden to change the appearance of
   the background of the selected cells in the same way as
   GetSelectedTextColour.

   It should be rarely, if ever, used because SetSelectionBackground
   allows to change the selection background for all cells at once and
   doing anything more fancy is probably going to look strangely.

   See also

   GetSelectedTextColour

=head2 Wx::HtmlListBox::GetSelectedTextColour

   wxColour GetSelectedTextColour(const wxColour& colFg) const

   This virtual function may be overridden to customize the appearance of
   the selected cells. It is used to determine how the colour colFg is
   going to look inside selection. By default all original colours are
   completely ignored and the standard, system-dependent, selection
   colour is used but the program may wish to override this to achieve
   some custom appearance.

   See also

   GetSelectedTextBgColour,

=head2 Wx::HtmlListBox::OnGetItem

   wxString OnGetItem(size_t n) const

   This method must be implemented in the derived class and should return
   the body (i.e. without <html> nor <body> tags) of the HTML fragment
   for the given item.

   Note that this function should always return a text fragment for the n
   item which renders with the same height both when it is selected and
   when it's not: i.e. if you call, inside your OnGetItem()
   implementation, IsSelected(n) to make the items appear differently
   when they are selected, then you should make sure that the returned
   HTML fragment will render with the same height or else you'll see some
   artifacts when the user selects an item.

=head2 Wx::HtmlListBox::OnGetItemMarkup

   wxString OnGetItemMarkup(size_t n) const

   This function may be overridden to decorate HTML returned by
   OnGetItem().

=head2 Wx::HtmlListBox::OnLinkClicked

   virtual void OnLinkClicked(size_t n, const wxHtmlLinkInfo& link)

   Called when the user clicks on hypertext link. Does nothing by
   default. Overloading this method is deprecated; intercept the event
   instead.

   Parameters

   n   

       Index of the item containing the link.

   link

       Description of the link.

   See also

   See also wxHtmlLinkInfo.

=head1 Wx::SimpleHtmlListBox

=head2 Wx::SimpleHtmlListBox::new

   wxHtmlListBox(wxWindow* parent, wxWindowID id, const wxPoint& pos =
   wxDefaultPosition, const wxSize& size = wxDefaultSize, int n = 0,
   const wxString choices[] = NULL, long style = wxHLB_DEFAULT_STYLE,
   const wxValidator& validator = wxDefaultValidator, const wxString&
   name = "simpleHtmlListBox")

   wxHtmlListBox(wxWindow* parent, wxWindowID id, const wxPoint& pos,
   const wxSize& size, const wxArrayString& choices, long style =
   wxHLB_DEFAULT_STYLE, const wxValidator& validator = wxDefaultValidator,
   const wxString& name = "simpleHtmlListBox")

   Constructor, creating and showing the HTML list box.

   Parameters

   parent

       Parent window. Must not be NULL.

   id  

       Window identifier. A value of -1 indicates a default value.

   pos 

       Window position.

   size

       Window size. If the default size (-1, -1) is specified then the
       window is sized appropriately.

   n   

       Number of strings with which to initialise the control.

   choices

       An array of strings with which to initialise the control.

   style

       Window style. See wxHLB_* flags.

   validator

       Window validator.

   name

       Window name.

   See also

   wxSimpleHtmlListBox::Create

   wxSimpleHtmlListBox()

   Default constructor, you must call Create() later.

=head2 Wx::SimpleHtmlListBox::DESTROY

   ~wxSimpleHtmlListBox()

   Frees the array of stored items and relative client data.

=head2 Wx::SimpleHtmlListBox::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxPoint& pos =
   wxDefaultPosition, const wxSize& size = wxDefaultSize, int n, const
   wxString choices[] = NULL, long style = wxHLB_DEFAULT_STYLE, const
   wxValidator& validator = wxDefaultValidator, const wxString& name =
   "simpleHtmlListBox")

   bool Create(wxWindow* parent, wxWindowID id, const wxPoint& pos, const
   wxSize& size, const wxArrayString& choices, long style =
   wxHLB_DEFAULT_STYLE, const wxValidator& validator = wxDefaultValidator,
   const wxString& name = "simpleHtmlListBox")

   Creates the HTML listbox for two-step construction. See
   wxSimpleHtmlListBox::wxSimpleHtmlListBox for further details.

=head1 Wx::HtmlParser

=head2 Wx::HtmlParser::new

   wxHtmlParser()

   Constructor.

=head2 Wx::HtmlParser::AddTag

   void AddTag(const wxHtmlTag& tag)

   This may (and may not) be overwritten in derived class.

   This method is called each time new tag is about to be added. tag
   contains information about the tag. (See wxHtmlTag for details.)

   Default (wxHtmlParser) behaviour is this: First it finds a handler
   capable of handling this tag and then it calls handler's HandleTag
   method.

=head2 Wx::HtmlParser::AddTagHandler

   virtual void AddTagHandler(wxHtmlTagHandler *handler)

   Adds handler to the internal list (& hash table) of handlers. This
   method should not be called directly by user but rather by derived
   class' constructor.

   This adds the handler to this instance of wxHtmlParser, not to all
   objects of this class! (Static front-end to AddTagHandler is provided
   by wxHtmlWinParser).

   All handlers are deleted on object deletion.

=head2 Wx::HtmlParser::AddText

   virtual void AddWord(const char* txt)

   Must be overwritten in derived class.

   This method is called by DoParsing each time a part of text is parsed.
   txt is NOT only one word, it is substring of input. It is not
   formatted or preprocessed (so white spaces are unmodified).

=head2 Wx::HtmlParser::DoParsing

   void DoParsing(int begin_pos, int end_pos)

   void DoParsing()

   Parses the m_Source from begin_pos to end_pos-1. (in noparams version
   it parses whole m_Source)

=head2 Wx::HtmlParser::DoneParser

   virtual void DoneParser()

   This must be called after DoParsing().

=head2 Wx::HtmlParser::GetFS

   wxFileSystem* GetFS() const

   Returns pointer to the file system. Because each tag handler has
   reference to it is parent parser it can easily request the file by
   calling

   wxFSFile *f = m_Parser -> GetFS() -> OpenFile("image.jpg");

=head2 Wx::HtmlParser::GetProduct

   virtual wxObject* GetProduct()

   Returns product of parsing. Returned value is result of parsing of the
   document. The type of this result depends on internal representation
   in derived parser (but it must be derived from wxObject!).

   See wxHtmlWinParser for details.

=head2 Wx::HtmlParser::GetSource

   wxString* GetSource()

   Returns pointer to the source being parsed.

=head2 Wx::HtmlParser::InitParser

   virtual void InitParser(const wxString& source)

   Setups the parser for parsing the source string. (Should be overridden
   in derived class)

=head2 Wx::HtmlParser::OpenURL

   virtual wxFSFile* OpenURL(wxHtmlURLType type, const wxString& url)

   Opens given URL and returns wxFSFile object that can be used to read
   data from it. This method may return NULL in one of two cases: either
   the URL doesn't point to any valid resource or the URL is blocked by
   overridden implementation of OpenURL in derived class.

   Parameters

   type

       Indicates type of the resource. Is one of:

=head2 Wx::HtmlParser::Parse

   wxObject* Parse(const wxString& source)

   Proceeds parsing of the document. This is end-user method. You can
   simply call it when you need to obtain parsed output (which is
   parser-specific)

   The method does these things:

=head2 Wx::HtmlParser::PushTagHandler

   void PushTagHandler(wxHtmlTagHandler* handler, const wxString& tags)

   Forces the handler to handle additional tags (not returned by
   GetSupportedTags). The handler should already be added to this parser.

   Parameters

   handler

       the handler

=head2 Wx::HtmlParser::PopTagHandler

   void PopTagHandler()

   Restores parser's state before last call to PushTagHandler.

=head2 Wx::HtmlParser::SetFS

   void SetFS(wxFileSystem *fs)

   Sets the virtual file system that will be used to request additional
   files. (For example <IMG> tag handler requests wxFSFile with the image
   data.)

=head2 Wx::HtmlParser::StopParsing

   void StopParsing()

   Call this function to interrupt parsing from a tag handler. No more
   tags will be parsed afterward. This function may only be called from
   wxHtmlParser::Parse or any function called by it (i.e. from tag
   handlers).

=head1 Wx::HtmlPrintout

=head2 Wx::HtmlPrintout::new

   wxHtmlPrintout(const wxString& title = "Printout")

   Constructor.

=head2 Wx::HtmlPrintout::AddFilter

   static void AddFilter(wxHtmlFilter* filter)

   Adds a filter to the static list of filters for wxHtmlPrintout. See
   wxHtmlFilter for further information.

=head2 Wx::HtmlPrintout::SetFonts

   void SetFonts(const wxString& normal_face, const wxString& fixed_face,
   const int *sizes = NULL)

   Sets fonts. See wxHtmlWindow::SetFonts for detailed description.

=head2 Wx::HtmlPrintout::SetFooter

   void SetFooter(const wxString& footer, int pg = wxPAGE_ALL)

   Set page footer. The following macros can be used inside it:

=head2 Wx::HtmlPrintout::SetHeader

   void SetHeader(const wxString& header, int pg = wxPAGE_ALL)

   Set page header. The following macros can be used inside it:

=head2 Wx::HtmlPrintout::SetHtmlFile

   void SetHtmlFile(const wxString& htmlfile)

   Prepare the class for printing this HTML file. The file may be located
   on any virtual file system or it may be normal file.

=head2 Wx::HtmlPrintout::SetHtmlText

   void SetHtmlText(const wxString& html, const wxString& basepath =
   wxEmptyString, bool isdir = true)

   Prepare the class for printing this HTML text.

   Parameters

   html

       HTML text. (NOT file!)

   basepath

       base directory (html string would be stored there if it was in
       file). It is used to determine path for loading images, for
       example.

   isdir

       false if basepath is filename, true if it is directory name (see
       wxFileSystem for detailed explanation)

=head2 Wx::HtmlPrintout::SetMargins

   void SetMargins(float top = 25.2, float bottom = 25.2, float left =
   25.2, float right = 25.2, float spaces = 5)

   Sets margins in millimeters. Defaults to 1 inch for margins and 0.5cm
   for space between text and header and/or footer

=head1 Wx::HtmlTag

=head2 Wx::HtmlTag::new

   wxHtmlTag(wxHtmlTag *parent, const wxString& source, int pos, int
   end_pos, wxHtmlTagsCache* cache, wxHtmlEntitiesParser *entParser)

   Constructor. You will probably never have to construct a wxHtmlTag
   object yourself. Feel free to ignore the constructor parameters. Have
   a look at src/html/htmlpars.cpp if you're interested in creating it.

=head2 Wx::HtmlTag::GetAllParams

   const wxString& GetAllParams() const

   Returns a string containing all parameters.

   Example : tag contains <FONT SIZE=+2 COLOR="#000000">. Call to
   tag.GetAllParams() would return SIZE=+2 COLOR="#000000".

=head2 Wx::HtmlTag::GetBeginPos

   int GetBeginPos() const

   Returns beginning position of the text between this tag and paired
   ending tag. See explanation (returned position is marked with '|'):

   bla bla bla <MYTAG> bla bla internal text</MYTAG> bla bla
                      |

=head2 Wx::HtmlTag::GetEndPos1

   int GetEndPos1() const

   Returns ending position of the text between this tag and paired ending
   tag. See explanation (returned position is marked with '|'):

   bla bla bla <MYTAG> bla bla internal text</MYTAG> bla bla
                                           |

=head2 Wx::HtmlTag::GetEndPos2

   int GetEndPos2() const

   Returns ending position 2 of the text between this tag and paired
   ending tag. See explanation (returned position is marked with '|'):

   bla bla bla <MYTAG> bla bla internal text</MYTAG> bla bla
                                                  |

=head2 Wx::HtmlTag::GetName

   wxString GetName() const

   Returns tag's name. The name is always in uppercase and it doesn't
   contain '<' or '/' characters. (So the name of <FONT SIZE=+2> tag is
   "FONT" and name of </table> is "TABLE")

=head2 Wx::HtmlTag::GetParam

   wxString GetParam(const wxString& par, bool with_commas = false) const

   Returns the value of the parameter. You should check whether the
   parameter exists or not (use HasParam) first.

   Parameters

   par 

       The parameter's name.

   with_commas

       true if you want to get commas as well. See example.

   Example

   ...
   /* you have wxHtmlTag variable tag which is equal to
      HTML tag <FONT SIZE=+2 COLOR="#0000FF"> */
   dummy = tag.GetParam("SIZE");
      // dummy == "+2"
   dummy = tag.GetParam("COLOR");
      // dummy == "#0000FF"
   dummy = tag.GetParam("COLOR", true);
      // dummy == "\"#0000FF\"" -- see the difference!!

=head2 Wx::HtmlTag::GetParamAsColour

   bool GetParamAsColour(const wxString& par, wxColour *clr) const

   Interprets tag parameter par as colour specification and saves its
   value into wxColour variable pointed by clr.

   Returns true on success and false if par is not colour specification
   or if the tag has no such parameter.

=head2 Wx::HtmlTag::GetParamAsInt

   bool GetParamAsInt(const wxString& par, int *value) const

   Interprets tag parameter par as an integer and saves its value into
   int variable pointed by value.

   Returns true on success and false if par is not an integer or if the
   tag has no such parameter.

=head2 Wx::HtmlTag::HasEnding

   bool HasEnding() const

   Returns true if this tag is paired with ending tag, false otherwise.

   See the example of HTML document:

   <html><body>
   Hello<p>
   How are you?
   <p align=center>This is centered...</p>
   Oops<br>Oooops!
   </body></html>

   In this example tags HTML and BODY have ending tags, first P and BR
   doesn't have ending tag while the second P has. The third P tag (which
   is ending itself) of course doesn't have ending tag.

=head2 Wx::HtmlTag::HasParam

   bool HasParam(const wxString& par) const

   Returns true if the tag has a parameter of the given name. Example :
   <FONT SIZE=+2 COLOR="#FF00FF"> has two parameters named "SIZE" and
   "COLOR".

   Parameters

   par 

       the parameter you're looking for.

=head2 Wx::HtmlTag::ScanParam

   wxString ScanParam(const wxString& par, const wxChar *format, void *value)
   const

   This method scans the given parameter. Usage is exactly the same as
   sscanf's usage except that you don't pass a string but a parameter
   name as the first argument and you can only retrieve one value (i.e.
   you can use only one "%" element in format).

=head1 Wx::HtmlTagHandler

=head2 Wx::HtmlTagHandler::m_Parser

   wxHtmlParser* m_Parser

   This attribute is used to access parent parser. It is protected so
   that it can't be accessed by user but can be accessed from derived
   classes.

=head2 Wx::HtmlTagHandler::new

   wxHtmlTagHandler()

   Constructor.

=head2 Wx::HtmlTagHandler::GetSupportedTags

   virtual wxString GetSupportedTags()

   Returns list of supported tags. The list is in uppercase and tags are
   delimited by ','. Example : "I,B,FONT,P"

=head2 Wx::HtmlTagHandler::HandleTag

   virtual bool HandleTag(const wxHtmlTag& tag)

   This is the core method of each handler. It is called each time one of
   supported tags is detected. tag contains all necessary info (see
   wxHtmlTag for details).

   Return value

   true if ParseInner was called, false otherwise.

   Example

   bool MyHandler::HandleTag(const wxHtmlTag& tag)
   {
       ...
       // change state of parser (e.g. set bold face)
       ParseInner(tag);
       ...
       // restore original state of parser
   }

   You shouldn't call ParseInner if the tag is not paired with an ending
   one.

=head2 Wx::HtmlTagHandler::ParseInner

   void ParseInner(const wxHtmlTag& tag)

   This method calls parser's DoParsing method for the string between
   this tag and the paired ending tag:

   ...<A HREF="x.htm">Hello, world!</A>...

   In this example, a call to ParseInner (with tag pointing to A tag)
   will parse 'Hello, world!'.

=head2 Wx::HtmlTagHandler::SetParser

   virtual void SetParser(wxHtmlParser *parser)

   Assigns parser to this handler. Each instance of handler is guaranteed
   to be called only from the parser.

=head1 Wx::HtmlTagsModule

=head2 Wx::HtmlTagsModule::FillHandlersTable

   virtual void FillHandlersTable(wxHtmlWinParser *parser)

   You must override this method. In most common case its body consists
   only of lines of the following type:

   parser -> AddTagHandler(new MyHandler);

   I recommend using the TAGS_MODULE_* macros.

   Paremeters

   parser

       Pointer to the parser that requested tables filling.

=head1 Wx::HtmlWidgetCell

=head2 Wx::HtmlWidgetCell::new

   wxHtmlWidgetCell(wxWindow* wnd, int w = 0)

   Constructor.

   Parameters

   wnd 

       Connected window. It is parent window must be the wxHtmlWindow
       object within which it is displayed!

   w   

       Floating width. If non-zero width of wnd window is adjusted so
       that it is always w percents of parent container's width. (For
       example w = 100 means that the window will always have same width
       as parent container)

=head1 Wx::HtmlWindow

=head2 Wx::HtmlWindow::new

   wxHtmlWindow()

   Default constructor.

   wxHtmlWindow(wxWindow *parent, wxWindowID id = -1, const wxPoint& pos
   = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style =
   wxHW_DEFAULT_STYLE, const wxString& name = "htmlWindow")

   Constructor. The parameters are the same as for the wxScrolledWindow
   constructor.

   Parameters

   style

       Window style. See wxHtmlWindow.

=head2 Wx::HtmlWindow::AddFilter

   static void AddFilter(wxHtmlFilter *filter)

   Adds input filter to the static list of available filters. These
   filters are present by default:

=head2 Wx::HtmlWindow::AppendToPage

   bool AppendToPage(const wxString& source)

   Appends HTML fragment to currently displayed text and refreshes the
   window.

   Parameters

   source

       HTML code fragment

   Return value

   false if an error occurred, true otherwise.

=head2 Wx::HtmlWindow::GetInternalRepresentation

   wxHtmlContainerCell* GetInternalRepresentation() const

   Returns pointer to the top-level container.

   See also: Cells Overview, Printing Overview

=head2 Wx::HtmlWindow::GetOpenedAnchor

   wxString GetOpenedAnchor()

   Returns anchor within currently opened page (see GetOpenedPage). If no
   page is opened or if the displayed page wasn't produced by call to
   LoadPage, empty string is returned.

=head2 Wx::HtmlWindow::GetOpenedPage

   wxString GetOpenedPage()

   Returns full location of the opened page. If no page is opened or if
   the displayed page wasn't produced by call to LoadPage, empty string
   is returned.

=head2 Wx::HtmlWindow::GetOpenedPageTitle

   wxString GetOpenedPageTitle()

   Returns title of the opened page or wxEmptyString if current page does
   not contain <TITLE> tag.

=head2 Wx::HtmlWindow::GetRelatedFrame

   wxFrame* GetRelatedFrame() const

   Returns the related frame.

=head2 Wx::HtmlWindow::HistoryBack

   bool HistoryBack()

   Moves back to the previous page. (each page displayed using LoadPage
   is stored in history list.)

=head2 Wx::HtmlWindow::HistoryCanBack

   bool HistoryCanBack()

   Returns true if it is possible to go back in the history (i.e.
   HistoryBack() won't fail).

=head2 Wx::HtmlWindow::HistoryCanForward

   bool HistoryCanForward()

   Returns true if it is possible to go forward in the history (i.e.
   HistoryBack() won't fail).

=head2 Wx::HtmlWindow::HistoryClear

   void HistoryClear()

   Clears history.

=head2 Wx::HtmlWindow::HistoryForward

   bool HistoryForward()

   Moves to next page in history.

=head2 Wx::HtmlWindow::LoadFile

   virtual bool LoadFile(const wxFileName& filename)

   Loads HTML page from file and displays it.

   Return value

   false if an error occurred, true otherwise

   See also

   LoadPage

=head2 Wx::HtmlWindow::LoadPage

   virtual bool LoadPage(const wxString& location)

   Unlike SetPage this function first loads HTML page from location and
   then displays it. See example:

   htmlwin->LoadPage("help/myproject/index.htm");

   Parameters

   location

       The address of document. See wxFileSystem for details on address
       format and behaviour of "opener".

   Return value

   false if an error occurred, true otherwise

   See also

   LoadFile

=head2 Wx::HtmlWindow::OnCellClicked

   virtual bool OnCellClicked(wxHtmlCell *cell, wxCoord x, wxCoord y,
   const wxMouseEvent& event)

   This method is called when a mouse button is clicked inside
   wxHtmlWindow.

   The default behaviour is to emit a wxHtmlCellEvent and, if the event
   was not processed or skipped, call OnLinkClicked if the cell contains
   an hypertext link.

   Overloading this method is deprecated; intercept the event instead.

=head2 Wx::HtmlWindow::OnCellMouseHover

   virtual void OnCellMouseHover(wxHtmlCell *cell, wxCoord x, wxCoord y)

   This method is called when a mouse moves over an HTML cell. Default
   behaviour is to emit a wxHtmlCellEvent. Overloading this method is
   deprecated; intercept the event instead.

   Parameters

   cell

       The cell inside which the mouse is currently, always a simple
       (i.e. non-container) cell

   x, y

       The logical coordinates of the click point

=head2 Wx::HtmlWindow::OnLinkClicked

   virtual void OnLinkClicked(const wxHtmlLinkInfo& link)

   Called when user clicks on hypertext link. Default behaviour is to
   emit a wxHtmlLinkEvent and, if the event was not processed or skipped,
   call LoadPage and do nothing else. Overloading this method is
   deprecated; intercept the event instead.

   Also see wxHtmlLinkInfo.

=head2 Wx::HtmlWindow::OnOpeningURL

   virtual wxHtmlOpeningStatus OnOpeningURL(wxHtmlURLType type,const
   wxString& url, wxString *redirect)

   Called when an URL is being opened (either when the user clicks on a
   link or an image is loaded). The URL will be opened only if
   OnOpeningURL returns wxHTML_OPEN. This method is called by
   wxHtmlParser::OpenURL. You can override OnOpeningURL to selectively
   block some URLs (e.g. for security reasons) or to redirect them
   elsewhere. Default behaviour is to always return wxHTML_OPEN.

   Parameters

   type

       Indicates type of the resource. Is one of

=head2 Wx::HtmlWindow::OnSetTitle

   virtual void OnSetTitle(const wxString& title)

   Called on parsing <TITLE> tag.

=head2 Wx::HtmlWindow::ReadCustomization

   virtual void ReadCustomization(wxConfigBase *cfg, wxString path =
   wxEmptyString)

   This reads custom settings from wxConfig. It uses the path 'path' if
   given, otherwise it saves info into currently selected path. The
   values are stored in sub-path wxHtmlWindow

   Read values: all things set by SetFonts, SetBorders.

   Parameters

   cfg 

       wxConfig from which you want to read the configuration.

   path

       Optional path in config tree. If not given current path is used.

=head2 Wx::HtmlWindow::SelectAll

   void SelectAll()

   Selects all text in the window.

   See also

   SelectLine, SelectWord

=head2 Wx::HtmlWindow::SelectionToText

   wxString SelectionToText()

   Returns current selection as plain text. Returns empty string if no
   text is currently selected.

=head2 Wx::HtmlWindow::SelectLine

   void SelectLine(const wxPoint& pos)

   Selects the line of text that pos points at. Note that pos is relative
   to the top of displayed page, not to window's origin, use
   CalcUnscrolledPosition to convert physical coordinate.

   See also

   SelectAll, SelectWord

=head2 Wx::HtmlWindow::SelectWord

   void SelectWord(const wxPoint& pos)

   Selects the word at position pos. Note that pos is relative to the top
   of displayed page, not to window's origin, use CalcUnscrolledPosition
   to convert physical coordinate.

   See also

   SelectAll, SelectLine

=head2 Wx::HtmlWindow::SetBorders

   void SetBorders(int b)

   This function sets the space between border of window and HTML
   contents. See image:

   [IMAGE]

   Parameters

   b   

       indentation from borders in pixels

=head2 Wx::HtmlWindow::SetFonts

   void SetFonts(const wxString& normal_face, const wxString& fixed_face,
   const int *sizes = NULL)

   This function sets font sizes and faces.

   Parameters

   normal_face

       This is face name for normal (i.e. non-fixed) font. It can be
       either empty string (then the default face is chosen) or
       platform-specific face name. Examples are "helvetica" under Unix
       or "Times New Roman" under Windows.

   fixed_face

       The same thing for fixed face ( <TT>..</TT> )

   sizes

       This is an array of 7 items of int type. The values represent size
       of font with HTML size from -2 to +4 ( <FONT SIZE=-2> to <FONT
       SIZE=+4> ). Default sizes are used if sizes is NULL.

   Defaults

   Default font sizes are defined by constants wxHTML_FONT_SIZE_1,
   wxHTML_FONT_SIZE_2, ..., wxHTML_FONT_SIZE_7. Note that they differ
   among platforms. Default face names are empty strings.

=head2 Wx::HtmlWindow::SetPage

   bool SetPage(const wxString& source)

   Sets HTML page and display it. This won't load the page!! It will
   display the source. See example:

   htmlwin -> SetPage("<html><body>Hello, world!</body></html>");

   If you want to load a document from some location use LoadPage
   instead.

   Parameters

   source

       The HTML document source to be displayed.

   Return value

   false if an error occurred, true otherwise.

=head2 Wx::HtmlWindow::SetRelatedFrame

   void SetRelatedFrame(wxFrame* frame, const wxString& format)

   Sets the frame in which page title will be displayed. format is format
   of frame title, e.g. "HtmlHelp : %s". It must contain exactly one %s.
   This %s is substituted with HTML page title.

=head2 Wx::HtmlWindow::SetRelatedStatusBar

   void SetRelatedStatusBar(int bar)

   After calling SetRelatedFrame, this sets statusbar slot where messages
   will be displayed. (Default is -1 = no messages.)

   Parameters

   bar 

       statusbar slot number (0..n)

=head2 Wx::HtmlWindow::ToText

   wxString ToText()

   Returns content of currently displayed page as plain text.

=head2 Wx::HtmlWindow::WriteCustomization

   virtual void WriteCustomization(wxConfigBase *cfg, wxString path =
   wxEmptyString)

   Saves custom settings into wxConfig. It uses the path 'path' if given,
   otherwise it saves info into currently selected path. Regardless of
   whether the path is given or not, the function creates sub-path
   wxHtmlWindow.

   Saved values: all things set by SetFonts, SetBorders.

   Parameters

   cfg 

       wxConfig to which you want to save the configuration.

   path

       Optional path in config tree. If not given, the current path is
       used.

=head1 Wx::HtmlLinkEvent

=head2 Wx::HtmlLinkEvent::new

   wxHyperlinkEvent(int id, const wxHtmlLinkInfo & linkinfo)

   The constructor is not normally used by the user code.

=head2 Wx::HtmlLinkEvent::GetLinkInfo

   const wxHtmlLinkInfo GetLinkInfo() const

   Returns the wxHtmlLinkInfo which contains info about the cell clicked
   and the hyperlink it contains.

=head1 Wx::HtmlCellEvent

=head2 Wx::HtmlCellEvent::new

   wxHtmlCellEvent(wxEventType commandType, int id, wxHtmlCell * cell,
   const wxPoint & point)

   The constructor is not normally used by the user code.

=head2 Wx::HtmlCellEvent::GetCell

   wxHtmlCell * GetCell() const

   Returns the wxHtmlCellEvent associated with the event.

=head2 Wx::HtmlCellEvent::GetPoint

   wxPoint GetPoint() const

   Returns the wxPoint associated with the event.

=head2 Wx::HtmlCellEvent::SetLinkClicked

   bool SetLinkClicked(bool linkclicked)

   Call this function with linkclicked set to true if the cell which has
   been clicked contained a link or false otherwise (which is the
   default). With this function the event handler can return info to the
   wxHtmlWindow which sent the event.

=head2 Wx::HtmlCellEvent::GetLinkClicked

   bool GetLinkClicked() const

   Returns true if SetLinkClicked(true) has previously been called; false
   otherwise.

=head1 Wx::HtmlWinParser

=head2 Wx::HtmlWinParser::new

   wxHtmlWinParser()

   wxHtmlWinParser(wxHtmlWindowInterface *wndIface)

   Constructor. Don't use the default one, use constructor with wndIface
   parameter (wndIface is a pointer to interface object for the
   associated wxHtmlWindow or other HTML rendering window such as
   wxHtmlListBox).

=head2 Wx::HtmlWinParser::AddModule

   static void AddModule(wxHtmlTagsModule *module)

   Adds module to the list of wxHtmlWinParser tag handler.

=head2 Wx::HtmlWinParser::CloseContainer

   wxHtmlContainerCell* CloseContainer()

   Closes the container, sets actual container to the parent one and
   returns pointer to it (see Overview).

=head2 Wx::HtmlWinParser::CreateCurrentFont

   virtual wxFont* CreateCurrentFont()

   Creates font based on current setting (see SetFontSize, SetFontBold,
   SetFontItalic, SetFontFixed, SetFontUnderlined) and returns pointer to
   it. If the font was already created only a pointer is returned.

=head2 Wx::HtmlWinParser::GetActualColor

   const wxColour& GetActualColor() const

   Returns actual text colour.

=head2 Wx::HtmlWinParser::GetAlign

   int GetAlign() const

   Returns default horizontal alignment.

=head2 Wx::HtmlWinParser::GetCharHeight

   int GetCharHeight() const

   Returns (average) char height in standard font. It is used as
   DC-independent metrics.

   Note: This function doesn't return the actual height. If you want to
   know the height of the current font, call GetDC -> GetCharHeight().

=head2 Wx::HtmlWinParser::GetCharWidth

   int GetCharWidth() const

   Returns average char width in standard font. It is used as
   DC-independent metrics.

   Note: This function doesn't return the actual width. If you want to
   know the height of the current font, call GetDC -> GetCharWidth()

=head2 Wx::HtmlWinParser::GetContainer

   wxHtmlContainerCell* GetContainer() const

   Returns pointer to the currently opened container (see Overview).
   Common use:

   m_WParser -> GetContainer() -> InsertCell(new ...);

=head2 Wx::HtmlWinParser::GetDC

   wxDC* GetDC()

   Returns pointer to the DC used during parsing.

=head2 Wx::HtmlWinParser::GetEncodingConverter

   wxEncodingConverter * GetEncodingConverter() const

   Returns wxEncodingConverter class used to do conversion between input
   encoding and output encoding.

=head2 Wx::HtmlWinParser::GetFontBold

   int GetFontBold() const

   Returns true if actual font is bold, false otherwise.

=head2 Wx::HtmlWinParser::GetFontFace

   wxString GetFontFace() const

   Returns actual font face name.

=head2 Wx::HtmlWinParser::GetFontFixed

   int GetFontFixed() const

   Returns true if actual font is fixed face, false otherwise.

=head2 Wx::HtmlWinParser::GetFontItalic

   int GetFontItalic() const

   Returns true if actual font is italic, false otherwise.

=head2 Wx::HtmlWinParser::GetFontSize

   int GetFontSize() const

   Returns actual font size (HTML size varies from -2 to +4)

=head2 Wx::HtmlWinParser::GetFontUnderlined

   int GetFontUnderlined() const

   Returns true if actual font is underlined, false otherwise.

=head2 Wx::HtmlWinParser::GetInputEncoding

   wxFontEncoding GetInputEncoding() const

   Returns input encoding.

=head2 Wx::HtmlWinParser::GetLink

   const wxHtmlLinkInfo& GetLink() const

   Returns actual hypertext link. (This value has a non-empty Href string
   if the parser is between <A> and </A> tags, wxEmptyString otherwise.)

=head2 Wx::HtmlWinParser::GetLinkColor

   const wxColour& GetLinkColor() const

   Returns the colour of hypertext link text.

=head2 Wx::HtmlWinParser::GetOutputEncoding

   wxFontEncoding GetOutputEncoding() const

   Returns output encoding, i.e. closest match to document's input
   encoding that is supported by operating system.

=head2 Wx::HtmlWinParser::GetWindow

   wxHtmlWindow* GetWindow()

   Returns associated window (wxHtmlWindow). This may be NULL! (You
   should always test if it is non-NULL. For example TITLE handler sets
   window title only if some window is associated, otherwise it does
   nothing)

=head2 Wx::HtmlWinParser::OpenContainer

   wxHtmlContainerCell* OpenContainer()

   Opens new container and returns pointer to it (see Overview).

=head2 Wx::HtmlWinParser::SetActualColor

   void SetActualColor(const wxColour& clr)

   Sets actual text colour. Note: this DOESN'T change the colour! You
   must create wxHtmlColourCell yourself.

=head2 Wx::HtmlWinParser::SetAlign

   void SetAlign(int a)

   Sets default horizontal alignment (see
   wxHtmlContainerCell::SetAlignHor.) Alignment of newly opened container
   is set to this value.

=head2 Wx::HtmlWinParser::SetContainer

   wxHtmlContainerCell* SetContainer(wxHtmlContainerCell *c)

   Allows you to directly set opened container. This is not recommended -
   you should use OpenContainer wherever possible.

=head2 Wx::HtmlWinParser::SetDC

   virtual void SetDC(wxDC *dc, double pixel_scale = 1.0)

   Sets the DC. This must be called before Parse! pixel_scale can be used
   when rendering to high-resolution DCs (e.g. printer) to adjust size of
   pixel metrics. (Many dimensions in HTML are given in pixels -- e.g.
   image sizes. 300x300 image would be only one inch wide on typical
   printer. With pixel_scale = 3.0 it would be 3 inches.)

=head2 Wx::HtmlWinParser::SetFontBold

   void SetFontBold(int x)

   Sets bold flag of actualfont. x is either true of false.

=head2 Wx::HtmlWinParser::SetFontFace

   void SetFontFace(const wxString& face)

   Sets current font face to face. This affects either fixed size font or
   proportional, depending on context (whether the parser is inside <TT>
   tag or not).

=head2 Wx::HtmlWinParser::SetFontFixed

   void SetFontFixed(int x)

   Sets fixed face flag of actualfont. x is either true of false.

=head2 Wx::HtmlWinParser::SetFontItalic

   void SetFontItalic(int x)

   Sets italic flag of actualfont. x is either true of false.

=head2 Wx::HtmlWinParser::SetFontSize

   void SetFontSize(int s)

   Sets actual font size (HTML size varies from 1 to 7)

=head2 Wx::HtmlWinParser::SetFontUnderlined

   void SetFontUnderlined(int x)

   Sets underlined flag of actualfont. x is either true of false.

=head2 Wx::HtmlWinParser::SetFonts

   void SetFonts(const wxString& normal_face, const wxString& fixed_face,
   const int *sizes = NULL)

   Sets fonts. See wxHtmlWindow::SetFonts for detailed description.

=head2 Wx::HtmlWinParser::SetInputEncoding

   void SetInputEncoding(wxFontEncoding enc)

   Sets input encoding. The parser uses this information to build
   conversion tables from document's encoding to some encoding supported
   by operating system.

=head2 Wx::HtmlWinParser::SetLink

   void SetLink(const wxHtmlLinkInfo& link)

   Sets actual hypertext link. Empty link is represented by
   wxHtmlLinkInfo with Href equal to wxEmptyString.

=head2 Wx::HtmlWinParser::SetLinkColor

   void SetLinkColor(const wxColour& clr)

   Sets colour of hypertext link.

=head1 Wx::HtmlWinTagHandler

=head2 Wx::HtmlWinTagHandler::m_WParser

   wxHtmlWinParser* m_WParser

   Value of this attribute is identical to value of m_Parser. The only
   different is that m_WParser points to wxHtmlWinParser object while
   m_Parser points to wxHtmlParser object. (The same object, but
   overcast.)

=head1 Wx::HTTP

=head2 Wx::HTTP::GetResponse

   int GetResponse() const

   Returns the HTTP response code returned by the server. Please refer to
   RFC 2616 for the list of responses.

=head2 Wx::HTTP::GetInputStream

   wxInputStream * GetInputStream(const wxString& path)

   Creates a new input stream on the specified path. Notice that this
   stream is unseekable, i.e. SeekI() and TellI() methods shouldn't be
   used.

   Note that you can still know the size of the file you are getting
   using wxStreamBase::GetSize(). However there is a limitation: in HTTP
   protocol, the size is not always specified so sometimes (size_t)-1 can
   returned ot indicate that the size is unknown. In such case, you may
   want to use wxInputStream::LastRead() method in a loop to get the
   total size.

   Return value

   Returns the initialized stream. You must delete it yourself once you
   don't use it anymore and this must be done before the wxHTTP object
   itself is destroyed. The destructor closes the network connection. The
   next time you will try to get a file the network connection will have
   to be reestablished, but you don't have to take care of this since
   wxHTTP reestablishes it automatically.

   See also

   wxInputStream

=head2 Wx::HTTP::SetHeader

   void SetHeader(const wxString& header, const wxString& h_data)

   It sets data of a field to be sent during the next request to the HTTP
   server. The field name is specified by header and the content by
   h_data. This is a low level function and it assumes that you know what
   you are doing.

=head2 Wx::HTTP::GetHeader

   wxString GetHeader(const wxString& header)

   Returns the data attached with a field whose name is specified by
   header. If the field doesn't exist, it will return an empty string and
   not a NULL string.

   Note

   The header is not case-sensitive, i.e. "CONTENT-TYPE" and
   "content-type" represent the same header.

=head1 Wx::HyperlinkCtrl

=head2 Wx::HyperlinkCtrl::wxHyperLink

   wxHyperLink(wxWindow* parent, wxWindowID id, const wxString & label,
   const wxString & url, const wxPoint& pos = wxDefaultPosition, const
   wxSize& size = wxDefaultSize, long style, const wxString& name =
   "hyperlink")

   Constructor. See Create for more info.

=head2 Wx::HyperlinkCtrl::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxString & label,
   const wxString & url, const wxPoint& pos = wxDefaultPosition, const
   wxSize& size = wxDefaultSize, long style, const wxString& name =
   "hyperlink")

   Creates the hyperlink control.

   Parameters

   parent

       Parent window. Must not be NULL.

   id  

       Window identifier. A value of wxID_ANY indicates a default value.

   label

       The label of the hyperlink.

   url 

       The URL associated with the given label.

   pos 

       Window position.

   size

       Window size. If the wxDefaultSize is specified then the window is
       sized appropriately.

   style

       Window style. See wxHyperlinkCtrl.

   validator

       Window validator.

   name

       Window name.

=head2 Wx::HyperlinkCtrl::GetHoverColour

   wxColour GetHoverColour() const

   Returns the colour used to print the label of the hyperlink when the
   mouse is over the control.

=head2 Wx::HyperlinkCtrl::SetHoverColour

   void SetHoverColour(const wxColour & colour)

   Sets the colour used to print the label of the hyperlink when the
   mouse is over the control.

=head2 Wx::HyperlinkCtrl::GetNormalColour

   wxColour GetNormalColour() const

   Returns the colour used to print the label when the link has never
   been clicked before (i.e. the link has not been visited) and the mouse
   is not over the control.

=head2 Wx::HyperlinkCtrl::SetNormalColour

   void SetNormalColour(const wxColour & colour)

   Sets the colour used to print the label when the link has never been
   clicked before (i.e. the link has not been visited) and the mouse is
   not over the control.

=head2 Wx::HyperlinkCtrl::GetVisitedColour

   wxColour GetVisitedColour() const

   Returns the colour used to print the label when the mouse is not over
   the control and the link has already been clicked before (i.e. the
   link has been visited).

=head2 Wx::HyperlinkCtrl::SetVisitedColour

   void SetVisitedColour(const wxColour & colour)

   Sets the colour used to print the label when the mouse is not over the
   control and the link has already been clicked before (i.e. the link
   has been visited).

=head2 Wx::HyperlinkCtrl::GetVisited

   bool GetVisited() const

   Returns true if the hyperlink has already been clicked by the user at
   least one time.

=head2 Wx::HyperlinkCtrl::SetVisited

   void SetVisited(bool visited = true)

   Marks the hyperlink as visited (see SetVisitedColour).

=head2 Wx::HyperlinkCtrl::GetURL

   wxString GetURL() const

   Returns the URL associated with the hyperlink.

=head2 Wx::HyperlinkCtrl::SetURL

   void SetURL(const wxString & url)

   Sets the URL associated with the hyperlink.

=head1 Wx::HyperlinkEvent

=head2 Wx::HyperlinkEvent::new

   wxHyperlinkEvent(wxObject * generator, int id, const wxString & url)

   The constructor is not normally used by the user code.

=head2 Wx::HyperlinkEvent::GetURL

   wxString GetURL() const

   Returns the URL of the hyperlink where the user has just clicked.

=head2 Wx::HyperlinkEvent::SetURL

   void SetURL(const wxString & url)

   Sets the URL associated with the event.

=head1 Wx::Icon

=head2 Wx::Icon::new

   wxIcon()

   Default constructor.

   wxIcon(const wxIcon& icon)

   Copy constructor.

   wxIcon(void* data, int type, int width, int height, int depth = -1)

   Creates an icon from the given data, which can be of arbitrary type.

   wxIcon(const char bits[], int width, int height

=head2 Wx::Icon::CopyFromBitmap

   void CopyFromBitmap(const wxBitmap& bmp)

   Copies bmp bitmap to this icon. Under MS Windows the bitmap must have
   mask colour set.

=head2 Wx::Icon::DESTROY

   ~wxIcon()

   Destructor. See reference-counted object destruction for more info.

   If the application omits to delete the icon explicitly, the icon will
   be destroyed automatically by wxWidgets when the application exits.

   Do not delete an icon that is selected into a memory device context.

=head2 Wx::Icon::GetDepth

   int GetDepth() const

   Gets the colour depth of the icon. A value of 1 indicates a monochrome
   icon.

=head2 Wx::Icon::GetHeight

   int GetHeight() const

   Gets the height of the icon in pixels.

=head2 Wx::Icon::GetWidth

   int GetWidth() const

   Gets the width of the icon in pixels.

   See also

   wxIcon::GetHeight

=head2 Wx::Icon::LoadFile

   bool LoadFile(const wxString& name, wxBitmapType type)

   Loads an icon from a file or resource.

   Parameters

   name

       Either a filename or a Windows resource name. The meaning of name
       is determined by the type parameter.

   type

       One of the following values:

=head2 Wx::Icon::IsOk

   bool IsOk() const

   Returns true if icon data is present.

=head2 Wx::Icon::SetDepth

   void SetDepth(int depth)

   Sets the depth member (does not affect the icon data).

   Parameters

   depth

       Icon depth.

=head2 Wx::Icon::SetHeight

   void SetHeight(int height)

   Sets the height member (does not affect the icon data).

   Parameters

   height

       Icon height in pixels.

=head2 Wx::Icon::SetWidth

   void SetWidth(int width)

   Sets the width member (does not affect the icon data).

   Parameters

   width

       Icon width in pixels.

=head1 Wx::IconBundle

=head2 Wx::IconBundle::new

   wxIconBundle()

   Default constructor.

   wxIconBundle(const wxString& file, long type)

   Initializes the bundle with the icon(s) found in the file.

   wxIconBundle(const wxIcon& icon)

   Initializes the bundle with a single icon.

   wxIconBundle(const wxIconBundle& ic)

   Copy constructor.

=head2 Wx::IconBundle::DESTROY

   ~wxIconBundle()

   Destructor.

=head2 Wx::IconBundle::AddIcon

   void AddIcon(const wxString& file, long type)

   Adds all the icons contained in the file to the bundle; if the
   collection already contains icons with the same width and height, they
   are replaced by the new ones.

   void AddIcon(const wxIcon& icon)

   Adds the icon to the collection; if the collection already contains an
   icon with the same width and height, it is replaced by the new one.

=head2 Wx::IconBundle::GetIcon

   const wxIcon& GetIcon(const wxSize& size) const

   Returns the icon with the given size; if no such icon exists, returns
   the icon with size wxSYS_ICON_X/wxSYS_ICON_Y; if no such icon exists,
   returns the first icon in the bundle. If size = wxSize( -1, -1 ),
   returns the icon with size wxSYS_ICON_X/wxSYS_ICON_Y.

   const wxIcon& GetIcon(wxCoord size = -1) const

   Same as GetIcon( wxSize( size, size ) ).

=head1 Wx::IconLocation

=head2 Wx::IconLocation::IsOk

   bool IsOk() const

   Returns true if the object is valid, i.e. was properly initialized,
   and false otherwise.

=head1 Wx::IconizeEvent

=head2 Wx::IconizeEvent::new

   wxIconizeEvent(int id = 0, bool iconized = true)

   Constructor.

=head2 Wx::IconizeEvent::Iconized

   bool Iconized() const

   Returns true if the frame has been iconized, false if it has been
   restored.

=head1 Wx::IdleEvent

=head2 Wx::IdleEvent::new

   wxIdleEvent()

   Constructor.

=head2 Wx::IdleEvent::CanSend

   static bool CanSend(wxWindow* window)

   Returns true if it is appropriate to send idle events to this window.

   This function looks at the mode used (see wxIdleEvent::SetMode), and
   the wxWS_EX_PROCESS_IDLE style in window to determine whether idle
   events should be sent to this window now. By default this will always
   return true because the update mode is initially wxIDLE_PROCESS_ALL.
   You can change the mode to only send idle events to windows with the
   wxWS_EX_PROCESS_IDLE extra window style set.

   See also

   wxIdleEvent::SetMode

=head2 Wx::IdleEvent::GetMode

   static wxIdleMode GetMode()

   Static function returning a value specifying how wxWidgets will send
   idle events: to all windows, or only to those which specify that they
   will process the events.

   See wxIdleEvent::SetMode.

=head2 Wx::IdleEvent::RequestMore

   void RequestMore(bool needMore = true)

   Tells wxWidgets that more processing is required. This function can be
   called by an OnIdle handler for a window or window event handler to
   indicate that wxApp::OnIdle should forward the OnIdle event once more
   to the application windows. If no window calls this function during
   OnIdle, then the application will remain in a passive event loop (not
   calling OnIdle) until a new event is posted to the application by the
   windowing system.

   See also

   wxIdleEvent::MoreRequested

=head2 Wx::IdleEvent::MoreRequested

   bool MoreRequested() const

   Returns true if the OnIdle function processing this event requested
   more processing time.

   See also

   wxIdleEvent::RequestMore

=head2 Wx::IdleEvent::SetMode

   static void SetMode(wxIdleMode mode)

   Static function for specifying how wxWidgets will send idle events: to
   all windows, or only to those which specify that they will process the
   events.

   mode can be one of the following values. The default is
   wxIDLE_PROCESS_ALL.

   enum wxIdleMode
   {
           // Send idle events to all windows
       wxIDLE_PROCESS_ALL,

=head1 Wx::Image

=head2 Wx::Image::new

   wxImage()

   Default constructor.

   wxImage(const wxImage& image)

   Copy constructor, uses reference counting.

   wxImage(const wxBitmap& bitmap)

   (Deprecated form, use wxBitmap::ConvertToImage instead.) Constructs an
   image from a platform-dependent bitmap. This preserves mask
   information so that bitmaps and images can be converted back and forth
   without loss in that respect.

   wxImage(int width, int height, bool clear=true)

   Creates an image with the given width and height. If clear is true,
   the new image will be initialized to black. Otherwise, the image data
   will be uninitialized.

   wxImage(int width, int height, unsigned char* data, bool static_data =
   false)

   Creates an image from given data with the given width and height. If
   static_data is true, then wxImage will not delete the actual image
   data in its destructor, otherwise it will free it by calling free().

   wxImage(const wxString& name, long type = wxBITMAP_TYPE_ANY, int index
   = -1)

   wxImage(const wxString& name, const wxString& mimetype, int index = -1)

   Loads an image from a file.

   wxImage(wxInputStream& stream, long type = wxBITMAP_TYPE_ANY, int
   index = -1)

   wxImage(wxInputStream& stream, const wxString& mimetype, int index =
   -1)

   Loads an image from an input stream.

   wxImage(const char* const* xpmData)

   Creates an image from XPM data.

   Parameters

   width

       Specifies the width of the image.

   height

       Specifies the height of the image.

   name

       Name of the file from which to load the image.

   stream

       Opened input stream from which to load the image. Currently, the
       stream must support seeking.

   type

       May be one of the following:

=head2 Wx::Image::DESTROY

   ~wxImage()

   Destructor. See reference-counted object destruction for more info.

=head2 Wx::Image::AddHandler

   static void AddHandler(wxImageHandler* handler)

   Adds a handler to the end of the static list of format handlers.

   handler

       A new image format handler object. There is usually only one
       instance of a given handler class in an application session.

   See also

   wxImageHandler

   bool CanRead(const wxString& filename)

   returns true if the current image handlers can read this file

   wxPython note: In wxPython this static method is named
   wxImage_AddHandler.

=head2 Wx::Image::Blur

   wxImage Blur(int blurRadius)

   Blurs the image in both horizontal and vertical directions by the
   specified pixel blurRadius. This should not be used when using a
   single mask colour for transparency.

   See also

   BlurHorizontal BlurVertical

=head2 Wx::Image::BlurHorizontal

   wxImage BlurHorizontal(int blurRadius)

   Blurs the image in the horizontal direction only. This should not be
   used when using a single mask colour for transparency. See also

   Blur BlurVertical

=head2 Wx::Image::BlurVertical

   wxImage BlurVertical(int blurRadius)

   Blurs the image in the vertical direction only. This should not be
   used when using a single mask colour for transparency.

   See also

   Blur BlurHorizontal

=head2 Wx::Image::CleanUpHandlers

   static void CleanUpHandlers()

   Deletes all image handlers.

   This function is called by wxWidgets on exit.

=head2 Wx::Image::ComputeHistogram

   unsigned long ComputeHistogram(wxImageHistogram& histogram) const

   Computes the histogram of the image. histogram is a reference to
   wxImageHistogram object. wxImageHistogram is a specialization of
   wxHashMap "template" and is defined as follows:

   class WXDLLEXPORT wxImageHistogramEntry
   {
   public:
       wxImageHistogramEntry() : index(0), value(0) {}
       unsigned long index;
       unsigned long value;
   };

=head2 Wx::Image::ConvertAlphaToMask

   bool ConvertAlphaToMask(unsigned char threshold = 128)

   If the image has alpha channel, this method converts it to mask. All
   pixels with alpha value less than threshold are replaced with mask
   colour and the alpha channel is removed. Mask colour is chosen
   automatically using FindFirstUnusedColour.

   If the image image doesn't have alpha channel, ConvertAlphaToMask does
   nothing.

   Return value

   false if FindFirstUnusedColour returns false, true otherwise.

=head2 Wx::Image::ConvertToBitmap

   wxBitmap ConvertToBitmap() const

   Deprecated, use equivalent wxBitmap constructor (which takes wxImage
   and depth as its arguments) instead.

=head2 Wx::Image::ConvertToGreyscale

   wxImage ConvertToGreyscale(double lr = 0.299, double lg = 0.587,
   double lb = 0.114) const

   Returns a greyscale version of the image. The returned image uses the
   luminance component of the original to calculate the greyscale.
   Defaults to using ITU-T BT.601 when converting to YUV, where every
   pixel equals (R * lr) + (G * lg) + (B * lb).

=head2 Wx::Image::ConvertToMono

   wxImage ConvertToMono(unsigned char r, unsigned char g, unsigned char
   b) const

   Returns monochromatic version of the image. The returned image has
   white colour where the original has (r,g,b) colour and black colour
   everywhere else.

=head2 Wx::Image::Copy

   wxImage Copy() const

   Returns an identical copy of the image.

=head2 Wx::Image::Create

   bool Create(int width, int height, bool clear=true)

   Creates a fresh image. If clear is true, the new image will be
   initialized to black. Otherwise, the image data will be uninitialized.

   Parameters

   width

       The width of the image in pixels.

   height

       The height of the image in pixels.

   Return value

   true if the call succeeded, false otherwise.

=head2 Wx::Image::Destroy

   void Destroy()

   Destroys the image data.

=head2 Wx::Image::FindFirstUnusedColour

   bool FindFirstUnusedColour(unsigned char * r, unsigned char * g,
   unsigned char * b, unsigned char startR = 1, unsigned char startG = 0,
   unsigned char startB = 0)

   Parameters

   r,g,b

       Pointers to variables to save the colour.

   startR,startG,startB

       Initial values of the colour. Returned colour will have RGB values
       equal to or greater than these.

   Finds the first colour that is never used in the image. The search
   begins at given initial colour and continues by increasing R, G and B
   components (in this order) by 1 until an unused colour is found or the
   colour space exhausted.

   Return value

   Returns false if there is no unused colour left, true on success.

   Notes

   Note that this method involves computing the histogram, which is
   computationally intensive operation.

=head2 Wx::Image::FindHandler

   static wxImageHandler* FindHandler(const wxString& name)

   Finds the handler with the given name.

   static wxImageHandler* FindHandler(const wxString& extension, long
   imageType)

   Finds the handler associated with the given extension and type.

   static wxImageHandler* FindHandler(long imageType)

   Finds the handler associated with the given image type.

   static wxImageHandler* FindHandlerMime(const wxString& mimetype)

   Finds the handler associated with the given MIME type.

   name

       The handler name.

   extension

       The file extension, such as "bmp".

   imageType

       The image type, such as wxBITMAP_TYPE_BMP.

   mimetype

       MIME type.

   Return value

   A pointer to the handler if found, NULL otherwise.

   See also

   wxImageHandler

=head2 Wx::Image::GetImageExtWildcard

   static wxString GetImageExtWildcard()

   Iterates all registered wxImageHandler objects, and returns a string
   containing file extension masks suitable for passing to file open/save
   dialog boxes.

   Return value

   The format of the returned string is "(*.ext1;*.ext2)|*.ext1;*.ext2".

   It is usually a good idea to prepend a description before passing the
   result to the dialog.

   Example:

       wxFileDialog FileDlg( this, "Choose Image", ::wxGetCwd(), "", _("Image Files ") + wxImage::GetImageExtWildcard(), wxFD_OPEN );

   See also

   wxImageHandler

=head2 Wx::Image::GetAlpha

   unsigned char GetAlpha(int x, int y) const

   Returns the alpha value for the given pixel. This function may only be
   called for the images with alpha channel, use HasAlpha to check for
   this.

   The returned value is the opacity of the image, i.e. the value of 0
   corresponds to the transparent pixels while the value of 255 -- to the
   opaque ones.

   unsigned char * GetAlpha() const

   Returns pointer to the array storing the alpha values for this image.
   This pointer is NULL for the images without the alpha channel. If the
   image does have it, this pointer may be used to directly manipulate
   the alpha values which are stored as the RGB ones.

=head2 Wx::Image::GetBlue

   unsigned char GetBlue(int x, int y) const

   Returns the blue intensity at the given coordinate.

=head2 Wx::Image::GetData

   unsigned char* GetData() const

   Returns the image data as an array. This is most often used when doing
   direct image manipulation. The return value points to an array of
   characters in RGBRGBRGB... format in the top-to-bottom, left-to-right
   order, that is the first RGB triplet corresponds to the pixel first
   pixel of the first row, the second one --- to the second pixel of the
   first row and so on until the end of the first row, with second row
   following after it and so on.

   You should not delete the returned pointer nor pass it to
   wxImage::SetData.

=head2 Wx::Image::GetGreen

   unsigned char GetGreen(int x, int y) const

   Returns the green intensity at the given coordinate.

=head2 Wx::Image::GetImageCount

   static int GetImageCount(const wxString& filename, long type =
   wxBITMAP_TYPE_ANY)

   static int GetImageCount(wxInputStream& stream, long type =
   wxBITMAP_TYPE_ANY)

   If the image file contains more than one image and the image handler
   is capable of retrieving these individually, this function will return
   the number of available images.

   name

       Name of the file to query.

   stream

       Opened input stream with image data. Currently, the stream must
       support seeking.

   type

       May be one of the following:

=head2 Wx::Image::GetHandlers

   static wxList& GetHandlers()

   Returns the static list of image format handlers.

   See also

   wxImageHandler

=head2 Wx::Image::GetHeight

   int GetHeight() const

   Gets the height of the image in pixels.

=head2 Wx::Image::GetMaskBlue

   unsigned char GetMaskBlue() const

   Gets the blue value of the mask colour.

=head2 Wx::Image::GetMaskGreen

   unsigned char GetMaskGreen() const

   Gets the green value of the mask colour.

=head2 Wx::Image::GetMaskRed

   unsigned char GetMaskRed() const

   Gets the red value of the mask colour.

=head2 Wx::Image::GetOrFindMaskColour

   bool GetOrFindMaskColour(unsigned char *r, unsigned char *g, unsigned
   char *b) const

   Get the current mask colour or find a suitable unused colour that
   could be used as a mask colour. Returns true if the image currently
   has a mask.

=head2 Wx::Image::GetPalette

   const wxPalette& GetPalette() const

   Returns the palette associated with the image. Currently the palette
   is only used when converting to wxBitmap under Windows. Some of the
   wxImage handlers have been modified to set the palette if one exists
   in the image file (usually 256 or less colour images in GIF or PNG
   format).

=head2 Wx::Image::GetRed

   unsigned char GetRed(int x, int y) const

   Returns the red intensity at the given coordinate.

=head2 Wx::Image::GetSubImage

   wxImage GetSubImage(const wxRect& rect) const

   Returns a sub image of the current one as long as the rect belongs
   entirely to the image.

=head2 Wx::Image::GetWidth

   int GetWidth() const

   Gets the width of the image in pixels.

   See also

   wxImage::GetHeight

=head2 HSVValue::HSVValue

   HSVValue(double h = 0.0, double s = 0.0, double v = 0.0)

   Constructor for HSVValue, an object that contains values for hue,
   saturation and value which represent the value of a color. It is used
   by wxImage::HSVtoRGB and wxImage::RGBtoHSV, which converts between HSV
   color space and RGB color space.

   wxPython note: use wxImage_HSVValue in wxPython

=head2 Wx::Image::HSVtoRGB

   wxImage::RGBValue HSVtoRGB(const HSVValue & hsv)

   Converts a color in HSV color space to RGB color space.

=head2 Wx::Image::HasAlpha

   bool HasAlpha() const

   Returns true if this image has alpha channel, false otherwise.

   See also

   GetAlpha, SetAlpha

=head2 Wx::Image::HasMask

   bool HasMask() const

   Returns true if there is a mask active, false otherwise.

=head2 Wx::Image::GetOption

   wxString GetOption(const wxString& name) const

   Gets a user-defined option. The function is case-insensitive to name.

   For example, when saving as a JPEG file, the option quality is used,
   which is a number between 0 and 100 (0 is terrible, 100 is very good).

   See also

   wxImage::SetOption, wxImage::GetOptionInt, wxImage::HasOption

=head2 Wx::Image::GetOptionInt

   int GetOptionInt(const wxString& name) const

   Gets a user-defined option as an integer. The function is
   case-insensitive to name.

   If the given option is not present, the function returns 0. Use
   wxImage::HasOption is 0 is a possibly valid value for the option.

   Options for wxPNGHandler

=head2 Wx::Image::HasOption

   bool HasOption(const wxString& name) const

   Returns true if the given option is present. The function is
   case-insensitive to name.

   See also

   wxImage::SetOption, wxImage::GetOption, wxImage::GetOptionInt

=head2 Wx::Image::InitAlpha

   void InitAlpha()

   Initializes the image alpha channel data. It is an error to call it if
   the image already has alpha data. If it doesn't, alpha data will be by
   default initialized to all pixels being fully opaque. But if the image
   has a a mask colour, all mask pixels will be completely transparent.

=head2 Wx::Image::InitStandardHandlers

   static void InitStandardHandlers()

   Internal use only. Adds standard image format handlers. It only
   install BMP for the time being, which is used by wxBitmap.

   This function is called by wxWidgets on startup, and shouldn't be
   called by the user.

   See also

   wxImageHandler, wxInitAllImageHandlers

=head2 Wx::Image::InsertHandler

   static void InsertHandler(wxImageHandler* handler)

   Adds a handler at the start of the static list of format handlers.

   handler

       A new image format handler object. There is usually only one
       instance of a given handler class in an application session.

   See also

   wxImageHandler

=head2 Wx::Image::IsTransparent

   bool IsTransparent(int x, int y, unsigned char threshold = 128) const

   Returns true if the given pixel is transparent, i.e. either has the
   mask colour if this image has a mask or if this image has alpha
   channel and alpha value of this pixel is strictly less than threshold.

=head2 Wx::Image::LoadFile

   bool LoadFile(const wxString& name, long type = wxBITMAP_TYPE_ANY, int
   index = -1)

   bool LoadFile(const wxString& name, const wxString& mimetype, int
   index = -1)

   Loads an image from a file. If no handler type is provided, the
   library will try to autodetect the format.

   bool LoadFile(wxInputStream& stream, long type, int index = -1)

   bool LoadFile(wxInputStream& stream, const wxString& mimetype, int
   index = -1)

   Loads an image from an input stream.

   Parameters

   name

       Name of the file from which to load the image.

   stream

       Opened input stream from which to load the image. Currently, the
       stream must support seeking.

   type

       One of the following values:

=head2 Wx::Image::IsOk

   bool IsOk() const

   Returns true if image data is present.

=head2 RGBValue::RGBValue

   RGBValue(unsigned char r = 0, unsigned char g = 0, unsigned char b = 0)

   Constructor for RGBValue, an object that contains values for red,
   green and blue which represent the value of a color. It is used by
   wxImage::HSVtoRGB and wxImage::RGBtoHSV, which converts between HSV
   color space and RGB color space.

   wxPython note: use wxImage_RGBValue in wxPython

=head2 Wx::Image::RGBtoHSV

   wxImage::HSVValue RGBtoHSV(const RGBValue& rgb)

   Converts a color in RGB color space to HSV color space.

=head2 Wx::Image::RemoveHandler

   static bool RemoveHandler(const wxString& name)

   Finds the handler with the given name, and removes it. The handler is
   not deleted.

   name

       The handler name.

   Return value

   true if the handler was found and removed, false otherwise.

   See also

   wxImageHandler

=head2 Wx::Image::Mirror

   wxImage Mirror(bool horizontally = true) const

   Returns a mirrored copy of the image. The parameter horizontally
   indicates the orientation.

=head2 Wx::Image::Replace

   void Replace(unsigned char r1, unsigned char g1, unsigned char b1,
   unsigned char r2, unsigned char g2, unsigned char b2)

   Replaces the colour specified by r1,g1,b1 by the colour r2,g2,b2.

=head2 Wx::Image::Rescale

   wxImage & Rescale(int width, int height, int quality =
   wxIMAGE_QUALITY_NORMAL)

   Changes the size of the image in-place by scaling it: after a call to
   this function, the image will have the given width and height.

   For a description of the quality parameter, see the Scale function.

   Returns the (modified) image itself.

   See also

   Scale

=head2 Wx::Image::Resize

   wxImage & Resize(const wxSize& size, const wxPoint pos, int red = -1,
   int green = -1, int blue = -1)

   Changes the size of the image in-place without scaling it by adding
   either a border with the given colour or cropping as necessary. The
   image is pasted into a new image with the given size and background
   colour at the position pos relative to the upper left of the new
   image. If red = green = blue = -1 then use either the current mask
   colour if set or find, use, and set a suitable mask colour for any
   newly exposed areas.

   Returns the (modified) image itself.

   See also

   Size

=head2 Wx::Image::Rotate

   wxImage Rotate(double angle, const wxPoint& rotationCentre, bool
   interpolating = true, wxPoint* offsetAfterRotation = NULL)

   Rotates the image about the given point, by angle radians. Passing
   true to interpolating results in better image quality, but is slower.
   If the image has a mask, then the mask colour is used for the
   uncovered pixels in the rotated image background. Else, black (rgb 0,
   0, 0) will be used.

   Returns the rotated image, leaving this image intact.

=head2 Wx::Image::RotateHue

   void RotateHue(double angle)

   Rotates the hue of each pixel in the image by angle, which is a double
   in the range of -1.0 to +1.0, where -1.0 corresponds to -360 degrees
   and +1.0 corresponds to +360 degrees.

=head2 Wx::Image::Rotate90

   wxImage Rotate90(bool clockwise = true) const

   Returns a copy of the image rotated 90 degrees in the direction
   indicated by clockwise.

=head2 Wx::Image::SaveFile

   bool SaveFile(const wxString& name, int type) const

   bool SaveFile(const wxString& name, const wxString& mimetype) const

   Saves an image in the named file.

   bool SaveFile(const wxString& name) const

   Saves an image in the named file. File type is determined from the
   extension of the file name. Note that this function may fail if the
   extension is not recognized! You can use one of the forms above to
   save images to files with non-standard extensions.

   bool SaveFile(wxOutputStream& stream, int type) const

   bool SaveFile(wxOutputStream& stream, const wxString& mimetype) const

   Saves an image in the given stream.

   Parameters

   name

       Name of the file to save the image to.

   stream

       Opened output stream to save the image to.

   type

       Currently these types can be used:

=head2 Wx::Image::Scale

   wxImage Scale(int width, int height, int quality =
   wxIMAGE_QUALITY_NORMAL) const

   Returns a scaled version of the image. This is also useful for scaling
   bitmaps in general as the only other way to scale bitmaps is to blit a
   wxMemoryDC into another wxMemoryDC.

   quality

       Determines what method to use for resampling the image. Can be one
       of the following:

=head2 Wx::Image::Size

   wxImage Size(const wxSize& size, const wxPoint pos, int red = -1, int
   green = -1, int blue = -1) const

   Returns a resized version of this image without scaling it by adding
   either a border with the given colour or cropping as necessary. The
   image is pasted into a new image with the given size and background
   colour at the position pos relative to the upper left of the new
   image. If red = green = blue = -1 then use either the current mask
   colour if set or find, use, and set a suitable mask colour for any
   newly exposed areas.

   See also

   Resize

=head2 Wx::Image::SetAlpha

   void SetAlpha(unsigned char *alpha = NULL,bool static_data = false)

   This function is similar to SetData and has similar restrictions. The
   pointer passed to it may however be NULL in which case the function
   will allocate the alpha array internally -- this is useful to add
   alpha channel data to an image which doesn't have any. If the pointer
   is not NULL, it must have one byte for each image pixel and be
   allocated with malloc(). wxImage takes ownership of the pointer and
   will free it unless static_data parameter is set to true -- in this
   case the caller should do it.

   void SetAlpha(int x, int y, unsigned char alpha)

   Sets the alpha value for the given pixel. This function should only be
   called if the image has alpha channel data, use HasAlpha to check for
   this.

=head2 Wx::Image::SetData

   void SetData(unsigned char*data)

   Sets the image data without performing checks. The data given must
   have the size (width*height*3) or results will be unexpected. Don't
   use this method if you aren't sure you know what you are doing.

   The data must have been allocated with malloc(), NOT with operator new.

   After this call the pointer to the data is owned by the wxImage
   object, that will be responsible for deleting it. Do not pass to this
   function a pointer obtained through wxImage::GetData.

=head2 Wx::Image::SetMask

   void SetMask(bool hasMask = true)

   Specifies whether there is a mask or not. The area of the mask is
   determined by the current mask colour.

=head2 Wx::Image::SetMaskColour

   void SetMaskColour(unsigned char red, unsigned char green, unsigned
   char blue)

   Sets the mask colour for this image (and tells the image to use the
   mask).

=head2 Wx::Image::SetMaskFromImage

   bool SetMaskFromImage(const wxImage& mask, unsigned char mr, unsigned
   char mg, unsigned char mb)

   Parameters

   mask

       The mask image to extract mask shape from. Must have same
       dimensions as the image.

   mr,mg,mb

       RGB value of pixels in mask that will be used to create the mask.

   Sets image's mask so that the pixels that have RGB value of mr,mg,mb
   in mask will be masked in the image. This is done by first finding an
   unused colour in the image, setting this colour as the mask colour and
   then using this colour to draw all pixels in the image who
   corresponding pixel in mask has given RGB value.

   Return value

   Returns false if mask does not have same dimensions as the image or if
   there is no unused colour left. Returns true if the mask was
   successfully applied.

   Notes

   Note that this method involves computing the histogram, which is
   computationally intensive operation.

=head2 Wx::Image::SetOption

   void SetOption(const wxString& name, const wxString& value)

   void SetOption(const wxString& name, int value)

   Sets a user-defined option. The function is case-insensitive to name.

   For example, when saving as a JPEG file, the option quality is used,
   which is a number between 0 and 100 (0 is terrible, 100 is very good).

   See also

   wxImage::GetOption, wxImage::GetOptionInt, wxImage::HasOption

=head2 Wx::Image::SetPalette

   void SetPalette(const wxPalette& palette)

   Associates a palette with the image. The palette may be used when
   converting wxImage to wxBitmap (MSW only at present) or in file save
   operations (none as yet).

=head2 Wx::Image::SetRGB

   void SetRGB(int x, int y, unsigned char red, unsigned char green,
   unsigned char blue)

   Sets the pixel at the given coordinate. This routine performs
   bounds-checks for the coordinate so it can be considered a safe way to
   manipulate the data, but in some cases this might be too slow so that
   the data will have to be set directly. In that case you will have to
   get access to the image data using the GetData method.

=head2 Wx::Image::SetRGB

   void SetRGB(wxRect & rect, unsigned char red, unsigned char green,
   unsigned char blue)

   Sets the colour of the pixels within the given rectangle. This routine
   performs bounds-checks for the coordinate so it can be considered a
   safe way to manipulate the data.

=head1 Wx::ImageHandler

=head2 Wx::ImageHandler::new

   wxImageHandler()

   Default constructor. In your own default constructor, initialise the
   members m_name, m_extension and m_type.

=head2 Wx::ImageHandler::DESTROY

   ~wxImageHandler()

   Destroys the wxImageHandler object.

=head2 Wx::ImageHandler::GetName

   const wxString& GetName() const

   Gets the name of this handler.

=head2 Wx::ImageHandler::GetExtension

   const wxString& GetExtension() const

   Gets the file extension associated with this handler.

=head2 Wx::ImageHandler::GetImageCount

   int GetImageCount(wxInputStream& stream)

   If the image file contains more than one image and the image handler
   is capable of retrieving these individually, this function will return
   the number of available images.

   stream

       Opened input stream for reading image data. Currently, the stream
       must support seeking.

   Return value

   Number of available images. For most image handlers, this is 1
   (exceptions are TIFF and ICO formats).

=head2 Wx::ImageHandler::GetType

   long GetType() const

   Gets the image type associated with this handler.

=head2 Wx::ImageHandler::GetMimeType

   const wxString& GetMimeType() const

   Gets the MIME type associated with this handler.

=head2 Wx::ImageHandler::LoadFile

   bool LoadFile(wxImage* image, wxInputStream& stream, bool verbose=true,
   int index=0)

   Loads a image from a stream, putting the resulting data into image. If
   the image file contains more than one image and the image handler is
   capable of retrieving these individually, index indicates which image
   to read from the stream.

   Parameters

   image

       The image object which is to be affected by this operation.

   stream

       Opened input stream for reading image data.

   verbose

       If set to true, errors reported by the image handler will produce
       wxLogMessages.

   index

       The index of the image in the file (starting from zero).

   Return value

   true if the operation succeeded, false otherwise.

   See also

   wxImage::LoadFile, wxImage::SaveFile, wxImageHandler::SaveFile

=head2 Wx::ImageHandler::SaveFile

   bool SaveFile(wxImage* image, wxOutputStream& stream)

   Saves a image in the output stream.

   Parameters

   image

       The image object which is to be affected by this operation.

   stream

       Opened output stream for writing the data.

   Return value

   true if the operation succeeded, false otherwise.

   See also

   wxImage::LoadFile, wxImage::SaveFile, wxImageHandler::LoadFile

=head2 Wx::ImageHandler::SetName

   void SetName(const wxString& name)

   Sets the handler name.

   Parameters

   name

       Handler name.

=head2 Wx::ImageHandler::SetExtension

   void SetExtension(const wxString& extension)

   Sets the handler extension.

   Parameters

   extension

       Handler extension.

=head2 Wx::ImageHandler::SetMimeType

   void SetMimeType(const wxString& mimetype)

   Sets the handler MIME type.

   Parameters

   mimename

       Handler MIME type.

=head2 Wx::ImageHandler::SetType

   void SetType(long type)

   Sets the handler type.

   Parameters

   name

       Handler type.

=head1 Wx::ImageList

=head2 Wx::ImageList::new

   wxImageList()

   Default constructor.

   wxImageList(int width, int height, const bool mask = true, int
   initialCount = 1)

   Constructor specifying the image size, whether image masks should be
   created, and the initial size of the list.

   Parameters

   width

       Width of the images in the list.

   height

       Height of the images in the list.

   mask

       true if masks should be created for all images.

   initialCount

       The initial size of the list.

   See also

   wxImageList::Create

=head2 Wx::ImageList::Add

   int Add(const wxBitmap& bitmap, const wxBitmap& mask = wxNullBitmap)

   Adds a new image or images using a bitmap and optional mask bitmap.

   int Add(const wxBitmap& bitmap, const wxColour& maskColour)

   Adds a new image or images using a bitmap and mask colour.

   int Add(const wxIcon& icon)

   Adds a new image using an icon.

   Parameters

   bitmap

       Bitmap representing the opaque areas of the image.

   mask

       Monochrome mask bitmap, representing the transparent areas of the
       image.

   maskColour

       Colour indicating which parts of the image are transparent.

   icon

       Icon to use as the image.

   Return value

   The new zero-based image index.

   Remarks

   The original bitmap or icon is not affected by the Add operation, and
   can be deleted afterwards.

   If the bitmap is wider than the images in the list, then the bitmap
   will automatically be split into smaller images, each matching the
   dimensions of the image list. This does not apply when adding icons.

   wxPython note: In place of a single overloaded method name, wxPython
   implements the following methods:

=head2 Wx::ImageList::Create

   bool Create(int width, int height, const bool mask = true, int
   initialCount = 1)

   Initializes the list. See wxImageList::wxImageList for details.

=head2 Wx::ImageList::Draw

   bool Draw(int index, wxDC& dc, int x, int y, int flags =
   wxIMAGELIST_DRAW_NORMAL, const bool solidBackground = false)

   Draws a specified image onto a device context.

   Parameters

   index

       Image index, starting from zero.

   dc  

       Device context to draw on.

   x   

       X position on the device context.

   y   

       Y position on the device context.

   flags

       How to draw the image. A bitlist of a selection of the following:

=head2 Wx::ImageList::GetBitmap

   wxBitmap GetBitmap(int index) const

   Returns the bitmap corresponding to the given index.

=head2 Wx::ImageList::GetIcon

   wxIcon GetIcon(int index) const

   Returns the icon corresponding to the given index.

=head2 Wx::ImageList::GetImageCount

   int GetImageCount() const

   Returns the number of images in the list.

=head2 Wx::ImageList::GetSize

   bool GetSize(int index, int& width, int &height) const

   Retrieves the size of the images in the list. Currently, the index
   parameter is ignored as all images in the list have the same size.

   Parameters

   index

       currently unused, should be 0

   width

       receives the width of the images in the list

   height

       receives the height of the images in the list

   Return value

   true if the function succeeded, false if it failed (for example, if
   the image list was not yet initialized).

=head2 Wx::ImageList::Remove

   bool Remove(int index)

   Removes the image at the given position.

=head2 Wx::ImageList::RemoveAll

   bool RemoveAll()

   Removes all the images in the list.

=head2 Wx::ImageList::Replace

   bool Replace(int index, const wxBitmap& bitmap, const wxBitmap& mask =
   wxNullBitmap)

   Replaces the existing image with the new image.

   Windows only.

   bool Replace(int index, const wxIcon& icon)

   Replaces the existing image with the new image.

   Parameters

   bitmap

       Bitmap representing the opaque areas of the image.

   mask

       Monochrome mask bitmap, representing the transparent areas of the
       image.

   icon

       Icon to use as the image.

   Return value

   true if the replacement was successful, false otherwise.

   Remarks

   The original bitmap or icon is not affected by the Replace operation,
   and can be deleted afterwards.

   wxPython note: The second form is called ReplaceIcon in wxPython.

=head1 Wx::IndividualLayoutConstraint

=head2 Edges and relationships

   The wxEdge enumerated type specifies the type of edge or dimension of
   a window.

=head2 Wx::IndividualLayoutConstraint::new

   void wxIndividualLayoutConstraint()

   Constructor. Not used by the end-user.

=head2 Wx::IndividualLayoutConstraint::Above

   void Above(wxWindow *otherWin, int margin = 0)

   Constrains this edge to be above the given window, with an optional
   margin. Implicitly, this is relative to the top edge of the other
   window.

=head2 Wx::IndividualLayoutConstraint::Absolute

   void Absolute(int value)

   Constrains this edge or dimension to be the given absolute value.

=head2 Wx::IndividualLayoutConstraint::AsIs

   void AsIs()

   Sets this edge or constraint to be whatever the window's value is at
   the moment. If either of the width and height constraints are as is,
   the window will not be resized, but moved instead. This is important
   when considering panel items which are intended to have a default
   size, such as a button, which may take its size from the size of the
   button label.

=head2 Wx::IndividualLayoutConstraint::Below

   void Below(wxWindow *otherWin, int margin = 0)

   Constrains this edge to be below the given window, with an optional
   margin. Implicitly, this is relative to the bottom edge of the other
   window.

=head2 Wx::IndividualLayoutConstraint::Unconstrained

   void Unconstrained()

   Sets this edge or dimension to be unconstrained, that is, dependent on
   other edges and dimensions from which this value can be deduced.

=head2 Wx::IndividualLayoutConstraint::LeftOf

   void LeftOf(wxWindow *otherWin, int margin = 0)

   Constrains this edge to be to the left of the given window, with an
   optional margin. Implicitly, this is relative to the left edge of the
   other window.

=head2 Wx::IndividualLayoutConstraint::PercentOf

   void PercentOf(wxWindow *otherWin, wxEdge edge, int per)

   Constrains this edge or dimension to be to a percentage of the given
   window, with an optional margin.

=head2 Wx::IndividualLayoutConstraint::RightOf

   void RightOf(wxWindow *otherWin, int margin = 0)

   Constrains this edge to be to the right of the given window, with an
   optional margin. Implicitly, this is relative to the right edge of the
   other window.

=head2 Wx::IndividualLayoutConstraint::SameAs

   void SameAs(wxWindow *otherWin, wxEdge edge, int margin = 0)

   Constrains this edge or dimension to be to the same as the edge of the
   given window, with an optional margin.

=head2 Wx::IndividualLayoutConstraint::Set

   void Set(wxRelationship rel, wxWindow *otherWin, wxEdge otherEdge, int
   value = 0, int margin = 0)

   Sets the properties of the constraint. Normally called by one of the
   convenience functions such as Above, RightOf, SameAs.

=head1 Wx::InitDialogEvent

=head2 Wx::InitDialogEvent::new

   wxInitDialogEvent(int id = 0)

   Constructor.

=head1 Wx::InputStream

=head2 Wx::InputStream::new

   wxInputStream()

   Creates a dummy input stream.

=head2 Wx::InputStream::DESTROY

   ~wxInputStream()

   Destructor.

=head2 Wx::InputStream::CanRead

   bool CanRead() const

   Returns true if some data is available in the stream right now, so
   that calling Read() wouldn't block.

=head2 Wx::InputStream::GetC

   char GetC()

   Returns the first character in the input queue and removes it,
   blocking until it appears if necessary.

   Note

   If EOF, return value is undefined and LastRead() will return 0 and not
   1.

=head2 Wx::InputStream::Eof

   bool Eof() const

   Returns true after an attempt has been made to read past the end of
   the stream.

   Note

   In wxWidgets 2.6.x and below some streams returned Eof() when the last
   byte had been read rather than when an attempt had been made to read
   past the last byte. If you want to avoid depending on one behaviour or
   the other then call LastRead() to check the number of bytes actually
   read.

=head2 Wx::InputStream::LastRead

   size_t LastRead() const

   Returns the last number of bytes read.

=head2 Wx::InputStream::Peek

   char Peek()

   Returns the first character in the input queue without removing it.

   Note

   Blocks until something appears in the stream if necessary, if nothing
   ever does (i.e. EOF) LastRead() will return 0 (and the return value is
   undefined), otherwise LastRead() returns 1.

=head2 Wx::InputStream::Read

   wxInputStream& Read(void *buffer, size_t size)

   Reads the specified amount of bytes and stores the data in buffer.

   Warning

   The buffer absolutely needs to have at least the specified size.

   Return value

   This function returns a reference on the current object, so the user
   can test any states of the stream right away.

   wxInputStream& Read(wxOutputStream& stream_out)

   Reads data from the input queue and stores it in the specified output
   stream. The data is read until an error is raised by one of the two
   streams.

   Return value

   This function returns a reference on the current object, so the user
   can test any states of the stream right away.

=head2 Wx::InputStream::SeekI

   off_t SeekI(off_t pos, wxSeekMode mode = wxFromStart)

   Changes the stream current position.

   Parameters

   pos 

       Offset to seek to.

   mode

       One of wxFromStart, wxFromEnd, wxFromCurrent.

   Return value

   The new stream position or wxInvalidOffset on error.

=head2 Wx::InputStream::TellI

   off_t TellI() const

   Returns the current stream position.

=head2 Wx::InputStream::Ungetch

   size_t Ungetch(const char* buffer, size_t size)

   This function is only useful in read mode. It is the manager of the
   "Write-Back" buffer. This buffer acts like a temporary buffer where
   data which has to be read during the next read IO call are put. This
   is useful when you get a big block of data which you didn't want to
   read: you can replace them at the top of the input queue by this way.

   Be very careful about this call in connection with calling SeekI() on
   the same stream. Any call to SeekI() will invalidate any previous call
   to this method (otherwise you could SeekI() to one position, "unread"
   a few bytes there, SeekI() to another position and data would be
   either lost or corrupted).

   Return value

   Returns the amount of bytes saved in the Write-Back buffer.

   bool Ungetch(char c)

   This function acts like the previous one except that it takes only one
   character: it is sometimes shorter to use than the generic function.

=head1 Wx::IPaddress

=head2 Wx::IPaddress::Hostname

   virtual bool Hostname(const wxString& hostname)

   Set the address to hostname, which can be a host name or an IP-style
   address in a format dependent on implementation.

   Return value

   Returns true on success, false if something goes wrong (invalid
   hostname or invalid IP address).

   virtual wxString Hostname()

   Returns the hostname which matches the IP address.

=head2 Wx::IPaddress::IPAddress

   virtual wxString IPAddress()

   Returns a wxString containing the IP address.

=head2 Wx::IPaddress::Service

   virtual bool Service(const wxString& service)

   Set the port to that corresponding to the specified service.

   Return value

   Returns true on success, false if something goes wrong (invalid
   service).

   virtual bool Service(unsigned short service)

   Set the port to that corresponding to the specified service.

   Return value

   Returns true on success, false if something goes wrong (invalid
   service).

   virtual unsigned short Service()

   Returns the current service.

=head2 Wx::IPaddress::AnyAddress

   virtual bool AnyAddress()

   Internally, this is the same as setting the IP address to INADDR_ANY.

   On IPV4 implementations, 0.0.0.0

   On IPV6 implementations, ::

   Return value

   Returns true on success, false if something went wrong.

=head2 Wx::IPaddress::LocalHost

   virtual bool LocalHost()

   Set address to localhost.

   On IPV4 implementations, 127.0.0.1

   On IPV6 implementations, ::1

   Return value

   Returns true on success, false if something went wrong.

=head2 Wx::IPaddress::IsLocalHost

   virtual bool IsLocalHost()

   Determines if current address is set to localhost.

   Return value

   Returns true if address is localhost, false if internet address.

=head1 Wx::IPV4address

=head2 Wx::IPV4address::Hostname

   bool Hostname(const wxString& hostname)

   Set the address to hostname, which can be a host name or an IP-style
   address in dot notation (a.b.c.d)

   Return value

   Returns true on success, false if something goes wrong (invalid
   hostname or invalid IP address).

   wxString Hostname()

   Returns the hostname which matches the IP address.

=head2 Wx::IPV4address::IPAddress

   wxString IPAddress()

   Returns a wxString containing the IP address in dot quad (127.0.0.1)
   format.

=head2 Wx::IPV4address::Service

   bool Service(const wxString& service)

   Set the port to that corresponding to the specified service.

   Return value

   Returns true on success, false if something goes wrong (invalid
   service).

   bool Service(unsigned short service)

   Set the port to that corresponding to the specified service.

   Return value

   Returns true on success, false if something goes wrong (invalid
   service).

   unsigned short Service()

   Returns the current service.

=head2 Wx::IPV4address::AnyAddress

   bool AnyAddress()

   Set address to any of the addresses of the current machine. Whenever
   possible, use this function instead of wxIPV4address::LocalHost, as
   this correctly handles multi-homed hosts and avoids other small
   problems. Internally, this is the same as setting the IP address to
   INADDR_ANY.

   Return value

   Returns true on success, false if something went wrong.

=head2 Wx::IPV4address::LocalHost

   bool LocalHost()

   Set address to localhost (127.0.0.1). Whenever possible, use the
   wxIPV4address::AnyAddress, function instead of this one, as this will
   correctly handle multi-homed hosts and avoid other small problems.

   Return value

   Returns true on success, false if something went wrong.

=head1 Wx::Joystick

=head2 Wx::Joystick::new

   wxJoystick(int joystick = wxJOYSTICK1)

   Constructor. joystick may be one of wxJOYSTICK1, wxJOYSTICK2,
   indicating the joystick controller of interest.

=head2 Wx::Joystick::DESTROY

   ~wxJoystick()

   Destroys the wxJoystick object.

=head2 Wx::Joystick::GetButtonState

   int GetButtonState() const

   Returns the state of the joystick buttons. Every button is mapped to a
   single bit in the returned integer, with the first button being mapped
   to the least significant bit, and so on. A bitlist of wxJOY_BUTTONn
   identifiers, where n is 1, 2, 3 or 4 is available for historical
   reasons.

=head2 Wx::Joystick::GetManufacturerId

   int GetManufacturerId() const

   Returns the manufacturer id.

=head2 Wx::Joystick::GetMovementThreshold

   int GetMovementThreshold() const

   Returns the movement threshold, the number of steps outside which the
   joystick is deemed to have moved.

=head2 Wx::Joystick::GetNumberAxes

   int GetNumberAxes() const

   Returns the number of axes for this joystick.

=head2 Wx::Joystick::GetNumberButtons

   int GetNumberButtons() const

   Returns the number of buttons for this joystick.

=head2 Wx::Joystick::GetNumberJoysticks

   static int GetNumberJoysticks()

   Returns the number of joysticks currently attached to the computer.

=head2 Wx::Joystick::GetPollingMax

   int GetPollingMax() const

   Returns the maximum polling frequency.

=head2 Wx::Joystick::GetPollingMin

   int GetPollingMin() const

   Returns the minimum polling frequency.

=head2 Wx::Joystick::GetProductId

   int GetProductId() const

   Returns the product id for the joystick.

=head2 Wx::Joystick::GetProductName

   wxString GetProductName() const

   Returns the product name for the joystick.

=head2 Wx::Joystick::GetPosition

   wxPoint GetPosition() const

   Returns the x, y position of the joystick.

=head2 Wx::Joystick::GetPOVPosition

   int GetPOVPosition() const

   Returns the point-of-view position, expressed in continuous,
   one-hundredth of a degree units, but limited to return 0, 9000, 18000
   or 27000. Returns -1 on error.

=head2 Wx::Joystick::GetPOVCTSPosition

   int GetPOVCTSPosition() const

   Returns the point-of-view position, expressed in continuous,
   one-hundredth of a degree units. Returns -1 on error.

=head2 Wx::Joystick::GetRudderMax

   int GetRudderMax() const

   Returns the maximum rudder position.

=head2 Wx::Joystick::GetRudderMin

   int GetRudderMin() const

   Returns the minimum rudder position.

=head2 Wx::Joystick::GetRudderPosition

   int GetRudderPosition() const

   Returns the rudder position.

=head2 Wx::Joystick::GetUMax

   int GetUMax() const

   Returns the maximum U position.

=head2 Wx::Joystick::GetUMin

   int GetUMin() const

   Returns the minimum U position.

=head2 Wx::Joystick::GetUPosition

   int GetUPosition() const

   Gets the position of the fifth axis of the joystick, if it exists.

=head2 Wx::Joystick::GetVMax

   int GetVMax() const

   Returns the maximum V position.

=head2 Wx::Joystick::GetVMin

   int GetVMin() const

   Returns the minimum V position.

=head2 Wx::Joystick::GetVPosition

   int GetVPosition() const

   Gets the position of the sixth axis of the joystick, if it exists.

=head2 Wx::Joystick::GetXMax

   int GetXMax() const

   Returns the maximum x position.

=head2 Wx::Joystick::GetXMin

   int GetXMin() const

   Returns the minimum x position.

=head2 Wx::Joystick::GetYMax

   int GetYMax() const

   Returns the maximum y position.

=head2 Wx::Joystick::GetYMin

   int GetYMin() const

   Returns the minimum y position.

=head2 Wx::Joystick::GetZMax

   int GetZMax() const

   Returns the maximum z position.

=head2 Wx::Joystick::GetZMin

   int GetZMin() const

   Returns the minimum z position.

=head2 Wx::Joystick::GetZPosition

   int GetZPosition() const

   Returns the z position of the joystick.

=head2 Wx::Joystick::HasPOV

   bool HasPOV() const

   Returns true if the joystick has a point of view control.

=head2 Wx::Joystick::HasPOV4Dir

   bool HasPOV4Dir() const

   Returns true if the joystick point-of-view supports discrete values
   (centered, forward, backward, left, and right).

=head2 Wx::Joystick::HasPOVCTS

   bool HasPOVCTS() const

   Returns true if the joystick point-of-view supports continuous degree
   bearings.

=head2 Wx::Joystick::HasRudder

   bool HasRudder() const

   Returns true if there is a rudder attached to the computer.

=head2 Wx::Joystick::HasU

   bool HasU() const

   Returns true if the joystick has a U axis.

=head2 Wx::Joystick::HasV

   bool HasV() const

   Returns true if the joystick has a V axis.

=head2 Wx::Joystick::HasZ

   bool HasZ() const

   Returns true if the joystick has a Z axis.

=head2 Wx::Joystick::IsOk

   bool IsOk() const

   Returns true if the joystick is functioning.

=head2 Wx::Joystick::ReleaseCapture

   bool ReleaseCapture()

   Releases the capture set by SetCapture.

   Return value

   true if the capture release succeeded.

   See also

   wxJoystick::SetCapture, wxJoystickEvent

=head2 Wx::Joystick::SetCapture

   bool SetCapture(wxWindow* win, int pollingFreq = 0)

   Sets the capture to direct joystick events to win.

   Parameters

   win 

       The window that will receive joystick events.

   pollingFreq

       If zero, movement events are sent when above the threshold. If
       greater than zero, events are received every pollingFreq
       milliseconds.

   Return value

   true if the capture succeeded.

   See also

   wxJoystick::ReleaseCapture, wxJoystickEvent

=head2 Wx::Joystick::SetMovementThreshold

   void SetMovementThreshold(int threshold)

   Sets the movement threshold, the number of steps outside which the
   joystick is deemed to have moved.

=head1 Wx::JoystickEvent

=head2 Wx::JoystickEvent::new

   wxJoystickEvent(WXTYPE eventType = 0, int state = 0, int joystick =
   wxJOYSTICK1, int change = 0)

   Constructor.

=head2 Wx::JoystickEvent::ButtonDown

   bool ButtonDown(int button = wxJOY_BUTTON_ANY) const

   Returns true if the event was a down event from the specified button
   (or any button).

   Parameters

   button

       Can be wxJOY_BUTTONn where n is 1, 2, 3 or 4; or wxJOY_BUTTON_ANY
       to indicate any button down event.

=head2 Wx::JoystickEvent::ButtonIsDown

   bool ButtonIsDown(int button = wxJOY_BUTTON_ANY) const

   Returns true if the specified button (or any button) was in a down
   state.

   Parameters

   button

       Can be wxJOY_BUTTONn where n is 1, 2, 3 or 4; or wxJOY_BUTTON_ANY
       to indicate any button down event.

=head2 Wx::JoystickEvent::ButtonUp

   bool ButtonUp(int button = wxJOY_BUTTON_ANY) const

   Returns true if the event was an up event from the specified button
   (or any button).

   Parameters

   button

       Can be wxJOY_BUTTONn where n is 1, 2, 3 or 4; or wxJOY_BUTTON_ANY
       to indicate any button down event.

=head2 Wx::JoystickEvent::GetButtonChange

   int GetButtonChange() const

   Returns the identifier of the button changing state. This is a
   wxJOY_BUTTONn identifier, where n is one of 1, 2, 3, 4.

=head2 Wx::JoystickEvent::GetButtonState

   int GetButtonState() const

   Returns the down state of the buttons. This is a bitlist of
   wxJOY_BUTTONn identifiers, where n is one of 1, 2, 3, 4.

=head2 Wx::JoystickEvent::GetJoystick

   int GetJoystick() const

   Returns the identifier of the joystick generating the event - one of
   wxJOYSTICK1 and wxJOYSTICK2.

=head2 Wx::JoystickEvent::GetPosition

   wxPoint GetPosition() const

   Returns the x, y position of the joystick event.

=head2 Wx::JoystickEvent::GetZPosition

   int GetZPosition() const

   Returns the z position of the joystick event.

=head2 Wx::JoystickEvent::IsButton

   bool IsButton() const

   Returns true if this was a button up or down event (not 'is any button
   down?').

=head2 Wx::JoystickEvent::IsMove

   bool IsMove() const

   Returns true if this was an x, y move event.

=head2 Wx::JoystickEvent::IsZMove

   bool IsZMove() const

   Returns true if this was a z move event.

=head1 Wx::KeyEvent

=head2 Wx::KeyEvent::m_altDown

   bool m_altDown

   Deprecated: Please use GetModifiers instead!

   true if the Alt key is pressed down.

=head2 Wx::KeyEvent::m_controlDown

   bool m_controlDown

   Deprecated: Please use GetModifiers instead!

   true if control is pressed down.

=head2 Wx::KeyEvent::m_keyCode

   long m_keyCode

   Deprecated: Please use GetKeyCode instead!

   Virtual keycode. See Keycodes for a list of identifiers.

=head2 Wx::KeyEvent::m_metaDown

   bool m_metaDown

   Deprecated: Please use GetModifiers instead!

   true if the Meta key is pressed down.

=head2 Wx::KeyEvent::m_shiftDown

   bool m_shiftDown

   Deprecated: Please use GetModifiers instead!

   true if shift is pressed down.

=head2 Wx::KeyEvent::m_x

   int m_x

   Deprecated: Please use GetX instead!

   X position of the event.

=head2 Wx::KeyEvent::m_y

   int m_y

   Deprecated: Please use GetY instead!

   Y position of the event.

=head2 Wx::KeyEvent::new

   wxKeyEvent(WXTYPE keyEventType)

   Constructor. Currently, the only valid event types are wxEVT_CHAR and
   wxEVT_CHAR_HOOK.

=head2 Wx::KeyEvent::AltDown

   bool AltDown() const

   Returns true if the Alt key was down at the time of the key event.

   Notice that GetModifiers is easier to use correctly than this function
   so you should consider using it in new code.

=head2 Wx::KeyEvent::CmdDown

   bool CmdDown() const

   CMD is a pseudo key which is the same as Control for PC and Unix
   platforms but the special APPLE (a.k.a as COMMAND) key under Macs: it
   makes often sense to use it instead of, say, ControlDown() because Cmd
   key is used for the same thing under Mac as Ctrl elsewhere (but Ctrl
   still exists, just not used for this purpose under Mac). So for
   non-Mac platforms this is the same as ControlDown() and under Mac this
   is the same as MetaDown().

=head2 Wx::KeyEvent::ControlDown

   bool ControlDown() const

   Returns true if the control key was down at the time of the key event.

   Notice that GetModifiers is easier to use correctly than this function
   so you should consider using it in new code.

=head2 Wx::KeyEvent::GetKeyCode

   int GetKeyCode() const

   Returns the virtual key code. ASCII events return normal ASCII values,
   while non-ASCII events return values such as WXK_LEFT for the left
   cursor key. See Keycodes for a full list of the virtual key codes.

   Note that in Unicode build, the returned value is meaningful only if
   the user entered a character that can be represented in current
   locale's default charset. You can obtain the corresponding Unicode
   character using GetUnicodeKey.

=head2 Wx::KeyEvent::GetModifiers

   int GetModifiers() const

   Return the bitmask of modifier keys which were pressed when this event
   happened. See key modifier constants for the full list of modifiers.

   Notice that this function is easier to use correctly than, for
   example, ControlDown because when using the latter you also have to
   remember to test that none of the other modifiers is pressed:

       if ( ControlDown() && !AltDown() && !ShiftDown() && !MetaDown() )
           ... handle Ctrl-XXX ...

   and forgetting to do it can result in serious program bugs (e.g.
   program not working with European keyboard layout where ALTGR key
   which is seen by the program as combination of CTRL and ALT is used).
   On the other hand, you can simply write

       if ( GetModifiers() == wxMOD_CONTROL )
           ... handle Ctrl-XXX ...

   with this function.

=head2 Wx::KeyEvent::GetPosition

   wxPoint GetPosition() const

   void GetPosition(long *x, long *y) const

   Obtains the position (in client coordinates) at which the key was
   pressed.

=head2 Wx::KeyEvent::GetRawKeyCode

   wxUint32 GetRawKeyCode() const

   Returns the raw key code for this event. This is a platform-dependent
   scan code which should only be used in advanced applications.

   NB: Currently the raw key codes are not supported by all ports, use
   #ifdef wxHAS_RAW_KEY_CODES to determine if this feature is available.

=head2 Wx::KeyEvent::GetRawKeyFlags

   wxUint32 GetRawKeyFlags() const

   Returns the low level key flags for this event. The flags are
   platform-dependent and should only be used in advanced applications.

   NB: Currently the raw key flags are not supported by all ports, use
   #ifdef wxHAS_RAW_KEY_CODES to determine if this feature is available.

=head2 Wx::KeyEvent::GetUnicodeKey

   wxChar GetUnicodeKey() const

   Returns the Unicode character corresponding to this key event.

   This function is only available in Unicode build, i.e. when
   wxUSE_UNICODE is 1.

=head2 Wx::KeyEvent::GetX

   long GetX() const

   Returns the X position (in client coordinates) of the event.

=head2 Wx::KeyEvent::GetY

   long GetY() const

   Returns the Y (in client coordinates) position of the event.

=head2 Wx::KeyEvent::HasModifiers

   bool HasModifiers() const

   Returns true if either CTRL or ALT keys was down at the time of the
   key event. Note that this function does not take into account neither
   SHIFT nor META key states (the reason for ignoring the latter is that
   it is common for NUMLOCK key to be configured as META under X but the
   key presses even while NUMLOCK is on should be still processed
   normally).

=head2 Wx::KeyEvent::MetaDown

   bool MetaDown() const

   Returns true if the Meta key was down at the time of the key event.

   Notice that GetModifiers is easier to use correctly than this function
   so you should consider using it in new code.

=head2 Wx::KeyEvent::ShiftDown

   bool ShiftDown() const

   Returns true if the shift key was down at the time of the key event.

   Notice that GetModifiers is easier to use correctly than this function
   so you should consider using it in new code.

=head1 Wx::LayoutAlgorithm

=head2 Wx::LayoutAlgorithm::new

   wxLayoutAlgorithm()

   Default constructor.

=head2 Wx::LayoutAlgorithm::DESTROY

   ~wxLayoutAlgorithm()

   Destructor.

=head2 Wx::LayoutAlgorithm::LayoutFrame

   bool LayoutFrame(wxFrame* frame, wxWindow* mainWindow = NULL) const

   Lays out the children of a normal frame. mainWindow is set to occupy
   the remaining space.

   This function simply calls wxLayoutAlgorithm::LayoutWindow.

=head2 Wx::LayoutAlgorithm::LayoutMDIFrame

   bool LayoutMDIFrame(wxMDIParentFrame* frame, wxRect* rect = NULL)
   const

   Lays out the children of an MDI parent frame. If rect is non-NULL, the
   given rectangle will be used as a starting point instead of the
   frame's client area.

   The MDI client window is set to occupy the remaining space.

=head2 Wx::LayoutAlgorithm::LayoutWindow

   bool LayoutWindow(wxWindow* parent, wxWindow* mainWindow = NULL) const

   Lays out the children of a normal frame or other window.

   mainWindow is set to occupy the remaining space. If this is not
   specified, then the last window that responds to a calculate layout
   event in query mode will get the remaining space (that is, a non-query
   OnCalculateLayout event will not be sent to this window and the window
   will be set to the remaining size).

=head1 Wx::LayoutConstraints

=head2 Wx::LayoutConstraints::new

   wxLayoutConstraints()

   Constructor.

=head2 Wx::LayoutConstraints::bottom

   wxIndividualLayoutConstraint bottom

   Constraint for the bottom edge.

=head2 Wx::LayoutConstraints::centreX

   wxIndividualLayoutConstraint centreX

   Constraint for the horizontal centre point.

=head2 Wx::LayoutConstraints::centreY

   wxIndividualLayoutConstraint centreY

   Constraint for the vertical centre point.

=head2 Wx::LayoutConstraints::height

   wxIndividualLayoutConstraint height

   Constraint for the height.

=head2 Wx::LayoutConstraints::left

   wxIndividualLayoutConstraint left

   Constraint for the left-hand edge.

=head2 Wx::LayoutConstraints::right

   wxIndividualLayoutConstraint right

   Constraint for the right-hand edge.

=head2 Wx::LayoutConstraints::top

   wxIndividualLayoutConstraint top

   Constraint for the top edge.

=head2 Wx::LayoutConstraints::width

   wxIndividualLayoutConstraint width

   Constraint for the width.

=head1 Wx::List&lt;T&gt;

=head2 Wx::List&lt;T&gt;::new

   wxList<T>()

   wxList<T>(size_t count, T *elements[])

   Constructors.

=head2 Wx::List&lt;T&gt;::DESTROY

   ~wxList<T>()

   Destroys the list, but does not delete the objects stored in the list
   unless you called DeleteContents(true ).

=head2 Wx::List&lt;T&gt;::Append

   wxList<T>::compatibility_iterator Append(T *object)

   Appends the pointer to object to the list.

=head2 Wx::List&lt;T&gt;::Clear

   void Clear()

   Clears the list, but does not delete the objects stored in the list
   unless you called DeleteContents(true ).

=head2 Wx::List&lt;T&gt;::DeleteContents

   void DeleteContents(bool destroy)

   If destroy is true, instructs the list to call delete on objects
   stored in the list whenever they are removed. The default is false.

=head2 Wx::List&lt;T&gt;::DeleteNode

   bool DeleteNode(const compatibility_iterator&iter)

   Deletes the given element refered to by iter from the list, returning
   true if successful.

=head2 Wx::List&lt;T&gt;::DeleteObject

   bool DeleteObject(T *object)

   Finds the given object and removes it from the list, returning true if
   successful. The application must delete the actual object separately.

=head2 Wx::List&lt;T&gt;::Erase

   void Erase(const compatibility_iterator&iter)

   Removes element refered to be iter.

=head2 Wx::List&lt;T&gt;::Find

   wxList<T>::compatibility_iterator Find(T * object) const

   Returns the iterator refering to object or NULL if none found.

=head2 Wx::List&lt;T&gt;::GetCount

   size_t GetCount() const

   Returns the number of elements in the list.

=head2 Wx::List&lt;T&gt;::GetFirst

   wxList<T>::compatibility_iterator GetFirst() const

   Returns the first iterator in the list (NULL if the list is empty).

=head2 Wx::List&lt;T&gt;::GetLast

   wxList<T>::compatibility_iterator GetLast() const

   Returns the last iterator in the list (NULL if the list is empty).

=head2 Wx::List&lt;T&gt;::IndexOf

   int IndexOf(T* obj ) const

   Returns the index of obj within the list or wxNOT_FOUND if obj is not
   found in the list.

=head2 Wx::List&lt;T&gt;::Insert

   wxList<T>::compatibility_iterator Insert(T *object)

   Insert object at the front of list.

   wxList<T>::compatibility_iterator Insert(size_t position, T *object)

   Insert object before position, i.e. the index of the new item in the
   list will be equal to position. position should be less than or equal
   to GetCount; if it is equal to it, this is the same as calling Append.

   wxList<T>::compatibility_iterator Insert(compatibility_iteratoriter, T
   *object)

   Inserts the object before the object refered to be iter.

=head2 Wx::List&lt;T&gt;::IsEmpty

   bool IsEmpty() const

   Returns true if the list is empty, false otherwise.

=head2 Wx::List&lt;T&gt;::Item

   wxList<T>::compatibility_iterator Item(size_t index) const

   Returns the iterator refering to the object at the given index in the
   list.

=head2 Wx::List&lt;T&gt;::Member

   wxList<T>::compatibility_iterator Member(T * object) const

   NB: This function is deprecated, use Find instead.

=head2 Wx::List&lt;T&gt;::Nth

   wxList<T>::compatibility_iterator Nth(int n) const

   NB: This function is deprecated, use Item instead.

   Returns the nth node in the list, indexing from zero (NULL if the list
   is empty or the nth node could not be found).

=head2 Wx::List&lt;T&gt;::Number

   int Number() const

   NB: This function is deprecated, use GetCount instead.

   Returns the number of elements in the list.

=head2 Wx::List&lt;T&gt;::Sort

   void Sort(wxSortCompareFunction compfunc)

     // Type of compare function for list sort operation (as in 'qsort')
     typedef int (*wxSortCompareFunction)(const void *elem1, const void *elem2);

   Allows the sorting of arbitrary lists by giving a function to compare
   two list elements. We use the system qsort function for the actual
   sorting process.

=head2 Wx::List&lt;T&gt;::assign

   void assign(const_iterator first, const const_iterator& last)

=head2 Wx::List&lt;T&gt;::back

   reference back()

   const_reference back() const

   Returns the last item of the list.

=head2 Wx::List&lt;T&gt;::begin

   iterator begin()

   const_iterator begin() const

   Returns a (const) iterator pointing to the beginning of the list.

=head2 Wx::List&lt;T&gt;::clear

   void clear()

   Removes all items from the list.

=head2 Wx::List&lt;T&gt;::empty

   bool empty() const

   Returns true if the list is empty.

=head2 Wx::List&lt;T&gt;::end

   iterator end()

   const_iterator end() const

   Returns a (const) iterator pointing at the end of the list.

=head2 Wx::List&lt;T&gt;::erase

   iterator erase(const iterator& it)

   Erases the item pointed to by it.

   iterator erase(const iterator& first, const iterator& last)

   Erases the items from first to last.

=head2 Wx::List&lt;T&gt;::front

   reference front()

   const_reference front() const

   Returns the first item in the list.

=head2 Wx::List&lt;T&gt;::insert

   iterator insert(const iterator& it, const_reference v = value_type())

   void insert(const iterator& it, size_type n, const_reference v =
   value_type())

   void insert(const iterator& it, const_iterator first, const
   const_iterator& last)

   Inserts an item (or several) at the given position.

=head2 Wx::List&lt;T&gt;::max_size

   size_type max_size() const

   Returns the largest possible size of the list.

=head2 Wx::List&lt;T&gt;::pop_back

   void pop_back()

   Removes the list item.

=head2 Wx::List&lt;T&gt;::pop_front

   void pop_front()

   Removes the first item.

=head2 Wx::List&lt;T&gt;::push_back

   void push_back(const_reference v = value_type())

   Adds an item to end of the list.

=head2 Wx::List&lt;T&gt;::push_front

   void push_front(const_reference v = value_type())

   Adds an item to the front of the list.

=head2 Wx::List&lt;T&gt;::rbegin

   reverse_iterator rbegin()

   const_reverse_iterator rbegin() const

   Returns a (const) reverse iterator pointer to the beginning of the
   reversed list.

=head2 Wx::List&lt;T&gt;::remove

   void remove(const_reference v)

   Removes an item from the list.

=head2 Wx::List&lt;T&gt;::rend

   reverse_iterator rend()

   const_reverse_iterator rend() const

   Returns a (const) reverse iterator pointer to the end of the reversed
   list.

=head2 Wx::List&lt;T&gt;::resize

   void resize(size_type n, value_type v = value_type())

   Resizes the list. If the the list is enlarges items with the value v
   are appended to the list.

=head2 Wx::List&lt;T&gt;::reverse

   void reverse()

   Reverses the list.

=head2 Wx::List&lt;T&gt;::size

   size_type size() const

   Returns the size of the list.

=head2 Wx::List&lt;T&gt;::splice

   void splice(const iterator& it, wxList<T>& l)

   void splice(const iterator& it, wxList<T>& l, const iterator& first)

   void splice(const iterator& it, wxList<T>& l, const iterator& first,
   const iterator& last)

   Moves part of the list into another list, starting from first and
   ending at last if specified.

=head1 Wx::ListBox

=head2 Wx::ListBox::new

   wxListBox()

   Default constructor.

   wxListBox(wxWindow* parent, wxWindowID id, const wxPoint& pos =
   wxDefaultPosition, const wxSize& size = wxDefaultSize, int n = 0,
   const wxString choices[] = NULL, long style = 0, const wxValidator&
   validator = wxDefaultValidator, const wxString& name = "listBox")

   wxListBox(wxWindow* parent, wxWindowID id, const wxPoint& pos, const
   wxSize& size, const wxArrayString& choices, long style = 0, const
   wxValidator& validator = wxDefaultValidator, const wxString& name =
   "listBox")

   Constructor, creating and showing a list box.

   Parameters

   parent

       Parent window. Must not be NULL.

   id  

       Window identifier. A value of -1 indicates a default value.

   pos 

       Window position.

   size

       Window size. If the default size (-1, -1) is specified then the
       window is sized appropriately.

   n   

       Number of strings with which to initialise the control.

   choices

       An array of strings with which to initialise the control.

   style

       Window style. See wxListBox.

   validator

       Window validator.

   name

       Window name.

   See also

   wxListBox::Create, wxValidator

   wxPython note: The wxListBox constructor in wxPython reduces the n and
   choices arguments are to a single argument, which is a list of
   strings.

   wxPerl note: In wxPerl there is just an array reference in place of n
   and choices.

=head2 Wx::ListBox::DESTROY

   void ~wxListBox()

   Destructor, destroying the list box.

=head2 Wx::ListBox::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxPoint& pos =
   wxDefaultPosition, const wxSize& size = wxDefaultSize, int n, const
   wxString choices[] = NULL, long style = 0, const wxValidator&
   validator = wxDefaultValidator, const wxString& name = "listBox")

   bool Create(wxWindow* parent, wxWindowID id, const wxPoint& pos, const
   wxSize& size, const wxArrayString& choices, long style = 0, const
   wxValidator& validator = wxDefaultValidator, const wxString& name =
   "listBox")

   Creates the listbox for two-step construction. See
   wxListBox::wxListBox for further details.

=head2 Wx::ListBox::Deselect

   void Deselect(int n)

   Deselects an item in the list box.

   Parameters

   n   

       The zero-based item to deselect.

   Remarks

   This applies to multiple selection listboxes only.

=head2 Wx::ListBox::GetSelections

   int GetSelections(wxArrayInt& selections) const

   Fill an array of ints with the positions of the currently selected
   items.

   Parameters

   selections

       A reference to an wxArrayInt instance that is used to store the
       result of the query.

   Return value

   The number of selections.

   Remarks

   Use this with a multiple selection listbox.

   See also

   wxControlWithItems::GetSelection,
   wxControlWithItems::GetStringSelection,
   wxControlWithItems::SetSelection

   wxPython note: The wxPython version of this method takes no parameters
   and returns a tuple of the selected items.

   wxPerl note: In wxPerl this method takes no parameters and return the
   selected items as a list.

=head2 Wx::ListBox::InsertItems

   void InsertItems(int nItems, const wxString *items, unsigned int pos)

   void InsertItems(const wxArrayString& nItems, unsigned int pos)

   Insert the given number of strings before the specified position.

   Parameters

   nItems

       Number of items in the array items

   items

       Labels of items to be inserted

   pos 

       Position before which to insert the items: for example, if pos is
       0 the items will be inserted in the beginning of the listbox

   wxPython note: The first two parameters are collapsed into a single
   parameter for wxPython, which is a list of strings.

   wxPerl note: In wxPerl there is just an array reference in place of
   nItems and items.

=head2 Wx::ListBox::HitTest

   int HitTest(const wxPoint point) const

   Returns the item located at point, or wxNOT_FOUND if there is no item
   located at point.

   This function is new since wxWidgets version 2.7.0. It is currently
   implemented for wxMSW, wxMac and wxGTK2 ports.

   Parameters

   point

       Point of item (in client coordinates) to obtain

   Return value

   Item located at point, or wxNOT_FOUND if unimplemented or the item
   does not exist.

=head2 Wx::ListBox::IsSelected

   bool IsSelected(int n) const

   Determines whether an item is selected.

   Parameters

   n   

       The zero-based item index.

   Return value

   true if the given item is selected, false otherwise.

=head2 Wx::ListBox::Set

   void Set(int n, const wxString* choices, void **clientData = NULL)

   void Set(const wxArrayString& choices, void **clientData = NULL)

   Clears the list box and adds the given strings to it.

   Parameters

   n   

       The number of strings to set.

   choices

       An array of strings to set.

   clientData

       Options array of client data pointers

   Remarks

   You may free the array from the calling program after this function
   has been called.

=head2 Wx::ListBox::SetFirstItem

   void SetFirstItem(int n)

   void SetFirstItem(const wxString& string)

   Set the specified item to be the first visible item.

   Parameters

   n   

       The zero-based item index.

   string

       The string that should be visible.

=head1 Wx::ListCtrl

=head2 Wx::ListCtrl::new

   wxListCtrl()

   Default constructor.

   wxListCtrl(wxWindow* parent, wxWindowID id, const wxPoint& pos =
   wxDefaultPosition, const wxSize& size = wxDefaultSize, long style =
   wxLC_ICON, const wxValidator& validator = wxDefaultValidator, const
   wxString& name = wxListCtrlNameStr)

   Constructor, creating and showing a list control.

   Parameters

   parent

       Parent window. Must not be NULL.

   id  

       Window identifier. A value of -1 indicates a default value.

   pos 

       Window position.

   size

       Window size. If the default size (-1, -1) is specified then the
       window is sized appropriately.

   style

       Window style. See wxListCtrl.

   validator

       Window validator.

   name

       Window name.

   See also

   wxListCtrl::Create, wxValidator

=head2 Wx::ListCtrl::DESTROY

   void ~wxListCtrl()

   Destructor, destroying the list control.

=head2 Wx::ListCtrl::Arrange

   bool Arrange(int flag = wxLIST_ALIGN_DEFAULT)

   Arranges the items in icon or small icon view. This only has effect on
   Win32. flag is one of:

=head2 Wx::ListCtrl::AssignImageList

   void AssignImageList(wxImageList* imageList, int which)

   Sets the image list associated with the control and takes ownership of
   it (i.e. the control will, unlike when using SetImageList, delete the
   list when destroyed). which is one of wxIMAGE_LIST_NORMAL,
   wxIMAGE_LIST_SMALL, wxIMAGE_LIST_STATE (the last is unimplemented).

   See also

   wxListCtrl::SetImageList

=head2 Wx::ListCtrl::ClearAll

   void ClearAll()

   Deletes all items and all columns.

=head2 Wx::ListCtrl::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxPoint& pos =
   wxDefaultPosition, const wxSize& size = wxDefaultSize, long style =
   wxLC_ICON, const wxValidator& validator = wxDefaultValidator, const
   wxString& name = wxListCtrlNameStr)

   Creates the list control. See wxListCtrl::wxListCtrl for further
   details.

=head2 Wx::ListCtrl::DeleteAllItems

   bool DeleteAllItems()

   Deletes all items in the list control.

   NB: This function does not send the wxEVT_COMMAND_LIST_DELETE_ITEM
   event because deleting many items from the control would be too slow
   then (unlike DeleteItem).

=head2 Wx::ListCtrl::DeleteColumn

   bool DeleteColumn(int col)

   Deletes a column.

=head2 Wx::ListCtrl::DeleteItem

   bool DeleteItem(long item)

   Deletes the specified item. This function sends the
   wxEVT_COMMAND_LIST_DELETE_ITEM event for the item being deleted.

   See also: DeleteAllItems

=head2 Wx::ListCtrl::EditLabel

   void EditLabel(long item)

   Starts editing the label of the given item. This function generates a
   EVT_LIST_BEGIN_LABEL_EDIT event which can be vetoed so that no text
   control will appear for in-place editing.

   If the user changed the label (i.e. s/he does not press ESC or leave
   the text control without changes, a EVT_LIST_END_LABEL_EDIT event will
   be sent which can be vetoed as well.

=head2 Wx::ListCtrl::EnsureVisible

   bool EnsureVisible(long item)

   Ensures this item is visible.

=head2 Wx::ListCtrl::FindItem

   long FindItem(long start, const wxString& str, const bool partial =
   false)

   Find an item whose label matches this string, starting from start or
   the beginning if start is -1. The string comparison is case
   insensitive. If partial is true then this method will look for items
   which begin with str.

   long FindItem(long start, long data)

   Find an item whose data matches this data, starting from start or the
   beginning if 'start' is -1.

   long FindItem(long start, const wxPoint& pt, int direction)

   Find an item nearest this position in the specified direction,
   starting from start or the beginning if start is -1.

   wxPython note: In place of a single overloaded method name, wxPython
   implements the following methods:

=head2 Wx::ListCtrl::GetColumn

   bool GetColumn(int col, wxListItem& item) const

   Gets information about this column. See wxListCtrl::SetItem for more
   information.

   wxPerl note: In wxPerl this method takes only the col parameter and
   returns a Wx::ListItem ( or undef ).

=head2 Wx::ListCtrl::GetColumnCount

   int GetColumnCount() const

   Returns the number of columns.

=head2 Wx::ListCtrl::GetColumnWidth

   int GetColumnWidth(int col) const

   Gets the column width (report view only).

=head2 Wx::ListCtrl::GetCountPerPage

   int GetCountPerPage() const

   Gets the number of items that can fit vertically in the visible area
   of the list control (list or report view) or the total number of items
   in the list control (icon or small icon view).

=head2 Wx::ListCtrl::GetEditControl

   wxTextCtrl * GetEditControl() const

   Returns the edit control being currently used to edit a label. Returns
   NULL if no label is being edited.

   NB: It is currently only implemented for wxMSW and the generic
   version, not for the native Mac OS X version.

=head2 Wx::ListCtrl::GetImageList

   wxImageList* GetImageList(int which) const

   Returns the specified image list. which may be one of:

=head2 Wx::ListCtrl::GetItem

   bool GetItem(wxListItem& info) const

   Gets information about the item. See wxListCtrl::SetItem for more
   information.

   You must call info.SetId() to the ID of item you're interested in
   before calling this method.

   wxPython note: The wxPython version of this method takes an integer
   parameter for the item ID, an optional integer for the column number,
   and returns the wxListItem object.

   wxPerl note: In wxPerl this method takes as parameter the ID of the
   item and ( optionally ) the column, and returns a Wx::ListItem object.

=head2 Wx::ListCtrl::GetItemBackgroundColour

   wxColour GetItemBackgroundColour(long item) const

   Returns the colour for this item. If the item has no specific colour,
   returns an invalid colour (and not the default background control of
   the control itself).

   See also

   GetItemTextColour

=head2 Wx::ListCtrl::GetItemCount

   int GetItemCount() const

   Returns the number of items in the list control.

=head2 Wx::ListCtrl::GetItemData

   long GetItemData(long item) const

   Gets the application-defined data associated with this item.

=head2 Wx::ListCtrl::GetItemFont

   wxFont GetItemFont(long item) const

   Returns the item's font.

=head2 Wx::ListCtrl::GetItemPosition

   bool GetItemPosition(long item, wxPoint& pos) const

   Returns the position of the item, in icon or small icon view.

   wxPython note: The wxPython version of this method accepts only the
   item ID and returns the wxPoint.

   wxPerl note: In wxPerl this method takes only the item parameter and
   returns a Wx::Point ( or undef ).

=head2 Wx::ListCtrl::GetItemRect

   bool GetItemRect(long item, wxRect& rect, int code =
   wxLIST_RECT_BOUNDS) const

   Returns the rectangle representing the item's size and position, in
   physical coordinates.

   code is one of wxLIST_RECT_BOUNDS, wxLIST_RECT_ICON,
   wxLIST_RECT_LABEL.

   wxPython note: The wxPython version of this method accepts only the
   item ID and code and returns the wxRect.

   wxPerl note: In wxPerl this method takes only the item parameter and
   returns a Wx::Rect ( or undef ).

=head2 Wx::ListCtrl::GetSubItemRect

   bool GetSubItemRect(long item, long subItem, wxRect& rect, int code =
   wxLIST_RECT_BOUNDS) const

   Returns the rectangle representing the size and position, in physical
   coordinates, of the given subitem, i.e. the part of the row item in
   the column subItem.

   This method is only meaningfull when the wxListCtrl is in the report
   mode. If subItem parameter is equal to the special value
   wxLIST_GETSUBITEMRECT_WHOLEITEM the return value is the same as for
   GetItemRect.

   code can be one of wxLIST_RECT_BOUNDS, wxLIST_RECT_ICON or
   wxLIST_RECT_LABEL.

   This function is new since wxWidgets version 2.7.0

=head2 Wx::ListCtrl::GetItemSpacing

   wxSize GetItemSpacing() const

   Retrieves the spacing between icons in pixels: horizontal spacing is
   returned as x component of the wxSize object and the vertical spacing
   as its y component.

=head2 Wx::ListCtrl::GetItemState

   int GetItemState(long item, long stateMask) const

   Gets the item state. For a list of state flags, see
   wxListCtrl::SetItem.

   The stateMask indicates which state flags are of interest.

=head2 Wx::ListCtrl::GetItemText

   wxString GetItemText(long item) const

   Gets the item text for this item.

=head2 Wx::ListCtrl::GetItemTextColour

   wxColour GetItemTextColour(long item) const

   Returns the colour for this item. If the item has no specific colour,
   returns an invalid colour (and not the default foreground control of
   the control itself as this wouldn't allow distinguishing between items
   having the same colour as the current control foreground and items
   with default colour which, hence, have always the same colour as the
   control).

=head2 Wx::ListCtrl::GetNextItem

   long GetNextItem(long item, int geometry = wxLIST_NEXT_ALL, int state
   = wxLIST_STATE_DONTCARE) const

   Searches for an item with the given geometry or state, starting from
   item but excluding the item itself. If item is -1, the first item that
   matches the specified flags will be returned.

   Returns the first item with given state following item or -1 if no
   such item found.

   This function may be used to find all selected items in the control
   like this:

       long item = -1;
       for ( ;; )
       {
           item = listctrl->GetNextItem(item,
                                        wxLIST_NEXT_ALL,
                                        wxLIST_STATE_SELECTED);
           if ( item == -1 )
               break;

=head2 Wx::ListCtrl::GetSelectedItemCount

   int GetSelectedItemCount() const

   Returns the number of selected items in the list control.

=head2 Wx::ListCtrl::GetTextColour

   wxColour GetTextColour() const

   Gets the text colour of the list control.

=head2 Wx::ListCtrl::GetTopItem

   long GetTopItem() const

   Gets the index of the topmost visible item when in list or report
   view.

=head2 Wx::ListCtrl::GetViewRect

   wxRect GetViewRect() const

   Returns the rectangle taken by all items in the control. In other
   words, if the controls client size were equal to the size of this
   rectangle, no scrollbars would be needed and no free space would be
   left.

   Note that this function only works in the icon and small icon views,
   not in list or report views (this is a limitation of the native Win32
   control).

=head2 Wx::ListCtrl::HitTest

   long HitTest(const wxPoint& point, int& flags, long *ptrSubItem) const

   Determines which item (if any) is at the specified point, giving
   details in flags. Returns index of the item or wxNOT_FOUND if no item
   is at the specified point. flags will be a combination of the
   following flags:

=head2 Wx::ListCtrl::InsertColumn

   long InsertColumn(long col, wxListItem& info)

   long InsertColumn(long col, const wxString& heading, int format =
   wxLIST_FORMAT_LEFT, int width = -1)

   For report view mode (only), inserts a column. For more details, see
   wxListCtrl::SetItem.

   wxPython note: In place of a single overloaded method name, wxPython
   implements the following methods:

=head2 Wx::ListCtrl::InsertItem

   long InsertItem(wxListItem& info)

   Inserts an item, returning the index of the new item if successful, -1
   otherwise.

   long InsertItem(long index, const wxString& label)

   Inserts a string item.

   long InsertItem(long index, int imageIndex)

   Inserts an image item.

   long InsertItem(long index, const wxString& label, int imageIndex)

   Insert an image/string item.

   Parameters

   info

       wxListItem object

   index

       Index of the new item, supplied by the application

   label

       String label

   imageIndex

       index into the image list associated with this control and view
       style

   wxPython note: In place of a single overloaded method name, wxPython
   implements the following methods:

=head2 Wx::ListCtrl::OnGetItemAttr

   virtual wxListItemAttr * OnGetItemAttr(long item) const

   This function may be overloaded in the derived class for a control
   with wxLC_VIRTUAL style. It should return the attribute for the for
   the specified item or NULL to use the default appearance parameters.

   wxListCtrl will not delete the pointer or keep a reference of it. You
   can return the same wxListItemAttr pointer for every OnGetItemAttr
   call.

   The base class version always returns NULL.

   See also

   OnGetItemImage,

=head2 Wx::ListCtrl::OnGetItemImage

   virtual int OnGetItemImage(long item) const

   This function must be overloaded in the derived class for a control
   with wxLC_VIRTUAL style having an image list (if the control doesn't
   have an image list, it is not necessary to overload it). It should
   return the index of the items image in the controls image list or -1
   for no image. In a control with wxLC_REPORT style, OnGetItemImage only
   gets called for the first column of each line.

   The base class version always returns -1.

   See also

   OnGetItemText,

=head2 Wx::ListCtrl::OnGetItemColumnImage

   virtual int OnGetItemColumnImage(long item, long column) const

   Overload this function in the derived class for a control with
   wxLC_VIRTUAL and wxLC_REPORT styles in order to specify the image
   index for the given line and column.

   The base class version always calls OnGetItemImage for the first
   column, else it returns -1.

   See also

   OnGetItemText,

=head2 Wx::ListCtrl::OnGetItemText

   virtual wxString OnGetItemText(long item, long column) const

   This function must be overloaded in the derived class for a control
   with wxLC_VIRTUAL style. It should return the string containing the
   text of the given column for the specified item.

   See also

   SetItemCount,

=head2 Wx::ListCtrl::RefreshItem

   void RefreshItem(long item)

   Redraws the given item. This is only useful for the virtual list
   controls as without calling this function the displayed value of the
   item doesn't change even when the underlying data does change.

   See also

   RefreshItems

=head2 Wx::ListCtrl::RefreshItems

   void RefreshItems(long itemFrom, long itemTo)

   Redraws the items between itemFrom and itemTo. The starting item must
   be less than or equal to the ending one.

   Just as RefreshItem this is only useful for virtual list controls.

=head2 Wx::ListCtrl::ScrollList

   bool ScrollList(int dx, int dy)

   Scrolls the list control. If in icon, small icon or report view mode,
   dx specifies the number of pixels to scroll. If in list view mode, dx
   specifies the number of columns to scroll. dy always specifies the
   number of pixels to scroll vertically.

   NB: This method is currently only implemented in the Windows version.

=head2 Wx::ListCtrl::SetBackgroundColour

   void SetBackgroundColour(const wxColour& col)

   Sets the background colour (GetBackgroundColour already implicit in
   wxWindow class).

=head2 Wx::ListCtrl::SetColumn

   bool SetColumn(int col, wxListItem& item)

   Sets information about this column. See wxListCtrl::SetItem for more
   information.

=head2 Wx::ListCtrl::SetColumnWidth

   bool SetColumnWidth(int col, int width)

   Sets the column width.

   width can be a width in pixels or wxLIST_AUTOSIZE (-1) or
   wxLIST_AUTOSIZE_USEHEADER (-2). wxLIST_AUTOSIZE will resize the column
   to the length of its longest item. wxLIST_AUTOSIZE_USEHEADER will
   resize the column to the length of the header (Win32) or 80 pixels
   (other platforms).

   In small or normal icon view, col must be -1, and the column width is
   set for all columns.

=head2 Wx::ListCtrl::SetImageList

   void SetImageList(wxImageList* imageList, int which)

   Sets the image list associated with the control. which is one of
   wxIMAGE_LIST_NORMAL, wxIMAGE_LIST_SMALL, wxIMAGE_LIST_STATE (the last
   is unimplemented).

   This method does not take ownership of the image list, you have to
   delete it yourself.

   See also

   wxListCtrl::AssignImageList

=head2 Wx::ListCtrl::SetItem

   bool SetItem(wxListItem& info)

   long SetItem(long index, int col, const wxString& label, int imageId =
   -1)

   Sets information about the item.

   wxListItem is a class with the following members:

=head2 Wx::ListCtrl::SetItemBackgroundColour

   void SetItemBackgroundColour(long item, const wxColour& col)

   Sets the background colour for this item. This function only works in
   report view.

   The colour can be retrieved using GetItemBackgroundColour.

=head2 Wx::ListCtrl::SetItemCount

   void SetItemCount(long count)

   This method can only be used with virtual list controls. It is used to
   indicate to the control the number of items it contains. After calling
   it, the main program should be ready to handle calls to various item
   callbacks (such as OnGetItemText) for all items in the range from 0 to
   count.

=head2 Wx::ListCtrl::SetItemData

   bool SetItemData(long item, long data)

   Associates application-defined data with this item.

   Notice that this function cannot be used to associate pointers with
   the control items, use SetItemPtrData instead.

=head2 Wx::ListCtrl::SetItemFont

   void SetItemFont(long item, const wxFont& font)

   Sets the item's font.

=head2 Wx::ListCtrl::SetItemImage

   bool SetItemImage(long item, int image)

   Sets the image associated with the item. The image is an index into
   the image list associated with the list control. In report view, this
   only sets the image for the first column.

   bool SetItemImage(long item, int image, int selImage)

   Sets the unselected and selected images associated with the item. The
   images are indices into the image list associated with the list
   control. This form is deprecated: selImage is not used.

=head2 Wx::ListCtrl::SetItemColumnImage

   bool SetItemImage(long item, long columnint image)

   Sets the image associated with the item. In report view, you can
   specify the column. The image is an index into the image list
   associated with the list control.

=head2 Wx::ListCtrl::SetItemPosition

   bool SetItemPosition(long item, const wxPoint& pos)

   Sets the position of the item, in icon or small icon view. Windows
   only.

=head2 Wx::ListCtrl::SetItemPtrData

   bool SetItemPtrData(long item, wxUIntPtr data)

   Associates application-defined data with this item. The data parameter
   may be either an integer or a pointer cast to the wxUIntPtr type which
   is guaranteed to be large enough to be able to contain all integer
   types and pointers.

   This function is new since wxWidgets version 2.8.4

=head2 Wx::ListCtrl::SetItemState

   bool SetItemState(long item, long state, long stateMask)

   Sets the item state. For a list of state flags, see
   wxListCtrl::SetItem.

   The stateMask indicates which state flags are valid.

=head2 Wx::ListCtrl::SetItemText

   void SetItemText(long item, const wxString& text)

   Sets the item text for this item.

=head2 Wx::ListCtrl::SetItemTextColour

   void SetItemTextColour(long item, const wxColour& col)

   Sets the colour for this item. This function only works in report
   view.

   The colour can be retrieved using GetItemTextColour.

=head2 Wx::ListCtrl::SetSingleStyle

   void SetSingleStyle(long style, const bool add = true)

   Adds or removes a single window style.

=head2 Wx::ListCtrl::SetTextColour

   void SetTextColour(const wxColour& col)

   Sets the text colour of the list control.

=head2 Wx::ListCtrl::SetWindowStyleFlag

   void SetWindowStyleFlag(long style)

   Sets the whole window style, deleting all items.

=head2 Wx::ListCtrl::SortItems

   bool SortItems(wxListCtrlCompare fnSortCallBack, long data)

   Call this function to sort the items in the list control. Sorting is
   done using the specified fnSortCallBack function. This function must
   have the following prototype:

   int wxCALLBACK wxListCompareFunction(long item1, long item2, long sortData)

   It is called each time when the two items must be compared and should
   return 0 if the items are equal, negative value if the first item is
   less than the second one and positive value if the first one is
   greater than the second one (the same convention as used by qsort(3)).

   Parameters

   item1

       client data associated with the first item (NOT the index).

   item2

       client data associated with the second item (NOT the index).

   data

       the value passed to SortItems() itself.

   Notice that the control may only be sorted on client data associated
   with the items, so you must use SetItemData if you want to be able to
   sort the items in the control.

   Please see the listctrl sample for an example of using this function.

   wxPython note: wxPython uses the sortData parameter to pass the Python
   function to call, so it is not available for programmer use. Call
   SortItems with a reference to a callable object that expects two
   parameters.

   wxPerl note: In wxPerl the comparison function must take just two
   parameters; however, you may use a closure to achieve an effect
   similar to the SortItems third parameter.

=head1 Wx::ListEvent

=head2 Wx::ListEvent::new

   wxListEvent(WXTYPE commandType = 0, int id = 0)

   Constructor.

=head2 Wx::ListEvent::GetCacheFrom

   long GetCacheFrom() const

   For EVT_LIST_CACHE_HINT event only: return the first item which the
   list control advises us to cache.

=head2 Wx::ListEvent::GetCacheTo

   long GetCacheTo() const

   For EVT_LIST_CACHE_HINT event only: return the last item (inclusive)
   which the list control advises us to cache.

=head2 Wx::ListEvent::GetKeyCode

   int GetKeyCode() const

   Key code if the event is a keypress event.

=head2 Wx::ListEvent::GetIndex

   long GetIndex() const

   The item index.

=head2 Wx::ListEvent::GetColumn

   int GetColumn() const

   The column position: it is only used with COL events. For the column
   dragging events, it is the column to the left of the divider being
   dragged, for the column click events it may be -1 if the user clicked
   in the list control header outside any column.

=head2 Wx::ListEvent::GetPoint

   wxPoint GetPoint() const

   The position of the mouse pointer if the event is a drag event.

=head2 Wx::ListEvent::GetLabel

   const wxString& GetLabel() const

   The (new) item label for EVT_LIST_END_LABEL_EDIT event.

=head2 Wx::ListEvent::GetText

   const wxString& GetText() const

   The text.

=head2 Wx::ListEvent::GetImage

   int GetImage() const

   The image.

=head2 Wx::ListEvent::GetData

   long GetData() const

   The data.

=head2 Wx::ListEvent::GetMask

   long GetMask() const

   The mask.

=head2 Wx::ListEvent::GetItem

   const wxListItem& GetItem() const

   An item object, used by some events. See also wxListCtrl::SetItem.

=head2 Wx::ListEvent::IsEditCancelled

   bool IsEditCancelled() const

   This method only makes sense for EVT_LIST_END_LABEL_EDIT message and
   returns true if it the label editing has been cancelled by the user (GetLabel
   returns an empty string in this case but it doesn't allow the
   application to distinguish between really cancelling the edit and the
   admittedly rare case when the user wants to rename it to an empty
   string).

=head1 Wx::ListItem

=head2 Wx::ListItem::new

   wxListItem()

   Constructor.

=head2 Wx::ListItem::Clear

   void Clear()

   Resets the item state to the default.

=head2 Wx::ListItem::GetAlign

   wxListColumnFormat GetAlign() const

   Returns the alignment for this item. Can be one of wxLIST_FORMAT_LEFT,
   wxLIST_FORMAT_RIGHT or wxLIST_FORMAT_CENTRE.

=head2 Wx::ListItem::GetBackgroundColour

   wxColour GetBackgroundColour() const

   Returns the background colour for this item.

=head2 Wx::ListItem::GetColumn

   int GetColumn() const

   Returns the zero-based column; meaningful only in report mode.

=head2 Wx::ListItem::GetData

   long GetData() const

   Returns client data associated with the control. Please note that
   client data is associated with the item and not with subitems.

=head2 Wx::ListItem::GetFont

   wxFont GetFont() const

   Returns the font used to display the item.

=head2 Wx::ListItem::GetId

   long GetId() const

   Returns the zero-based item position.

=head2 Wx::ListItem::GetImage

   int GetImage() const

   Returns the zero-based index of the image associated with the item
   into the image list.

=head2 Wx::ListItem::GetMask

   long GetMask() const

   Returns a bit mask indicating which fields of the structure are valid;
   can be any combination of the following values:

=head2 Wx::ListItem::GetState

   long GetState() const

   Returns a bit field representing the state of the item. Can be any
   combination of:

=head2 Wx::ListItem::GetText

   const wxString& GetText() const

   Returns the label/header text.

=head2 Wx::ListItem::GetTextColour

   wxColour GetTextColour() const

   Returns the text colour.

=head2 Wx::ListItem::GetWidth

   int GetWidth() const

   Meaningful only for column headers in report mode. Returns the column
   width.

=head2 Wx::ListItem::SetAlign

   void SetAlign(wxListColumnFormat align)

   Sets the alignment for the item. See also wxListItem::GetAlign

=head2 Wx::ListItem::SetBackgroundColour

   void SetBackgroundColour(const wxColour& colBack)

   Sets the background colour for the item.

=head2 Wx::ListItem::SetColumn

   void SetColumn(int col)

   Sets the zero-based column. Meaningful only in report mode.

=head2 Wx::ListItem::SetData

   void SetData(long data)

   void SetData(void* data)

   Sets client data for the item. Please note that client data is
   associated with the item and not with subitems.

=head2 Wx::ListItem::SetFont

   void SetFont(const wxFont& font)

   Sets the font for the item.

=head2 Wx::ListItem::SetId

   void SetId(long id)

   Sets the zero-based item position.

=head2 Wx::ListItem::SetImage

   void SetImage(int image)

   Sets the zero-based index of the image associated with the item into
   the image list.

=head2 Wx::ListItem::SetMask

   void SetMask(long mask)

   Sets the mask of valid fields. See wxListItem::GetMask.

=head2 Wx::ListItem::SetState

   void SetState(long state)

   Sets the item state flags (note that the valid state flags are
   influenced by the value of the state mask, see
   wxListItem::SetStateMask). See wxListItem::GetState for valid flag
   values.

=head2 Wx::ListItem::SetStateMask

   void SetStateMask(long stateMask)

   Sets the bitmask that is used to determine which of the state flags
   are to be set. See also wxListItem::SetState.

=head2 Wx::ListItem::SetText

   void SetText(const wxString& text)

   Sets the text label for the item.

=head2 Wx::ListItem::SetTextColour

   void SetTextColour(const wxColour& colText)

   Sets the text colour for the item.

=head2 Wx::ListItem::SetWidth

   void SetWidth(int width)

   Meaningful only for column headers in report mode. Sets the column
   width.

=head1 Wx::ListItemAttr

=head2 Wx::ListItemAttr::new

   wxListItemAttr()

   Default constructor.

   wxListItemAttr(const wxColour colText, const wxColour colBack, const
   wxFont font)

   Construct a wxListItemAttr with the specified foreground and
   background colors and font.

=head2 Wx::ListItemAttr::GetBackgroundColour

   const wxColour& GetBackgroundColour() const

   Returns the currently set background color.

=head2 Wx::ListItemAttr::GetFont

   const wxFont& GetFont() const

   Returns the currently set font.

=head2 Wx::ListItemAttr::GetTextColour

   const wxColour& GetTextColour() const

   Returns the currently set text color.

=head2 Wx::ListItemAttr::HasBackgroundColour

   bool HasBackgroundColour() const

   Returns true if the currently set background color is valid.

=head2 Wx::ListItemAttr::HasFont

   bool HasFont() const

   Returns true if the currently set font is valid.

=head2 Wx::ListItemAttr::HasTextColour

   bool HasTextColour() const

   Returns true if the currently set text color is valid.

=head2 Wx::ListItemAttr::SetBackgroundColour

   void SetBackgroundColour(const wxColour& colour)

   Sets a new background color.

=head2 Wx::ListItemAttr::SetFont

   void SetFont(const wxFont& font)

   Sets a new font.

=head2 Wx::ListItemAttr::SetTextColour

   void SetTextColour(const wxColour& colour)

   Sets a new text color.

=head1 Wx::ListView

=head2 Wx::ListView::ClearColumnImage

   void ClearColumnImage(int col)

   Resets the column image -- after calling this function, no image will
   be shown.

   Parameters

   col 

       the column to clear image for

   See also

   SetColumnImage

=head2 Wx::ListView::Focus

   void Focus(long index)

   Sets focus to the item with the given index.

=head2 Wx::ListView::GetFirstSelected

   long GetFirstSelected() const

   Returns the first selected item in a (presumably) multiple selection
   control. Together with GetNextSelected it can be used to iterate over
   all selected items in the control.

   Return value

   The first selected item, if any, -1 otherwise.

=head2 Wx::ListView::GetFocusedItem

   long GetFocusedItem() const

   Returns the currently focused item or -1 if none.

   See also

   IsSelected,

=head2 Wx::ListView::GetNextSelected

   long GetNextSelected(long item) const

   Used together with GetFirstSelected to iterate over all selected items
   in the control.

   Return value

   Returns the next selected item or -1 if there are no more of them.

=head2 Wx::ListView::IsSelected

   bool IsSelected(long index) const

   Returns true if the item with the given index is selected, false
   otherwise.

   See also

   GetFirstSelected,

=head2 Wx::ListView::Select

   void Select(long n, bool on = true)

   Selects or unselects the given item.

   Parameters

   n   

       the item to select or unselect

   on  

       if true (default), selects the item, otherwise unselects it

   See also

   SetItemState

=head2 Wx::ListView::SetColumnImage

   void SetColumnImage(int col, int image)

   Sets the column image for the specified column. To use the column
   images, the control must have a valid image list with at least one
   image.

   Parameters

   col 

       the column to set image for

   image

       the index of the column image in the controls image list

   See also

   ClearColumnImage,

=head1 Wx::Locale

=head2 Supported languages

   See list of recognized language constants. These constants may be used
   to specify the language in Init and are returned by GetSystemLanguage:

=head2 Wx::Locale::new

   wxLocale()

   This is the default constructor and it does nothing to initialize the
   object: Init() must be used to do that.

   wxLocale(int language, int flags = wxLOCALE_LOAD_DEFAULT |
   wxLOCALE_CONV_ENCODING)

   See Init() for parameters description.

   wxLocale(const char *szName, const char *szShort = NULL, const char
   *szLocale = NULL, bool bLoadDefault = true, bool bConvertEncoding =
   false)

   See Init() for parameters description.

   The call of this function has several global side effects which you
   should understand: first of all, the application locale is changed -
   note that this will affect many of standard C library functions such
   as printf() or strftime(). Second, this wxLocale object becomes the
   new current global locale for the application and so all subsequent
   calls to wxGetTranslation() will try to translate the messages using
   the message catalogs for this locale.

=head2 Wx::Locale::DESTROY

   ~wxLocale()

   The destructor, like the constructor, also has global side effects:
   the previously set locale is restored and so the changes described in
   Init documentation are rolled back.

=head2 Wx::Locale::AddCatalog

   bool AddCatalog(const char *szDomain)

   bool AddCatalog(const char *szDomain, wxLanguagemsgIdLanguage, const
   char *msgIdCharset)

   Add a catalog for use with the current locale: it is searched for in
   standard places (current directory first, then the system one), but
   you may also prepend additional directories to the search path with
   AddCatalogLookupPathPrefix().

   All loaded catalogs will be used for message lookup by GetString() for
   the current locale.

   Returns true if catalog was successfully loaded, false otherwise
   (which might mean that the catalog is not found or that it isn't in
   the correct format).

   The second form of this method takes two additional arguments,
   msgIdLanguage and msgIdCharset.

   msgIdLanguage specifies the language of "msgid" strings in source code
   (i.e. arguments to GetString, wxGetTranslation and the _() macro). It
   is used if AddCatalog cannot find any catalog for current language: if
   the language is same as source code language, then strings from source
   code are used instead.

   msgIdCharset lets you specify the charset used for msgids in sources
   in case they use 8-bit characters (e.g. German or French strings).
   This argument has no effect in Unicode build, because literals in
   sources are Unicode strings; you have to use compiler-specific method
   of setting the right charset when compiling with Unicode.

   By default (i.e. when you use the first form), msgid strings are
   assumed to be in English and written only using 7-bit ASCII
   characters.

   If you have to deal with non-English strings or 8-bit characters in
   the source code, see the instructions in Writing non-English
   applications.

=head2 Wx::Locale::AddCatalogLookupPathPrefix

   void AddCatalogLookupPathPrefix(const wxString& prefix)

   Add a prefix to the catalog lookup path: the message catalog files
   will be looked up under prefix/<lang>/LC_MESSAGES, prefix/<lang> and
   prefix (in this order).

   This only applies to subsequent invocations of AddCatalog().

=head2 Wx::Locale::AddLanguage

   static void AddLanguage(const wxLanguageInfo& info)

   Adds custom, user-defined language to the database of known languages.
   This database is used in conjunction with the first form of Init.

   wxLanguageInfo is defined as follows:

   struct WXDLLEXPORT wxLanguageInfo
   {
       int Language;                   // wxLanguage id
       wxString CanonicalName;         // Canonical name, e.g. fr_FR
   #ifdef __WIN32__
       wxUint32 WinLang, WinSublang;   // Win32 language identifiers
                                       // (LANG_xxxx, SUBLANG_xxxx)
   #endif
       wxString Description;           // human-readable name of the language
   };

=head2 Wx::Locale::FindLanguageInfo

   static wxLanguageInfo * FindLanguageInfo(const wxString& locale)

   This function may be used to find the language description structure
   for the given locale, specified either as a two letter ISO language
   code (for example, "pt"), a language code followed by the country code
   ("pt_BR") or a full, human readable, language description
   ("Portuguese-Brazil").

   Returns the information for the given language or NULL if this
   language is unknown. Note that even if the returned pointer is valid,
   the caller should not delete it.

   See also

   GetLanguageInfo

=head2 Wx::Locale::GetCanonicalName

   wxString GetCanonicalName() const

   Returns the canonical form of current locale name. Canonical form is
   the one that is used on UNIX systems: it is a two- or five-letter
   string in xx or xx_YY format, where xx is ISO 639 code of language and
   YY is ISO 3166 code of the country. Examples are "en", "en_GB",
   "en_US" or "fr_FR".

   This form is internally used when looking up message catalogs.

   Compare GetSysName.

=head2 Wx::Locale::GetLanguage

   int GetLanguage() const

   Returns wxLanguage constant of current language. Note that you can
   call this function only if you used the form of Init that takes
   wxLanguage argument.

=head2 Wx::Locale::GetLanguageInfo

   static wxLanguageInfo * GetLanguageInfo(int lang) const

   Returns a pointer to wxLanguageInfo structure containing information
   about the given language or NULL if this language is unknown. Note
   that even if the returned pointer is valid, the caller should not
   delete it.

   See AddLanguage for the wxLanguageInfo description.

   As with Init, wxLANGUAGE_DEFAULT has the special meaning if passed as
   an argument to this function and in this case the result of
   GetSystemLanguage() is used.

=head2 Wx::Locale::GetLanguageName

   static wxString GetLanguageName(int lang) const

   Returns English name of the given language or empty string if this
   language is unknown.

   See GetLanguageInfo for a remark about special meaning of
   wxLANGUAGE_DEFAULT.

=head2 Wx::Locale::GetLocale

   const char* GetLocale() const

   Returns the locale name as passed to the constructor or Init(). This
   is full, human-readable name, e.g. "English" or "French".

=head2 Wx::Locale::GetName

   const wxString& GetName() const

   Returns the current short name for the locale (as given to the
   constructor or the Init() function).

=head2 Wx::Locale::GetString

   const char* GetString(const char *szOrigString, const char *szDomain =
   NULL) const

   const char* GetString(const char *szOrigString, const char
   *szOrigString2, size_t n, const char *szDomain = NULL) const

   Retrieves the translation for a string in all loaded domains unless
   the szDomain parameter is specified (and then only this catalog/domain
   is searched).

   Returns original string if translation is not available (in this case
   an error message is generated the first time a string is not found;
   use wxLogNull to suppress it).

   The second form is used when retrieving translation of string that has
   different singular and plural form in English or different plural
   forms in some other language. It takes two extra arguments:
   szOrigString parameter must contain the singular form of the string to
   be converted. It is also used as the key for the search in the
   catalog. The szOrigString2 parameter is the plural form (in English).
   The parameter n is used to determine the plural form. If no message
   catalog is found szOrigString is returned if 'n == 1', otherwise
   szOrigString2. See GNU gettext manual for additional information on
   plural forms handling.

   This method is called by the wxGetTranslation function and _() macro.

   Remarks

   Domains are searched in the last to first order, i.e. catalogs added
   later override those added before.

=head2 Wx::Locale::GetHeaderValue

   wxString GetHeaderValue(const char *szHeader, const char *szDomain =
   NULL) const

   Returns the header value for header szHeader. The search for szHeader
   is case sensitive. If an szDomain is passed, this domain is searched.
   Else all domains will be searched until a header has been found. The
   return value is the value of the header if found. Else this will be
   empty.

=head2 Wx::Locale::GetSysName

   wxString GetSysName() const

   Returns current platform-specific locale name as passed to
   setlocale().

   Compare GetCanonicalName.

=head2 Wx::Locale::GetSystemEncoding

   static wxFontEncoding GetSystemEncoding() const

   Tries to detect the user's default font encoding. Returns
   wxFontEncoding value or wxFONTENCODING_SYSTEM if it couldn't be
   determined.

=head2 Wx::Locale::GetSystemEncodingName

   static wxString GetSystemEncodingName() const

   Tries to detect the name of the user's default font encoding. This
   string isn't particularly useful for the application as its form is
   platform-dependent and so you should probably use GetSystemEncoding
   instead.

   Returns a user-readable string value or an empty string if it couldn't
   be determined.

=head2 Wx::Locale::GetSystemLanguage

   static int GetSystemLanguage() const

   Tries to detect the user's default language setting. Returns
   wxLanguage value or wxLANGUAGE_UNKNOWN if the language-guessing
   algorithm failed.

=head2 Wx::Locale::Init



=head2 Wx::Locale::IsAvailable

   static bool IsAvailable(int lang)

   Check whether the operating system and/or C run time environment
   supports this locale. For example in Windows 2000 and Windows XP,
   support for many locales is not installed by default. Returns true if
   the locale is supported.

   The argument lang is the wxLanguage identifier. To obtain this for a
   given a two letter ISO language code, use FindLanguageInfo to obtain
   its wxLanguageInfo structure. See AddLanguage for the wxLanguageInfo
   description.

   This function is new since wxWidgets version 2.7.1.

=head2 Wx::Locale::IsLoaded

   bool IsLoaded(const char* domain) const

   Check if the given catalog is loaded, and returns true if it is.

   According to GNU gettext tradition, each catalog normally corresponds
   to 'domain' which is more or less the application name.

   See also: AddCatalog

=head2 Wx::Locale::IsOk

   bool IsOk() const

   Returns true if the locale could be set successfully.

=head1 Wx::Log

=head2 Global functions

   The functions in this section work with and manipulate the active log
   target. The OnLog() is called by the wxLogXXX() functions and invokes
   the DoLog() of the active log target if any. Get/Set methods are used
   to install/query the current active target and, finally,
   DontCreateOnDemand() disables the automatic creation of a standard log
   target if none actually exists. It is only useful when the application
   is terminating and shouldn't be used in other situations because it
   may easily lead to a loss of messages.

   OnLog

=head2 Logging functions

   There are two functions which must be implemented by any derived class
   to actually process the log messages: DoLog and DoLogString. The
   second function receives a string which just has to be output in some
   way and the easiest way to write a new log target is to override just
   this function in the derived class. If more control over the output
   format is needed, then the first function must be overridden which
   allows to construct custom messages depending on the log level or even
   do completely different things depending on the message severity (for
   example, throw away all messages except warnings and errors, show
   warnings on the screen and forward the error messages to the user's
   (or programmer's) cell phone - maybe depending on whether the
   timestamp tells us if it is day or night in the current time zone).

   There also functions to support message buffering. Why are they
   needed? Some of wxLog implementations, most notably the standard
   wxLogGui class, buffer the messages (for example, to avoid showing the
   user a zillion of modal message boxes one after another -- which would
   be really annoying). Flush() shows them all and clears the buffer
   contents. This function doesn't do anything if the buffer is already
   empty.

   Flush

=head2 Customization

   The functions below allow some limited customization of wxLog
   behaviour without writing a new log target class (which, aside of
   being a matter of several minutes, allows you to do anything you
   want).

   The verbose messages are the trace messages which are not disabled in
   the release mode and are generated by wxLogVerbose. They are not
   normally shown to the user because they present little interest, but
   may be activated, for example, in order to help the user find some
   program problem.

   As for the (real) trace messages, their handling depends on the
   settings of the (application global) trace mask. There are two ways to
   specify it: either by using SetTraceMask and GetTraceMask and using
   wxLogTrace which takes an integer mask or by using AddTraceMask for
   string trace masks.

   The difference between bit-wise and string trace masks is that a
   message using integer trace mask will only be logged if all bits of
   the mask are set in the current mask while a message using string mask
   will be logged simply if the mask had been added before to the list of
   allowed ones.

   For example,

   // wxTraceOleCalls is one of standard bit masks
   wxLogTrace(wxTraceRefCount | wxTraceOleCalls, "Active object ref count: %d", nRef);

   will do something only if the current trace mask contains both
   wxTraceRefCount and wxTraceOle, but

   // wxTRACE_OleCalls is one of standard string masks
   wxLogTrace(wxTRACE_OleCalls, "IFoo::Bar() called");

   will log the message if it was preceded by

   wxLog::AddTraceMask(wxTRACE_OleCalls);

   Using string masks is simpler and allows to easily add custom ones, so
   this is the preferred way of working with trace messages. The integer
   trace mask is kept for compatibility and for additional (but very
   rarely needed) flexibility only.

   The standard trace masks are given in wxLogTrace documentation.

   Finally, the wxLog::DoLog() function automatically prepends a time
   stamp to all the messages. The format of the time stamp may be
   changed: it can be any string with % specifications fully described in
   the documentation of the standard strftime() function. For example,
   the default format is "[%d/%b/%y %H:%M:%S] " which gives something
   like "[17/Sep/98 22:10:16] " (without quotes) for the current date.
   Setting an empty string as the time format disables timestamping of
   the messages completely.

   NB: Timestamping is disabled for Visual C++ users in debug builds by
   default because otherwise it would be impossible to directly go to the
   line from which the log message was generated by simply clicking in
   the debugger window on the corresponding error message. If you wish to
   enable it, please use SetTimestamp explicitly.

   AddTraceMask

=head2 Wx::Log::AddTraceMask

   static void AddTraceMask(const wxString& mask)

   Add the mask to the list of allowed masks for wxLogTrace.

   See also

   RemoveTraceMask GetTraceMasks

=head2 Wx::Log::ClearTraceMasks

   static void ClearTraceMasks()

   Removes all trace masks previously set with AddTraceMask.

   See also

   RemoveTraceMask

=head2 Wx::Log::GetTraceMasks

   static const wxArrayString & GetTraceMasks()

   Returns the currently allowed list of string trace masks.

   See also

   AddTraceMask.

=head2 Wx::Log::OnLog

   static void OnLog(wxLogLevel level, const char * message)

   Forwards the message at specified level to the DoLog() function of the
   active log target if there is any, does nothing otherwise.

=head2 Wx::Log::GetActiveTarget

   static wxLog * GetActiveTarget()

   Returns the pointer to the active log target (may be NULL).

=head2 Wx::Log::SetActiveTarget

   static wxLog * SetActiveTarget(wxLog * logtarget)

   Sets the specified log target as the active one. Returns the pointer
   to the previous active log target (may be NULL). To suppress logging
   use a new instance of wxLogNull not NULL. If the active log target is
   set to NULL a new default log target will be created when logging
   occurs.

=head2 Wx::Log::Suspend

   static void Suspend()

   Suspends the logging until Resume is called. Note that the latter must
   be called the same number of times as the former to undo it, i.e. if
   you call Suspend() twice you must call Resume() twice as well.

   Note that suspending the logging means that the log sink won't be be
   flushed periodically, it doesn't have any effect if the current log
   target does the logging immediately without waiting for Flush to be
   called (the standard GUI log target only shows the log dialog when it
   is flushed, so Suspend() works as expected with it).

   See also

   Resume,

=head2 Wx::Log::Resume

   static void Resume()

   Resumes logging previously suspended by a call to Suspend. All
   messages logged in the meanwhile will be flushed soon.

=head2 Wx::Log::DoLog

   virtual void DoLog(wxLogLevel level, const wxChar *msg, time_t
   timestamp)

   Called to process the message of the specified severity. msg is the
   text of the message as specified in the call of wxLogXXX() function
   which generated it and timestamp is the moment when the message was
   generated.

   The base class version prepends the timestamp to the message, adds a
   prefix corresponding to the log level and then calls DoLogString with
   the resulting string.

=head2 Wx::Log::DoLogString

   virtual void DoLogString(const wxChar *msg, time_t timestamp)

   Called to log the specified string. The timestamp is already included
   into the string but still passed to this function.

   A simple implementation may just send the string to stdout or, better,
   stderr.

=head2 Wx::Log::DontCreateOnDemand

   static void DontCreateOnDemand()

   Instructs wxLog to not create new log targets on the fly if there is
   none currently. (Almost) for internal use only: it is supposed to be
   called by the application shutdown code.

   Note that this function also calls ClearTraceMasks.

=head2 Wx::Log::Flush

   virtual void Flush()

   Shows all the messages currently in buffer and clears it. If the
   buffer is already empty, nothing happens.

=head2 Wx::Log::FlushActive

   static void FlushActive()

   Flushes the current log target if any, does nothing if there is none.

   See also

   Flush

=head2 Wx::Log::SetVerbose

   static void SetVerbose(bool verbose = true)

   Activates or deactivates verbose mode in which the verbose messages
   are logged as the normal ones instead of being silently dropped.

=head2 Wx::Log::GetVerbose

   static bool GetVerbose()

   Returns whether the verbose mode is currently active.

=head2 Wx::Log::SetLogLevel

   static void SetLogLevel(wxLogLevel logLevel)

   Specifies that log messages with level > logLevel should be ignored
   and not sent to the active log target.

=head2 Wx::Log::GetLogLevel

   static wxLogLevel GetLogLevel()

   Returns the current log level limit.

=head2 Wx::Log::SetRepetitionCounting

   static void SetRepetitionCounting(bool repetCounting = true)

   Enables logging mode in which a log message is logged once, and in
   case exactly the same message successively repeats one or more times,
   only the number of repetitions is logged.

=head2 Wx::Log::GetRepetitionCounting

   static bool GetRepetitionCounting()

   Returns whether the repetition counting mode is enabled.

=head2 Wx::Log::SetTimestamp

   void SetTimestamp(const char * format)

   Sets the timestamp format prepended by the default log targets to all
   messages. The string may contain any normal characters as well as %
   prefixed format specificators, see strftime() manual for details.
   Passing a NULL value (not empty string) to this function disables
   message timestamping.

=head2 Wx::Log::GetTimestamp

   const char * GetTimestamp() const

   Returns the current timestamp format string.

=head2 Wx::Log::SetTraceMask

   static void SetTraceMask(wxTraceMask mask)

   Sets the trace mask, see Customization section for details.

=head2 Wx::Log::GetTraceMask

   Returns the current trace mask, see Customization section for details.

=head2 Wx::Log::IsAllowedTraceMask

   static bool IsAllowedTraceMask(const wxChar *mask)

   Returns true if the mask is one of allowed masks for wxLogTrace.

   See also: AddTraceMask, RemoveTraceMask

=head2 Wx::Log::RemoveTraceMask

   static void RemoveTraceMask(const wxString& mask)

   Remove the mask from the list of allowed masks for wxLogTrace.

   See also: AddTraceMask

=head1 Wx::LogChain

=head2 Wx::LogChain::new

   wxLogChain(wxLog *logger)

   Sets the specified logger (which may be NULL) as the default log
   target but the log messages are also passed to the previous log target
   if any.

=head2 Wx::LogChain::DESTROY

   ~wxLogChain()

   Destroys the previous log target.

=head2 Wx::LogChain::DetachOldLog

   void DetachOldLog()

   Detaches the old log target so it won't be destroyed when the
   wxLogChain object is destroyed.

=head2 Wx::LogChain::GetOldLog

   wxLog * GetOldLog() const

   Returns the pointer to the previously active log target (which may be
   NULL).

=head2 Wx::LogChain::IsPassingMessages

   bool IsPassingMessages() const

   Returns true if the messages are passed to the previously active log
   target (default) or false if PassMessages had been called.

=head2 Wx::LogChain::PassMessages

   void PassMessages(bool passMessages)

   By default, the log messages are passed to the previously active log
   target. Calling this function with false parameter disables this
   behaviour (presumably temporarily, as you shouldn't use wxLogChain at
   all otherwise) and it can be reenabled by calling it again with
   passMessages set to true.

=head2 Wx::LogChain::SetLog

   void SetLog(wxLog *logger)

   Sets another log target to use (may be NULL). The log target specified
   in the constructor or in a previous call to this function is deleted.

   This doesn't change the old log target value (the one the messages are
   forwarded to) which still remains the same as was active when
   wxLogChain object was created.

=head1 Wx::LogGui

=head2 Wx::LogGui::new

   wxLogGui()

   Default constructor.

=head1 Wx::LogNull

=head2 Wx::LogNull::new

   wxLogNull()

   Suspends logging.

=head2 Wx::LogNull::DESTROY

   Resumes logging.

=head1 Wx::LogPassThrough

=head2 Wx::LogPassThrough::new

   Default ctor installs this object as the current active log target.

=head1 Wx::LogStderr

=head2 Wx::LogStderr::new

   wxLogStderr(FILE *fp = NULL)

   Constructs a log target which sends all the log messages to the given
   FILE. If it is NULL, the messages are sent to stderr.

=head1 Wx::LogStream

=head2 Wx::LogStream::new

   wxLogStream(std::ostream *ostr = NULL)

   Constructs a log target which sends all the log messages to the given
   output stream. If it is NULL, the messages are sent to cerr.

=head1 Wx::LogTextCtrl

=head2 Wx::LogTextCtrl::new

   wxLogTextCtrl(wxTextCtrl *textctrl)

   Constructs a log target which sends all the log messages to the given
   text control. The textctrl parameter cannot be NULL.

=head1 Wx::LogWindow

=head2 Wx::LogWindow::new

   wxLogWindow(wxFrame *parent, const wxChar *title, bool show = true,
   bool passToOld = true)

   Creates the log frame window and starts collecting the messages in it.

   Parameters

   parent

       The parent window for the log frame, may be NULL

   title

       The title for the log frame

   show

       true to show the frame initially (default), otherwise
       wxLogWindow::Show must be called later.

   passToOld

       true to process the log messages normally in addition to logging
       them in the log frame (default), false to only log them in the log
       frame.

=head2 Wx::LogWindow::Show

   void Show(bool show = true)

   Shows or hides the frame.

=head2 Wx::LogWindow::GetFrame

   wxFrame * GetFrame() const

   Returns the associated log frame window. This may be used to position
   or resize it but use wxLogWindow::Show to show or hide it.

=head2 Wx::LogWindow::OnFrameCreate

   virtual void OnFrameCreate(wxFrame *frame)

   Called immediately after the log frame creation allowing for any extra
   initializations.

=head2 Wx::LogWindow::OnFrameClose

   virtual bool OnFrameClose(wxFrame *frame)

   Called if the user closes the window interactively, will not be called
   if it is destroyed for another reason (such as when program exits).

   Return true from here to allow the frame to close, false to prevent
   this from happening.

   See also

   wxLogWindow::OnFrameDelete

=head2 Wx::LogWindow::OnFrameDelete

   virtual void OnFrameDelete(wxFrame *frame)

   Called right before the log frame is going to be deleted: will always
   be called unlike OnFrameClose().

=head1 Wx::LongLong

=head2 Wx::LongLong::new

   wxLongLong()

   Default constructor initializes the object to 0.

=head2 Wx::LongLong::new

   wxLongLong(wxLongLong_t ll)

   Constructor from native long long (only for compilers supporting it).

=head2 Wx::LongLong::new

   wxLongLong(long hi, unsigned long lo)

   Constructor from 2 longs: the high and low part are combined into one
   wxLongLong.

=head2 Wx::LongLong::Abs

   wxLongLong Abs() const

   wxLongLong& Abs()

   Returns an absolute value of wxLongLong - either making a copy (const
   version) or modifying it in place (the second one). Not in
   wxULongLong.

=head2 Wx::LongLong::Assign

   wxLongLong& Assign(double d)

   This allows to convert a double value to wxLongLong type. Such
   conversion is not always possible in which case the result will be
   silently truncated in a platform-dependent way. Not in wxULongLong.

=head2 Wx::LongLong::GetHi

   long GetHi() const

   Returns the high 32 bits of 64 bit integer.

=head2 Wx::LongLong::GetLo

   unsigned long GetLo() const

   Returns the low 32 bits of 64 bit integer.

=head2 Wx::LongLong::GetValue

   wxLongLong_t GetValue() const

   Convert to native long long (only for compilers supporting it)

=head2 Wx::LongLong::ToDouble

   double ToDouble() const

   Returns the value as double.

=head2 Wx::LongLong::ToLong

   long ToLong() const

   Truncate wxLongLong to long. If the conversion loses data (i.e. the
   wxLongLong value is outside the range of built-in long type), an
   assert will be triggered in debug mode.

=head2 Wx::LongLong::ToString

   wxString ToString() const

   Returns the string representation of a wxLongLong.

=head1 Wx::Mask

=head2 Wx::Mask::new

   wxMask()

   Default constructor.

   wxMask(const wxBitmap& bitmap)

   Constructs a mask from a monochrome bitmap.

   wxPython note: This is the default constructor for wxMask in wxPython.

   wxMask(const wxBitmap& bitmap, const wxColour& colour)

   Constructs a mask from a bitmap and a colour that indicates the
   background.

   wxPython note: wxPython has an alternate wxMask constructor matching
   this form called wxMaskColour.

   wxMask(const wxBitmap& bitmap, int index)

   Constructs a mask from a bitmap and a palette index that indicates the
   background. Not yet implemented for GTK.

   Parameters

   bitmap

       A valid bitmap.

   colour

       A colour specifying the transparency RGB values.

   index

       Index into a palette, specifying the transparency colour.

=head2 Wx::Mask::DESTROY

   ~wxMask()

   Destroys the wxMask object and the underlying bitmap data.

=head2 Wx::Mask::Create

   bool Create(const wxBitmap& bitmap)

   Constructs a mask from a monochrome bitmap.

   bool Create(const wxBitmap& bitmap, const wxColour& colour)

   Constructs a mask from a bitmap and a colour that indicates the
   background.

   bool Create(const wxBitmap& bitmap, int index)

   Constructs a mask from a bitmap and a palette index that indicates the
   background. Not yet implemented for GTK.

   Parameters

   bitmap

       A valid bitmap.

   colour

       A colour specifying the transparency RGB values.

   index

       Index into a palette, specifying the transparency colour.

=head1 Wx::MaximizeEvent

=head2 Wx::MaximizeEvent::new

   wxMaximizeEvent(int id = 0)

   Constructor.

=head1 Wx::MBConv

=head2 Wx::MBConv::new

   wxMBConv()

   Trivial default constructor.

=head2 Wx::MBConv::MB2WC

   virtual size_t MB2WC(wchar_t *out, const char *in, size_t outLen)
   const

   This function is deprecated, please use ToWChar instead

   Converts from a string in in multibyte encoding to Unicode putting up
   to outLen characters into the buffer out.

   If out is NULL, only the length of the string which would result from
   the conversion is calculated and returned. Note that this is the
   length and not size, i.e. the returned value does not include the
   trailing NUL. But when the function is called with a non-NULL out
   buffer, the outLen parameter should be one more to allow to properly
   NUL-terminate the string.

   Parameters

   out 

       The output buffer, may be NULL if the caller is only interested in
       the length of the resulting string

   in  

       The NUL-terminated input string, cannot be NULL

   outLen

       The length of the output buffer but including NUL, ignored if out
       is NULL

   Return value

   The length of the converted string excluding the trailing NUL.

=head2 Wx::MBConv::WC2MB

   virtual size_t WC2MB(char* buf, const wchar_t* psz, size_t n) const

   This function is deprecated, please use FromWChar instead

   Converts from Unicode to multibyte encoding. The semantics of this
   function (including the return value meaning) is the same as for MB2WC.

   Notice that when the function is called with a non-NULL buffer, the n
   parameter should be the size of the buffer and so it should take into
   account the trailing NUL, which might take two or four bytes for some
   encodings (UTF-16 and UTF-32) and not one.

=head2 Wx::MBConv::cMB2WC

   const wxWCharBuffer cMB2WC(const char *in) const

   const wxWCharBuffer cMB2WC(const char *in, size_t inLen, size_t
   *outLen) const

   Converts from multibyte encoding to Unicode by calling MB2WC,
   allocating a temporary wxWCharBuffer to hold the result.

   The first overload takes a NUL-terminated input string. The second one
   takes a string of exactly the specified length and the string may
   include or not the trailing NUL character(s). If the string is not NUL-terminated,
   a temporary NUL-terminated copy of it suitable for passing to MB2WC is
   made, so it is more efficient to ensure that the string is does have
   the appropriate number of NUL bytes (which is usually 1 but may be 2
   or 4 for UTF-16 or UTF-32, see GetMBNulLen), especially for long
   strings.

   If outLen is not-NULL, it receives the length of the converted string.

=head2 Wx::MBConv::cWC2MB

   const wxCharBuffer cWC2MB(const wchar_t* in) const

   const wxCharBuffer cWC2MB(const wchar_t* in, size_t inLen, size_t
   *outLen) const

   Converts from Unicode to multibyte encoding by calling WC2MB,
   allocating a temporary wxCharBuffer to hold the result.

   The second overload of this function allows to convert a string of the
   given length inLen, whether it is NUL-terminated or not (for wide
   character strings, unlike for the multibyte ones, a single NUL is
   always enough). But notice that just as with cMB2WC, it is more
   efficient to pass an already terminated string to this function as
   otherwise a copy is made internally.

   If outLen is not-NULL, it receives the length of the converted string.

=head2 Wx::MBConv::cMB2WX

   const char* cMB2WX(const char* psz) const

   const wxWCharBuffer cMB2WX(const char* psz) const

   Converts from multibyte encoding to the current wxChar type (which
   depends on whether wxUSE_UNICODE is set to 1). If wxChar is char, it
   returns the parameter unaltered. If wxChar is wchar_t, it returns the
   result in a wxWCharBuffer. The macro wxMB2WXbuf is defined as the
   correct return type (without const).

=head2 Wx::MBConv::cWX2MB

   const char* cWX2MB(const wxChar* psz) const

   const wxCharBuffer cWX2MB(const wxChar* psz) const

   Converts from the current wxChar type to multibyte encoding. If wxChar
   is char, it returns the parameter unaltered. If wxChar is wchar_t, it
   returns the result in a wxCharBuffer. The macro wxWX2MBbuf is defined
   as the correct return type (without const).

=head2 Wx::MBConv::cWC2WX

   const wchar_t* cWC2WX(const wchar_t* psz) const

   const wxCharBuffer cWC2WX(const wchar_t* psz) const

   Converts from Unicode to the current wxChar type. If wxChar is
   wchar_t, it returns the parameter unaltered. If wxChar is char, it
   returns the result in a wxCharBuffer. The macro wxWC2WXbuf is defined
   as the correct return type (without const).

=head2 Wx::MBConv::cWX2WC

   const wchar_t* cWX2WC(const wxChar* psz) const

   const wxWCharBuffer cWX2WC(const wxChar* psz) const

   Converts from the current wxChar type to Unicode. If wxChar is
   wchar_t, it returns the parameter unaltered. If wxChar is char, it
   returns the result in a wxWCharBuffer. The macro wxWX2WCbuf is defined
   as the correct return type (without const).

=head2 Wx::MBConv::FromWChar

   virtual size_t FromWChar(char_t *dst, size_t dstLen, const wchar_t *src,
   size_t srcLen = wxNO_LEN) const

   This function has the same semantics as ToWChar except that it
   converts a wide string to multibyte one.

=head2 Wx::MBConv::GetMaxMBNulLen

   const size_t GetMaxMBNulLen()

   Returns the maximal value which can be returned by GetMBNulLen for any
   conversion object. Currently this value is 4.

   This method can be used to allocate the buffer with enough space for
   the trailing NUL characters for any encoding.

=head2 Wx::MBConv::GetMBNulLen

   size_t GetMBNulLen() const

   This function returns 1 for most of the multibyte encodings in which
   the string is terminated by a single NUL, 2 for UTF-16 and 4 for
   UTF-32 for which the string is terminated with 2 and 4 NUL characters
   respectively. The other cases are not currently supported and
   wxCONV_FAILED (defined as -1) is returned for them.

=head2 Wx::MBConv::ToWChar

   virtual size_t ToWChar(wchar_t *dst, size_t dstLen, const char_t *src,
   size_t srcLen = wxNO_LEN) const

   The most general function for converting a multibyte string to a wide
   string. The main case is when dst is not NULL and srcLen is not
   wxNO_LEN (which is defined as (size_t)-1): then the function converts
   exactly srcLen bytes starting at src into wide string which it output
   to dst. If the length of the resulting wide string is greater than
   dstLen, an error is returned. Note that if srcLen bytes don't include
   NUL characters, the resulting wide string is not NUL-terminated
   neither.

   If srcLen is wxNO_LEN, the function supposes that the string is
   properly (i.e. as necessary for the encoding handled by this
   conversion) NUL-terminated and converts the entire string, including
   any trailing NUL bytes. In this case the wide string is also NUL-terminated.

   Finally, if dst is NULL, the function returns the length of the needed
   buffer.

   Return value

   The number of characters written to dst (or the number of characters
   which would have been written to it if it were non-NULL) on success or
   wxCONV_FAILED on error.

=head1 Wx::MBConvFile

=head2 Wx::MBConvFile::MB2WC

   size_t MB2WC(wchar_t* buf, const char* psz, size_t n) const

   Converts from multibyte filename encoding to Unicode. Returns the size
   of the destination buffer.

=head2 Wx::MBConvFile::WC2MB

   size_t WC2MB(char* buf, const wchar_t* psz, size_t n) const

   Converts from Unicode to multibyte filename encoding. Returns the size
   of the destination buffer.

=head1 Wx::MBConvUTF7

=head2 Wx::MBConvUTF7::MB2WC

   size_t MB2WC(wchar_t* buf, const char* psz, size_t n) const

   Converts from UTF-7 encoding to Unicode. Returns the size of the
   destination buffer.

=head2 Wx::MBConvUTF7::WC2MB

   size_t WC2MB(char* buf, const wchar_t* psz, size_t n) const

   Converts from Unicode to UTF-7 encoding. Returns the size of the
   destination buffer.

=head1 Wx::MBConvUTF8

=head2 Wx::MBConvUTF8::MB2WC

   size_t MB2WC(wchar_t* buf, const char* psz, size_t n) const

   Converts from UTF-8 encoding to Unicode. Returns the size of the
   destination buffer.

=head2 Wx::MBConvUTF8::WC2MB

   size_t WC2MB(char* buf, const wchar_t* psz, size_t n) const

   Converts from Unicode to UTF-8 encoding. Returns the size of the
   destination buffer.

=head1 Wx::MBConvUTF16

=head2 Wx::MBConvUTF16::MB2WC

   size_t MB2WC(wchar_t* buf, const char* psz, size_t n) const

   Converts from UTF-16 encoding to Unicode. Returns the size of the
   destination buffer.

=head2 Wx::MBConvUTF16::WC2MB

   size_t WC2MB(char* buf, const wchar_t* psz, size_t n) const

   Converts from Unicode to UTF-16 encoding. Returns the size of the
   destination buffer.

=head1 Wx::MBConvUTF32

=head2 Wx::MBConvUTF32::MB2WC

   size_t MB2WC(wchar_t* buf, const char* psz, size_t n) const

   Converts from UTF-32 encoding to Unicode. Returns the size of the
   destination buffer.

=head2 Wx::MBConvUTF32::WC2MB

   size_t WC2MB(char* buf, const wchar_t* psz, size_t n) const

   Converts from Unicode to UTF-32 encoding. Returns the size of the
   destination buffer.

=head1 Wx::MDIChildFrame

=head2 Wx::MDIChildFrame::new

   wxMDIChildFrame()

   Default constructor.

   wxMDIChildFrame(wxMDIParentFrame* parent, wxWindowID id, const
   wxString& title, const wxPoint& pos = wxDefaultPosition, const wxSize&
   size = wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE, const
   wxString& name = "frame")

   Constructor, creating the window.

   Parameters

   parent

       The window parent. This should not be NULL.

   id  

       The window identifier. It may take a value of -1 to indicate a
       default value.

   title

       The caption to be displayed on the frame's title bar.

   pos 

       The window position. A value of (-1, -1) indicates a default
       position, chosen by either the windowing system or wxWidgets,
       depending on platform.

   size

       The window size. A value of (-1, -1) indicates a default size,
       chosen by either the windowing system or wxWidgets, depending on
       platform.

   style

       The window style. See wxMDIChildFrame.

   name

       The name of the window. This parameter is used to associate a name
       with the item, allowing the application user to set Motif resource
       values for individual windows.

   Remarks

   None.

   See also

   wxMDIChildFrame::Create

=head2 Wx::MDIChildFrame::DESTROY

   ~wxMDIChildFrame()

   Destructor. Destroys all child windows and menu bar if present.

=head2 Wx::MDIChildFrame::Activate

   void Activate()

   Activates this MDI child frame.

   See also

   wxMDIChildFrame::Maximize, wxMDIChildFrame::Restore

=head2 Wx::MDIChildFrame::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxString& title,
   const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE, const wxString&
   name = "frame")

   Used in two-step frame construction. See
   wxMDIChildFrame::wxMDIChildFrame for further details.

=head2 Wx::MDIChildFrame::Maximize

   void Maximize(boolmaximize)

   Maximizes this MDI child frame.

   See also

   wxMDIChildFrame::Activate, wxMDIChildFrame::Restore

=head2 Wx::MDIChildFrame::Restore

   void Restore()

   Restores this MDI child frame (unmaximizes).

   See also

   wxMDIChildFrame::Activate, wxMDIChildFrame::Maximize

=head1 Wx::MDIClientWindow

=head2 Wx::MDIClientWindow::new

   wxMDIClientWindow()

   Default constructor.

   wxMDIClientWindow(wxMDIParentFrame* parent, long style = 0)

   Constructor, creating the window.

   Parameters

   parent

       The window parent.

   style

       The window style. Currently unused.

   Remarks

   The second style of constructor is called within
   wxMDIParentFrame::OnCreateClient.

   See also

   wxMDIParentFrame::wxMDIParentFrame, wxMDIParentFrame::OnCreateClient

=head2 Wx::MDIClientWindow::DESTROY

   ~wxMDIClientWindow()

   Destructor.

=head2 Wx::MDIClientWindow::CreateClient

   bool CreateClient(wxMDIParentFrame* parent, long style = 0)

   Used in two-step frame construction. See
   wxMDIClientWindow::wxMDIClientWindow for further details.

=head1 Wx::MDIParentFrame

=head2 Wx::MDIParentFrame::new

   wxMDIParentFrame()

   Default constructor.

   wxMDIParentFrame(wxWindow* parent, wxWindowID id, const wxString&
   title, const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE | wxVSCROLL |
   wxHSCROLL, const wxString& name = "frame")

   Constructor, creating the window.

   Parameters

   parent

       The window parent. This should be NULL.

   id  

       The window identifier. It may take a value of -1 to indicate a
       default value.

   title

       The caption to be displayed on the frame's title bar.

   pos 

       The window position. A value of (-1, -1) indicates a default
       position, chosen by either the windowing system or wxWidgets,
       depending on platform.

   size

       The window size. A value of (-1, -1) indicates a default size,
       chosen by either the windowing system or wxWidgets, depending on
       platform.

   style

       The window style. See wxMDIParentFrame.

   name

       The name of the window. This parameter is used to associate a name
       with the item, allowing the application user to set Motif resource
       values for individual windows.

   Remarks

   During the construction of the frame, the client window will be
   created. To use a different class from wxMDIClientWindow, override
   wxMDIParentFrame::OnCreateClient.

   Under Windows 95, the client window will automatically have a sunken
   border style when the active child is not maximized, and no border
   style when a child is maximized.

   See also

   wxMDIParentFrame::Create, wxMDIParentFrame::OnCreateClient

=head2 Wx::MDIParentFrame::DESTROY

   ~wxMDIParentFrame()

   Destructor. Destroys all child windows and menu bar if present.

=head2 Wx::MDIParentFrame::ActivateNext

   void ActivateNext()

   Activates the MDI child following the currently active one.

   See also

   wxMDIParentFrame::ActivatePrevious

=head2 Wx::MDIParentFrame::ActivatePrevious

   void ActivatePrevious()

   Activates the MDI child preceding the currently active one.

   See also

   wxMDIParentFrame::ActivateNext

=head2 Wx::MDIParentFrame::ArrangeIcons

   void ArrangeIcons()

   Arranges any iconized (minimized) MDI child windows.

   See also

   wxMDIParentFrame::Cascade, wxMDIParentFrame::Tile

=head2 Wx::MDIParentFrame::Cascade

   void Cascade()

   Arranges the MDI child windows in a cascade.

   See also

   wxMDIParentFrame::Tile, wxMDIParentFrame::ArrangeIcons

=head2 Wx::MDIParentFrame::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxString& title,
   const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE | wxVSCROLL |
   wxHSCROLL, const wxString& name = "frame")

   Used in two-step frame construction. See
   wxMDIParentFrame::wxMDIParentFrame for further details.

=head2 Wx::MDIParentFrame::GetClientSize

   virtual void GetClientSize(int* width, int* height) const

   This gets the size of the frame 'client area' in pixels.

   Parameters

   width

       Receives the client width in pixels.

   height

       Receives the client height in pixels.

   Remarks

   The client area is the area which may be drawn on by the programmer,
   excluding title bar, border, status bar, and toolbar if present.

   If you wish to manage your own toolbar (or perhaps you have more than
   one), provide an OnSize event handler. Call GetClientSize to find how
   much space there is for your windows and don't forget to set the size
   and position of the MDI client window as well as your toolbar and
   other windows (but not the status bar).

   If you have set a toolbar with wxMDIParentFrame::SetToolbar, the
   client size returned will have subtracted the toolbar height. However,
   the available positions for the client window and other windows of the
   frame do not start at zero - you must add the toolbar height.

   The position and size of the status bar and toolbar (if known to the
   frame) are always managed by wxMDIParentFrame, regardless of what
   behaviour is defined in your OnSize event handler. However, the client
   window position and size are always set in OnSize, so if you override
   this event handler, make sure you deal with the client window.

   You do not have to manage the size and position of MDI child windows,
   since they are managed automatically by the client window.

   See also

   wxMDIParentFrame::GetToolBar, wxMDIParentFrame::SetToolBar,
   wxMDIClientWindow

=head2 Wx::MDIParentFrame::GetActiveChild

   wxMDIChildFrame* GetActiveChild() const

   Returns a pointer to the active MDI child, if there is one.

=head2 Wx::MDIParentFrame::GetClientWindow

   wxMDIClientWindow* GetClientWindow() const

   Returns a pointer to the client window.

   See also

   wxMDIParentFrame::OnCreateClient

=head2 Wx::MDIParentFrame::GetToolBar

   virtual wxWindow* GetToolBar() const

   Returns the window being used as the toolbar for this frame.

   See also

   wxMDIParentFrame::SetToolBar

=head2 Wx::MDIParentFrame::GetWindowMenu

   wxMenu* GetWindowMenu() const

   Returns the current Window menu (added by wxWidgets to the menubar).
   This function is available under Windows only.

=head2 Wx::MDIParentFrame::OnCreateClient

   virtual wxMDIClientWindow* OnCreateClient()

   Override this to return a different kind of client window. If you
   override this function, you must create your parent frame in two
   stages, or your function will never be called, due to the way C++
   treats virtual functions called from constructors. For example:

     frame = new MyParentFrame;
     frame->Create(parent, myParentFrameId, wxT("My Parent Frame"));

   Remarks

   You might wish to derive from wxMDIClientWindow in order to implement
   different erase behaviour, for example, such as painting a bitmap on
   the background.

   Note that it is probably impossible to have a client window that
   scrolls as well as painting a bitmap or pattern, since in OnScroll,
   the scrollbar positions always return zero. (Solutions to:
   julian.smart@btopenworld.com).

   See also

   wxMDIParentFrame::GetClientWindow, wxMDIClientWindow

=head2 Wx::MDIParentFrame::SetToolBar

   virtual void SetToolBar(wxWindow* toolbar)

   Sets the window to be used as a toolbar for this MDI parent window. It
   saves the application having to manage the positioning of the toolbar
   MDI client window.

   Parameters

   toolbar

       Toolbar to manage.

   Remarks

   When the frame is resized, the toolbar is resized to be the width of
   the frame client area, and the toolbar height is kept the same.

   The parent of the toolbar must be this frame.

   If you wish to manage your own toolbar (or perhaps you have more than
   one), don't call this function, and instead manage your subwindows and
   the MDI client window by providing an OnSize event handler. Call
   wxMDIParentFrame::GetClientSize to find how much space there is for
   your windows.

   Note that SDI (normal) frames and MDI child windows must always have
   their toolbars managed by the application.

   See also

   wxMDIParentFrame::GetToolBar, wxMDIParentFrame::GetClientSize

=head2 Wx::MDIParentFrame::SetWindowMenu

   void SetWindowMenu(wxMenu* menu)

   Call this to change the current Window menu. Ownership of the menu
   object passes to the frame when you call this function.

   This call is available under Windows only.

   To remove the window completely, use the wxFRAME_NO_WINDOW_MENU window
   style.

=head2 Wx::MDIParentFrame::Tile

   void Tile(wxOrientation orient = wxHORIZONTAL)

   Tiles the MDI child windows either horizontally or vertically
   depending on whether orient is wxHORIZONTAL or wxVERTICAL.

   Currently only implemented for MSW, does nothing under the other
   platforms.

   See also

   wxMDIParentFrame::Cascade, wxMDIParentFrame::ArrangeIcons

=head1 Wx::MediaCtrl

=head2 Rendering media

   Depending upon the backend, wxMediaCtrl can render and display pretty
   much any kind of media that the native system can - such as an image,
   mpeg video, or mp3 (without license restrictions - since it relies on
   native system calls that may not technically have mp3 decoding
   available, for example, it falls outside the realm of licensing
   restrictions).

   For general operation, all you need to do is call wxMediaCtrl::Load to
   load the file you want to render, catch the EVT_MEDIA_LOADED event,
   and then call wxMediaCtrl::Play to show the video/audio of the media
   in that event.

   More complex operations are generally more heavily dependant on the
   capabilities of the backend. For example, QuickTime cannot set the
   playback rate of certain streaming media - while DirectShow is
   slightly more flexible in that regard.

=head2 Operation

   When wxMediaCtrl plays a file, it plays until the stop position is
   reached (currently the end of the file/stream). Right before it hits
   the end of the stream, it fires off a EVT_MEDIA_STOP event to its
   parent window, at which point the event handler can choose to veto the
   event, preventing the stream from actually stopping.

   Example:

   //connect to the media event
   this->Connect(wxMY_ID, wxEVT_MEDIA_STOP, (wxObjectEventFunction)
   (wxEventFunction)(wxMediaEventFunction) &MyFrame::OnMediaStop);

=head2 Video size

   By default, wxMediaCtrl will scale the size of the video to the
   requested amount passed to either it's constructor or Create(). After
   calling Load or performing an equivilant operation, you can
   subsequently obtain the "real" size of the video (if there is any) by
   calling GetBestSize(). Note that the actual result on the display will
   be slightly different when ShowPlayerControls is activated and the
   actual video size will be less then specified due to the extra
   controls provided by the native toolkit. In addition, the backend may
   modify GetBestSize() to include the size of the extra controls - so if
   you want the real size of the video just disable ShowPlayerControls().

   The idea with setting GetBestSize to the size of the video is that
   GetBestSize is a wxWindow-derived function that is called when sizers
   on a window recalculate. What this means is that if you use sizers by
   default the video will show in it's original size without any extra
   assistance needed from the user.

=head2 Player controls

   Normally, when you use wxMediaCtrl it is just a window for the video
   to play in. However, some toolkits have their own media player
   interface. For example, QuickTime generally has a bar below the video
   with a slider. A special feature available to wxMediaCtrl, you can use
   the toolkit's interface instead of making your own by using the
   ShowPlayerControls() function. There are several options for the flags
   parameter, with the two general flags being
   wxMEDIACTRLPLAYERCONTROLS_NONE which turns off the native interface,
   and wxMEDIACTRLPLAYERCONTROLS_DEFAULT which lets wxMediaCtrl decide
   what native controls on the interface. Be sure to review the caveats
   outlined in Video size before doing so.

=head2 Choosing a backend

   Generally, you should almost certainly leave this part up to
   wxMediaCtrl - but if you need a certain backend for a particular
   reason, such as QuickTime for playing .mov files, all you need to do
   to choose a specific backend is to pass the name of the backend class
   to wxMediaCtrl::Create.

   The following are valid backend identifiers -

=head2 Creating a backend

   Creating a backend for wxMediaCtrl is a rather simple process. Simply
   derive from wxMediaBackendCommonBase and implement the methods you
   want. The methods in wxMediaBackend correspond to those in wxMediaCtrl
   except for CreateControl which does the actual creation of the
   control, in cases where a custom control is not needed you may simply
   call wxControl::Create.

   You need to make sure to use the DECLARE_CLASS and IMPLEMENT_CLASS
   macros.

   The only real tricky part is that you need to make sure the file in
   compiled in, which if there are just backends in there will not happen
   and you may need to use a force link hack (see
   http://www.wxwidgets.org/wiki/index.php/RTTI).

   This is a rather simple example of how to create a backend in the
   wxActiveXContainer documentation.

=head2 Wx::MediaCtrl::new

   wxMediaCtrl()

   Default constructor - you must call Create before calling any other
   methods of wxMediaCtrl.

   wxMediaCtrl( wxWindow* parent, wxWindowID id, const wxString& fileName
   = wxT(""), const wxPoint& pos = wxDefaultPosition, const wxSize& size
   = wxDefaultSize, long style = 0, const wxString& szBackend = wxT(""),
   const wxValidatorvalidator = wxDefaultValidator, const wxString& name
   = wxPanelNameStr )

   Constructor that calls Create. You may prefer to call Create directly
   to check to see if wxMediaCtrl is available on the system.

   parent

       parent of this control. Must not be NULL.

=head2 Wx::MediaCtrl::Create

   bool Create( wxWindow* parent, wxWindowID id, const wxString& fileName
   = wxT(""), const wxPoint& pos = wxDefaultPosition, const wxSize& size
   = wxDefaultSize, long style = 0, const wxString& szBackend = wxT(""),
   const wxValidatorvalidator = wxDefaultValidator, const wxString& name
   = wxPanelNameStr )

   Creates this control. Returns false if it can't load the movie located
   at fileName or it cannot load one of its native backends.

   If you specify a file to open via fileName and you don't specify a
   backend to use, wxMediaCtrl tries each of its backends until one that
   can render the path referred to by fileName can be found.

   parent

       parent of this control. Must not be NULL.

=head2 Wx::MediaCtrl::GetBestSize

   wxSize GetBestSize()

   Obtains the best size relative to the original/natural size of the
   video, if there is any. See Video size for more information.

=head2 Wx::MediaCtrl::GetPlaybackRate

   double GetPlaybackrate()

   Obtains the playback rate, or speed of the media. 1.0 represents
   normal speed, while 2.0 represents twice the normal speed of the
   media, for example. Not supported on the GStreamer (Unix) backend.
   Returns 0 on failure.

=head2 Wx::MediaCtrl::GetVolume

   double GetVolume()

   Gets the volume of the media from a 0.0 to 1.0 range. Note that due to
   rounding and other errors this may not be the exact value sent to
   SetVolume.

=head2 Wx::MediaCtrl::GetState

   wxMediaCtrlState GetState()

   Obtains the state the playback of the media is in -

=head2 Wx::MediaCtrl::Length

   wxFileOffset Length()

   Obtains the length - the total amount of time the movie has in
   milliseconds.

=head2 Wx::MediaCtrl::Load

   bool Load(const wxString& fileName)

   Loads the file that fileName refers to. Returns false if loading
   fails.

=head2 Wx::MediaCtrl::Load

   bool Load(const wxURI& uri)

   Loads the location that uri refers to. Note that this is very
   implementation-dependant, although HTTP URI/URLs are generally
   supported, for example. Returns false if loading fails.

=head2 Wx::MediaCtrl::Load

   bool Load(const wxURI& uri, const wxURI& proxy)

   Loads the location that uri refers to with the proxy proxy. Not
   implemented on most backends so it should be called with caution.
   Returns false if loading fails.

=head2 Wx::MediaCtrl::LoadURI

   bool LoadURI(const wxURI& uri)

   Same as Load. Kept for wxPython compatability.

=head2 Wx::MediaCtrl::LoadURIWithProxy

   bool LoadURIWithProxy(const wxURI& uri, const wxURI& proxy)

   Same as Load. Kept for wxPython compatability.

=head2 Wx::MediaCtrl::Pause

   bool Pause()

   Pauses playback of the movie.

=head2 Wx::MediaCtrl::Play

   bool Play()

   Resumes playback of the movie.

=head2 Wx::MediaCtrl::Seek

   wxFileOffset Seek(wxFileOffset where, wxSeekMode mode)

   Seeks to a position within the movie.

=head2 Wx::MediaCtrl::SetPlaybackRate

   bool SetPlaybackRate(double dRate)

   Sets the playback rate, or speed of the media, to that referred by
   dRate. 1.0 represents normal speed, while 2.0 represents twice the
   normal speed of the media, for example. Not supported on the GStreamer
   (Unix) backend. Returns true if successful.

=head2 Wx::MediaCtrl::SetVolume

   bool SetVolume(double dVolume)

   Sets the volume of the media from a 0.0 to 1.0 range to that referred
   by dVolume. 1.0 represents full volume, while 0.5 represents half (50
   percent) volume, for example. Note that this may not be exact due to
   conversion and rounding errors, although setting the volume to full or
   none is always exact. Returns true if successful.

=head2 Wx::MediaCtrl::ShowPlayerControls

   bool ShowPlayerControls(wxMediaCtrlPlayerControls flags =
   wxMEDIACTRLPLAYERCONTROLS_DEFAULT)

   A special feature to wxMediaCtrl. Applications using native toolkits
   such as QuickTime usually have a scrollbar, play button, and more
   provided to them by the toolkit. By default wxMediaCtrl does not do
   this. However, on the directshow and quicktime backends you can show
   or hide the native controls provided by the underlying toolkit at will
   using ShowPlayerControls. Simply calling the function with default
   parameters tells wxMediaCtrl to use the default controls provided by
   the toolkit. The function takes a wxMediaCtrlPlayerControls
   enumeration as follows:

=head2 Wx::MediaCtrl::Stop

   bool Stop()

   Stops the media.

   See Operation for an overview of how stopping works.

=head2 Wx::MediaCtrl::Tell

   wxFileOffset Tell()

   Obtains the current position in time within the movie in milliseconds.

=head1 Wx::MemoryBuffer

=head2 Wx::MemoryBuffer::new

   wxMemoryBuffer(const wxMemoryBuffer& src)

   Copy constructor, refcounting is used for performance , but
   wxMemoryBuffer is not a copy-on-write structure so changes made to one
   buffer effect all copies made from it.

   wxMemoryBuffer(size_t size)

   Create a new buffer.

   size

       size of new buffer.

=head2 Wx::MemoryBuffer::GetData

   void* GetData()

   Return a pointer to the data in the buffer.

=head2 Wx::MemoryBuffer::GetBufSize

   size_t GetBufSize()

   Returns the size of the buffer.

=head2 Wx::MemoryBuffer::GetDataLen

   size_t GetDataLen()

   Returns the length of the valid data in the buffer.

=head2 Wx::MemoryBuffer::SetBufSize

   void SetBufSize(size_t size)

   Ensures the buffer has at least size bytes available.

=head2 Wx::MemoryBuffer::SetDataLen

   void SetDataLen(size_t size)

   Sets the length of the data stored in the buffer. Mainly useful for
   truncating existing data.

   size

       New length of the valid data in the buffer. This is distinct from
       the allocated size

=head2 Wx::MemoryBuffer::GetWriteBuf

   void * GetWriteBuf(size_t sizeNeeded)

   Ensure the buffer is big enough and return a pointer to the buffer
   which can be used to directly write into the buffer up to sizeNeeded
   bytes.

=head2 Wx::MemoryBuffer::UngetWriteBuf

   void UngetWriteBuf(size_t sizeUsed)

   Update the buffer after completing a direct write, which you must have
   used GetWriteBuf() to initialise.

   sizeUsed

       The amount of data written in to buffer by the direct write

=head2 Wx::MemoryBuffer::GetAppendBuf

   void * GetAppendBuf(size_t sizeNeeded)

   Ensure that the buffer is big enough and return a pointer to the start
   of the empty space in the buffer. This pointer can be used to directly
   write data into the buffer, this new data will be appended to the
   existing data.

   sizeNeeded

       Amount of extra space required in the buffer for the append
       operation

=head2 Wx::MemoryBuffer::UngetAppendBuf

   void UngetAppendBuf(size_t sizeUsed)

   Update the length after completing a direct append, which you must
   have used GetAppendBuf() to initialise.

   sizeUsed

       This is the amount of new data that has been appended.

=head2 Wx::MemoryBuffer::AppendByte

   void AppendByte(char data)

   Append a single byte to the buffer.

   data

       New byte to append to the buffer.

=head2 Wx::MemoryBuffer::AppendData

   void AppendData(void* data, size_t len)

   Single call to append a data block to the buffer.

   data

       Pointer to block to append to the buffer.

=head1 Wx::MemoryDC

=head2 Wx::MemoryDC::new

   wxMemoryDC()

   Constructs a new memory device context.

   Use the IsOk member to test whether the constructor was successful in
   creating a usable device context. Don't forget to select a bitmap into
   the DC before drawing on it.

   wxMemoryDC(wxBitmap& bitmap)

   Constructs a new memory device context and calls SelectObject with the
   given bitmap. Use the IsOk member to test whether the constructor was
   successful in creating a usable device context.

=head2 Wx::MemoryDC::SelectObject

   void SelectObject(wxBitmap& bitmap)

   Works exactly like SelectObjectAsSource but this is the function you
   should use when you select a bitmap because you want to modify it,
   e.g. drawing on this DC.

   Be careful to use this function and not SelectObjectAsSource when you
   want to modify the bitmap you are selecting otherwise you may incurr
   in some problems related to wxBitmap being a reference counted object
   (see reference counting overview).

   See also

   wxDC::DrawBitmap

=head2 Wx::MemoryDC::SelectObjectAsSource

   void SelectObjectAsSource(const wxBitmap& bitmap)

   Selects the given bitmap into the device context, to use as the memory
   bitmap. Selecting the bitmap into a memory DC allows you to draw into
   the DC (and therefore the bitmap) and also to use wxDC::Blit to copy
   the bitmap to a window. For this purpose, you may find wxDC::DrawIcon
   easier to use instead.

   If the argument is wxNullBitmap (or some other uninitialised wxBitmap)
   the current bitmap is selected out of the device context, and the
   original bitmap restored, allowing the current bitmap to be destroyed
   safely.

   See also

   wxMemoryDC::SelectObject

=head1 Wx::MemoryFSHandler

=head2 Wx::MemoryFSHandler::new

   wxMemoryFSHandler()

   Constructor.

=head2 Wx::MemoryFSHandler::AddFile

   static void AddFile(const wxString& filename, wxImage& image, long
   type)

   static void AddFile(const wxString& filename, const wxBitmap& bitmap,
   long type)

   Add file to list of files stored in memory. Stored data (bitmap, text
   or raw data) will be copied into private memory stream and available
   under name "memory:" + filename.

   The type argument is one of wxBITMAP_TYPE_XXX constants. Note that you
   must use a type value (aka image format) that wxWidgets can save (e.g.
   JPG, PNG, see wxImage documentation)!

   See also

   AddFileWithMimeType

=head2 Wx::MemoryFSHandler::AddFileWithMimeType

   static void AddFileWithMimeType(const wxString& filename, const
   wxString& textdata, const wxString& mimetype)

   static void AddFileWithMimeType(const wxString& filename, const void*
   binarydata, size_t size, const wxString& mimetype)

   Like AddFile, but lets you explicitly specify added file's MIME type.
   This version should be used whenever you know the MIME type, because
   it makes accessing the files faster.

   This function is new since wxWidgets version 2.8.5

   See also

   AddFile

=head2 Wx::MemoryFSHandler::RemoveFile

   static void RemoveFile(const wxString& filename)

   Remove file from memory FS and free occupied memory.

=head1 Wx::MemoryInputStream

=head2 Wx::MemoryInputStream::new

   wxMemoryInputStream(const char * data, size_t len)

   Initializes a new read-only memory stream which will use the specified
   buffer data of length len. The stream does not take ownership of the
   buffer, i.e. the buffer will not be deleted in its destructor.

   wxMemoryInputStream(const wxMemoryOutputStream& stream)

   Creates a new read-only memory stream, initializing it with the data
   from the given output stream stream.

=head2 Wx::MemoryInputStream::DESTROY

   ~wxMemoryInputStream()

   Destructor.

=head2 Wx::MemoryInputStream::GetInputStreamBuffer

   wxStreamBuffer * GetInputStreamBuffer() const

   Returns the pointer to the stream object used as an internal buffer
   for that stream.

=head1 Wx::MemoryOutputStream

=head2 Wx::MemoryOutputStream::new

   wxMemoryOutputStream(char * data = NULL, size_t length = 0)

   If data is NULL, then it will initialize a new empty buffer which will
   grow if required.

   Warning

   If the buffer is created, it will be destroyed at the destruction of
   the stream.

=head2 Wx::MemoryOutputStream::DESTROY

   ~wxMemoryOutputStream()

   Destructor.

=head2 Wx::MemoryOutputStream::CopyTo

   size_t CopyTo(char *buffer, size_t len) const

   CopyTo allowed you to transfer data from the internal buffer of
   wxMemoryOutputStream to an external buffer. len specifies the size of
   the buffer.

   Returned value

   CopyTo returns the number of bytes copied to the buffer. Generally it
   is either len or the size of the stream buffer.

=head2 Wx::MemoryOutputStream::GetOutputStreamBuffer

   wxStreamBuffer * GetOutputStreamBuffer() const

   Returns the pointer to the stream object used as an internal buffer
   for that stream.

=head1 Wx::Menu

=head2 Wx::Menu::new

   wxMenu(const wxString& title = "", long style = 0)

   Constructs a wxMenu object.

   Parameters

   title

       A title for the popup menu: the empty string denotes no title.

   style

       If set to wxMENU_TEAROFF, the menu will be detachable (wxGTK
       only).

   wxMenu(long style)

   Constructs a wxMenu object.

   Parameters

   style

       If set to wxMENU_TEAROFF, the menu will be detachable (wxGTK
       only).

=head2 Wx::Menu::DESTROY

   ~wxMenu()

   Destructor, destroying the menu.

   Note: under Motif, a popup menu must have a valid parent (the window
   it was last popped up on) when being destroyed. Therefore, make sure
   you delete or re-use the popup menu before destroying the parent
   window. Re-use in this context means popping up the menu on a
   different window from last time, which causes an implicit destruction
   and recreation of internal data structures.

=head2 Wx::Menu::Append

   wxMenuItem* Append(int id, const wxString& item = "", const wxString&
   helpString = "", wxItemKind kind = wxITEM_NORMAL)

   Adds a string item to the end of the menu.

   wxMenuItem* Append(int id, const wxString& item, wxMenu *subMenu,
   const wxString& helpString = "")

   Adds a pull-right submenu to the end of the menu. Append the submenu
   to the parent menu after you have added your menu items, or
   accelerators may not be registered properly.

   wxMenuItem* Append(wxMenuItem* menuItem)

   Adds a menu item object. This is the most generic variant of Append()
   method because it may be used for both items (including separators)
   and submenus and because you can also specify various extra properties
   of a menu item this way, such as bitmaps and fonts.

   Parameters

   id  

       The menu command identifier.

   item

       The string to appear on the menu item.

   menu

       Pull-right submenu.

   kind

       May be wxITEM_SEPARATOR, wxITEM_NORMAL, wxITEM_CHECK or
       wxITEM_RADIO

   helpString

       An optional help string associated with the item. By default, the
       handler for the wxEVT_MENU_HIGHLIGHT event displays this string in
       the status line.

   menuItem

       A menuitem object. It will be owned by the wxMenu object after
       this function is called, so do not delete it yourself.

   Remarks

   This command can be used after the menu has been shown, as well as on
   initial creation of a menu or menubar.

   The item string for the normal menu items (not submenus or separators)
   may include the accelerator which can be used to activate the menu
   item from keyboard. The accelerator string follows the item label and
   is separated from it by a TAB character ('\t'). Its general syntax is
   any combination of "CTRL", "ALT" and "SHIFT" strings (case doesn't
   matter) separated by either '-' or '+' characters and followed by the
   accelerator itself. The accelerator may be any alphanumeric character,
   any function key (from F1 to F12) or one of the special characters
   listed in the table below (again, case doesn't matter):

=head2 Wx::Menu::AppendCheckItem

   wxMenuItem* AppendCheckItem(int id, const wxString& item, const
   wxString& helpString = "")

   Adds a checkable item to the end of the menu.

   See also

   wxMenu::Append, wxMenu::InsertCheckItem

=head2 Wx::Menu::AppendRadioItem

   wxMenuItem* AppendRadioItem(int id, const wxString& item, const
   wxString& helpString = "")

   Adds a radio item to the end of the menu. All consequent radio items
   form a group and when an item in the group is checked, all the others
   are automatically unchecked.

   See also

   wxMenu::Append, wxMenu::InsertRadioItem

=head2 Wx::Menu::AppendSeparator

   wxMenuItem* AppendSeparator()

   Adds a separator to the end of the menu.

   See also

   wxMenu::Append, wxMenu::InsertSeparator

=head2 Wx::Menu::AppendSubMenu

   wxMenuItem * AppendSubMenu(wxMenu *submenu, const wxString& text,
   const wxString& help = wxEmptyString)

   Adds the given submenu to this menu. text is the text shown in the
   menu for it and help is the help string shown in the status bar when
   the submenu item is selected.

=head2 Wx::Menu::Break

   void Break()

   Inserts a break in a menu, causing the next appended item to appear in
   a new column.

=head2 Wx::Menu::Check

   void Check(int id, const bool check)

   Checks or unchecks the menu item.

   Parameters

   id  

       The menu item identifier.

   check

       If true, the item will be checked, otherwise it will be unchecked.

   See also

   wxMenu::IsChecked

=head2 Wx::Menu::Delete

   void Delete(int id)

   void Delete(wxMenuItem *item)

   Deletes the menu item from the menu. If the item is a submenu, it will
   not be deleted. Use Destroy if you want to delete a submenu.

   Parameters

   id  

       Id of the menu item to be deleted.

   item

       Menu item to be deleted.

   See also

   wxMenu::FindItem, wxMenu::Destroy, wxMenu::Remove

=head2 Wx::Menu::Destroy

   void Destroy(int id)

   void Destroy(wxMenuItem *item)

   Deletes the menu item from the menu. If the item is a submenu, it will
   be deleted. Use Remove if you want to keep the submenu (for example,
   to reuse it later).

   Parameters

   id  

       Id of the menu item to be deleted.

   item

       Menu item to be deleted.

   See also

   wxMenu::FindItem, wxMenu::Deletes, wxMenu::Remove

=head2 Wx::Menu::Enable

   void Enable(int id, const bool enable)

   Enables or disables (greys out) a menu item.

   Parameters

   id  

       The menu item identifier.

   enable

       true to enable the menu item, false to disable it.

   See also

   wxMenu::IsEnabled

=head2 Wx::Menu::FindItem

   int FindItem(const wxString& itemString) const

   Finds the menu item id for a menu item string.

   wxMenuItem * FindItem(int id, wxMenu **menu = NULL) const

   Finds the menu item object associated with the given menu item
   identifier and, optionally, the (sub)menu it belongs to.

   wxPerl note: In wxPerl this method takes just the id parameter; in
   scalar context it returns the associated Wx::MenuItem, in list context
   it returns a 2-element list ( item, submenu )

   Parameters

   itemString

       Menu item string to find.

   id  

       Menu item identifier.

   menu

       If the pointer is not NULL, it will be filled with the item's
       parent menu (if the item was found)

   Return value

   First form: menu item identifier, or wxNOT_FOUND if none is found.

   Second form: returns the menu item object, or NULL if it is not found.

   Remarks

   Any special menu codes are stripped out of source and target strings
   before matching.

   wxPython note: The name of this method in wxPython is FindItemById and
   it does not support the second parameter.

=head2 Wx::Menu::FindItemByPosition

   wxMenuItem* FindItemByPosition(size_t position) const

   Returns the wxMenuItem given a position in the menu.

=head2 Wx::Menu::GetHelpString

   wxString GetHelpString(int id) const

   Returns the help string associated with a menu item.

   Parameters

   id  

       The menu item identifier.

   Return value

   The help string, or the empty string if there is no help string or the
   item was not found.

   See also

   wxMenu::SetHelpString, wxMenu::Append

=head2 Wx::Menu::GetLabel

   wxString GetLabel(int id) const

   Returns a menu item label, including any mnemonics and accelerators.

   Parameters

   id  

       The menu item identifier.

   Return value

   The item label, or the empty string if the item was not found.

   See also

   wxMenu::GetLabelText, wxMenu::SetLabel

=head2 Wx::Menu::GetLabelText

   wxString GetLabelText(int id) const

   Returns a menu item label, without any of the original mnemonics and
   accelerators.

   Parameters

   id  

       The menu item identifier.

   Return value

   The item label, or the empty string if the item was not found.

   See also

   wxMenu::GetLabel, wxMenu::SetLabel

=head2 Wx::Menu::GetMenuItemCount

   size_t GetMenuItemCount() const

   Returns the number of items in the menu.

=head2 Wx::Menu::GetMenuItems

   wxMenuItemList& GetMenuItems() const

   Returns the list of items in the menu. wxMenuItemList is a
   pseudo-template list class containing wxMenuItem pointers, see wxList.

=head2 Wx::Menu::GetTitle

   wxString GetTitle() const

   Returns the title of the menu.

   Remarks

   This is relevant only to popup menus, use wxMenuBar::GetMenuLabel for
   the menus in the menubar.

   See also

   wxMenu::SetTitle

=head2 Wx::Menu::Insert

   wxMenuItem* Insert(size_t pos, wxMenuItem *item)

   wxMenuItem* Insert(size_t pos, int id, const wxString& item = "",
   const wxString& helpString = "", wxItemKind kind = wxITEM_NORMAL)

   Inserts the given item before the position pos. Inserting the item at
   position GetMenuItemCount is the same as appending it.

   See also

   wxMenu::Append, wxMenu::Prepend

=head2 Wx::Menu::InsertCheckItem

   wxMenuItem* InsertCheckItem(size_t pos, int id, const wxString& item,
   const wxString& helpString = "")

   Inserts a checkable item at the given position.

   See also

   wxMenu::Insert, wxMenu::AppendCheckItem

=head2 Wx::Menu::InsertRadioItem

   wxMenuItem* InsertRadioItem(size_t pos, int id, const wxString& item,
   const wxString& helpString = "")

   Inserts a radio item at the given position.

   See also

   wxMenu::Insert, wxMenu::AppendRadioItem

=head2 Wx::Menu::InsertSeparator

   wxMenuItem* InsertSeparator(size_t pos)

   Inserts a separator at the given position.

   See also

   wxMenu::Insert, wxMenu::AppendSeparator

=head2 Wx::Menu::IsChecked

   bool IsChecked(int id) const

   Determines whether a menu item is checked.

   Parameters

   id  

       The menu item identifier.

   Return value

   true if the menu item is checked, false otherwise.

   See also

   wxMenu::Check

=head2 Wx::Menu::IsEnabled

   bool IsEnabled(int id) const

   Determines whether a menu item is enabled.

   Parameters

   id  

       The menu item identifier.

   Return value

   true if the menu item is enabled, false otherwise.

   See also

   wxMenu::Enable

=head2 Wx::Menu::Prepend

   wxMenuItem* Prepend(wxMenuItem *item)

   wxMenuItem* Prepend(int id, const wxString& item = "", const wxString&
   helpString = "", wxItemKind kind = wxITEM_NORMAL)

   Inserts the given item at position 0, i.e. before all the other
   existing items.

   See also

   wxMenu::Append, wxMenu::Insert

=head2 Wx::Menu::PrependCheckItem

   wxMenuItem* PrependCheckItem(int id, const wxString& item, const
   wxString& helpString = "")

   Inserts a checkable item at position 0.

   See also

   wxMenu::Prepend, wxMenu::AppendCheckItem

=head2 Wx::Menu::PrependRadioItem

   wxMenuItem* PrependRadioItem(int id, const wxString& item, const
   wxString& helpString = "")

   Inserts a radio item at position 0.

   See also

   wxMenu::Prepend, wxMenu::AppendRadioItem

=head2 Wx::Menu::PrependSeparator

   wxMenuItem* PrependSeparator()

   Inserts a separator at position 0.

   See also

   wxMenu::Prepend, wxMenu::AppendSeparator

=head2 Wx::Menu::Remove

   wxMenuItem * Remove(int id)

   wxMenuItem * Remove(wxMenuItem *item)

   Removes the menu item from the menu but doesn't delete the associated
   C++ object. This allows to reuse the same item later by adding it back
   to the menu (especially useful with submenus).

   Parameters

   id  

       The identifier of the menu item to remove.

   item

       The menu item to remove.

   Return value

   The item which was detached from the menu.

=head2 Wx::Menu::SetHelpString

   void SetHelpString(int id, const wxString& helpString)

   Sets an item's help string.

   Parameters

   id  

       The menu item identifier.

   helpString

       The help string to set.

   See also

   wxMenu::GetHelpString

=head2 Wx::Menu::SetLabel

   void SetLabel(int id, const wxString& label)

   Sets the label of a menu item.

   Parameters

   id  

       The menu item identifier.

   label

       The menu item label to set.

   See also

   wxMenu::Append, wxMenu::GetLabel

=head2 Wx::Menu::SetTitle

   void SetTitle(const wxString& title)

   Sets the title of the menu.

   Parameters

   title

       The title to set.

   Remarks

   This is relevant only to popup menus, use wxMenuBar::SetLabelTop for
   the menus in the menubar.

   See also

   wxMenu::GetTitle

=head2 Wx::Menu::UpdateUI

   void UpdateUI(wxEvtHandler* source = NULL) const

   Sends events to source (or owning window if NULL) to update the menu
   UI. This is called just before the menu is popped up with
   wxWindow::PopupMenu, but the application may call it at other times if
   required.

   See also

   wxUpdateUIEvent

=head1 Wx::MenuBar

=head2 Wx::MenuBar::new

   wxMenuBar(long style = 0)

   Default constructor.

   wxMenuBar(size_t n, wxMenu* menus[], const wxString titles[], long
   style = 0)

   Construct a menu bar from arrays of menus and titles.

   Parameters

   n   

       The number of menus.

   menus

       An array of menus. Do not use this array again - it now belongs to
       the menu bar.

   titles

       An array of title strings. Deallocate this array after creating
       the menu bar.

   style

       If wxMB_DOCKABLE the menu bar can be detached (wxGTK only).

   wxPython note: Only the default constructor is supported in wxPython.
   Use wxMenuBar::Append instead.

   wxPerl note: wxPerl only supports the first constructor: use
   wxMenuBar::Append instead.

=head2 Wx::MenuBar::DESTROY

   void ~wxMenuBar()

   Destructor, destroying the menu bar and removing it from the parent
   frame (if any).

=head2 Wx::MenuBar::Append

   bool Append(wxMenu *menu, const wxString& title)

   Adds the item to the end of the menu bar.

   Parameters

   menu

       The menu to add. Do not deallocate this menu after calling Append.

   title

       The title of the menu.

   Return value

   true on success, false if an error occurred.

   See also

   wxMenuBar::Insert

=head2 Wx::MenuBar::Check

   void Check(int id, const bool check)

   Checks or unchecks a menu item.

   Parameters

   id  

       The menu item identifier.

   check

       If true, checks the menu item, otherwise the item is unchecked.

   Remarks

   Only use this when the menu bar has been associated with a frame;
   otherwise, use the wxMenu equivalent call.

=head2 Wx::MenuBar::Enable

   void Enable(int id, const bool enable)

   Enables or disables (greys out) a menu item.

   Parameters

   id  

       The menu item identifier.

   enable

       true to enable the item, false to disable it.

   Remarks

   Only use this when the menu bar has been associated with a frame;
   otherwise, use the wxMenu equivalent call.

=head2 Wx::MenuBar::EnableTop

   void EnableTop(int pos, const bool enable)

   Enables or disables a whole menu.

   Parameters

   pos 

       The position of the menu, starting from zero.

   enable

       true to enable the menu, false to disable it.

   Remarks

   Only use this when the menu bar has been associated with a frame.

=head2 Wx::MenuBar::FindMenu

   int FindMenu(const wxString& title) const

   Returns the index of the menu with the given title or wxNOT_FOUND if
   no such menu exists in this menubar. The title parameter may specify
   either the menu title (with accelerator characters, i.e. "&File") or
   just the menu label ("File") indifferently.

=head2 Wx::MenuBar::FindMenuItem

   int FindMenuItem(const wxString& menuString, const wxString&
   itemString) const

   Finds the menu item id for a menu name/menu item string pair.

   Parameters

   menuString

       Menu title to find.

   itemString

       Item to find.

   Return value

   The menu item identifier, or wxNOT_FOUND if none was found.

   Remarks

   Any special menu codes are stripped out of source and target strings
   before matching.

=head2 Wx::MenuBar::FindItem

   wxMenuItem * FindItem(int id, wxMenu **menu = NULL) const

   Finds the menu item object associated with the given menu item
   identifier.

   Parameters

   id  

       Menu item identifier.

   menu

       If not NULL, menu will get set to the associated menu.

   Return value

   The found menu item object, or NULL if one was not found.

=head2 Wx::MenuBar::GetHelpString

   wxString GetHelpString(int id) const

   Gets the help string associated with the menu item identifier.

   Parameters

   id  

       The menu item identifier.

   Return value

   The help string, or the empty string if there was no help string or
   the menu item was not found.

   See also

   wxMenuBar::SetHelpString

=head2 Wx::MenuBar::GetLabel

   wxString GetLabel(int id) const

   Gets the label associated with a menu item.

   Parameters

   id  

       The menu item identifier.

   Return value

   The menu item label, or the empty string if the item was not found.

   Remarks

   Use only after the menubar has been associated with a frame.

=head2 Wx::MenuBar::GetLabelTop

   wxString GetLabelTop(int pos) const

   Returns the label of a top-level menu. Note that the returned string
   does not include the accelerator characters which could have been
   specified in the menu title string during its construction.

   Parameters

   pos 

       Position of the menu on the menu bar, starting from zero.

   Return value

   The menu label, or the empty string if the menu was not found.

   Remarks

   Use only after the menubar has been associated with a frame.

   This function is deprecated in favour of GetMenuLabel and
   GetMenuLabelText.

   See also

   wxMenuBar::SetLabelTop

=head2 Wx::MenuBar::GetMenu

   wxMenu* GetMenu(int menuIndex) const

   Returns the menu at menuIndex (zero-based).

=head2 Wx::MenuBar::GetMenuCount

   int GetMenuCount() const

   Returns the number of menus in this menubar.

=head2 Wx::MenuBar::GetMenuLabel

   wxString GetMenuLabel(int pos) const

   Returns the label of a top-level menu. Note that the returned string
   includes the accelerator characters that have been specified in the
   menu title string during its construction.

   Parameters

   pos 

       Position of the menu on the menu bar, starting from zero.

   Return value

   The menu label, or the empty string if the menu was not found.

   Remarks

   Use only after the menubar has been associated with a frame.

   See also

   wxMenuBar::GetMenuLabelText, wxMenuBar::SetMenuLabel

=head2 Wx::MenuBar::GetMenuLabelText

   wxString GetMenuLabelText(int pos) const

   Returns the label of a top-level menu. Note that the returned string
   does not include any accelerator characters that may have been
   specified in the menu title string during its construction.

   Parameters

   pos 

       Position of the menu on the menu bar, starting from zero.

   Return value

   The menu label, or the empty string if the menu was not found.

   Remarks

   Use only after the menubar has been associated with a frame.

   See also

   wxMenuBar::GetMenuLabel, wxMenuBar::SetMenuLabel

=head2 Wx::MenuBar::Insert

   bool Insert(size_t pos, wxMenu *menu, const wxString& title)

   Inserts the menu at the given position into the menu bar. Inserting
   menu at position 0 will insert it in the very beginning of it,
   inserting at position GetMenuCount() is the same as calling Append().

   Parameters

   pos 

       The position of the new menu in the menu bar

   menu

       The menu to add. wxMenuBar owns the menu and will free it.

   title

       The title of the menu.

   Return value

   true on success, false if an error occurred.

   See also

   wxMenuBar::Append

=head2 Wx::MenuBar::IsChecked

   bool IsChecked(int id) const

   Determines whether an item is checked.

   Parameters

   id  

       The menu item identifier.

   Return value

   true if the item was found and is checked, false otherwise.

=head2 Wx::MenuBar::IsEnabled

   bool IsEnabled(int id) const

   Determines whether an item is enabled.

   Parameters

   id  

       The menu item identifier.

   Return value

   true if the item was found and is enabled, false otherwise.

=head2 Wx::MenuBar::Refresh

   void Refresh()

   Redraw the menu bar

=head2 Wx::MenuBar::Remove

   wxMenu * Remove(size_t pos)

   Removes the menu from the menu bar and returns the menu object - the
   caller is responsible for deleting it. This function may be used
   together with wxMenuBar::Insert to change the menubar dynamically.

   See also

   wxMenuBar::Replace

=head2 Wx::MenuBar::Replace

   wxMenu * Replace(size_t pos, wxMenu *menu, const wxString& title)

   Replaces the menu at the given position with another one.

   Parameters

   pos 

       The position of the new menu in the menu bar

   menu

       The menu to add.

   title

       The title of the menu.

   Return value

   The menu which was previously at position pos. The caller is
   responsible for deleting it.

   See also

   wxMenuBar::Insert, wxMenuBar::Remove

=head2 Wx::MenuBar::SetHelpString

   void SetHelpString(int id, const wxString& helpString)

   Sets the help string associated with a menu item.

   Parameters

   id  

       Menu item identifier.

   helpString

       Help string to associate with the menu item.

   See also

   wxMenuBar::GetHelpString

=head2 Wx::MenuBar::SetLabel

   void SetLabel(int id, const wxString& label)

   Sets the label of a menu item.

   Parameters

   id  

       Menu item identifier.

   label

       Menu item label.

   Remarks

   Use only after the menubar has been associated with a frame.

   See also

   wxMenuBar::GetLabel

=head2 Wx::MenuBar::SetLabelTop

   void SetLabelTop(int pos, const wxString& label)

   Sets the label of a top-level menu.

   Parameters

   pos 

       The position of a menu on the menu bar, starting from zero.

   label

       The menu label.

   Remarks

   Use only after the menubar has been associated with a frame.

   This function has been deprecated in favour of SetMenuLabel.

   See also

   wxMenuBar::GetLabelTop

=head2 Wx::MenuBar::SetMenuLabel

   void SetMenuLabel(int pos, const wxString& label)

   Sets the label of a top-level menu.

   Parameters

   pos 

       The position of a menu on the menu bar, starting from zero.

   label

       The menu label.

   Remarks

   Use only after the menubar has been associated with a frame.

   See also

   wxMenuBar::GetMenuLabel, wxMenuBar::GetMenuLabelText

=head1 Wx::MenuEvent

=head2 Wx::MenuEvent::new

   wxMenuEvent(WXTYPE id = 0, int id = 0, wxMenu* menu = NULL)

   Constructor.

=head2 Wx::MenuEvent::GetMenu

   wxMenu * GetMenu() const

   Returns the menu which is being opened or closed. This method should
   only be used with the OPEN and CLOSE events and even for them the
   returned pointer may be NULL in some ports.

=head2 Wx::MenuEvent::GetMenuId

   int GetMenuId() const

   Returns the menu identifier associated with the event. This method
   should be only used with the HIGHLIGHT events.

=head2 Wx::MenuEvent::IsPopup

   bool IsPopup() const

   Returns true if the menu which is being opened or closed is a popup
   menu, false if it is a normal one.

   This method should only be used with the OPEN and CLOSE events.

=head1 Wx::MenuItem

=head2 Wx::MenuItem::new

   wxMenuItem(wxMenu* parentMenu = NULL, int id = wxID_SEPARATOR, const
   wxString& text = "", const wxString& helpString = "", wxItemKind kind
   = wxITEM_NORMAL, wxMenu* subMenu = NULL)

   Constructs a wxMenuItem object.

   Menu items can be standard, or "stock menu items'', or custom. For the
   standard menu items (such as commands to open a file, exit the program
   and so on, see stock items for the full list) it is enough to specify
   just the stock ID and leave text and helpString empty. In fact,
   leaving at least text empty for the stock menu items is strongly
   recommended as they will have appearance and keyboard interface
   (including standard accelerators) familiar to the user.

   For the custom (non-stock) menu items, text must be specified and
   while helpString may be left empty, it's recommended to pass the item
   description (which is automatically shown by the library in the status
   bar when the menu item is selected) in this parameter.

   Finally note that you can e.g. use a stock menu label without using
   its stock help string:

   // use all stock properties:
   helpMenu->Append(wxID_ABOUT);

=head2 Wx::MenuItem::DESTROY

   ~wxMenuItem()

   Destructor.

=head2 Wx::MenuItem::Check

   void Check(bool check = true)

   Checks or unchecks the menu item.

   Note that this only works when the item is already appended to a menu.

=head2 Wx::MenuItem::Enable

   void Enable(bool enable = true)

   Enables or disables the menu item.

=head2 Wx::MenuItem::GetBackgroundColour

   wxColour& GetBackgroundColour() const

   Returns the background colour associated with the menu item (Windows
   only).

=head2 Wx::MenuItem::GetBitmap

   wxBitmap& GetBitmap(bool checked = true) const

   Returns the checked or unchecked bitmap (Windows only).

=head2 Wx::MenuItem::GetFont

   wxFont& GetFont() const

   Returns the font associated with the menu item (Windows only).

=head2 Wx::MenuItem::GetHelp

   wxString GetHelp() const

   Returns the help string associated with the menu item.

=head2 Wx::MenuItem::GetId

   int GetId() const

   Returns the menu item identifier.

=head2 Wx::MenuItem::GetItemLabel

   wxString GetItemLabel() const

   Returns the text associated with the menu item including any
   accelerator characters that were passed to the constructor or
   SetItemLabel.

   See also

   GetItemLabelText, GetLabelText

=head2 Wx::MenuItem::GetItemLabelText

   wxString GetItemLabelText() const

   Returns the text associated with the menu item, without any
   accelerator characters.

   See also

   GetItemLabel, GetLabelText

=head2 Wx::MenuItem::GetKind

   wxItemKind GetKind() const

   Returns the item kind, one of wxITEM_SEPARATOR, wxITEM_NORMAL,
   wxITEM_CHECK or wxITEM_RADIO.

=head2 Wx::MenuItem::GetLabel

   wxString GetLabel() const

   Returns the text associated with the menu item without any accelerator
   characters it might contain.

   This function is deprecated in favour of GetItemLabelText.

   See also

   GetText, GetLabelFromText

=head2 Wx::MenuItem::GetLabelText

   static wxString GetLabelText(const wxString& text)

   Strips all accelerator characters and mnemonics from the given text.
   For example,

   wxMenuItem::GetLabelFromText("&Hello\tCtrl-H");

   will return just "Hello".

   See also

   GetItemLabelText, GetItemLabel

=head2 Wx::MenuItem::GetLabelFromText

   static wxString GetLabelFromText(const wxString& text)

   Strips all accelerator characters and mnemonics from the given text.
   For example,

   wxMenuItem::GetLabelFromText("&Hello\tCtrl-H");

   will return just "Hello".

   This function is deprecated; please use wxMenuItem::GetLabelText
   instead.

   See also

   GetText, GetLabel

=head2 Wx::MenuItem::GetMarginWidth

   int GetMarginWidth() const

   Gets the width of the menu item checkmark bitmap (Windows only).

=head2 Wx::MenuItem::GetMenu

   wxMenu* GetMenu() const

   Returns the menu this menu item is in, or NULL if this menu item is
   not attached.

=head2 Wx::MenuItem::GetName

   wxString GetName() const

   Returns the text associated with the menu item.

   NB: this function is deprecated, please use GetItemLabel or
   GetItemLabelText instead.

=head2 Wx::MenuItem::GetText

   wxString GetText() const

   Returns the text associated with the menu item, such as it was passed
   to the wxMenuItem constructor, i.e. with any accelerator characters it
   may contain.

   This function is deprecated in favour of GetItemLabel.

   See also

   GetLabel, GetLabelFromText

=head2 Wx::MenuItem::GetSubMenu

   wxMenu* GetSubMenu() const

   Returns the submenu associated with the menu item, or NULL if there
   isn't one.

=head2 Wx::MenuItem::GetTextColour

   wxColour& GetTextColour() const

   Returns the text colour associated with the menu item (Windows only).

=head2 Wx::MenuItem::IsCheckable

   bool IsCheckable() const

   Returns true if the item is checkable.

=head2 Wx::MenuItem::IsChecked

   bool IsChecked() const

   Returns true if the item is checked.

=head2 Wx::MenuItem::IsEnabled

   bool IsEnabled() const

   Returns true if the item is enabled.

=head2 Wx::MenuItem::IsSeparator

   bool IsSeparator() const

   Returns true if the item is a separator.

=head2 Wx::MenuItem::IsSubMenu

   bool IsSubMenu() const

   Returns true if the item is a submenu.

=head2 Wx::MenuItem::SetBackgroundColour

   void SetBackgroundColour(const wxColour& colour) const

   Sets the background colour associated with the menu item (Windows
   only).

=head2 Wx::MenuItem::SetBitmap

   void SetBitmap(const wxBitmap& bmp)

   Sets the bitmap for the menu item (Windows and GTK+ only). It is
   equivalent to SetBitmaps(bmp, wxNullBitmap).

=head2 Wx::MenuItem::SetBitmaps

   void SetBitmaps(const wxBitmap& checked, const wxBitmap& unchecked =
   wxNullBitmap)

   Sets the checked/unchecked bitmaps for the menu item (Windows only).
   The first bitmap is also used as the single bitmap for uncheckable
   menu items.

=head2 Wx::MenuItem::SetFont

   void SetFont(const wxFont& font)

   Sets the font associated with the menu item (Windows only).

=head2 Wx::MenuItem::SetHelp

   void SetHelp(const wxString& helpString)

   Sets the help string.

=head2 Wx::MenuItem::SetItemLabel

   void SetItemLabel(const wxString& label)

   Sets the label associated with the menu item.

=head2 Wx::MenuItem::SetMarginWidth

   void SetMarginWidth(int width) const

   Sets the width of the menu item checkmark bitmap (Windows only).

=head2 Wx::MenuItem::SetMenu

   void SetMenu(const wxMenu*menu)

   Sets the parent menu which will contain this menu item.

=head2 Wx::MenuItem::SetSubMenu

   void SetSubMenu(const wxMenu*menu)

   Sets the submenu of this menu item.

=head2 Wx::MenuItem::SetText

   void SetText(const wxString& text)

   Sets the text associated with the menu item.

   This function is deprecated in favour of SetItemLabel.

=head2 Wx::MenuItem::SetTextColour

   void SetTextColour(const wxColour& colour)

   Sets the text colour associated with the menu item (Windows only).

=head1 Wx::MessageDialog

=head2 Wx::MessageDialog::new

   wxMessageDialog(wxWindow* parent, const wxString& message, const
   wxString& caption = "Message box", long style = wxOK | wxCANCEL, const
   wxPoint& pos = wxDefaultPosition)

   Constructor. Use wxMessageDialog::ShowModal to show the dialog.

   Parameters

   parent

       Parent window.

   message

       Message to show on the dialog.

   caption

       The dialog caption.

   style

       A dialog style (bitlist) containing flags chosen from the
       following:

=head2 Wx::MessageDialog::DESTROY

   ~wxMessageDialog()

   Destructor.

=head2 Wx::MessageDialog::ShowModal

   int ShowModal()

   Shows the dialog, returning one of wxID_OK, wxID_CANCEL, wxID_YES,
   wxID_NO.

=head1 Wx::Metafile

=head2 Wx::Metafile::new

   wxMetafile(const wxString& filename = "")

   Constructor. If a filename is given, the Windows disk metafile is read
   in. Check whether this was performed successfully by using the
   wxMetafile:IsOk member.

=head2 Wx::Metafile::DESTROY

   ~wxMetafile()

   Destructor. See reference-counted object destruction for more info.

=head2 Wx::Metafile::IsOk

   bool Ok()

   Returns true if the metafile is valid.

=head2 Wx::Metafile::Play

   bool Play(wxDC *dc)

   Plays the metafile into the given device context, returning true if
   successful.

=head2 Wx::Metafile::SetClipboard

   bool SetClipboard(int width = 0, int height = 0)

   Passes the metafile data to the clipboard. The metafile can no longer
   be used for anything, but the wxMetafile object must still be
   destroyed by the application.

   Below is a example of metafile, metafile device context and clipboard
   use from the hello.cpp example. Note the way the metafile dimensions
   are passed to the clipboard, making use of the device context's
   ability to keep track of the maximum extent of drawing commands.

     wxMetafileDC dc;
     if (dc.Ok())
     {
       Draw(dc, false);
       wxMetafile *mf = dc.Close();
       if (mf)
       {
         bool success = mf->SetClipboard((int)(dc.MaxX() + 10), (int)(dc.MaxY() + 10));
         delete mf;
       }
     }

=head1 Wx::MetafileDC

=head2 Wx::MetafileDC::new

   wxMetafileDC(const wxString& filename = "")

   Constructor. If no filename is passed, the metafile is created in
   memory.

=head2 Wx::MetafileDC::DESTROY

   ~wxMetafileDC()

   Destructor.

=head2 Wx::MetafileDC::Close

   wxMetafile * Close()

   This must be called after the device context is finished with. A
   metafile is returned, and ownership of it passes to the calling
   application (so it should be destroyed explicitly).

=head1 Wx::MimeTypesManager

=head2 Helper functions

   All of these functions are static (i.e. don't need a
   wxMimeTypesManager object to call them) and provide some useful
   operations for string representations of MIME types. Their usage is
   recommended instead of directly working with MIME types using wxString
   functions.

   IsOfType

=head2 Constructor and destructor

   NB: You won't normally need to use more than one wxMimeTypesManager
   object in a program.

   wxMimeTypesManager

=head2 Query database

   These functions are the heart of this class: they allow to find a file
   type object from either file extension or MIME type. If the function
   is successful, it returns a pointer to the wxFileType object which
   must be deleted by the caller, otherwise NULL will be returned.

   GetFileTypeFromMimeType

=head2 Initialization functions

   Unix: These functions may be used to load additional files (except for
   the default ones which are loaded automatically) containing MIME
   information in either mailcap(5) or mime.types(5) format.

   ReadMailcap

=head2 Wx::MimeTypesManager::new

   wxMimeTypesManager()

   Constructor puts the object in the "working" state, no additional
   initialization are needed - but ReadXXX may be used to load additional
   mailcap/mime.types files.

=head2 Wx::MimeTypesManager::DESTROY

   ~wxMimeTypesManager()

   Destructor is not virtual, so this class should not be derived from.

=head2 Wx::MimeTypesManager::AddFallbacks

   void AddFallbacks(const wxFileTypeInfo *fallbacks)

   This function may be used to provide hard-wired fallbacks for the MIME
   types and extensions that might not be present in the system MIME
   database.

   Please see the typetest sample for an example of using it.

=head2 Wx::MimeTypesManager::GetFileTypeFromExtension

   wxFileType* GetFileTypeFromExtension(const wxString& extension)

   Gather information about the files with given extension and return the
   corresponding wxFileType object or NULL if the extension is unknown.

   The extension parameter may have, or not, the leading dot, if it has
   it, it is stripped automatically. It must not however be empty.

=head2 Wx::MimeTypesManager::GetFileTypeFromMimeType

   wxFileType* GetFileTypeFromMimeType(const wxString& mimeType)

   Gather information about the files with given MIME type and return the
   corresponding wxFileType object or NULL if the MIME type is unknown.

=head2 Wx::MimeTypesManager::IsOfType

   bool IsOfType(const wxString& mimeType, const wxString& wildcard)

   This function returns true if either the given mimeType is exactly the
   same as wildcard or if it has the same category and the subtype of
   wildcard is '*'. Note that the '*' wildcard is not allowed in mimeType
   itself.

   The comparison don by this function is case insensitive so it is not
   necessary to convert the strings to the same case before calling it.

=head2 Wx::MimeTypesManager::ReadMailcap

   bool ReadMailcap(const wxString& filename, bool fallback = false)

   Load additional file containing information about MIME types and
   associated information in mailcap format. See metamail(1) and
   mailcap(5) for more information.

   fallback parameter may be used to load additional mailcap files
   without overriding the settings found in the standard files: normally,
   entries from files loaded with ReadMailcap will override the entries
   from files loaded previously (and the standard ones are loaded in the
   very beginning), but this will not happen if this parameter is set to
   true (default is false).

   The return value is true if there were no errors in the file or false
   otherwise.

=head2 Wx::MimeTypesManager::ReadMimeTypes

   bool ReadMimeTypes(const wxString& filename)

   Load additional file containing information about MIME types and
   associated information in mime.types file format. See metamail(1) and
   mailcap(5) for more information.

   The return value is true if there were no errors in the file or false
   otherwise.

=head1 Wx::MiniFrame

=head2 Wx::MiniFrame::new

   wxMiniFrame()

   Default constructor.

   wxMiniFrame(wxWindow* parent, wxWindowID id, const wxString& title,
   const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = wxCAPTION | wxRESIZE_BORDER, const
   wxString& name = "frame")

   Constructor, creating the window.

   Parameters

   parent

       The window parent. This may be NULL. If it is non-NULL, the frame
       will always be displayed on top of the parent window on Windows.

   id  

       The window identifier. It may take a value of -1 to indicate a
       default value.

   title

       The caption to be displayed on the frame's title bar.

   pos 

       The window position. A value of (-1, -1) indicates a default
       position, chosen by either the windowing system or wxWidgets,
       depending on platform.

   size

       The window size. A value of (-1, -1) indicates a default size,
       chosen by either the windowing system or wxWidgets, depending on
       platform.

   style

       The window style. See wxMiniFrame.

   name

       The name of the window. This parameter is used to associate a name
       with the item, allowing the application user to set Motif resource
       values for individual windows.

   Remarks

   The frame behaves like a normal frame on non-Windows platforms.

   See also

   wxMiniFrame::Create

=head2 Wx::MiniFrame::DESTROY

   void ~wxMiniFrame()

   Destructor. Destroys all child windows and menu bar if present.

=head2 Wx::MiniFrame::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxString& title,
   const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = wxCAPTION | wxRESIZE_BORDER, const
   wxString& name = "frame")

   Used in two-step frame construction. See wxMiniFrame::wxMiniFrame for
   further details.

=head1 Wx::MirrorDC

=head2 Wx::MirrorDC::new

   wxMirrorDC(wxDC& dc, bool mirror)

   Creates a (maybe) mirrored DC associated with the real dc. Everything
   drawn on wxMirrorDC will appear (and maybe mirrored) on dc.

   mirror specifies if we do mirror (if it is true) or not (if it is
   false).

=head1 Wx::Module

=head2 Wx::Module::new

   wxModule()

   Constructs a wxModule object.

=head2 Wx::Module::DESTROY

   ~wxModule()

   Destructor.

=head2 Wx::Module::AddDependency

   void AddDependency(wxClassInfo * dep)

   Call this function from the constructor of the derived class. dep must
   be the CLASSINFO of a wxModule-derived class and the corresponding
   module will be loaded before and unloaded after this module.

   Note that circular dependencies are detected and result in a fatal
   error.

   Parameters

   dep 

       The class information object for the dependent module.

=head2 Wx::Module::OnExit

   virtual void OnExit()

   Provide this function with appropriate cleanup for your module.

=head2 Wx::Module::OnInit

   virtual bool OnInit()

   Provide this function with appropriate initialization for your module.
   If the function returns false, wxWidgets will exit immediately.

=head1 Wx::MouseCaptureChangedEvent

=head2 Wx::MouseCaptureChangedEvent::new

   wxMouseCaptureChangedEvent(wxWindowID windowId = 0, wxWindow*
   gainedCapture = NULL)

   Constructor.

=head2 Wx::ActivateEvent::GetCapturedWindow

   wxWindow* GetCapturedWindow() const

   Returns the window that gained the capture, or NULL if it was a
   non-wxWidgets window.

=head1 Wx::MouseCaptureLostEvent

=head2 Wx::MouseCaptureLostEvent::new

   wxMouseCaptureLostEvent(wxWindowID windowId = 0)

   Constructor.

=head1 Wx::MouseEvent

=head2 Wx::MouseEvent::m_altDown

   bool m_altDown

   true if the Alt key is pressed down.

=head2 Wx::MouseEvent::m_controlDown

   bool m_controlDown

   true if control key is pressed down.

=head2 Wx::MouseEvent::m_leftDown

   bool m_leftDown

   true if the left mouse button is currently pressed down.

=head2 Wx::MouseEvent::m_middleDown

   bool m_middleDown

   true if the middle mouse button is currently pressed down.

=head2 Wx::MouseEvent::m_rightDown

   bool m_rightDown

   true if the right mouse button is currently pressed down.

=head2 Wx::MouseEvent::m_metaDown

   bool m_metaDown

   true if the Meta key is pressed down.

=head2 Wx::MouseEvent::m_shiftDown

   bool m_shiftDown

   true if shift is pressed down.

=head2 Wx::MouseEvent::m_x

   long m_x

   X-coordinate of the event.

=head2 Wx::MouseEvent::m_y

   long m_y

   Y-coordinate of the event.

=head2 Wx::MouseEvent::m_wheelRotation

   int m_wheelRotation

   The distance the mouse wheel is rotated.

=head2 Wx::MouseEvent::m_wheelDelta

   int m_wheelDelta

   The wheel delta, normally 120.

=head2 Wx::MouseEvent::m_linesPerAction

   int m_linesPerAction

   The configured number of lines (or whatever) to be scrolled per wheel
   action.

=head2 Wx::MouseEvent::new

   wxMouseEvent(WXTYPE mouseEventType = 0)

   Constructor. Valid event types are:

=head2 Wx::MouseEvent::AltDown

   bool AltDown()

   Returns true if the Alt key was down at the time of the event.

=head2 Wx::MouseEvent::Button

   bool Button(int button)

   Returns true if the identified mouse button is changing state. Valid
   values of button are:

=head2 Wx::MouseEvent::ButtonDClick

   bool ButtonDClick(int but = wxMOUSE_BTN_ANY)

   If the argument is omitted, this returns true if the event was a mouse
   double click event. Otherwise the argument specifies which double
   click event was generated (see Button for the possible values).

=head2 Wx::MouseEvent::ButtonDown

   bool ButtonDown(int but = -1)

   If the argument is omitted, this returns true if the event was a mouse
   button down event. Otherwise the argument specifies which button-down
   event was generated (see Button for the possible values).

=head2 Wx::MouseEvent::ButtonUp

   bool ButtonUp(int but = -1)

   If the argument is omitted, this returns true if the event was a mouse
   button up event. Otherwise the argument specifies which button-up
   event was generated (see Button for the possible values).

=head2 Wx::MouseEvent::CmdDown

   bool CmdDown() const

   Same as MetaDown under Mac, same as ControlDown elsewhere.

   See also

   wxKeyEvent::CmdDown

=head2 Wx::MouseEvent::ControlDown

   bool ControlDown()

   Returns true if the control key was down at the time of the event.

=head2 Wx::MouseEvent::Dragging

   bool Dragging()

   Returns true if this was a dragging event (motion while a button is
   depressed).

   See also

   Moving

=head2 Wx::MouseEvent::Entering

   bool Entering()

   Returns true if the mouse was entering the window.

   See also wxMouseEvent::Leaving.

=head2 Wx::MouseEvent::GetButton

   int GetButton() const

   Returns the mouse button which generated this event or
   wxMOUSE_BTN_NONE if no button is involved (for mouse move, enter or
   leave event, for example). Otherwise wxMOUSE_BTN_LEFT is returned for
   the left button down, up and double click events, wxMOUSE_BTN_MIDDLE
   and wxMOUSE_BTN_RIGHT for the same events for the middle and the right
   buttons respectively.

=head2 Wx::MouseEvent::GetPosition

   wxPoint GetPosition() const

   void GetPosition(wxCoord* x, wxCoord* y) const

   void GetPosition(long* x, long* y) const

   Sets *x and *y to the position at which the event occurred on the
   window.

   Returns the physical mouse position on the window in pixels.

   Note that if the mouse event has been artificially generated from a
   special keyboard combination (e.g. under Windows when the "menu'' key
   is pressed), the returned position is wxDefaultPosition.

=head2 Wx::MouseEvent::GetLogicalPosition

   wxPoint GetLogicalPosition(const wxDC& dc) const

   Returns the logical mouse position on the window in pixels (i.e.
   translated according to the translation set for the DC, which usually
   indicates that the window has been scrolled).

=head2 Wx::MouseEvent::GetLinesPerAction

   int GetLinesPerAction() const

   Returns the configured number of lines (or whatever) to be scrolled
   per wheel action. Defaults to three.

=head2 Wx::MouseEvent::GetWheelRotation

   int GetWheelRotation() const

   Get wheel rotation, positive or negative indicates direction of
   rotation. Current devices all send an event when rotation is at least
   +/-WheelDelta, but finer resolution devices can be created in the
   future. Because of this you shouldn't assume that one event is equal
   to 1 line, but you should be able to either do partial line scrolling
   or wait until several events accumulate before scrolling.

=head2 Wx::MouseEvent::GetWheelDelta

   int GetWheelDelta() const

   Get wheel delta, normally 120. This is the threshold for action to be
   taken, and one such action (for example, scrolling one increment)
   should occur for each delta.

=head2 Wx::MouseEvent::GetX

   long GetX() const

   Returns the X coordinate of the physical mouse event position on the
   window.

=head2 Wx::MouseEvent::GetY

   long GetY()

   Returns the Y coordinate of the physical mouse event position on the
   window.

=head2 Wx::MouseEvent::IsButton

   bool IsButton() const

   Returns true if the event was a mouse button event (not necessarily a
   button down event - that may be tested using ButtonDown).

=head2 Wx::MouseEvent::IsPageScroll

   bool IsPageScroll() const

   Returns true if the system has been setup to do page scrolling with
   the mouse wheel instead of line scrolling.

=head2 Wx::MouseEvent::Leaving

   bool Leaving() const

   Returns true if the mouse was leaving the window.

   See also wxMouseEvent::Entering.

=head2 Wx::MouseEvent::LeftDClick

   bool LeftDClick() const

   Returns true if the event was a left double click.

=head2 Wx::MouseEvent::LeftDown

   bool LeftDown() const

   Returns true if the left mouse button changed to down.

=head2 Wx::MouseEvent::LeftIsDown

   bool LeftIsDown() const

   Returns true if the left mouse button is currently down, independent
   of the current event type.

   Please notice that it is not the same as LeftDown which returns true
   if the event was generated by the left mouse button being pressed.
   Rather, it simply describes the state of the left mouse button at the
   time when the event was generated (so while it will be true for a left
   click event, it can also be true for a right click if it happened
   while the left mouse button was pressed).

   This event is usually used in the mouse event handlers which process
   "move mouse" messages to determine whether the user is (still)
   dragging the mouse.

=head2 Wx::MouseEvent::LeftUp

   bool LeftUp() const

   Returns true if the left mouse button changed to up.

=head2 Wx::MouseEvent::MetaDown

   bool MetaDown() const

   Returns true if the Meta key was down at the time of the event.

=head2 Wx::MouseEvent::MiddleDClick

   bool MiddleDClick() const

   Returns true if the event was a middle double click.

=head2 Wx::MouseEvent::MiddleDown

   bool MiddleDown() const

   Returns true if the middle mouse button changed to down.

=head2 Wx::MouseEvent::MiddleIsDown

   bool MiddleIsDown() const

   Returns true if the middle mouse button is currently down, independent
   of the current event type.

=head2 Wx::MouseEvent::MiddleUp

   bool MiddleUp() const

   Returns true if the middle mouse button changed to up.

=head2 Wx::MouseEvent::Moving

   bool Moving() const

   Returns true if this was a motion event and no mouse buttons were
   pressed. If any mouse button is held pressed, then this method returns
   false and Dragging returns true.

=head2 Wx::MouseEvent::RightDClick

   bool RightDClick() const

   Returns true if the event was a right double click.

=head2 Wx::MouseEvent::RightDown

   bool RightDown() const

   Returns true if the right mouse button changed to down.

=head2 Wx::MouseEvent::RightIsDown

   bool RightIsDown() const

   Returns true if the right mouse button is currently down, independent
   of the current event type.

=head2 Wx::MouseEvent::RightUp

   bool RightUp() const

   Returns true if the right mouse button changed to up.

=head2 Wx::MouseEvent::ShiftDown

   bool ShiftDown() const

   Returns true if the shift key was down at the time of the event.

=head1 Wx::MoveEvent

=head2 Wx::MoveEvent::new

   wxMoveEvent(const wxPoint& pt, int id = 0)

   Constructor.

=head2 Wx::MoveEvent::GetPosition

   wxPoint GetPosition() const

   Returns the position of the window generating the move change event.

=head1 Wx::MultiChoiceDialog

=head2 Wx::MultiChoiceDialog::new

   wxMultiChoiceDialog(wxWindow* parent, const wxString& message, const
   wxString& caption, int n, const wxString* choices, long style =
   wxCHOICEDLG_STYLE, const wxPoint& pos = wxDefaultPosition)

   wxMultiChoiceDialog(wxWindow* parent, const wxString& message, const
   wxString& caption, const wxArrayString& choices, long style =
   wxCHOICEDLG_STYLE, const wxPoint& pos = wxDefaultPosition)

   Constructor taking an array of wxString choices.

   Parameters

   parent

       Parent window.

   message

       Message to show on the dialog.

   caption

       The dialog caption.

   n   

       The number of choices.

   choices

       An array of strings, or a string list, containing the choices.

   style

       A dialog style (bitlist) containing flags chosen from standard
       dialog styles and the following:

=head2 Wx::MultiChoiceDialog::GetSelections

   wxArrayInt GetSelections() const

   Returns array with indexes of selected items.

=head2 Wx::MultiChoiceDialog::SetSelections

   void SetSelections(const wxArrayInt& selections) const

   Sets selected items from the array of selected items' indexes.

=head2 Wx::MultiChoiceDialog::ShowModal

   int ShowModal()

   Shows the dialog, returning either wxID_OK or wxID_CANCEL.

=head1 Wx::Mutex

=head2 Wx::Mutex::new

   wxMutex(wxMutexType type = wxMUTEX_DEFAULT)

   Default constructor.

=head2 Wx::Mutex::DESTROY

   ~wxMutex()

   Destroys the wxMutex object.

=head2 Wx::Mutex::Lock

   wxMutexError Lock()

   Locks the mutex object.

   Return value

   One of:

=head2 Wx::Mutex::TryLock

   wxMutexError TryLock()

   Tries to lock the mutex object. If it can't, returns immediately with
   an error.

   Return value

   One of:

=head2 Wx::Mutex::Unlock

   wxMutexError Unlock()

   Unlocks the mutex object.

   Return value

   One of:

=head1 Wx::MutexLocker

=head2 Wx::MutexLocker::new

   wxMutexLocker(wxMutex& mutex)

   Constructs a wxMutexLocker object associated with mutex and locks it.
   Call IsOk to check if the mutex was successfully locked.

=head2 Wx::MutexLocker::DESTROY

   ~wxMutexLocker()

   Destructor releases the mutex if it was successfully acquired in the
   ctor.

=head2 Wx::MutexLocker::IsOk

   bool IsOk() const

   Returns true if mutex was acquired in the constructor, false
   otherwise.

=head1 Wx::Node

=head2 Wx::Node&lt;T&gt;::GetData

   T * GetData() const

   Retrieves the client data pointer associated with the node.

=head2 Wx::Node&lt;T&gt;::GetNext

   wxNode<T> * GetNext() const

   Retrieves the next node or NULL if this node is the last one.

=head2 Wx::Node&lt;T&gt;::GetPrevious

   wxNode<T> * GetPrevious()

   Retrieves the previous node or NULL if this node is the first one in
   the list.

=head2 Wx::Node&lt;T&gt;::SetData

   void SetData(T *data)

   Sets the data associated with the node (usually the pointer will have
   been set when the node was created).

=head2 Wx::Node&lt;T&gt;::IndexOf

   int IndexOf()

   Returns the zero-based index of this node within the list. The return
   value will be wxNOT_FOUND if the node has not been added to a list
   yet.

=head1 Wx::Notebook

=head2 Wx::Notebook::new

   wxNotebook()

   Default constructor.

   wxNotebook(wxWindow* parent, wxWindowID id, const wxPoint& pos =
   wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0,
   const wxString& name = wxNotebookNameStr)

   Constructs a notebook control.

   Note that sometimes you can reduce flicker by passing the
   wxCLIP_CHILDREN window style.

   Parameters

   parent

       The parent window. Must be non-NULL.

   id  

       The window identifier.

   pos 

       The window position.

   size

       The window size.

   style

       The window style. See wxNotebook.

   name

       The name of the control (used only under Motif).

=head2 Wx::Notebook::DESTROY

   ~wxNotebook()

   Destroys the wxNotebook object.

=head2 Wx::Notebook::AddPage

   bool AddPage(wxNotebookPage* page, const wxString& text, bool select =
   false, int imageId = -1)

   Adds a new page.

   The call to this function may generate the page changing events.

   Parameters

   page

       Specifies the new page.

   text

       Specifies the text for the new page.

   select

       Specifies whether the page should be selected.

   imageId

       Specifies the optional image index for the new page.

   Return value

   true if successful, false otherwise.

   Remarks

   Do not delete the page, it will be deleted by the notebook.

   See also

   wxNotebook::InsertPage

=head2 Wx::Notebook::AdvanceSelection

   void AdvanceSelection(bool forward = true)

   Cycles through the tabs.

   The call to this function generates the page changing events.

=head2 Wx::Notebook::AssignImageList

   void AssignImageList(wxImageList* imageList)

   Sets the image list for the page control and takes ownership of the
   list.

   See also

   wxImageList, SetImageList

=head2 Wx::Notebook::ChangeSelection

   int ChangeSelection(size_t page)

   Changes the selection for the given page, returning the previous
   selection.

   The call to this function does not generate the page changing events.
   This is the only difference with SetSelection. See this topic for more
   info.

=head2 Wx::Notebook::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxPoint& pos =
   wxDefaultPosition, const wxSize& size, long style = 0, const wxString&
   name = wxNotebookNameStr)

   Creates a notebook control. See wxNotebook::wxNotebook for a
   description of the parameters.

=head2 Wx::Notebook::DeleteAllPages

   bool DeleteAllPages()

   Deletes all pages.

=head2 Wx::Notebook::DeletePage

   bool DeletePage(size_t page)

   Deletes the specified page, and the associated window.

   The call to this function generates the page changing events.

=head2 Wx::Notebook::GetCurrentPage

   wxWindow * GetCurrentPage() const

   Returns the currently selected notebook page or NULL.

=head2 Wx::Notebook::GetImageList

   wxImageList* GetImageList() const

   Returns the associated image list.

   See also

   wxImageList, wxNotebook::SetImageList

=head2 Wx::Notebook::GetPage

   wxNotebookPage* GetPage(size_t page)

   Returns the window at the given page position.

=head2 Wx::Notebook::GetPageCount

   size_t GetPageCount() const

   Returns the number of pages in the notebook control.

=head2 Wx::Notebook::GetPageImage

   int GetPageImage(size_t nPage) const

   Returns the image index for the given page.

=head2 Wx::Notebook::GetPageText

   wxString GetPageText(size_t nPage) const

   Returns the string for the given page.

=head2 Wx::Notebook::GetRowCount

   int GetRowCount() const

   Returns the number of rows in the notebook control.

=head2 Wx::Notebook::GetSelection

   int GetSelection() const

   Returns the currently selected page, or -1 if none was selected.

   Note that this method may return either the previously or newly
   selected page when called from the EVT_NOTEBOOK_PAGE_CHANGED handler
   depending on the platform and so wxNotebookEvent::GetSelection should
   be used instead in this case.

=head2 Wx::Notebook::GetThemeBackgroundColour

   wxColour GetThemeBackgroundColour() const

   If running under Windows and themes are enabled for the application,
   this function returns a suitable colour for painting the background of
   a notebook page, and can be passed to SetBackgroundColour. Otherwise,
   an uninitialised colour will be returned.

=head2 Wx::Notebook::HitTest

   int HitTest(const wxPoint& pt, long *flags = NULL)

   Returns the index of the tab at the specified position or wxNOT_FOUND
   if none. If flags parameter is non-NULL, the position of the point
   inside the tab is returned as well.

   Parameters

   pt  

       Specifies the point for the hit test.

   flags

       Return value for detailed information. One of the following
       values:

=head2 Wx::Notebook::InsertPage

   bool InsertPage(size_t index, wxNotebookPage* page, const wxString&
   text, bool select = false, int imageId = -1)

   Inserts a new page at the specified position.

   Parameters

   index

       Specifies the position for the new page.

   page

       Specifies the new page.

   text

       Specifies the text for the new page.

   select

       Specifies whether the page should be selected.

   imageId

       Specifies the optional image index for the new page.

   Return value

   true if successful, false otherwise.

   Remarks

   Do not delete the page, it will be deleted by the notebook.

   See also

   wxNotebook::AddPage

=head2 Wx::Notebook::OnSelChange

   void OnSelChange(wxNotebookEvent& event)

   An event handler function, called when the page selection is changed.

   See also

   wxNotebookEvent

=head2 Wx::Notebook::RemovePage

   bool RemovePage(size_t page)

   Deletes the specified page, without deleting the associated window.

=head2 Wx::Notebook::SetImageList

   void SetImageList(wxImageList* imageList)

   Sets the image list for the page control. It does not take ownership
   of the image list, you must delete it yourself.

   See also

   wxImageList, AssignImageList

=head2 Wx::Notebook::SetPadding

   void SetPadding(const wxSize& padding)

   Sets the amount of space around each page's icon and label, in pixels.

   NB: The vertical padding cannot be changed in wxGTK.

=head2 Wx::Notebook::SetPageSize

   void SetPageSize(const wxSize& size)

   Sets the width and height of the pages.

   NB: This method is currently not implemented for wxGTK.

=head2 Wx::Notebook::SetPageImage

   bool SetPageImage(size_t page, int image)

   Sets the image index for the given page. image is an index into the
   image list which was set with wxNotebook::SetImageList.

=head2 Wx::Notebook::SetPageText

   bool SetPageText(size_t page, const wxString& text)

   Sets the text for the given page.

=head2 Wx::Notebook::SetSelection

   int SetSelection(size_t page)

   Sets the selection for the given page, returning the previous
   selection.

   The call to this function generates the page changing events.

   This function is deprecated and should not be used in new code. Please
   use the ChangeSelection function instead.

   See also

   wxNotebook::GetSelection

=head1 Wx::NotebookEvent

=head2 Wx::NotebookEvent::new

   wxNotebookEvent(wxEventType eventType = wxEVT_NULL, int id = 0, int
   sel = -1, int oldSel = -1)

   Constructor (used internally by wxWidgets only).

=head2 Wx::NotebookEvent::GetOldSelection

   int GetOldSelection() const

   Returns the page that was selected before the change, -1 if none was
   selected.

=head2 Wx::NotebookEvent::GetSelection

   int GetSelection() const

   Returns the currently selected page, or -1 if none was selected.

   NB: under Windows, GetSelection() will return the same value as
   GetOldSelection() when called from EVT_NOTEBOOK_PAGE_CHANGING handler
   and not the page which is going to be selected. Also note that the
   values of selection and old selection returned for an event generated
   in response to a call to wxNotebook::SetSelection shouldn't be trusted
   as they are currently inconsistent under different platforms (but in
   this case you presumably don't need them anyhow as you already have
   the corresponding information).

=head2 Wx::NotebookEvent::SetOldSelection

   void SetOldSelection(int page)

   Sets the id of the page selected before the change.

=head2 Wx::NotebookEvent::SetSelection

   void SetSelection(int page)

   Sets the selection member variable.

   See also

   wxNotebookEvent::GetSelection

=head1 Wx::NotebookSizer

=head2 Wx::NotebookSizer::new

   wxNotebookSizer(wxNotebook* notebook)

   Constructor. It takes an associated notebook as its only parameter.

=head2 Wx::NotebookSizer::GetNotebook

   wxNotebook* GetNotebook()

   Returns the notebook associated with the sizer.

=head1 Wx::NotifyEvent

=head2 Wx::NotifyEvent::new

   wxNotifyEvent(wxEventType eventType = wxEVT_NULL, int id = 0)

   Constructor (used internally by wxWidgets only).

=head2 Wx::NotifyEvent::Allow

   void Allow()

   This is the opposite of Veto(): it explicitly allows the event to be
   processed. For most events it is not necessary to call this method as
   the events are allowed anyhow but some are forbidden by default (this
   will be mentioned in the corresponding event description).

=head2 Wx::NotifyEvent::IsAllowed

   bool IsAllowed() const

   Returns true if the change is allowed (Veto() hasn't been called) or
   false otherwise (if it was).

=head2 Wx::NotifyEvent::Veto

   void Veto()

   Prevents the change announced by this event from happening.

   It is in general a good idea to notify the user about the reasons for
   vetoing the change because otherwise the applications behaviour (which
   just refuses to do what the user wants) might be quite surprising.

=head1 Wx::Object

=head2 Wx::Object::new

   wxObject()

   wxObject(const wxObject& other)

   Default and copy constructors.

=head2 Wx::Object::DESTROY

   wxObject()

   Destructor. Performs dereferencing, for those objects that use
   reference counting.

=head2 Wx::Object::m_refData

   wxObjectRefData* m_refData

   Pointer to an object which is the object's reference-counted data.

   See also

   wxObject::Ref, wxObject::UnRef, wxObject::SetRefData,
   wxObject::GetRefData, wxObjectRefData

=head2 Wx::Object::Dump

   void Dump(ostream& stream)

   A virtual function that may be redefined by derived classes to allow
   dumping of memory states.

   This function is only defined in debug build and doesn't exist at all
   if __WXDEBUG__ is not defined.

   Parameters

   stream

       Stream on which to output dump information.

   Remarks

   Currently wxWidgets does not define Dump for derived classes, but
   programmers may wish to use it for their own applications. Be sure to
   call the Dump member of the class's base class to allow all
   information to be dumped.

   The implementation of this function in wxObject just writes the class
   name of the object.

=head2 Wx::Object::GetClassInfo

   wxClassInfo * GetClassInfo()

   This virtual function is redefined for every class that requires
   run-time type information, when using DECLARE_CLASS macros.

=head2 Wx::Object::GetRefData

   wxObjectRefData* GetRefData() const

   Returns the m_refData pointer.

   See also

   wxObject::Ref, wxObject::UnRef, wxObject::m_refData,
   wxObject::SetRefData, wxObjectRefData

=head2 Wx::Object::IsKindOf

   bool IsKindOf(wxClassInfo *info)

   Determines whether this class is a subclass of (or the same class as)
   the given class.

   Parameters

   info

       A pointer to a class information object, which may be obtained by
       using the CLASSINFO macro.

   Return value

   true if the class represented by info is the same class as this one or
   is derived from it.

   Example

     bool tmp = obj->IsKindOf(CLASSINFO(wxFrame));

=head2 Wx::Object::IsSameAs

   bool IsSameAs(const wxObject& obj)

   Returns true if this object has the same data pointer as obj. Notice
   that true is returned if the data pointers are NULL in both objects.

   This function only does a shallow comparison, i.e. it doesn't compare
   the objects pointed to by the data pointers of these objects.

=head2 Wx::Object::Ref

   void Ref(const wxObject& clone)

   Makes this object refer to the data in clone.

   Parameters

   clone

       The object to 'clone'.

   Remarks

   First this function calls wxObject::UnRef on itself to decrement (and
   perhaps free) the data it is currently referring to.

   It then sets its own m_refData to point to that of clone, and
   increments the reference count inside the data.

   See also

   wxObject::UnRef, wxObject::m_refData, wxObject::SetRefData,
   wxObject::GetRefData, wxObjectRefData

=head2 Wx::Object::SetRefData

   void SetRefData(wxObjectRefData* data)

   Sets the m_refData pointer.

   See also

   wxObject::Ref, wxObject::UnRef, wxObject::m_refData,
   wxObject::GetRefData, wxObjectRefData

=head2 Wx::Object::UnRef

   void UnRef()

   Decrements the reference count in the associated data, and if it is
   zero, deletes the data. The m_refData member is set to NULL.

   See also

   wxObject::Ref, wxObject::m_refData, wxObject::SetRefData,
   wxObject::GetRefData, wxObjectRefData

=head2 Wx::Object::UnShare

   void UnShare()

   Ensure that this object's data is not shared with any other object.

   if we have no data, it is created using CreateRefData() below, if we
   have shared data it is copied using CloneRefData(), otherwise nothing
   is done.

=head1 Wx::ObjectRefData

=head2 Wx::ObjectRefData::new

   wxObjectRefData()

   Default constructor. Initialises the m_count member to 1.

=head2 Wx::ObjectRefData::DESTROY

   wxObjectRefData()

   Destructor.

=head2 Wx::ObjectRefData::GetRefCount

   int GetRefCount() const

   Returns the reference count associated with this shared data. When
   this goes to zero during a wxObject::UnRef, an object can delete this
   wxObjectRefData object.

=head1 Wx::OwnerDrawnComboBox

=head2 Wx::OwnerDrawnComboBox::new

   wxOwnerDrawnComboBox()

   Default constructor.

   wxOwnerDrawnComboBox(wxWindow* parent, wxWindowID id, const wxString&
   value = "", const wxPoint& pos = wxDefaultPosition, const wxSize& size
   = wxDefaultSize, int n = 0, const wxString choices[] = NULL, long
   style = 0, const wxValidator& validator = wxDefaultValidator, const
   wxString& name = "comboBox")

   wxOwnerDrawnComboBox(wxWindow* parent, wxWindowID id, const wxString&
   value, const wxPoint& pos, const wxSize& size, const wxArrayString&
   choices, long style = 0, const wxValidator& validator =
   wxDefaultValidator, const wxString& name = "comboBox")

   Constructor, creating and showing a owner-drawn combobox.

   Parameters

   parent

       Parent window. Must not be NULL.

   id  

       Window identifier. A value of -1 indicates a default value.

   value

       Initial selection string. An empty string indicates no selection.

   pos 

       Window position.

   size

       Window size. If the default size (-1, -1) is specified then the
       window is sized appropriately.

   n   

       Number of strings with which to initialise the control.

   choices

       An array of strings with which to initialise the control.

   style

       Window style. See wxOwnerDrawnComboBox.

   validator

       Window validator.

   name

       Window name.

   See also

   wxOwnerDrawnComboBox::Create, wxValidator

=head2 Wx::OwnerDrawnComboBox::DESTROY

   ~wxOwnerDrawnComboBox()

   Destructor, destroying the owner-drawn combobox.

=head2 Wx::OwnerDrawnComboBox::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxString& value =
   "", const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, int n, const wxString choices[], long style = 0, const
   wxValidator& validator = wxDefaultValidator, const wxString& name =
   "comboBox")

   bool Create(wxWindow* parent, wxWindowID id, const wxString& value,
   const wxPoint& pos, const wxSize& size, const wxArrayString& choices,
   long style = 0, const wxValidator& validator = wxDefaultValidator,
   const wxString& name = "comboBox")

   Creates the combobox for two-step construction. Derived classes should
   call or replace this function. See
   wxOwnerDrawnComboBox::wxOwnerDrawnComboBox for further details.

=head2 Wx::OwnerDrawnComboBox::GetWidestItem

   int GetWidestItem() const

   Returns index to the widest item in the list.

=head2 Wx::OwnerDrawnComboBox::GetWidestItemWidth

   int GetWidestItemWidth() const

   Returns width of the widest item in the list.

=head2 Wx::OwnerDrawnComboBox::OnDrawBackground

   void OnDrawBackground(wxDC& dc, const wxRect& rect, int item, int
   flags) const

   This method is used to draw the items background and, maybe, a border
   around it.

   The base class version implements a reasonable default behaviour which
   consists in drawing the selected item with the standard background
   colour and drawing a border around the item if it is either selected
   or current.

   Remarks

   flags has the same meaning as with OnDrawItem.

=head2 Wx::OwnerDrawnComboBox::OnDrawItem

   void OnDrawItem(wxDC& dc, const wxRect& rect, int item, int flags)
   const

   The derived class may implement this function to actually draw the
   item with the given index on the provided DC. If function is not
   implemented, the item text is simply drawn, as if the control was a
   normal combobox.

   Parameters

   dc  

       The device context to use for drawing

   rect

       The bounding rectangle for the item being drawn (DC clipping
       region is set to this rectangle before calling this function)

   item

       The index of the item to be drawn

   flags

       Combines any of the following flag values:

=head2 Wx::OwnerDrawnComboBox::OnMeasureItem

   wxCoord OnMeasureItem(size_t item) const

   The derived class may implement this method to return the height of
   the specified item (in pixels).

   The default implementation returns text height, as if this control was
   a normal combobox.

=head2 Wx::OwnerDrawnComboBox::OnMeasureItemWidth

   wxCoord OnMeasureItemWidth(size_t item) const

   The derived class may implement this method to return the width of the
   specified item (in pixels). If -1 is returned, then the item text
   width is used.

   The default implementation returns -1.

=head1 Wx::OutputStream

=head2 Wx::OutputStream::new

   wxOutputStream()

   Creates a dummy wxOutputStream object.

=head2 Wx::OutputStream::DESTROY

   ~wxOutputStream()

   Destructor.

=head2 Wx::OutputStream::Close

   bool Close()

   Closes the stream, returning false if an error occurs. The stream is
   closed implicitly in the destructor if Close() is not called
   explicitly.

   If this stream wraps another stream or some other resource such as a
   file, then the underlying resource is closed too if it is owned by
   this stream, or left open otherwise.

=head2 Wx::OutputStream::LastWrite

   size_t LastWrite() const

   Returns the number of bytes written during the last Write(). It may
   return 0 even if there is no error on the stream if it is only
   temporarily impossible to write to it.

=head2 Wx::OutputStream::PutC

   void PutC(char c)

   Puts the specified character in the output queue and increments the
   stream position.

=head2 Wx::OutputStream::SeekO

   off_t SeekO(off_t pos, wxSeekMode mode = wxFromStart)

   Changes the stream current position.

   Parameters

   pos 

       Offset to seek to.

   mode

       One of wxFromStart, wxFromEnd, wxFromCurrent.

   Return value

   The new stream position or wxInvalidOffset on error.

=head2 Wx::OutputStream::TellO

   off_t TellO() const

   Returns the current stream position.

=head2 Wx::OutputStream::Write

   wxOutputStream& Write(const void *buffer, size_t size)

   Writes up to the specified amount of bytes using the data of buffer.
   Note that not all data can always be written so you must check the
   number of bytes really written to the stream using LastWrite() when
   this function returns. In some cases (for example a write end of a
   pipe which is currently full) it is even possible that there is no
   errors and zero bytes have been written.

   This function returns a reference on the current object, so the user
   can test any states of the stream right away.

   wxOutputStream& Write(wxInputStream& stream_in)

   Reads data from the specified input stream and stores them in the
   current stream. The data is read until an error is raised by one of
   the two streams.

=head1 Wx::PageSetupDialog

=head2 Wx::PageSetupDialog::new

   wxPageSetupDialog(wxWindow* parent, wxPageSetupDialogData* data = NULL)

   Constructor. Pass a parent window, and optionally a pointer to a block
   of page setup data, which will be copied to the print dialog's
   internal data.

=head2 Wx::PageSetupDialog::DESTROY

   ~wxPageSetupDialog()

   Destructor.

=head2 Wx::PageSetupDialog::GetPageSetupData

   wxPageSetupDialogData& GetPageSetupData()

   Returns the page setup data associated with the dialog.

=head2 Wx::PageSetupDialog::ShowModal

   int ShowModal()

   Shows the dialog, returning wxID_OK if the user pressed OK, and
   wxID_CANCEL otherwise.

=head1 Wx::PageSetupDialogData

=head2 Wx::PageSetupDialogData::new

   wxPageSetupDialogData()

   Default constructor.

   wxPageSetupDialogData(wxPageSetupDialogData& data)

   Copy constructor.

   wxPageSetupDialogData(wxPrintData& printData)

   Construct an object from a print data object.

=head2 Wx::PageSetupDialogData::DESTROY

   ~wxPageSetupDialogData()

   Destructor.

=head2 Wx::PageSetupDialogData::EnableHelp

   void EnableHelp(bool flag)

   Enables or disables the 'Help' button (Windows only).

=head2 Wx::PageSetupDialogData::EnableMargins

   void EnableMargins(bool flag)

   Enables or disables the margin controls (Windows only).

=head2 Wx::PageSetupDialogData::EnableOrientation

   void EnableOrientation(bool flag)

   Enables or disables the orientation control (Windows only).

=head2 Wx::PageSetupDialogData::EnablePaper

   void EnablePaper(bool flag)

   Enables or disables the paper size control (Windows only).

=head2 Wx::PageSetupDialogData::EnablePrinter

   void EnablePrinter(bool flag)

   Enables or disables the Printer button, which invokes a printer setup
   dialog.

=head2 Wx::PageSetupDialogData::GetDefaultMinMargins

   bool GetDefaultMinMargins() const

   Returns true if the page setup dialog will take its minimum margin
   values from the currently selected printer properties. Windows only.

=head2 Wx::PageSetupDialogData::GetEnableMargins

   bool GetEnableMargins() const

   Returns true if the margin controls are enabled (Windows only).

=head2 Wx::PageSetupDialogData::GetEnableOrientation

   bool GetEnableOrientation() const

   Returns true if the orientation control is enabled (Windows only).

=head2 Wx::PageSetupDialogData::GetEnablePaper

   bool GetEnablePaper() const

   Returns true if the paper size control is enabled (Windows only).

=head2 Wx::PageSetupDialogData::GetEnablePrinter

   bool GetEnablePrinter() const

   Returns true if the printer setup button is enabled.

=head2 Wx::PageSetupDialogData::GetEnableHelp

   bool GetEnableHelp() const

   Returns true if the printer setup button is enabled.

=head2 Wx::PageSetupDialogData::GetDefaultInfo

   bool GetDefaultInfo() const

   Returns true if the dialog will simply return default printer
   information (such as orientation) instead of showing a dialog. Windows
   only.

=head2 Wx::PageSetupDialogData::GetMarginTopLeft

   wxPoint GetMarginTopLeft() const

   Returns the left (x) and top (y) margins in millimetres.

=head2 Wx::PageSetupDialogData::GetMarginBottomRight

   wxPoint GetMarginBottomRight() const

   Returns the right (x) and bottom (y) margins in millimetres.

=head2 Wx::PageSetupDialogData::GetMinMarginTopLeft

   wxPoint GetMinMarginTopLeft() const

   Returns the left (x) and top (y) minimum margins the user can enter
   (Windows only). Units are in millimetres

=head2 Wx::PageSetupDialogData::GetMinMarginBottomRight

   wxPoint GetMinMarginBottomRight() const

   Returns the right (x) and bottom (y) minimum margins the user can
   enter (Windows only). Units are in millimetres

=head2 Wx::PageSetupDialogData::GetPaperId

   wxPaperSize GetPaperId() const

   Returns the paper id (stored in the internal wxPrintData object).

   For further information, see wxPrintData::SetPaperId.

=head2 Wx::PageSetupDialogData::GetPaperSize

   wxSize GetPaperSize() const

   Returns the paper size in millimetres.

=head2 Wx::PageSetupDialogData::GetPrintData

   wxPrintData& GetPrintData()

   Returns a reference to the print data associated with this object.

=head2 Wx::PageSetupDialogData::IsOk

   bool IsOk() const

   Returns true if the print data associated with the dialog data is
   valid. This can return false on Windows if the current printer is not
   set, for example. On all other platforms, it returns true.

=head2 Wx::PageSetupDialogData::SetDefaultInfo

   void SetDefaultInfo(bool flag)

   Pass true if the dialog will simply return default printer information
   (such as orientation) instead of showing a dialog. Windows only.

=head2 Wx::PageSetupDialogData::SetDefaultMinMargins

   void SetDefaultMinMargins(bool flag)

   Pass true if the page setup dialog will take its minimum margin values
   from the currently selected printer properties. Windows only. Units
   are in millimetres

=head2 Wx::PageSetupDialogData::SetMarginTopLeft

   void SetMarginTopLeft(const wxPoint& pt)

   Sets the left (x) and top (y) margins in millimetres.

=head2 Wx::PageSetupDialogData::SetMarginBottomRight

   void SetMarginBottomRight(const wxPoint& pt)

   Sets the right (x) and bottom (y) margins in millimetres.

=head2 Wx::PageSetupDialogData::SetMinMarginTopLeft

   void SetMinMarginTopLeft(const wxPoint& pt)

   Sets the left (x) and top (y) minimum margins the user can enter
   (Windows only). Units are in millimetres.

=head2 Wx::PageSetupDialogData::SetMinMarginBottomRight

   void SetMinMarginBottomRight(const wxPoint& pt)

   Sets the right (x) and bottom (y) minimum margins the user can enter
   (Windows only). Units are in millimetres.

=head2 Wx::PageSetupDialogData::SetPaperId

   void SetPaperId(wxPaperSize& id)

   Sets the paper size id. For further information, see
   wxPrintData::SetPaperId.

   Calling this function overrides the explicit paper dimensions passed
   in wxPageSetupDialogData::SetPaperSize.

=head2 Wx::PageSetupDialogData::SetPaperSize

   void SetPaperSize(const wxSize& size)

   Sets the paper size in millimetres. If a corresponding paper id is
   found, it will be set in the internal wxPrintData object, otherwise
   the paper size overrides the paper id.

=head2 Wx::PageSetupDialogData::SetPrintData

   void SetPrintData(const wxPrintData& printData)

   Sets the print data associated with this object.

=head1 Wx::PaintDC

=head2 Wx::PaintDC::new

   wxPaintDC(wxWindow* window)

   Constructor. Pass a pointer to the window on which you wish to paint.

=head1 Wx::PaintEvent

=head2 Wx::PaintEvent::new

   wxPaintEvent(int id = 0)

   Constructor.

=head1 Wx::Palette

=head2 Wx::Palette::new

   wxPalette()

   Default constructor.

   wxPalette(const wxPalette& palette)

   Copy constructor, uses reference counting.

   wxPalette(int n, const unsigned char* red,

=head2 Wx::Palette::DESTROY

   ~wxPalette()

   Destructor. See reference-counted object destruction for more info.

=head2 Wx::Palette::Create

   bool Create(int n, const unsigned char* red, const unsigned char*
   green, const unsigned char* blue)

   Creates a palette from arrays of size n, one for each red, blue or
   green component.

   Parameters

   n   

       The number of indices in the palette.

   red 

       An array of red values.

   green

       An array of green values.

   blue

       An array of blue values.

   Return value

   true if the creation was successful, false otherwise.

   See also

   wxPalette::wxPalette

=head2 Wx::Palette::GetColoursCount

   int GetColoursCount() const

   Returns number of entries in palette.

=head2 Wx::Palette::GetPixel

   int GetPixel(unsigned char red, unsigned char green, unsigned char
   blue) const

   Returns a pixel value (index into the palette) for the given RGB
   values.

   Parameters

   red 

       Red value.

   green

       Green value.

   blue

       Blue value.

   Return value

   The nearest palette index or wxNOT_FOUND for unexpected errors.

   See also

   wxPalette::GetRGB

=head2 Wx::Palette::GetRGB

   bool GetRGB(int pixel, const unsigned char* red, const unsigned char*
   green, const unsigned char* blue) const

   Returns RGB values for a given palette index.

   Parameters

   pixel

       The palette index.

   red 

       Receives the red value.

   green

       Receives the green value.

   blue

       Receives the blue value.

   Return value

   true if the operation was successful.

   See also

   wxPalette::GetPixel

   wxPerl note: In wxPerl this method takes only the pixel parameter and
   returns a 3-element list ( or the empty list upon failure ).

=head2 Wx::Palette::IsOk

   bool IsOk() const

   Returns true if palette data is present.

=head1 Wx::Panel

=head2 Wx::Panel::new

   wxPanel()

   Default constructor.

   wxPanel(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint& pos
   = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style =
   wxTAB_TRAVERSAL, const wxString& name = "panel")

   Constructor.

   Parameters

   parent

       The parent window.

   id  

       An identifier for the panel. A value of -1 is taken to mean a
       default.

   pos 

       The panel position. A value of (-1, -1) indicates a default
       position, chosen by either the windowing system or wxWidgets,
       depending on platform.

   size

       The panel size. A value of (-1, -1) indicates a default size,
       chosen by either the windowing system or wxWidgets, depending on
       platform.

   style

       The window style. See wxPanel.

   name

       Used to associate a name with the window, allowing the application
       user to set Motif resource values for individual dialog boxes.

   See also

   wxPanel::Create

=head2 Wx::Panel::DESTROY

   ~wxPanel()

   Destructor. Deletes any child windows before deleting the physical
   window.

=head2 Wx::Panel::Create

   bool Create(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint&
   pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long
   style = wxTAB_TRAVERSAL, const wxString& name = "panel")

   Used for two-step panel construction. See wxPanel::wxPanel for
   details.

=head2 Wx::Panel::InitDialog

   void InitDialog()

   Sends a wxInitDialogEvent, which in turn transfers data to the dialog
   via validators.

   See also

   wxInitDialogEvent

=head2 Wx::Panel::OnSysColourChanged

   void OnSysColourChanged(wxSysColourChangedEvent& event)

   The default handler for wxEVT_SYS_COLOUR_CHANGED.

   Parameters

   event

       The colour change event.

   Remarks

   Changes the panel's colour to conform to the current settings (Windows
   only). Add an event table entry for your panel class if you wish the
   behaviour to be different (such as keeping a user-defined background
   colour). If you do override this function, call wxEvent::Skip to
   propagate the notification to child windows and controls.

   See also

   wxSysColourChangedEvent

=head2 Wx::Panel::SetFocus

   virtual void SetFocus()

   Overrides wxWindow::SetFocus. This method uses the (undocumented)
   mix-in class wxControlContainer which manages the focus and TAB logic
   for controls which usually have child controls. In practice, if you
   call this method and the control has at least one child window, the
   focus will be given to the child window.

   See also

   wxFocusEvent wxWindow::SetFocus

=head2 Wx::Panel::SetFocusIgnoringChildren

   virtual void SetFocusIgnoringChildren()

   In contrast to wxPanel::SetFocus (see above) this will set the focus
   to the panel even of there are child windows in the panel. This is
   only rarely needed.

   See also

   wxFocusEvent wxPanel::SetFocus

=head1 Wx::PasswordEntryDialog

=head2 Wx::PasswordEntryDialog::new

   wxPasswordEntryDialog(wxWindow* parent, const wxString& message, const
   wxString& caption = "Enter password", const wxString& defaultValue =
   "", long style = wxOK | wxCANCEL | wxCENTRE, const wxPoint& pos =
   wxDefaultPosition)

   Constructor. Use wxTextEntryDialog::ShowModal to show the dialog.

   Parameters

   parent

       Parent window.

   message

       Message to show on the dialog.

   defaultValue

       The default value, which may be the empty string.

   style

       A dialog style, specifying the buttons (wxOK, wxCANCEL) and an
       optional wxCENTRE style. You do not need to specify the
       wxTE_PASSWORD style, it is always applied.

   pos 

       Dialog position.

=head1 Wx::PathList

=head2 Wx::PathList::new

   wxPathList()

   Empty constructor.

   wxPathList(const wxArrayString& arr)

   Constructs the object calling the Add function.

=head2 Wx::PathList::AddEnvList

   void AddEnvList(const wxString& env_variable)

   Finds the value of the given environment variable, and adds all paths
   to the path list. Useful for finding files in the PATH variable, for
   example.

=head2 Wx::PathList::Add

   bool Add(const wxString& path)

   void Add(const wxArrayString& arr)

   The first form adds the given directory to the path list, if the path
   is not already in the list. If the path cannot be normalized for some
   reason, it returns false.

   The second form just calls the first form on all elements of the given
   array.

   The path is always considered a directory but no existence checks will
   be done on it (because if it doesn't exist, it could be created later
   and thus result a valid path when FindValidPath is called).

   Note: if the given path is relative, it won't be made absolute before
   adding it (this is why FindValidPath may return relative paths).

=head2 Wx::PathList::EnsureFileAccessible

   bool EnsureFileAccessible(const wxString& filename)

   Given a full filename (with path), calls Add with the path of the
   file.

=head2 Wx::PathList::FindAbsoluteValidPath

   wxString FindAbsoluteValidPath(const wxString& file) const

   Like FindValidPath but this function always returns an absolute path
   (eventually prepending the current working directory to the value
   returned FindValidPath) or an empty string.

=head2 Wx::PathList::FindValidPath

   wxString FindValidPath(const wxString& file) const

   Searches the given file in all paths stored in this class. The first
   path which concatenated to the given string points to an existing file
   (see wxFileExists) is returned.

   If the file wasn't found in any of the stored paths, an empty string
   is returned.

   The given string must be a file name, eventually with a path prefix
   (if the path prefix is absolute, only its name will be searched); i.e.
   it must not end with a directory separator (see
   wxFileName::GetPathSeparator) otherwise an assertion will fail.

   The returned path may be relative to the current working directory.
   Note in fact that wxPathList can be used to store both relative and
   absolute paths so that if you Add()ed relative paths, then the current
   working directory (see wxGetCwd and wxSetWorkingDirectory) may affect
   the value returned by this function!

=head1 Wx::Pen

=head2 Wx::Pen::new

   wxPen()

   Default constructor. The pen will be uninitialised, and wxPen:IsOk
   will return false.

   wxPen(const wxColour& colour, int width = 1, int style = wxSOLID)

   Constructs a pen from a colour object, pen width and style.

   wxPen(const wxString& colourName, int width, int style)

   Constructs a pen from a colour name, pen width and style.

   wxPen(const wxBitmap& stipple, int width)

   Constructs a stippled pen from a stipple bitmap and a width.

   wxPen(const wxPen& pen)

   Copy constructor, uses reference counting.

   Parameters

   colour

       A colour object.

   colourName

       A colour name.

   width

       Pen width. Under Windows, the pen width cannot be greater than 1
       if the style is wxDOT, wxLONG_DASH, wxSHORT_DASH, wxDOT_DASH, or
       wxUSER_DASH.

   stipple

       A stipple bitmap.

   pen 

       A pointer or reference to a pen to copy.

   style

       The style may be one of the following:

=head2 Wx::Pen::DESTROY

   ~wxPen()

   Destructor. See reference-counted object destruction for more info.

   Remarks

   Although all remaining pens are deleted when the application exits,
   the application should try to clean up all pens itself. This is
   because wxWidgets cannot know if a pointer to the pen object is stored
   in an application data structure, and there is a risk of double
   deletion.

=head2 Wx::Pen::GetCap

   int GetCap() const

   Returns the pen cap style, which may be one of wxCAP_ROUND,
   wxCAP_PROJECTING and wxCAP_BUTT. The default is wxCAP_ROUND.

   See also

   wxPen::SetCap

=head2 Wx::Pen::GetColour

   wxColour& GetColour() const

   Returns a reference to the pen colour.

   See also

   wxPen::SetColour

=head2 Wx::Pen::GetDashes

   int GetDashes(wxDash** dashes) const

   Gets an array of dashes (defined as char in X, DWORD under Windows).
   dashes is a pointer to the internal array. Do not deallocate or store
   this pointer. The function returns the number of dashes associated
   with this pen.

   See also

   wxPen::SetDashes

=head2 Wx::Pen::GetJoin

   int GetJoin() const

   Returns the pen join style, which may be one of wxJOIN_BEVEL,
   wxJOIN_ROUND and wxJOIN_MITER. The default is wxJOIN_ROUND.

   See also

   wxPen::SetJoin

=head2 Wx::Pen::GetStipple

   wxBitmap* GetStipple() const

   Gets a pointer to the stipple bitmap.

   See also

   wxPen::SetStipple

=head2 Wx::Pen::GetStyle

   int GetStyle() const

   Returns the pen style.

   See also

   wxPen::wxPen, wxPen::SetStyle

=head2 Wx::Pen::GetWidth

   int GetWidth() const

   Returns the pen width.

   See also

   wxPen::SetWidth

=head2 Wx::Pen::IsOk

   bool IsOk() const

   Returns true if the pen is initialised.

=head2 Wx::Pen::SetCap

   void SetCap(int capStyle)

   Sets the pen cap style, which may be one of wxCAP_ROUND,
   wxCAP_PROJECTING and wxCAP_BUTT. The default is wxCAP_ROUND.

   See also

   wxPen::GetCap

=head2 Wx::Pen::SetColour

   void SetColour(wxColour& colour)

   void SetColour(const wxString& colourName)

   void SetColour(unsigned char red, unsigned char green, unsigned char
   blue)

   The pen's colour is changed to the given colour.

   See also

   wxPen::GetColour

=head2 Wx::Pen::SetDashes

   void SetDashes(int n, wxDash* dashes)

   Associates an array of pointers to dashes (defined as char in X, DWORD
   under Windows) with the pen. The array is not deallocated by wxPen,
   but neither must it be deallocated by the calling application until
   the pen is deleted or this function is called with a NULL array.

   See also

   wxPen::GetDashes

=head2 Wx::Pen::SetJoin

   void SetJoin(int join_style)

   Sets the pen join style, which may be one of wxJOIN_BEVEL,
   wxJOIN_ROUND and wxJOIN_MITER. The default is wxJOIN_ROUND.

   See also

   wxPen::GetJoin

=head2 Wx::Pen::SetStipple

   void SetStipple(wxBitmap* stipple)

   Sets the bitmap for stippling.

   See also

   wxPen::GetStipple

=head2 Wx::Pen::SetStyle

   void SetStyle(int style)

   Set the pen style.

   See also

   wxPen::wxPen

=head2 Wx::Pen::SetWidth

   void SetWidth(int width)

   Sets the pen width.

   See also

   wxPen::GetWidth

=head1 Wx::PenList

=head2 Wx::PenList::new

   void wxPenList()

   Constructor. The application should not construct its own pen list:
   use the object pointer wxThePenList.

=head2 Wx::PenList::FindOrCreatePen

   wxPen* FindOrCreatePen(const wxColour& colour, int width, int style)

   Finds a pen with the specified attributes and returns it, else creates
   a new pen, adds it to the pen list, and returns it.

   wxPen* FindOrCreatePen(const wxString& colourName, int width, int
   style)

   Finds a pen with the specified attributes and returns it, else creates
   a new pen, adds it to the pen list, and returns it.

   Parameters

   colour

       Colour object.

   colourName

       Colour name, which should be in the colour database.

   width

       Width of pen.

   style

       Pen style. See wxPen::wxPen for a list of styles.

=head1 Wx::PickerBase

=head2 Wx::PickerBase::SetInternalMargin

   void SetInternalMargin(intmargin)

   Sets the margin (in pixel) between the picker and the text control.
   This function can be used only when HasTextCtrl returns true.

=head2 Wx::PickerBase::GetInternalMargin

   int GetInternalMargin() const

   Returns the margin (in pixel) between the picker and the text control.
   This function can be used only when HasTextCtrl returns true.

=head2 Wx::PickerBase::SetTextCtrlProportion

   void SetTextCtrlProportion(intprop)

   Sets the proportion value of the text control. Look at the overview of
   wxPickerBase for more details about this. This function can be used
   only when HasTextCtrl returns true.

=head2 Wx::PickerBase::SetPickerCtrlProportion

   void SetPickerCtrlProportion(intprop)

   Sets the proportion value of the picker. Look at the overview of
   wxPickerBase for more details about this.

=head2 Wx::PickerBase::GetTextCtrlProportion

   int GetTextCtrlProportion() const

   Returns the proportion value of the text control. This function can be
   used only when HasTextCtrl returns true.

=head2 Wx::PickerBase::GetPickerCtrlProportion

   int GetPickerCtrlProportion() const

   Returns the proportion value of the picker.

=head2 Wx::PickerBase::HasTextCtrl

   bool HasTextCtrl() const

   Returns true if this window has a valid text control (i.e. if the
   wxPB_USE_TEXTCTRL style was given when creating this control).

=head2 Wx::PickerBase::GetTextCtrl

   wxTextCtrl * GetTextCtrl()

   Returns a pointer to the text control handled by this window or NULL
   if the wxPB_USE_TEXTCTRL style was not specified when this control was
   created. Very important: the contents of the text control could be
   containing an invalid representation of the entity which can be chosen
   through the picker (e.g. the user entered an invalid colour syntax
   because of a typo). Thus you should never parse the content of the
   textctrl to get the user's input; rather use the derived-class getter
   (e.g. wxColourPickerCtrl::GetColour, wxFilePickerCtrl::GetPath, etc).

=head2 Wx::PickerBase::IsTextCtrlGrowable

   bool IsTextCtrlGrowable() const

   Returns true if the text control is growable. This function can be
   used only when HasTextCtrl returns true.

=head2 Wx::PickerBase::SetPickerCtrlGrowable

   void SetPickerCtrlGrowable(bool grow = true)

   Sets the picker control as growable when grow is true.

=head2 Wx::PickerBase::SetTextCtrlGrowable

   void SetTextCtrlGrowable(bool grow = true)

   Sets the text control as growable when grow is true. This function can
   be used only when HasTextCtrl returns true.

=head2 Wx::PickerBase::IsPickerCtrlGrowable

   bool IsPickerCtrlGrowable() const

   Returns true if the picker control is growable.

=head1 Wx::PlatformInfo

=head2 Wx::PlatformInfo::new

   wxPlatformInfo()

   Initializes the instance with the values corresponding to the
   currently running platform. This is a fast operation because it only
   requires to copy the values internally cached for the currently
   running platform (see also Get).

   wxPlatformInfo(wxPortId pid = wxPORT_UNKNOWN, int tkMajor = -1, int
   tkMinor = -1, wxOperatingSystemId id = wxOS_UNKNOWN, int osMajor = -1,
   int osMinor = -1, wxArchitecture arch = wxARCH_INVALID, wxEndianness
   endian = wxENDIAN_INVALID)

   Initializes the object using given values.

=head2 Wx::PlatformInfo::CheckOSVersion

   bool CheckOSVersion(int major, int minor) const

   Returns true if the OS version is at least major.minor.

   See also

   GetOSMajorVersion, GetOSMinorVersion, CheckToolkitVersion

=head2 Wx::PlatformInfo::CheckToolkitVersion

   bool CheckToolkitVersion(int major, int minor) const

   Returns true if the toolkit version is at least major.minor.

   See also

   GetToolkitMajorVersion, GetToolkitMinorVersion, CheckOSVersion

=head2 Wx::PlatformInfo::Get

   static const wxPlatformInfo& Get()

   Returns the global wxPlatformInfo object, initialized with the values
   for the currently running platform.

=head2 Wx::PlatformInfo::GetArch

   static wxArchitecture GetArch(const wxString& arch)

   Converts the given string to a wxArchitecture enum value or to
   wxARCH_INVALID if the given string is not a valid architecture string
   (i.e. does not contain nor 32 nor 64 strings).

=head2 Wx::PlatformInfo::GetArchName

   static wxString GetArchName(wxArchitecture arch)

   Returns the name for the given wxArchitecture enumeration value.

   wxString GetArchName() const

   Returns the name for the architecture of this wxPlatformInfo instance.

=head2 Wx::PlatformInfo::GetArchitecture

   wxArchitecture GetArchitecture() const

   Returns the architecture ID of this wxPlatformInfo instance.

=head2 Wx::PlatformInfo::GetEndianness

   static wxEndianness GetEndianness(const wxString& end)

   Converts the given string to a wxEndianness enum value or to
   wxENDIAN_INVALID if the given string is not a valid endianness string
   (i.e. does not contain nor little nor big strings).

   wxEndianness GetEndianness() const

   Returns the endianness ID of this wxPlatformInfo instance.

=head2 Wx::PlatformInfo::GetEndiannessName

   static wxString GetEndiannessName(wxEndianness end)

   Returns name for the given wxEndianness enumeration value.

   wxString GetEndiannessName() const

   Returns the name for the endianness of this wxPlatformInfo instance.

=head2 Wx::PlatformInfo::GetOSMajorVersion

   int GetOSMajorVersion() const

   Returns the run-time major version of the OS associated with this
   wxPlatformInfo instance. See wxGetOsVersion for more info.

   See also

   CheckOSVersion

=head2 Wx::PlatformInfo::GetOSMinorVersion

   int GetOSMinorVersion() const

   Returns the run-time minor version of the OS associated with this
   wxPlatformInfo instance. See wxGetOsVersion for more info.

   See also

   CheckOSVersion

=head2 Wx::PlatformInfo::GetOperatingSystemFamilyName

   static wxString GetOperatingSystemFamilyName(wxOperatingSystemId os)

   Returns the operating system family name for the given
   wxOperatingSystemId enumeration value: Unix for wxOS_UNIX, Macintosh
   for wxOS_MAC, Windows for wxOS_WINDOWS, DOS for wxOS_DOS, OS/2 for
   wxOS_OS2.

   wxString GetOperatingSystemFamilyName() const

   Returns the operating system family name of the OS associated with
   this wxPlatformInfo instance.

=head2 Wx::PlatformInfo::GetOperatingSystemId

   static wxOperatingSystemId GetOperatingSystemId(const wxString& name)

   Converts the given string to a wxOperatingSystemId enum value or to
   wxOS_UNKNOWN if the given string is not a valid operating system name.

   wxOperatingSystemId GetOperatingSystemId() const

   Returns the operating system ID of this wxPlatformInfo instance.

=head2 Wx::PlatformInfo::GetOperatingSystemIdName

   static wxString GetOperatingSystemIdName(wxOperatingSystemId os)

   Returns the name for the given operating system ID value. This can be
   a long name (e.g. Microsoft Windows NT); use
   GetOperatingSystemFamilyName to retrieve a short, generic name.

=head2 Wx::PlatformInfo::GetPortId

   static wxPortId GetPortId(const wxString& portname)

   Converts the given string to a wxWidgets port ID value or to
   wxPORT_UNKNOWN if the given string does not match any of the wxWidgets
   canonical name ports ("wxGTK", "wxMSW", etc) nor any of the short
   wxWidgets name ports ("gtk", "msw", etc).

   wxPortId GetPortId() const

   Returns the wxWidgets port ID associated with this wxPlatformInfo
   instance.

=head2 Wx::PlatformInfo::GetPortIdName

   static wxString GetPortIdName(wxPortId port, bool usingUniversal)

   Returns the name of the given wxWidgets port ID value. The
   usingUniversal argument specifies whether the port is in its native or
   wxUniversal variant.

   The returned string always starts with the "wx" prefix and is a
   mixed-case string.

   wxString GetPortIdName() const

   Returns the name of the wxWidgets port ID associated with this
   wxPlatformInfo instance.

=head2 Wx::PlatformInfo::GetPortIdShortName

   static wxString GetPortIdShortName(wxPortId port, bool usingUniversal)

   Returns the short name of the given wxWidgets port ID value. The
   usingUniversal argument specifies whether the port is in its native or
   wxUniversal variant.

   The returned string does not start with the "wx" prefix and is always
   lower case.

   wxString GetPortIdShortName() const

   Returns the short name of the wxWidgets port ID associated with this
   wxPlatformInfo instance.

=head2 Wx::PlatformInfo::GetToolkitMajorVersion

   int GetToolkitMajorVersion() const

   Returns the run-time major version of the toolkit associated with this
   wxPlatformInfo instance. Note that if GetPortId returns wxPORT_BASE,
   then this value is zero (unless externally modified with
   SetToolkitVersion); that is, no native toolkit is in use.

   See wxAppTraits::GetToolkitVersion for more info.

=head2 Wx::PlatformInfo::GetToolkitMinorVersion

   int GetToolkitMinorVersion() const

   Returns the run-time minor version of the toolkit associated with this
   wxPlatformInfo instance. Note that if GetPortId returns wxPORT_BASE,
   then this value is zero (unless externally modified with
   SetToolkitVersion); that is, no native toolkit is in use.

   See wxAppTraits::GetToolkitVersion for more info.

   See also

   CheckToolkitVersion

=head2 Wx::PlatformInfo::IsOk

   bool IsOk() const

   Returns true if this instance is fully initialized with valid values.

=head2 Wx::PlatformInfo::IsUsingUniversalWidgets

   bool IsUsingUniversalWidgets() const

   Returns true if this wxPlatformInfo describes wxUniversal build.

=head2 Wx::PlatformInfo::SetArchitecture

   void SetArchitecture(wxArchitecture n)

   Sets the architecture enum value associated with this wxPlatformInfo
   instance.

=head2 Wx::PlatformInfo::SetEndianness

   void SetEndianness(wxEndianness n)

   Sets the endianness enum value associated with this wxPlatformInfo
   instance.

=head2 Wx::PlatformInfo::SetOSVersion

   void SetOSVersion(int major, int minor)

   Sets the version of the operating system associated with this
   wxPlatformInfo instance.

=head2 Wx::PlatformInfo::SetOperatingSystemId

   void SetOperatingSystemId(wxOperatingSystemId n)

   Sets the operating system associated with this wxPlatformInfo
   instance.

=head2 Wx::PlatformInfo::SetPortId

   void SetPortId(wxPortId n)

   Sets the wxWidgets port ID associated with this wxPlatformInfo
   instance.

=head2 Wx::PlatformInfo::SetToolkitVersion

   void SetToolkitVersion(int major, int minor)

   Sets the version of the toolkit associated with this wxPlatformInfo
   instance.

=head1 Wx::Point

=head2 Wx::Point::new

   wxPoint()

   wxPoint(int x, int y)

   Create a point.

=head2 Wx::Point::x

   int x

   x member.

=head2 Wx::Point::y

   int y

   y member.

=head2 Operators

   void operator =(const wxPoint& pt)

   Assignment operator.

=head1 Wx::PostScriptDC

=head2 Wx::PostScriptDC::new

   wxPostScriptDC(const wxPrintData& printData)

   Constructs a PostScript printer device context from a wxPrintData
   object.

   wxPostScriptDC(const wxString& output, bool interactive = true,

=head2 Wx::PostScriptDC::SetResolution

   static void SetResolution(int ppi)

   Set resolution (in pixels per inch) that will be used in PostScript
   output. Default is 720ppi.

=head2 Wx::PostScriptDC::GetResolution

   static int GetResolution()

   Return resolution used in PostScript output. See SetResolution.

=head1 Wx::PowerEvent

=head2 Wx::PowerEvent::Veto

   void Veto()

   Call this to prevent suspend from taking place in
   wxEVT_POWER_SUSPENDING handler (it is ignored for all the others).

=head1 Wx::PreviewCanvas

=head2 Wx::PreviewCanvas::new

   wxPreviewCanvas(wxPrintPreview* preview, wxWindow* parent, const
   wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
   long style = 0, const wxString& name = "canvas")

   Constructor.

=head2 Wx::PreviewCanvas::DESTROY

   ~wxPreviewCanvas()

   Destructor.

=head2 Wx::PreviewCanvas::OnPaint

   void OnPaint(wxPaintEvent& event)

   Calls wxPrintPreview::PaintPage to refresh the canvas.

=head1 Wx::PreviewControlBar

=head2 Wx::PreviewControlBar::wxPreviewControlbar

   wxPreviewControlBar(wxPrintPreview* preview, long buttons, wxWindow*
   parent, const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = 0, const wxString& name = "panel")

   Constructor.

   The buttons parameter may be a combination of the following, using the
   bitwise 'or' operator.

=head2 Wx::PreviewControlBar::DESTROY

   ~wxPreviewControlBar()

   Destructor.

=head2 Wx::PreviewControlBar::CreateButtons

   void CreateButtons()

   Creates buttons, according to value of the button style flags.

=head2 Wx::PreviewControlBar::GetPrintPreview

   wxPrintPreview * GetPrintPreview()

   Gets the print preview object associated with the control bar.

=head2 Wx::PreviewControlBar::GetZoomControl

   int GetZoomControl()

   Gets the current zoom setting in percent.

=head2 Wx::PreviewControlBar::SetZoomControl

   void SetZoomControl(int percent)

   Sets the zoom control.

=head1 Wx::PreviewFrame

=head2 Wx::PreviewFrame::new

   wxPreviewFrame(wxPrintPreview* preview, wxWindow* parent, const
   wxString& title, const wxPoint& pos = wxDefaultPosition, const wxSize&
   size size = wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE, const
   wxString& name = "frame")

   Constructor. Pass a print preview object plus other normal frame
   arguments. The print preview object will be destroyed by the frame
   when it closes.

=head2 Wx::PreviewFrame::DESTROY

   ~wxPreviewFrame()

   Destructor.

=head2 Wx::PreviewFrame::CreateControlBar

   void CreateControlBar()

   Creates a wxPreviewControlBar. Override this function to allow a
   user-defined preview control bar object to be created.

=head2 Wx::PreviewFrame::CreateCanvas

   void CreateCanvas()

   Creates a wxPreviewCanvas. Override this function to allow a
   user-defined preview canvas object to be created.

=head2 Wx::PreviewFrame::Initialize

   void Initialize()

   Creates the preview canvas and control bar, and calls
   wxWindow::MakeModal(true) to disable other top-level windows in the
   application.

   This function should be called by the application prior to showing the
   frame.

=head2 Wx::PreviewFrame::OnCloseWindow

   void OnCloseWindow(wxCloseEvent& event)

   Enables the other frames in the application, and deletes the print
   preview object, implicitly deleting any printout objects associated
   with the print preview object.

=head1 Wx::PrintData

=head2 Wx::PrintData::new

   wxPrintData()

   Default constructor.

   wxPrintData(const wxPrintData& data)

   Copy constructor.

=head2 Wx::PrintData::DESTROY

   ~wxPrintData()

   Destructor.

=head2 Wx::PrintData::GetCollate

   bool GetCollate() const

   Returns true if collation is on.

=head2 Wx::PrintData::GetBin

   wxPrintBin GetBin() const

   Returns the current bin (papersource). By default, the system is left
   to select the bin (wxPRINTBIN_DEFAULT is returned).

   See SetBin() for the full list of bin values.

=head2 Wx::PrintData::GetColour

   bool GetColour() const

   Returns true if colour printing is on.

=head2 Wx::PrintData::GetDuplex

   wxDuplexMode GetDuplex() const

   Returns the duplex mode. One of wxDUPLEX_SIMPLEX, wxDUPLEX_HORIZONTAL,
   wxDUPLEX_VERTICAL.

=head2 Wx::PrintData::GetNoCopies

   int GetNoCopies() const

   Returns the number of copies requested by the user.

=head2 Wx::PrintData::GetOrientation

   int GetOrientation() const

   Gets the orientation. This can be wxLANDSCAPE or wxPORTRAIT.

=head2 Wx::PrintData::GetPaperId

   wxPaperSize GetPaperId() const

   Returns the paper size id. For more information, see
   wxPrintData::SetPaperId.

=head2 Wx::PrintData::GetPrinterName

   const wxString& GetPrinterName() const

   Returns the printer name. If the printer name is the empty string, it
   indicates that the default printer should be used.

=head2 Wx::PrintData::GetQuality

   wxPrintQuality GetQuality() const

   Returns the current print quality. This can be a positive integer,
   denoting the number of dots per inch, or one of the following
   identifiers:

   wxPRINT_QUALITY_HIGH
   wxPRINT_QUALITY_MEDIUM
   wxPRINT_QUALITY_LOW
   wxPRINT_QUALITY_DRAFT

   On input you should pass one of these identifiers, but on return you
   may get back a positive integer indicating the current resolution
   setting.

=head2 Wx::PrintData::IsOk

   bool IsOk() const

   Returns true if the print data is valid for using in print dialogs.
   This can return false on Windows if the current printer is not set,
   for example. On all other platforms, it returns true.

=head2 Wx::PrintData::SetBin

   void SetBin(wxPrintBin flag)

   Sets the current bin. Possible values are:

   enum wxPrintBin
   {
       wxPRINTBIN_DEFAULT,

=head2 Wx::PrintData::SetCollate

   void SetCollate(bool flag)

   Sets collation to on or off.

=head2 Wx::PrintData::SetColour

   void SetColour(bool flag)

   Sets colour printing on or off.

=head2 Wx::PrintData::SetDuplex

   void SetDuplex(wxDuplexMode mode)

   Returns the duplex mode. One of wxDUPLEX_SIMPLEX, wxDUPLEX_HORIZONTAL,
   wxDUPLEX_VERTICAL.

=head2 Wx::PrintData::SetNoCopies

   void SetNoCopies(int n)

   Sets the default number of copies to be printed out.

=head2 Wx::PrintData::SetOrientation

   void SetOrientation(int orientation)

   Sets the orientation. This can be wxLANDSCAPE or wxPORTRAIT.

=head2 Wx::PrintData::SetPaperId

   void SetPaperId(wxPaperSize paperId)

   Sets the paper id. This indicates the type of paper to be used. For a
   mapping between paper id, paper size and string name, see
   wxPrintPaperDatabase in paper.h (not yet documented).

   paperId can be one of:

       wxPAPER_NONE,               // Use specific dimensions
       wxPAPER_LETTER,             // Letter, 8 1/2 by 11 inches
       wxPAPER_LEGAL,              // Legal, 8 1/2 by 14 inches
       wxPAPER_A4,                 // A4 Sheet, 210 by 297 millimeters
       wxPAPER_CSHEET,             // C Sheet, 17 by 22 inches
       wxPAPER_DSHEET,             // D Sheet, 22 by 34 inches
       wxPAPER_ESHEET,             // E Sheet, 34 by 44 inches
       wxPAPER_LETTERSMALL,        // Letter Small, 8 1/2 by 11 inches
       wxPAPER_TABLOID,            // Tabloid, 11 by 17 inches
       wxPAPER_LEDGER,             // Ledger, 17 by 11 inches
       wxPAPER_STATEMENT,          // Statement, 5 1/2 by 8 1/2 inches
       wxPAPER_EXECUTIVE,          // Executive, 7 1/4 by 10 1/2 inches
       wxPAPER_A3,                 // A3 sheet, 297 by 420 millimeters
       wxPAPER_A4SMALL,            // A4 small sheet, 210 by 297 millimeters
       wxPAPER_A5,                 // A5 sheet, 148 by 210 millimeters
       wxPAPER_B4,                 // B4 sheet, 250 by 354 millimeters
       wxPAPER_B5,                 // B5 sheet, 182-by-257-millimeter paper
       wxPAPER_FOLIO,              // Folio, 8-1/2-by-13-inch paper
       wxPAPER_QUARTO,             // Quarto, 215-by-275-millimeter paper
       wxPAPER_10X14,              // 10-by-14-inch sheet
       wxPAPER_11X17,              // 11-by-17-inch sheet
       wxPAPER_NOTE,               // Note, 8 1/2 by 11 inches
       wxPAPER_ENV_9,              // #9 Envelope, 3 7/8 by 8 7/8 inches
       wxPAPER_ENV_10,             // #10 Envelope, 4 1/8 by 9 1/2 inches
       wxPAPER_ENV_11,             // #11 Envelope, 4 1/2 by 10 3/8 inches
       wxPAPER_ENV_12,             // #12 Envelope, 4 3/4 by 11 inches
       wxPAPER_ENV_14,             // #14 Envelope, 5 by 11 1/2 inches
       wxPAPER_ENV_DL,             // DL Envelope, 110 by 220 millimeters
       wxPAPER_ENV_C5,             // C5 Envelope, 162 by 229 millimeters
       wxPAPER_ENV_C3,             // C3 Envelope, 324 by 458 millimeters
       wxPAPER_ENV_C4,             // C4 Envelope, 229 by 324 millimeters
       wxPAPER_ENV_C6,             // C6 Envelope, 114 by 162 millimeters
       wxPAPER_ENV_C65,            // C65 Envelope, 114 by 229 millimeters
       wxPAPER_ENV_B4,             // B4 Envelope, 250 by 353 millimeters
       wxPAPER_ENV_B5,             // B5 Envelope, 176 by 250 millimeters
       wxPAPER_ENV_B6,             // B6 Envelope, 176 by 125 millimeters
       wxPAPER_ENV_ITALY,          // Italy Envelope, 110 by 230 millimeters
       wxPAPER_ENV_MONARCH,        // Monarch Envelope, 3 7/8 by 7 1/2 inches
       wxPAPER_ENV_PERSONAL,       // 6 3/4 Envelope, 3 5/8 by 6 1/2 inches
       wxPAPER_FANFOLD_US,         // US Std Fanfold, 14 7/8 by 11 inches
       wxPAPER_FANFOLD_STD_GERMAN, // German Std Fanfold, 8 1/2 by 12 inches
       wxPAPER_FANFOLD_LGL_GERMAN, // German Legal Fanfold, 8 1/2 by 13 inches

=head2 Wx::PrintData::SetPrinterName

   void SetPrinterName(const wxString& printerName)

   Sets the printer name. This can be the empty string to indicate that
   the default printer should be used.

=head2 Wx::PrintData::SetQuality

   void SetQuality(wxPrintQuality quality)

   Sets the desired print quality. This can be a positive integer,
   denoting the number of dots per inch, or one of the following
   identifiers:

   wxPRINT_QUALITY_HIGH
   wxPRINT_QUALITY_MEDIUM
   wxPRINT_QUALITY_LOW
   wxPRINT_QUALITY_DRAFT

   On input you should pass one of these identifiers, but on return you
   may get back a positive integer indicating the current resolution
   setting.

=head1 Wx::PrintDialog

=head2 Wx::PrintDialog::new

   wxPrintDialog(wxWindow* parent, wxPrintDialogData* data = NULL)

   Constructor. Pass a parent window, and optionally a pointer to a block
   of print data, which will be copied to the print dialog's print data.

   See also

   wxPrintDialogData

=head2 Wx::PrintDialog::DESTROY

   ~wxPrintDialog()

   Destructor. If wxPrintDialog::GetPrintDC has not been called, the
   device context obtained by the dialog (if any) will be deleted.

=head2 Wx::PrintDialog::GetPrintDialogData

   wxPrintDialogData& GetPrintDialogData()

   Returns the print dialog data associated with the print dialog.

=head2 Wx::PrintDialog::GetPrintDC

   wxDC* GetPrintDC()

   Returns the device context created by the print dialog, if any. When
   this function has been called, the ownership of the device context is
   transferred to the application, so it must then be deleted explicitly.

=head2 Wx::PrintDialog::ShowModal

   int ShowModal()

   Shows the dialog, returning wxID_OK if the user pressed OK, and
   wxID_CANCEL otherwise. After this function is called, a device context
   may be retrievable using wxPrintDialog::GetPrintDC.

=head1 Wx::PrintDialogData

=head2 Wx::PrintDialogData::new

   wxPrintDialogData()

   Default constructor.

   wxPrintDialogData(wxPrintDialogData& dialogData)

   Copy constructor.

   wxPrintDialogData(wxPrintData& printData)

   Construct an object from a print dialog data object.

=head2 Wx::PrintDialogData::DESTROY

   ~wxPrintDialogData()

   Destructor.

=head2 Wx::PrintDialogData::EnableHelp

   void EnableHelp(bool flag)

   Enables or disables the 'Help' button.

=head2 Wx::PrintDialogData::EnablePageNumbers

   void EnablePageNumbers(bool flag)

   Enables or disables the 'Page numbers' controls.

=head2 Wx::PrintDialogData::EnablePrintToFile

   void EnablePrintToFile(bool flag)

   Enables or disables the 'Print to file' checkbox.

=head2 Wx::PrintDialogData::EnableSelection

   void EnableSelection(bool flag)

   Enables or disables the 'Selection' radio button.

=head2 Wx::PrintDialogData::GetAllPages

   bool GetAllPages() const

   Returns true if the user requested that all pages be printed.

=head2 Wx::PrintDialogData::GetCollate

   bool GetCollate() const

   Returns true if the user requested that the document(s) be collated.

=head2 Wx::PrintDialogData::GetFromPage

   int GetFromPage() const

   Returns the from page number, as entered by the user.

=head2 Wx::PrintDialogData::GetMaxPage

   int GetMaxPage() const

   Returns the maximum page number.

=head2 Wx::PrintDialogData::GetMinPage

   int GetMinPage() const

   Returns the minimum page number.

=head2 Wx::PrintDialogData::GetNoCopies

   int GetNoCopies() const

   Returns the number of copies requested by the user.

=head2 Wx::PrintDialogData::GetPrintData

   wxPrintData& GetPrintData()

   Returns a reference to the internal wxPrintData object.

=head2 Wx::PrintDialogData::GetPrintToFile

   bool GetPrintToFile() const

   Returns true if the user has selected printing to a file.

=head2 Wx::PrintDialogData::GetSelection

   bool GetSelection() const

   Returns true if the user requested that the selection be printed
   (where 'selection' is a concept specific to the application).

=head2 Wx::PrintDialogData::GetToPage

   int GetToPage() const

   Returns the to page number, as entered by the user.

=head2 Wx::PrintDialogData::IsOk

   bool IsOk() const

   Returns true if the print data is valid for using in print dialogs.
   This can return false on Windows if the current printer is not set,
   for example. On all other platforms, it returns true.

=head2 Wx::PrintDialogData::SetCollate

   void SetCollate(bool flag)

   Sets the 'Collate' checkbox to true or false.

=head2 Wx::PrintDialogData::SetFromPage

   void SetFromPage(int page)

   Sets the from page number.

=head2 Wx::PrintDialogData::SetMaxPage

   void SetMaxPage(int page)

   Sets the maximum page number.

=head2 Wx::PrintDialogData::SetMinPage

   void SetMinPage(int page)

   Sets the minimum page number.

=head2 Wx::PrintDialogData::SetNoCopies

   void SetNoCopies(int n)

   Sets the default number of copies the user has requested to be printed
   out.

=head2 Wx::PrintDialogData::SetPrintData

   void SetPrintData(const wxPrintData& printData)

   Sets the internal wxPrintData.

=head2 Wx::PrintDialogData::SetPrintToFile

   void SetPrintToFile(bool flag)

   Sets the 'Print to file' checkbox to true or false.

=head2 Wx::PrintDialogData::SetSelection

   void SetSelection(bool flag)

   Selects the 'Selection' radio button. The effect of printing the
   selection depends on how the application implements this command, if
   at all.

=head2 Wx::PrintDialogData::SetSetupDialog

   void SetSetupDialog(bool flag)

   Determines whether the dialog to be shown will be the Print dialog
   (pass false) or Print Setup dialog (pass true).

   This function has been deprecated since version 2.5.4.

=head2 Wx::PrintDialogData::SetToPage

   void SetToPage(int page)

   Sets the to page number.

=head1 Wx::Printer

=head2 Wx::Printer::new

   wxPrinter(wxPrintDialogData* data = NULL)

   Constructor. Pass an optional pointer to a block of print dialog data,
   which will be copied to the printer object's local data.

   See also

   wxPrintDialogData, wxPrintData

=head2 Wx::Printer::CreateAbortWindow

   void CreateAbortWindow(wxWindow* parent, wxPrintout* printout)

   Creates the default printing abort window, with a cancel button.

=head2 Wx::Printer::GetAbort

   bool GetAbort()

   Returns true if the user has aborted the print job.

=head2 Wx::Printer::GetLastError

   static wxPrinterError GetLastError()

   Return last error. Valid after calling Print, PrintDialog or
   wxPrintPreview::Print. These functions set last error to
   wxPRINTER_NO_ERROR if no error happened.

   Returned value is one of the following:

=head2 Wx::Printer::GetPrintDialogData

   wxPrintDialogData& GetPrintDialogData()

   Returns the print data associated with the printer object.

=head2 Wx::Printer::Print

   bool Print(wxWindow *parent, wxPrintout *printout, bool prompt=true)

   Starts the printing process. Provide a parent window, a user-defined
   wxPrintout object which controls the printing of a document, and
   whether the print dialog should be invoked first.

   Print could return false if there was a problem initializing the
   printer device context (current printer not set, for example) or the
   user cancelled printing. Call wxPrinter::GetLastError to get detailed
   information about the kind of the error.

=head2 Wx::Printer::PrintDialog

   wxDC* PrintDialog(wxWindow *parent)

   Invokes the print dialog. If successful (the user did not press Cancel
   and no error occurred), a suitable device context will be returned
   (otherwise NULL is returned -- call wxPrinter::GetLastError to get
   detailed information about the kind of the error).

   The application must delete this device context to avoid a memory
   leak.

=head2 Wx::Printer::ReportError

   void ReportError(wxWindow *parent, wxPrintout *printout, const
   wxString& message)

   Default error-reporting function.

=head2 Wx::Printer::Setup

   bool Setup(wxWindow *parent)

   Invokes the print setup dialog. Note that the setup dialog is obsolete
   from Windows 95, though retained for backward compatibility.

=head1 Wx::PrinterDC

=head2 Wx::PrinterDC::new

   wxPrinterDC(const wxPrintData& printData)

   Constructor. Pass a wxPrintData object with information necessary for
   setting up a suitable printer device context. This is the recommended
   way to construct a wxPrinterDC. Make sure you specify a reference to a
   wxPrintData object, not a pointer - you may not even get a warning if
   you pass a pointer instead.

   wxPrinterDC(const wxString& driver, const wxString& device, const
   wxString& output, const bool interactive = true, int orientation =
   wxPORTRAIT)

   Constructor. With empty strings for the first three arguments, the
   default printer dialog is displayed. device indicates the type of
   printer and output is an optional file for printing to. The driver
   parameter is currently unused. Use the Ok member to test whether the
   constructor was successful in creating a usable device context.

   This constructor is deprecated and retained only for backward
   compatibility.

=head2 Wx::PrinterDC::GetPaperRect

   wxRect wxPrinterDC::GetPaperRect()

   Return the rectangle in device coordinates that corresponds to the
   full paper area, including the nonprinting regions of the paper. The
   point (0,0) in device coordinates is the top left corner of the page
   rectangle, which is the printable area on MSW and Mac. The coordinates
   of the top left corner of the paper rectangle will therefore have
   small negative values, while the bottom right coordinates will be
   somewhat larger than the values returned by wxDC::GetSize.

=head1 Wx::Printout

=head2 Wx::Printout::new

   wxPrintout(const wxString& title = "Printout")

   Constructor. Pass an optional title argument - the current filename
   would be a good idea. This will appear in the printing list (at least
   in MSW)

=head2 Wx::Printout::DESTROY

   ~wxPrintout()

   Destructor.

=head2 Wx::Printout::GetDC

   wxDC * GetDC()

   Returns the device context associated with the printout (given to the
   printout at start of printing or previewing). This will be a
   wxPrinterDC if printing under Windows or Mac, a wxPostScriptDC if
   printing on other platforms, and a wxMemoryDC if previewing.

=head2 Wx::Printout::GetPageInfo

   void GetPageInfo(int *minPage, int *maxPage, int *pageFrom, int *pageTo)

   Called by the framework to obtain information from the application
   about minimum and maximum page values that the user can select, and
   the required page range to be printed. By default this returns 1,
   32000 for the page minimum and maximum values, and 1, 1 for the
   required page range.

   If minPage is zero, the page number controls in the print dialog will
   be disabled.

   wxPython note: When this method is implemented in a derived Python
   class, it should be designed to take no parameters (other than the
   self reference) and to return a tuple of four integers.

   wxPerl note: When this method is overridden in a derived class, it
   must not take any parameters, and returns a 4-element list.

=head2 Wx::Printout::GetPageSizeMM

   void GetPageSizeMM(int *w, int *h)

   Returns the size of the printer page in millimetres.

   wxPython note: This method returns the output-only parameters as a
   tuple.

   wxPerl note: In wxPerl this method takes no arguments and returns a
   2-element list ( w, h )

=head2 Wx::Printout::GetPageSizePixels

   void GetPageSizePixels(int *w, int *h)

   Returns the size of the printer page in pixels, called the page
   rectangle. The page rectangle has a top left corner at (0,0) and a
   bottom right corner at (w,h). These values may not be the same as the
   values returned from wxDC::GetSize; if the printout is being used for
   previewing, a memory device context is used, which uses a bitmap size
   reflecting the current preview zoom. The application must take this
   discrepancy into account if previewing is to be supported.

   wxPython note: This method returns the output-only parameters as a
   tuple.

   wxPerl note: In wxPerl this method takes no arguments and returns a
   2-element list ( w, h )

=head2 Wx::Printout::GetPaperRectPixels

   wxRect GetPaperRectPixels()

   Returns the rectangle that corresponds to the entire paper in pixels,
   called the paper rectangle. This distinction between paper rectangle
   and page rectangle reflects the fact that most printers cannot print
   all the way to the edge of the paper. The page rectangle is a
   rectangle whose top left corner is at (0,0) and whose width and height
   are given by wxDC::GetPageSizePixels. On MSW and Mac, the page
   rectangle gives the printable area of the paper, while the paper
   rectangle represents the entire paper, including non-printable
   borders. Thus, the rectangle returned by GetPaperRectPixels will have
   a top left corner whose coordinates are small negative numbers and the
   bottom right corner will have values somewhat larger than the width
   and height given by wxDC::GetPageSizePixels. On other platforms and
   for PostScript printing, the paper is treated as if its entire area
   were printable, so this function will return the same rectangle as the
   page rectangle.

=head2 Wx::Printout::GetPPIPrinter

   void GetPPIPrinter(int *w, int *h)

   Returns the number of pixels per logical inch of the printer device
   context. Dividing the printer PPI by the screen PPI can give a
   suitable scaling factor for drawing text onto the printer. Remember to
   multiply this by a scaling factor to take the preview DC size into
   account. Or you can just use the FitThisSizeToXXX() and
   MapScreenSizeToXXX routines below, which do most of the scaling
   calculations for you.

   wxPython note: This method returns the output-only parameters as a
   tuple.

   wxPerl note: In wxPerl this method takes no arguments and returns a
   2-element list ( w, h )

=head2 Wx::Printout::GetPPIScreen

   void GetPPIScreen(int *w, int *h)

   Returns the number of pixels per logical inch of the screen device
   context. Dividing the printer PPI by the screen PPI can give a
   suitable scaling factor for drawing text onto the printer. If you are
   doing your own scaling, remember to multiply this by a scaling factor
   to take the preview DC size into account.

=head2 Wx::Printout::GetTitle

   wxString GetTitle()

   Returns the title of the printout

   wxPython note: This method returns the output-only parameters as a
   tuple.

   wxPerl note: In wxPerl this method takes no arguments and returns a
   2-element list ( w, h )

=head2 Wx::Printout::HasPage

   bool HasPage(int pageNum)

   Should be overridden to return true if the document has this page, or
   false if not. Returning false signifies the end of the document. By
   default, HasPage behaves as if the document has only one page.

=head2 Wx::Printout::IsPreview

   bool IsPreview()

   Returns true if the printout is currently being used for previewing.

=head2 Wx::Printout::FitThisSizeToPaper

   void FitThisSizeToPaper(const wxSize& imageSize)

   Set the user scale and device origin of the wxDC associated with this
   wxPrintout so that the given image size fits entirely within the paper
   and the origin is at the top left corner of the paper. Note that with
   most printers, the region around the edges of the paper are not
   printable so that the edges of the image could be cut off. Use this if
   you're managing your own page margins.

=head2 Wx::Printout::FitThisSizeToPage



=head2 Wx::Printout::FitThisSizeToPageMargins

   void FitThisSizeToPageMargins(const wxSize& imageSize, const
   wxPageSetupDialogData& pageSetupData)

   Set the user scale and device origin of the wxDC associated with this
   wxPrintout so that the given image size fits entirely within the page
   margins set in the given wxPageSetupDialogData object. This function
   provides the greatest consistency across all platforms because it does
   not depend on having access to the printable area of the paper. Note
   that on Mac, the native wxPageSetupDialog does not let you set the
   page margins; you'll have to provide your own mechanism, or you can
   use the Mac-only class wxMacPageMarginsDialog.

=head2 Wx::Printout::MapScreenSizeToPaper

   void MapScreenSizeToPaper()

   Set the user scale and device origin of the wxDC associated with this
   wxPrintout so that the printed page matches the screen size as closely
   as possible and the logical origin is in the top left corner of the
   paper rectangle. That is, a 100-pixel object on screen should appear
   at the same size on the printed page. (It will, of course, be larger
   or smaller in the preview image, depending on the zoom factor.) Use
   this if you want WYSIWYG behavior, e.g., in a text editor.

=head2 Wx::Printout::MapScreenSizeToPage

   void MapScreenSizeToPage()

   This sets the user scale of the wxDC assocated with this wxPrintout to
   the same scale as MapScreenSizeToPaper but sets the logical origin to
   the top left corner of the page rectangle.

=head2 Wx::Printout::MapScreenSizeToPageMargins

   void MapScreenSizeToPageMargins(const wxPageSetupDialogData&
   pageSetupData)

   This sets the user scale of the wxDC assocated with this wxPrintout to
   the same scale as MapScreenSizeToPageMargins but sets the logical
   origin to the top left corner of the page margins specified by the
   given wxPageSetupDialogData object.

=head2 Wx::Printout::MapScreenSizeToDevice

   void MapScreenSizeToDevice()

   Set the user scale and device origin of the wxDC associated with this
   wxPrintout so that one screen pixel maps to one device pixel on the
   DC. That is, the user scale is set to (1,1) and the device origin is
   set to (0,0). Use this if you want to do your own scaling prior to
   calling wxDC drawing calls, for example, if your underlying model is
   floating-point and you want to achieve maximum drawing precision on
   high-resolution printers. (Note that while the underlying drawing
   model of Mac OS X is floating-point, wxWidgets's drawing model scales
   from integer coordinates.) You can use the GetLogicalXXXRect()
   routines below to obtain the paper rectangle, page rectangle, or page
   margins rectangle to perform your own scaling.

=head2 Wx::Printout::GetLogicalPaperRect

   wxRect GetLogicalPaperRect()

   Return the rectangle corresponding to the paper in the associated
   wxDC's logical coordinates for the current user scale and device
   origin.

=head2 Wx::Printout::GetLogicalPageRect

   wxRect GetLogicalPageRect()

   Return the rectangle corresponding to the page in the associated
   wxDC's logical coordinates for the current user scale and device
   origin. On MSW and Mac, this will be the printable area of the paper.
   On other platforms and PostScript printing, this will be the full
   paper rectangle.

=head2 Wx::Printout::GetLogicalPageMarginsRect

   wxRect GetLogicalPageMarginsRect(const wxPageSetupDialogData&
   pageSetupData)

   Return the rectangle corresponding to the page margins specified by
   the given wxPageSetupDialogData object in the associated wxDC's
   logical coordinates for the current user scale and device origin. The
   page margins are specified with respect to the edges of the paper on
   all platforms.

=head2 Wx::Printout::SetLogicalOrigin

   void SetLogicalOrigin(wxCoord x, wxCoord y)

   Set the device origin of the associated wxDC so that the current
   logical point becomes the new logical origin.

=head2 Wx::Printout::OffsetLogicalOrigin

   void OffsetLogicalOrigin(wxCoord xoff, wxCoord yoff)

   Shift the device origin by an amount specified in logical coordinates.

=head2 Wx::Printout::OnBeginDocument

   bool OnBeginDocument(int startPage, int endPage)

   Called by the framework at the start of document printing. Return
   false from this function cancels the print job. OnBeginDocument is
   called once for every copy printed.

   The base wxPrintout::OnBeginDocument must be called (and the return
   value checked) from within the overridden function, since it calls
   wxDC::StartDoc.

   wxPython note: If this method is overridden in a Python class then the
   base class version can be called by using the method
   base_OnBeginDocument(startPage, endPage).

=head2 Wx::Printout::OnEndDocument

   void OnEndDocument()

   Called by the framework at the end of document printing. OnEndDocument
   is called once for every copy printed.

   The base wxPrintout::OnEndDocument must be called from within the
   overridden function, since it calls wxDC::EndDoc.

=head2 Wx::Printout::OnBeginPrinting

   void OnBeginPrinting()

   Called by the framework at the start of printing. OnBeginPrinting is
   called once for every print job (regardless of how many copies are
   being printed).

=head2 Wx::Printout::OnEndPrinting

   void OnEndPrinting()

   Called by the framework at the end of printing. OnEndPrinting is
   called once for every print job (regardless of how many copies are
   being printed).

=head2 Wx::Printout::OnPreparePrinting

   void OnPreparePrinting()

   Called once by the framework before any other demands are made of the
   wxPrintout object. This gives the object an opportunity to calculate
   the number of pages in the document, for example.

=head2 Wx::Printout::OnPrintPage

   bool OnPrintPage(int pageNum)

   Called by the framework when a page should be printed. Returning false
   cancels the print job. The application can use wxPrintout::GetDC to
   obtain a device context to draw on.

=head1 Wx::PrintPreview

=head2 Wx::PrintPreview::new

   wxPrintPreview(wxPrintout* printout, wxPrintout* printoutForPrinting,
   wxPrintData* data=NULL)

   Constructor. Pass a printout object, an optional printout object to be
   used for actual printing, and the address of an optional block of
   printer data, which will be copied to the print preview object's print
   data.

   If printoutForPrinting is non-NULL, a Print... button will be placed
   on the preview frame so that the user can print directly from the
   preview interface.

   Do not explicitly delete the printout objects once this destructor has
   been called, since they will be deleted in the wxPrintPreview
   constructor. The same does not apply to the data argument.

   Test the Ok member to check whether the wxPrintPreview object was
   created correctly. Ok could return false if there was a problem
   initializing the printer device context (current printer not set, for
   example).

=head2 Wx::PrintPreview::DESTROY

   ~wxPrinter()

   Destructor. Deletes both print preview objects, so do not destroy
   these objects in your application.

=head2 Wx::PrintPreview::GetCanvas

   wxPreviewCanvas* GetCanvas()

   Gets the preview window used for displaying the print preview image.

=head2 Wx::PrintPreview::GetCurrentPage

   int GetCurrentPage()

   Gets the page currently being previewed.

=head2 Wx::PrintPreview::GetFrame

   wxFrame * GetFrame()

   Gets the frame used for displaying the print preview canvas and
   control bar.

=head2 Wx::PrintPreview::GetMaxPage

   int GetMaxPage()

   Returns the maximum page number.

=head2 Wx::PrintPreview::GetMinPage

   int GetMinPage()

   Returns the minimum page number.

=head2 Wx::PrintPreview::GetPrintout

   wxPrintout * GetPrintout()

   Gets the preview printout object associated with the wxPrintPreview
   object.

=head2 Wx::PrintPreview::GetPrintoutForPrinting

   wxPrintout * GetPrintoutForPrinting()

   Gets the printout object to be used for printing from within the
   preview interface, or NULL if none exists.

=head2 Wx::PrintPreview::IsOk

   bool Ok()

   Returns true if the wxPrintPreview is valid, false otherwise. It could
   return false if there was a problem initializing the printer device
   context (current printer not set, for example).

=head2 Wx::PrintPreview::PaintPage

   bool PaintPage(wxPreviewCanvas *canvas, wxDCdc)

   This refreshes the preview window with the preview image. It must be
   called from the preview window's OnPaint member.

   The implementation simply blits the preview bitmap onto the canvas,
   creating a new preview bitmap if none exists.

=head2 Wx::PrintPreview::Print

   bool Print(bool prompt)

   Invokes the print process using the second wxPrintout object supplied
   in the wxPrintPreview constructor. Will normally be called by the
   Print... panel item on the preview frame's control bar.

   Returns false in case of error -- call wxPrinter::GetLastError to get
   detailed information about the kind of the error.

=head2 Wx::PrintPreview::RenderPage

   bool RenderPage(int pageNum)

   Renders a page into a wxMemoryDC. Used internally by wxPrintPreview.

=head2 Wx::PrintPreview::SetCanvas

   void SetCanvas(wxPreviewCanvas* window)

   Sets the window to be used for displaying the print preview image.

=head2 Wx::PrintPreview::SetCurrentPage

   void SetCurrentPage(int pageNum)

   Sets the current page to be previewed.

=head2 Wx::PrintPreview::SetFrame

   void SetFrame(wxFrame *frame)

   Sets the frame to be used for displaying the print preview canvas and
   control bar.

=head2 Wx::PrintPreview::SetPrintout

   void SetPrintout(wxPrintout *printout)

   Associates a printout object with the wxPrintPreview object.

=head2 Wx::PrintPreview::SetZoom

   void SetZoom(int percent)

   Sets the percentage preview zoom, and refreshes the preview canvas
   accordingly.

=head1 Wx::Process

=head2 Wx::Process::new

   wxProcess(wxEvtHandler * parent = NULL, int id = -1)

   wxProcess(int flags)

   Constructs a process object. id is only used in the case you want to
   use wxWidgets events. It identifies this object, or another window
   that will receive the event.

   If the parent parameter is different from NULL, it will receive a
   wxEVT_END_PROCESS notification event (you should insert
   EVT_END_PROCESS macro in the event table of the parent to handle it)
   with the given id.

   The second constructor creates an object without any associated parent
   (and hence no id neither) but allows to specify the flags which can
   have the value of wxPROCESS_DEFAULT or wxPROCESS_REDIRECT. Specifying
   the former value has no particular effect while using the latter one
   is equivalent to calling Redirect.

   Parameters

   parent

       The event handler parent.

   id  

       id of an event.

   flags

       either wxPROCESS_DEFAULT or wxPROCESS_REDIRECT

=head2 Wx::Process::DESTROY

   ~wxProcess()

   Destroys the wxProcess object.

=head2 Wx::Process::CloseOutput

   void CloseOutput()

   Closes the output stream (the one connected to the stdin of the child
   process). This function can be used to indicate to the child process
   that there is no more data to be read - usually, a filter program will
   only terminate when the input stream is closed.

=head2 Wx::Process::Detach

   void Detach()

   Normally, a wxProcess object is deleted by its parent when it receives
   the notification about the process termination. However, it might
   happen that the parent object is destroyed before the external process
   is terminated (e.g. a window from which this external process was
   launched is closed by the user) and in this case it should not delete
   the wxProcess object, but should call Detach() instead. After the
   wxProcess object is detached from its parent, no notification events
   will be sent to the parent and the object will delete itself upon
   reception of the process termination notification.

=head2 Wx::Process::GetErrorStream

   wxInputStream* GetErrorStream() const

   Returns an input stream which corresponds to the standard error output
   (stderr) of the child process.

=head2 Wx::Process::GetInputStream

   wxInputStream* GetInputStream() const

   It returns an input stream corresponding to the standard output stream
   of the subprocess. If it is NULL, you have not turned on the
   redirection. See wxProcess::Redirect.

=head2 Wx::Process::GetOutputStream

   wxOutputStream* GetOutputStream() const

   It returns an output stream correspoding to the input stream of the
   subprocess. If it is NULL, you have not turned on the redirection. See
   wxProcess::Redirect.

=head2 Wx::Process::IsErrorAvailable

   bool IsErrorAvailable() const

   Returns true if there is data to be read on the child process standard
   error stream.

   See also

   IsInputAvailable

=head2 Wx::Process::IsInputAvailable

   bool IsInputAvailable() const

   Returns true if there is data to be read on the child process standard
   output stream. This allows to write simple (and extremely inefficient)
   polling-based code waiting for a better mechanism in future wxWidgets
   versions.

   See the exec sample for an example of using this function.

   See also

   IsInputOpened

=head2 Wx::Process::IsInputOpened

   bool IsInputOpened() const

   Returns true if the child process standard output stream is opened.

=head2 Wx::Process::Kill

   static wxKillError Kill(int pid, wxSignal signal = wxSIGNONE, int
   flags = wxKILL_NOCHILDREN)

   Send the specified signal to the given process. Possible signal values
   are:

   enum wxSignal
   {
       wxSIGNONE = 0,  // verify if the process exists under Unix
       wxSIGHUP,
       wxSIGINT,
       wxSIGQUIT,
       wxSIGILL,
       wxSIGTRAP,
       wxSIGABRT,
       wxSIGEMT,
       wxSIGFPE,
       wxSIGKILL,      // forcefully kill, dangerous!
       wxSIGBUS,
       wxSIGSEGV,
       wxSIGSYS,
       wxSIGPIPE,
       wxSIGALRM,
       wxSIGTERM       // terminate the process gently
   };

   wxSIGNONE, wxSIGKILL and wxSIGTERM have the same meaning under both
   Unix and Windows but all the other signals are equivalent to wxSIGTERM
   under Windows.

   The flags parameter can be wxKILL_NOCHILDREN (the default), or
   wxKILL_CHILDREN, in which case the child processes of this process
   will be killed too. Note that under Unix, for wxKILL_CHILDREN to work
   you should have created the process passing wxEXEC_MAKE_GROUP_LEADER.

   Returns the element of wxKillError enum:

   enum wxKillError
   {
       wxKILL_OK,              // no error
       wxKILL_BAD_SIGNAL,      // no such signal
       wxKILL_ACCESS_DENIED,   // permission denied
       wxKILL_NO_PROCESS,      // no such process
       wxKILL_ERROR            // another, unspecified error
   };

   See also

   wxProcess::Exists, wxKill, Exec sample

=head2 Wx::Process::Exists

   static bool Exists(int pid)

   Returns true if the given process exists in the system.

   See also

   wxProcess::Kill, Exec sample

=head2 Wx::Process::OnTerminate

   void OnTerminate(int pid, int status)

   It is called when the process with the pid pid finishes. It raises a
   wxWidgets event when it isn't overridden.

   pid 

       The pid of the process which has just terminated.

   status

       The exit code of the process.

=head2 Wx::Process::Open

   static wxProcess * Open(const wxString& cmd, int flags = wxEXEC_ASYNC)

   This static method replaces the standard popen() function: it launches
   the process specified by the cmd parameter and returns the wxProcess
   object which can be used to retrieve the streams connected to the
   standard input, output and error output of the child process.

   If the process couldn't be launched, NULL is returned. Note that in
   any case the returned pointer should not be deleted, rather the
   process object will be destroyed automatically when the child process
   terminates. This does mean that the child process should be told to
   quit before the main program exits to avoid memory leaks.

   Parameters

   cmd 

       The command to execute, including optional arguments.

=head2 Wx::Process::GetPid

   long GetPid() const

   Returns the process ID of the process launched by Open.

=head2 Wx::Process::Redirect

   void Redirect()

   Turns on redirection. wxExecute will try to open a couple of pipes to
   catch the subprocess stdio. The caught input stream is returned by
   GetOutputStream() as a non-seekable stream. The caught output stream
   is returned by GetInputStream() as a non-seekable stream.

=head1 Wx::ProcessEvent

=head2 Wx::ProcessEvent::new

   wxProcessEvent(int id = 0, int pid = 0, int exitcode = 0)

   Constructor. Takes a wxProcessObject or window id, a process id and an
   exit status.

=head2 Wx::ProcessEvent::GetPid

   int GetPid() const

   Returns the process id.

=head2 Wx::ProcessEvent::GetExitCode

   int GetExitCode()

   Returns the exist status.

=head1 Wx::ProgressDialog

=head2 Wx::ProgressDialog::new

   wxProgressDialog(const wxString& title, const wxString& message, int
   maximum = 100, wxWindow * parent = NULL, int style = wxPD_AUTO_HIDE |
   wxPD_APP_MODAL)

   Constructor. Creates the dialog, displays it and disables user input
   for other windows, or, if wxPD_APP_MODAL flag is not given, for its
   parent window only.

   Parameters

   title

       Dialog title to show in titlebar.

   message

       Message displayed above the progress bar.

   maximum

       Maximum value for the progress bar.

   parent

       Parent window.

   style

       The dialog style. See wxProgressDialog.

=head2 Wx::ProgressDialog::DESTROY

   ~wxProgressDialog()

   Destructor. Deletes the dialog and enables all top level windows.

=head2 Wx::ProgressDialog::Resume

   void Resume()

   Can be used to continue with the dialog, after the user had chosen
   ABORT.

=head2 Wx::ProgressDialog::Update

   virtual bool Update(int value, const wxString& newmsg = "", bool *skip
   = NULL)

   Updates the dialog, setting the progress bar to the new value and, if
   given changes the message above it. Returns true unless the Cancel
   button has been pressed.

   If false is returned, the application can either immediately destroy
   the dialog or ask the user for the confirmation and if the abort is
   not confirmed the dialog may be resumed with Resume function.

   Parameters

   value

       The new value of the progress meter. It should be less than or
       equal to the maximum value given to the constructor and the dialog
       is closed if it is equal to the maximum.

=head2 Wx::ProgressDialog::Pulse

   virtual bool Pulse(const wxString& newmsg = "", bool *skip = NULL)

   Just like Update but makes the gauge control run in indeterminate mode
   (see wxGauge documentation), sets the remaining and the estimated time
   labels (if present) to Unknown and moves the progress bar a bit to
   indicate that some progress was done.

=head1 Wx::PropertySheetDialog

=head2 Wx::PropertySheetDialog::new

   wxPropertySheetDialog(wxWindow* parent, wxWindowID id, const wxString&
   title, const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = wxDEFAULT_DIALOG_STYLE, const wxString&
   name = "dialogBox")

   Constructor.

=head2 Wx::PropertySheetDialog::AddBookCtrl

   virtual void AddBookCtrl(wxSizer* sizer)

   Override this if you wish to add the book control in a way different
   from the standard way (for example, using different spacing).

=head2 Wx::PropertySheetDialog::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxString& title,
   const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = wxDEFAULT_DIALOG_STYLE, const wxString&
   name = "dialogBox")

   Call this from your own Create function, before adding buttons and
   pages.

=head2 Wx::PropertySheetDialog::CreateBookCtrl

   virtual wxBookCtrlBase* CreateBookCtrl()

   Override this if you wish to create a different kind of book control;
   by default, the value passed to SetSheetStyle is used to determine the
   control. The default behaviour is to create a notebook except on
   Smartphone, where a choicebook is used.

=head2 Wx::PropertySheetDialog::CreateButtons

   void CreateButtons(int flags=wxOK|wxCANCEL)

   Call this to create the buttons for the dialog. This calls
   wxDialog::CreateButtonSizer, and the flags are the same. On PocketPC,
   no buttons are created.

=head2 Wx::PropertySheetDialog::GetBookCtrl

   wxBookCtrlBase* GetBookCtrl() const

   Returns the book control that will contain your settings pages.

=head2 Wx::PropertySheetDialog::GetInnerSizer

   wxSizer* GetInnerSizer() const

   Returns the inner sizer that contains the book control and button
   sizer.

=head2 Wx::PropertySheetDialog::GetSheetStyle

   long GetSheetStyle() const

   Returns the sheet style. See SetSheetStyle for permissable values.

=head2 Wx::PropertySheetDialog::LayoutDialog

   void LayoutDialog(int centreFlags=wxBOTH)

   Call this to lay out the dialog. On PocketPC, this does nothing, since
   the dialog will be shown full-screen, and the layout will be done when
   the dialog receives a size event.

=head2 Wx::PropertySheetDialog::SetBookCtrl

   void SetBookCtrl(wxBookCtrlBase* bookCtrl)

   Sets the book control used for the dialog. You will normally not need
   to use this.

=head2 Wx::PropertySheetDialog::SetInnerSizer

   void SetInnerSizer(wxSizer* sizer)

   Sets the inner sizer that contains the book control and button sizer.
   You will normally not need to use this.

=head2 Wx::PropertySheetDialog::SetSheetStyle

   void SetSheetStyle(long style)

   You can customize the look and feel of the dialog by setting the sheet
   style. It is a bit list of the following values:

=head1 Wx::Protocol

=head2 Wx::Protocol::Reconnect

   bool Reconnect()

   Tries to reestablish a previous opened connection (close and
   renegotiate connection).

   Return value

   true, if the connection is established, else false.

=head2 Wx::Protocol::GetInputStream

   wxInputStream * GetInputStream(const wxString& path)

   Creates a new input stream on the specified path. You can use all but
   seek functionality of wxStream. Seek isn't available on all streams.
   For example, HTTP or FTP streams don't deal with it. Other functions
   like StreamSize and Tell aren't available for the moment for this sort
   of stream. You will be notified when the EOF is reached by an error.

   Return value

   Returns the initialized stream. You will have to delete it yourself
   once you don't use it anymore. The destructor closes the network
   connection.

   See also

   wxInputStream

=head2 Wx::Protocol::Abort

   bool Abort()

   Abort the current stream.

   Warning

   It is advised to destroy the input stream instead of aborting the
   stream this way.

   Return value

   Returns true, if successful, else false.

=head2 Wx::Protocol::GetError

   wxProtocolError GetError()

   Returns the last occurred error.

=head2 Wx::Protocol::GetContentType

   wxString GetContentType()

   Returns the type of the content of the last opened stream. It is a
   mime-type.

=head2 Wx::Protocol::SetUser

   void SetUser(const wxString& user)

   Sets the authentication user. It is mainly useful when FTP is used.

=head2 Wx::Protocol::SetPassword

   void SetPassword(const wxString& user)

   Sets the authentication password. It is mainly useful when FTP is
   used.

=head1 Wx::Quantize

=head2 Wx::Quantize::new

   wxQuantize()

   Constructor. You do not need to construct a wxQuantize object since
   its functions are static.

=head2 Wx::Quantize::Quantize

   bool Quantize(const wxImage& src, wxImage& dest, wxPalette** pPalette,
   int desiredNoColours = 236, unsigned char** eightBitData = 0, int
   flags =
   wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE|wxQUANTIZE_RETURN_8BIT_DATA)

   Reduce the colours in the source image and put the result into the
   destination image. Both images may be the same, to overwrite the
   source image. Specify an optional palette pointer to receive the
   resulting palette. This palette may be passed to ConvertImageToBitmap,
   for example.

   If you pass a palette pointer, you must free the palette yourself.

   bool Quantize(const wxImage& src, wxImage& dest, int desiredNoColours
   = 236, unsigned char** eightBitData = 0, int flags =
   wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE|wxQUANTIZE_RETURN_8BIT_DATA)

   This version sets a palette in the destination image so you don't have
   to manage it yourself.

=head2 Wx::Quantize::DoQuantize

   void DoQuantize(unsigned w, unsigned h, unsigned char** in_rows,
   unsigned char** out_rows, unsigned char* palette, int desiredNoColours)

   Converts input bitmap(s) into 8bit representation with custom palette.

   in_rows and out_rows are arrays [0..h-1] of pointer to rows (in_rows
   contains w * 3 bytes per row, out_rows w bytes per row).

   Fills out_rows with indexes into palette (which is also stored into
   palette variable).

=head1 Wx::QueryLayoutInfoEvent

=head2 Wx::QueryLayoutInfoEvent::new

   wxQueryLayoutInfoEvent(wxWindowID id = 0)

   Constructor.

=head2 Wx::QueryLayoutInfoEvent::GetAlignment

   void GetAlignment() const

   Specifies the alignment of the window (which side of the remaining
   parent client area the window sticks to). One of wxLAYOUT_TOP,
   wxLAYOUT_LEFT, wxLAYOUT_RIGHT, wxLAYOUT_BOTTOM.

=head2 Wx::QueryLayoutInfoEvent::GetFlags

   int GetFlags() const

   Returns the flags associated with this event. Not currently used.

=head2 Wx::QueryLayoutInfoEvent::GetOrientation

   wxLayoutOrientation GetOrientation() const

   Returns the orientation that the event handler specified to the event
   object. May be one of wxLAYOUT_HORIZONTAL, wxLAYOUT_VERTICAL.

=head2 Wx::QueryLayoutInfoEvent::GetRequestedLength

   int GetRequestedLength() const

   Returns the requested length of the window in the direction of the
   window orientation. This information is not yet used.

=head2 Wx::QueryLayoutInfoEvent::GetSize

   wxSize GetSize() const

   Returns the size that the event handler specified to the event object
   as being the requested size of the window.

=head2 Wx::QueryLayoutInfoEvent::SetAlignment

   void SetAlignment(wxLayoutAlignment alignment)

   Call this to specify the alignment of the window (which side of the
   remaining parent client area the window sticks to). May be one of
   wxLAYOUT_TOP, wxLAYOUT_LEFT, wxLAYOUT_RIGHT, wxLAYOUT_BOTTOM.

=head2 Wx::QueryLayoutInfoEvent::SetFlags

   void SetFlags(int flags)

   Sets the flags associated with this event. Not currently used.

=head2 Wx::QueryLayoutInfoEvent::SetOrientation

   void SetOrientation(wxLayoutOrientation orientation)

   Call this to specify the orientation of the window. May be one of
   wxLAYOUT_HORIZONTAL, wxLAYOUT_VERTICAL.

=head2 Wx::QueryLayoutInfoEvent::SetRequestedLength

   void SetRequestedLength(int length)

   Sets the requested length of the window in the direction of the window
   orientation. This information is not yet used.

=head2 Wx::QueryLayoutInfoEvent::SetSize

   void SetSize(const wxSize& size)

   Call this to let the calling code know what the size of the window is.

=head1 Wx::RadioBox

=head2 Wx::RadioBox::new

   wxRadioBox()

   Default constructor.

   wxRadioBox(wxWindow* parent, wxWindowID id, const wxString& label,
   const wxPoint& point = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, int n = 0, const wxString choices[] = NULL, int
   majorDimension = 0, long style = wxRA_SPECIFY_COLS, const wxValidator&
   validator = wxDefaultValidator, const wxString& name = "radioBox")

   wxRadioBox(wxWindow* parent, wxWindowID id, const wxString& label,
   const wxPoint& point, const wxSize& size, const wxArrayString& choices,
   int majorDimension = 0, long style = wxRA_SPECIFY_COLS, const
   wxValidator& validator = wxDefaultValidator, const wxString& name =
   "radioBox")

   Constructor, creating and showing a radiobox.

   Parameters

   parent

       Parent window. Must not be NULL.

   id  

       Window identifier. A value of -1 indicates a default value.

   label

       Label for the static box surrounding the radio buttons.

   pos 

       Window position. If the position (-1, -1) is specified then a
       default position is chosen.

   size

       Window size. If the default size (-1, -1) is specified then a
       default size is chosen.

   n   

       Number of choices with which to initialize the radiobox.

   choices

       An array of choices with which to initialize the radiobox.

   majorDimension

       Specifies the maximum number of rows (if style contains
       wxRA_SPECIFY_ROWS) or columns (if style contains
       wxRA_SPECIFY_COLS) for a two-dimensional radiobox.

   style

       Window style. See wxRadioBox.

   validator

       Window validator.

   name

       Window name.

   See also

   wxRadioBox::Create, wxValidator

   wxPython note: The wxRadioBox constructor in wxPython reduces the n
   and choices arguments are to a single argument, which is a list of
   strings.

   wxPerl note: In wxPerl there is just an array reference in place of n
   and choices.

=head2 Wx::RadioBox::DESTROY

   ~wxRadioBox()

   Destructor, destroying the radiobox item.

=head2 Wx::RadioBox::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxString& label,
   const wxPoint& point = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, int n = 0, const wxString choices[] = NULL, int
   majorDimension = 0, long style = wxRA_SPECIFY_COLS, const wxValidator&
   validator = wxDefaultValidator, const wxString& name = "radioBox")

   bool Create(wxWindow* parent, wxWindowID id, const wxString& label,
   const wxPoint& point, const wxSize& size, const wxArrayString& choices,
   int majorDimension = 0, long style = wxRA_SPECIFY_COLS, const
   wxValidator& validator = wxDefaultValidator, const wxString& name =
   "radioBox")

   Creates the radiobox for two-step construction. See
   wxRadioBox::wxRadioBox for further details.

=head2 Wx::RadioBox::Enable

   virtual bool Enable(bool enable = true)

   Enables or disables the entire radiobox.

   virtual bool Enable(unsigned int n, bool enable = true)

   Enables or disables an individual button in the radiobox.

   Parameters

   enable

       true to enable, false to disable.

   n   

       The zero-based button to enable or disable.

   wxPython note: In place of a single overloaded method name, wxPython
   implements the following methods:

=head2 Wx::RadioBox::FindString

   int FindString(const wxString& string) const

   Finds a button matching the given string, returning the position if
   found, or -1 if not found.

   Parameters

   string

       The string to find.

=head2 Wx::RadioBox::GetColumnCount

   unsigned int GetColumnCount() const

   Returns the number of columns in the radiobox.

=head2 Wx::RadioBox::GetItemHelpText

   wxString GetItemHelpText(unsigned int item) const

   Returns the helptext associated with the specified item if any or
   wxEmptyString.

   Parameters

   item

       The zero-based item index.

   See also

   SetItemHelpText

=head2 Wx::RadioBox::GetItemToolTip

   wxToolTip * GetItemToolTip(unsigned int item) const

   Returns the tooltip associated with the specified item if any or NULL.

   See also

   SetItemToolTip,

=head2 Wx::RadioBox::GetItemFromPoint

   int GetItemFromPoint(const wxPoint pt) const

   Returns a radio box item under the point, a zero-based item index, or
   wxNOT_FOUND if no item is under the point.

   pt  

       Point in client coordinates.

=head2 Wx::RadioBox::GetLabel

   wxString GetLabel() const

   Returns the radiobox label.

   Parameters

   n   

       The zero-based button index.

   See also

   wxRadioBox::SetLabel

   wxPython note: In place of a single overloaded method name, wxPython
   implements the following methods:

=head2 Wx::RadioBox::GetRowCount

   unsigned int GetRowCount() const

   Returns the number of rows in the radiobox.

=head2 Wx::RadioBox::GetSelection

   int GetSelection() const

   Returns the zero-based position of the selected button.

=head2 Wx::RadioBox::GetStringSelection

   wxString GetStringSelection() const

   Returns the selected string.

=head2 Wx::RadioBox::GetString

   wxString GetString(unsigned int n) const

   Returns the label for the button at the given position.

   Parameters

   n   

       The zero-based button position.

=head2 Wx::RadioBox::IsItemEnabled

   bool IsItemEnabled(unsigned int n) const

   Returns true if the item is enabled or false if it was disabled using
   Enable(n, false).

   Platform note: Currently only implemented in wxMSW, wxGTK and
   wxUniversal and always returns true in the other ports.

   Parameters

   n   

       The zero-based button position.

=head2 Wx::RadioBox::IsItemShown

   bool IsItemShown(unsigned int n) const

   Returns true if the item is currently shown or false if it was hidden
   using Show(n, false).

   Note that this function returns true for an item which hadn't been
   hidden even if the entire radiobox is not currently shown.

   Platform note: Currently only implemented in wxMSW, wxGTK and
   wxUniversal and always returns true in the other ports.

   Parameters

   n   

       The zero-based button position.

=head2 Wx::RadioBox::SetItemHelpText

   void SetItemHelpText(unsigned int item, const wxString& helptext)

   Sets the helptext for an item. Empty string erases any existing
   helptext.

   Parameters

   item

       The zero-based item index.

   helptext

       The help text to set for the item.

   See also

   GetItemHelpText

=head2 Wx::RadioBox::SetLabel

   void SetLabel(const wxString& label)

   Sets the radiobox label.

=head2 Wx::RadioBox::SetSelection

   void SetSelection(int n)

   Sets a button by passing the desired string position. This does not
   cause a wxEVT_COMMAND_RADIOBOX_SELECTED event to get emitted.

   Parameters

   n   

       The zero-based button position.

=head2 Wx::RadioBox::SetStringSelection

   void SetStringSelection(const wxString& string)

   Sets the selection to a button by passing the desired string. This
   does not cause a wxEVT_COMMAND_RADIOBOX_SELECTED event to get emitted.

   Parameters

   string

       The label of the button to select.

=head2 Wx::RadioBox::SetItemToolTip

   void SetItemToolTip(unsigned int item, const wxString& text)

   Sets the tooltip text for the specified item in the radio group.

   Platform note: Currently only implemented in wxMSW and wxGTK2 and does
   nothing in the other ports.

   Parameters

   item

       Index of the item the tooltip will be shown for.

   text

       Tooltip text for the item, the tooltip is removed if empty.

   See also

   GetItemToolTip,

=head2 Wx::RadioBox::Show

   virtual bool Show(const bool show = true)

   Shows or hides the entire radiobox.

   virtual bool Show(unsigned int item, const bool show = true)

   Shows or hides individual buttons.

   Parameters

   show

       true to show, false to hide.

   item

       The zero-based position of the button to show or hide.

   Return value

   true if the box or item has been shown or hidden or false if nothing
   was done because it already was in the requested state.

   See also

   wxWindow::Show

   wxPython note: In place of a single overloaded method name, wxPython
   implements the following methods:

=head1 Wx::RadioButton

=head2 Wx::RadioButton::new

   wxRadioButton()

   Default constructor.

   wxRadioButton(wxWindow* parent, wxWindowID id, const wxString& label,
   const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = 0, const wxValidator& validator =
   wxDefaultValidator, const wxString& name = "radioButton")

   Constructor, creating and showing a radio button.

   Parameters

   parent

       Parent window. Must not be NULL.

   id  

       Window identifier. A value of -1 indicates a default value.

   label

       Label for the radio button.

   pos 

       Window position. If the position (-1, -1) is specified then a
       default position is chosen.

   size

       Window size. If the default size (-1, -1) is specified then a
       default size is chosen.

   style

       Window style. See wxRadioButton.

   validator

       Window validator.

   name

       Window name.

   See also

   wxRadioButton::Create, wxValidator

=head2 Wx::RadioButton::DESTROY

   void ~wxRadioButton()

   Destructor, destroying the radio button item.

=head2 Wx::RadioButton::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxString& label,
   const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = 0, const wxValidator& validator =
   wxDefaultValidator, const wxString& name = "radioButton")

   Creates the choice for two-step construction. See
   wxRadioButton::wxRadioButton for further details.

=head2 Wx::RadioButton::GetValue

   bool GetValue() const

   Returns true if the radio button is depressed, false otherwise.

=head2 Wx::RadioButton::SetValue

   void SetValue(const bool value)

   Sets the radio button to selected or deselected status. This does not
   cause a wxEVT_COMMAND_RADIOBUTTON_SELECTED event to get emitted.

   Parameters

   value

       true to select, false to deselect.

=head1 Wx::RealPoint

=head2 Wx::RealPoint::new

   wxRealPoint()

   wxRealPoint(double x, double y)

   Create a point.

   double x

   double y

   Members of the wxRealPoint object.

=head1 Wx::Rect

=head2 Wx::Rect::new

   wxRect()

   Default constructor.

   wxRect(int x, int y, int width, int height)

   Creates a wxRect object from x, y, width and height values.

   wxRect(const wxPoint& topLeft, const wxPoint& bottomRight)

   Creates a wxRect object from top-left and bottom-right points.

   wxRect(const wxPoint& pos, const wxSize& size)

   Creates a wxRect object from position and size values.

   wxRect(const wxSize& size)

   Creates a wxRect object from size values at the origin.

=head2 Wx::Rect::x

   int x

   x coordinate of the top-level corner of the rectangle.

=head2 Wx::Rect::y

   int y

   y coordinate of the top-level corner of the rectangle.

=head2 Wx::Rect::width

   int width

   Width member.

=head2 Wx::Rect::height

   int height

   Height member.

=head2 Wx::Rect::CentreIn

   wxRect CentreIn(const wxRect& r, int dir = wxBOTH) const

   wxRect CenterIn(const wxRect& r, int dir = wxBOTH) const

   Returns the rectangle having the same size as this one but centered
   relatively to the given rectangle r. By default, rectangle is centred
   in both directions but if dir includes only wxVERTICAL or only
   wxHORIZONTAL flag, then it is only centered in this direction while
   the other component of its position remains unchanged.

=head2 Wx::Rect::Contains

   bool Contains(int x, int y) const

   bool Contains(const wxPoint& pt) const

   Returns true if the given point is inside the rectangle (or on its
   boundary) and false otherwise.

   bool Contains(const wxRect& rect) const

   Returns true if the given rectangle is completely inside this
   rectangle (or touches its boundary) and false otherwise.

=head2 Wx::Rect::Deflate

   void Deflate(wxCoord dx, wxCoord dy)

   void Deflate(const wxSize& diff)

   void Deflate(wxCoord diff)

   wxRect Deflate(wxCoord dx, wxCoord dy) const

   Decrease the rectangle size.

   This method is the opposite from Inflate: Deflate(a, b) is equivalent
   to Inflate(-a, -b). Please refer to Inflate for full description.

   See also

   Inflate

=head2 Wx::Rect::GetBottom

   int GetBottom() const

   Gets the bottom point of the rectangle.

=head2 Wx::Rect::GetHeight

   int GetHeight() const

   Gets the height member.

=head2 Wx::Rect::GetLeft

   int GetLeft() const

   Gets the left point of the rectangle (the same as wxRect::GetX).

=head2 Wx::Rect::GetPosition

   wxPoint GetPosition() const

   Gets the position.

=head2 Wx::Rect::GetTopLeft

   wxPoint GetTopLeft() const

   Gets the position of the top left corner of the rectangle, same as
   GetPosition.

=head2 Wx::Rect::GetTopRight

   wxPoint GetTopRight() const

   Gets the position of the top right corner.

=head2 Wx::Rect::GetBottomLeft

   wxPoint GetBottomLeft() const

   Gets the position of the bottom left corner.

=head2 Wx::Rect::GetBottomRight

   wxPoint GetBottomRight() const

   Gets the position of the bottom right corner.

=head2 Wx::Rect::GetRight

   int GetRight() const

   Gets the right point of the rectangle.

=head2 Wx::Rect::GetSize

   wxSize GetSize() const

   Gets the size.

   See also

   wxRect::SetSize

=head2 Wx::Rect::GetTop

   int GetTop() const

   Gets the top point of the rectangle (the same as wxRect::GetY).

=head2 Wx::Rect::GetWidth

   int GetWidth() const

   Gets the width member.

=head2 Wx::Rect::GetX

   int GetX() const

   Gets the x member.

=head2 Wx::Rect::GetY

   int GetY() const

   Gets the y member.

=head2 Wx::Rect::Inflate

   void Inflate(wxCoord dx, wxCoord dy)

   void Inflate(const wxSize& diff)

   void Inflate(wxCoord diff)

   wxRect Inflate(wxCoord dx, wxCoord dy) const

   Increases the size of the rectangle.

   The second form uses the same diff for both dx and dy.

   The first two versions modify the rectangle in place, the last one
   returns a new rectangle leaving this one unchanged.

   The left border is moved farther left and the right border is moved
   farther right by dx. The upper border is moved farther up and the
   bottom border is moved farther down by dy. (Note the the width and
   height of the rectangle thus change by 2*dx and 2*dy, respectively.)
   If one or both of dx and dy are negative, the opposite happens: the
   rectangle size decreases in the respective direction.

   Inflating and deflating behaves "naturally''. Defined more precisely,
   that means:

=head2 Wx::Rect::Intersect

   wxRect Intersect(const wxRect& rect) const

   wxRect& Intersect(const wxRect& rect)

   Modifies the rectangle to contain the overlapping box of this
   rectangle and the one passed in as parameter. The const version
   returns the new rectangle, the other one modifies this rectangle in
   place.

=head2 Wx::Rect::Intersects

   bool Intersects(const wxRect& rect) const

   Returns true if this rectangle has a non-empty intersection with the
   rectangle rect and false otherwise.

=head2 Wx::Rect::IsEmpty

   bool IsEmpty() const

   Returns true if this rectangle has a width or height less than or
   equal to 0 and false otherwise.

=head2 Wx::Rect::Offset

   void Offset(wxCoord dx, wxCoord dy)

   void Offset(const wxPoint& pt)

   Moves the rectangle by the specified offset. If dx is positive, the
   rectangle is moved to the right, if dy is positive, it is moved to the
   bottom, otherwise it is moved to the left or top respectively.

=head2 Wx::Rect::SetHeight

   void SetHeight(int height)

   Sets the height.

=head2 Wx::Rect::SetSize

   void SetSize(const wxSize& s)

   Sets the size.

   See also

   wxRect::GetSize

=head2 Wx::Rect::SetWidth

   void SetWidth(int width)

   Sets the width.

=head2 Wx::Rect::SetX

   void SetX(int x)

   Sets the x position.

=head2 Wx::Rect::SetY

   void SetY(int y)

   Sets the y position.

=head2 Wx::Rect::Union

   wxRect Union(const wxRect& rect) const

   wxRect& Union(const wxRect& rect)

   Modifies the rectangle to contain the bounding box of this rectangle
   and the one passed in as parameter. The const version returns the new
   rectangle, the other one modifies this rectangle in place.

=head1 Wx::RecursionGuard

=head2 Wx::RecursionGuard::new

   wxRecursionGuard(wxRecursionGuardFlag& flag)

   A wxRecursionGuard object must always be initialized with a (static)
   wxRecursionGuardFlag. The constructor saves the value of the flag to
   be able to return the correct value from IsInside.

=head2 Wx::RecursionGuard::DESTROY

   ~wxRecursionGuard()

   The destructor resets the flag value so that the function can be
   entered again the next time.

   Note that it is not virtual and so this class is not meant to be
   derived from (besides, there is absolutely no reason to do it anyhow).

=head2 Wx::RecursionGuard::IsInside

   bool IsInside() const

   Returns true if we're already inside the code block "protected'' by
   this wxRecursionGuard (i.e. between this line and the end of current
   scope). Usually the function using wxRecursionGuard takes some
   specific actions in such case (may be simply returning) to prevent
   reentrant calls to itself.

   If this method returns false, it is safe to continue.

=head1 Wx::RegEx

=head2 Wx::RegEx::new

   wxRegEx()

   Default ctor: use Compile() later.

   wxRegEx(const wxString& expr, int flags = wxRE_DEFAULT)

   Create and compile the regular expression, use IsValid to test for
   compilation errors.

=head2 Wx::RegEx::DESTROY

   ~wxRegEx()

   dtor not virtual, don't derive from this class

=head2 Wx::RegEx::Compile

   bool Compile(const wxString& pattern, int flags = wxRE_DEFAULT)

   Compile the string into regular expression, return true if ok or false
   if string has a syntax error.

=head2 Wx::RegEx::IsValid

   bool IsValid() const

   Return true if this is a valid compiled regular expression, false
   otherwise.

=head2 Wx::RegEx::GetMatch

   bool GetMatch(size_t* start, size_t* len, size_t index = 0) const

   Get the start index and the length of the match of the expression (if
   index is 0) or a bracketed subexpression (index different from 0).

   May only be called after successful call to Matches() and only if
   wxRE_NOSUB was not used in Compile().

   Returns false if no match or if an error occurred.

   wxString GetMatch(const wxString& text, size_t index = 0) const

   Returns the part of string corresponding to the match where index is
   interpreted as above. Empty string is returned if match failed

   May only be called after successful call to Matches() and only if
   wxRE_NOSUB was not used in Compile().

=head2 Wx::RegEx::GetMatchCount

   size_t GetMatchCount() const

   Returns the size of the array of matches, i.e. the number of bracketed
   subexpressions plus one for the expression itself, or 0 on error.

   May only be called after successful call to Compile(). and only if
   wxRE_NOSUB was not used.

=head2 Wx::RegEx::Matches

   bool Matches(const wxChar* text, int flags = 0) const

   bool Matches(const wxChar* text, int flags, size_t len) const

   bool Matches(const wxString& text, int flags = 0) const

   Matches the precompiled regular expression against the string text,
   returns true if matches and false otherwise.

   Flags may be combination of wxRE_NOTBOL and wxRE_NOTEOL.

   Some regex libraries assume that the text given is null terminated,
   while others require the length be given as a separate parameter.
   Therefore for maximum portability assume that text cannot contain
   embedded nulls.

   When the Matches(const wxChar *text, int flags = 0) form is used, a
   wxStrlen() will be done internally if the regex library requires the
   length. When using Matches() in a loop the Matches(text, flags, len)
   form can be used instead, making it possible to avoid a wxStrlen()
   inside the loop.

   May only be called after successful call to Compile().

=head2 Wx::RegEx::Replace

   int Replace(wxString* text, const wxString& replacement, size_t
   maxMatches = 0) const

   Replaces the current regular expression in the string pointed to by
   text, with the text in replacement and return number of matches
   replaced (maybe 0 if none found) or -1 on error.

   The replacement text may contain back references \number which will be
   replaced with the value of the corresponding subexpression in the
   pattern match. \0 corresponds to the entire match and & is a synonym
   for it. Backslash may be used to quote itself or & character.

   maxMatches may be used to limit the number of replacements made,
   setting it to 1, for example, will only replace first occurrence (if
   any) of the pattern in the text while default value of 0 means replace
   all.

=head2 Wx::RegEx::ReplaceAll

   int ReplaceAll(wxString* text, const wxString& replacement) const

   Replace all occurrences: this is actually a synonym for Replace().

   See also

   ReplaceFirst

=head2 Wx::RegEx::ReplaceFirst

   int ReplaceFirst(wxString* text, const wxString& replacement) const

   Replace the first occurrence.

   See also

   Replace

=head1 Wx::Region

=head2 Wx::Region::new

   wxRegion()

   Default constructor.

   wxRegion(wxCoord x, wxCoord y, wxCoord width, wxCoord height)

   Constructs a rectangular region with the given position and size.

   wxRegion(const wxPoint& topLeft, const wxPoint& bottomRight)

   Constructs a rectangular region from the top left point and the bottom
   right point.

   wxRegion(const wxRect& rect)

   Constructs a rectangular region a wxRect object.

   wxRegion(const wxRegion& region)

   Copy constructor, uses reference counting.

   wxRegion(size_t n, const wxPoint *points, int fillStyle =
   wxWINDING_RULE)

   Constructs a region corresponding to the polygon made of n points in
   the provided array. fillStyle parameter may have values wxWINDING_RULE
   or wxODDEVEN_RULE.

   wxRegion(const wxBitmap& bmp)

   wxRegion(const wxBitmap& bmp, const wxColour& transColour, int
   tolerance = 0)

   Constructs a region using the non-transparent pixels of a bitmap. See
   Union for more details.

=head2 Wx::Region::DESTROY

   ~wxRegion()

   Destructor. See reference-counted object destruction for more info.

=head2 Wx::Region::Clear

   void Clear()

   Clears the current region.

=head2 Wx::Region::Contains

   wxRegionContain Contains(long& x, long& y) const

   Returns a value indicating whether the given point is contained within
   the region.

   wxRegionContain Contains(const wxPoint& pt) const

   Returns a value indicating whether the given point is contained within
   the region.

   wxRegionContain Contains(long& x, long& y, long& width, long& height)
   const

   Returns a value indicating whether the given rectangle is contained
   within the region.

   wxRegionContain Contains(const wxRect& rect) const

   Returns a value indicating whether the given rectangle is contained
   within the region.

   Return value

   The return value is one of wxOutRegion, wxPartRegion and wxInRegion.

   On Windows, only wxOutRegion and wxInRegion are returned; a value
   wxInRegion then indicates that all or some part of the region is
   contained in this region.

=head2 Wx::Region::ConvertToBitmap

   wxBitmap ConvertToBitmap() const

   Convert the region to a black and white bitmap with the white pixels
   being inside the region.

=head2 Wx::Region::GetBox

   void GetBox(wxCoord& x, wxCoord& y, wxCoord& width, wxCoord& height)
   const

   Returns the outer bounds of the region.

   wxRect GetBox() const

   Returns the outer bounds of the region.

=head2 Wx::Region::Intersect

   bool Intersect(wxCoord x, wxCoord y, wxCoord width, wxCoord height)

   Finds the intersection of this region and another, rectangular region,
   specified using position and size.

   bool Intersect(const wxRect& rect)

   Finds the intersection of this region and another, rectangular region.

   bool Intersect(const wxRegion& region)

   Finds the intersection of this region and another region.

   Return value

   true if successful, false otherwise.

   Remarks

   Creates the intersection of the two regions, that is, the parts which
   are in both regions. The result is stored in this region.

=head2 Wx::Region::IsEmpty

   bool IsEmpty() const

   Returns true if the region is empty, false otherwise.

=head2 Wx::Region::IsEqual

   bool IsEqual(const wxRegion& region) const

   Returns true if the region is equal to, i.e. covers the same area as,
   another one. Note that if both this region and region are invalid,
   they are considered to be equal.

=head2 Wx::Region::Subtract

   bool Subtract(const wxRect& rect)

   Subtracts a rectangular region from this region.

   bool Subtract(const wxRegion& region)

   Subtracts a region from this region.

   Return value

   true if successful, false otherwise.

   Remarks

   This operation combines the parts of 'this' region that are not part
   of the second region. The result is stored in this region.

=head2 Wx::Region::Offset

   bool Offset(wxCoord x, wxCoord y)

   bool Offset(const wxPoint& pt)

   Moves the region by the specified offsets in horizontal and vertical
   directions.

   Return value

   true if successful, false otherwise (the region is unchanged then).

=head2 Wx::Region::Union

   bool Union(wxCoord x, wxCoord y, wxCoord width, wxCoord height)

   Finds the union of this region and another, rectangular region,
   specified using position and size.

   bool Union(const wxRect& rect)

   Finds the union of this region and another, rectangular region.

   bool Union(const wxRegion& region)

   Finds the union of this region and another region.

   bool Union(const wxBitmap& bmp)

   Finds the union of this region and the non-transparent pixels of a
   bitmap. Bitmap's mask is used to determine transparency. If the bitmap
   doesn't have a mask, solid rectangle of bitmap's dimensions is used.

   bool Union(const wxBitmap& bmp, const wxColour& transColour, int
   tolerance = 0)

   Finds the union of this region and the non-transparent pixels of a
   bitmap. Colour to be treated as transparent is specified in the
   transColour argument, along with an optional colour tolerance value.

   Return value

   true if successful, false otherwise.

   Remarks

   This operation creates a region that combines all of this region and
   the second region. The result is stored in this region.

=head2 Wx::Region::Xor

   bool Xor(wxCoord x, wxCoord y, wxCoord width, wxCoord height)

   Finds the Xor of this region and another, rectangular region,
   specified using position and size.

   bool Xor(const wxRect& rect)

   Finds the Xor of this region and another, rectangular region.

   bool Xor(const wxRegion& region)

   Finds the Xor of this region and another region.

   Return value

   true if successful, false otherwise.

   Remarks

   This operation creates a region that combines all of this region and
   the second region, except for any overlapping areas. The result is
   stored in this region.

=head1 Wx::RegionIterator

=head2 Wx::RegionIterator::new

   wxRegionIterator()

   Default constructor.

   wxRegionIterator(const wxRegion& region)

   Creates an iterator object given a region.

=head2 Wx::RegionIterator::GetX

   wxCoord GetX() const

   Returns the x value for the current region.

=head2 Wx::RegionIterator::GetY

   wxCoord GetY() const

   Returns the y value for the current region.

=head2 Wx::RegionIterator::GetW

   wxCoord GetW() const

   An alias for GetWidth.

=head2 Wx::RegionIterator::GetHeight

   wxCoord GetHeight() const

   Returns the height value for the current region.

=head2 Wx::RegionIterator::GetH

   wxCoord GetH() const

   An alias for GetHeight.

=head2 Wx::RegionIterator::GetRect

   wxRect GetRect() const

   Returns the current rectangle.

=head2 Wx::RegionIterator::GetWidth

   wxCoord GetWidth() const

   Returns the width value for the current region.

=head2 Wx::RegionIterator::HaveRects

   bool HaveRects() const

   Returns true if there are still some rectangles; otherwise returns
   false.

=head2 Wx::RegionIterator::Reset

   void Reset()

   Resets the iterator to the beginning of the rectangles.

   void Reset(const wxRegion& region)

   Resets the iterator to the given region.

=head1 Wx::RegKey

=head2 Wx::RegKey::new

   wxRegKey()

   The Constructor to set to HKCR

   wxRegKey(const wxString& strKey)

   The constructor to set the full name of the key.

   wxRegKey(const wxRegKey& keyParent, const wxString& strKey)

   The constructor to set the full name of the key under a previously
   created parent.

=head2 Wx::RegKey::Close

   void Close()

   Closes the key.

=head2 Wx::RegKey::Create

   bool Create(bool bOkIfExists = true)

   Creates the key. Will fail if the key already exists and bOkIfExists
   is false.

=head2 Wx::RegKey::DeleteSelf

   void DeleteSelf()

   Deletes this key and all of its subkeys and values recursively.

=head2 Wx::RegKey::DeleteKey

   void DeleteKey(const wxChar *szKey)

   Deletes the subkey with all of its subkeys/values recursively.

=head2 Wx::RegKey::DeleteValue

   void DeleteValue(const wxChar *szKey)

   Deletes the named value.

=head2 Wx::RegKey::Exists

   static bool Exists() const

   Returns true if the key exists.

=head2 Wx::RegKey::GetName

   wxString GetName(bool bShortPrefix = true) const

   Gets the name of the registry key.

=head2 Wx::RegKey::GetFirstKey

   bool GetFirstKey(wxString& strKeyName, long& lIndex)

   Gets the first key.

=head2 Wx::RegKey::GetFirstValue

   bool GetFirstValue(wxString& strValueName, long& lIndex)

   Gets the first value of this key.

=head2 Wx::RegKey::GetKeyInfo

   bool Exists(size_t *pnSubKeys, size_t *pnValues, size_t *pnMaxValueLen)
   const

   Gets information about the key.

   Parameters

   pnSubKeys

       The number of subkeys.

   pnMaxKeyLen

       The maximum length of the subkey name.

   pnValues

       The number of values.

=head2 Wx::RegKey::GetNextKey

   bool GetNextKey(wxString& strKeyName, long& lIndex) const

   Gets the next key.

=head2 Wx::RegKey::GetNextValue

   bool GetNextValue(wxString& strValueName, long& lIndex) const

   Gets the next key value for this key.

=head2 Wx::RegKey::HasValue

   bool HasValue(const wxChar *szValue) const

   Returns true if the value exists.

=head2 Wx::RegKey::HasValues

   bool HasValues() const

   Returns true if any values exist.

=head2 Wx::RegKey::HasSubKey

   bool HasSubKey(const wxChar *szKey) const

   Returns true if given subkey exists.

=head2 Wx::RegKey::HasSubKeys

   bool HasSubKeys() const

   Returns true if any subkeys exist.

=head2 Wx::RegKey::IsEmpty

   bool IsEmpty() const

   Returns true if this key is empty, nothing under this key.

=head2 Wx::RegKey::IsOpened

   bool IsOpened() const

   Returns true if the key is opened.

=head2 Wx::RegKey::Open

   bool Open(AccessMode mode = Write)

   Explicitly opens the key. This method also allows the key to be opened
   in read-only mode by passing wxRegKey::Read instead of default
   wxRegKey::Write parameter.

=head2 Wx::RegKey::QueryValue

   bool QueryValue(const wxChar *szValue, wxString& strValue) const

   Retrieves the string value.

   bool QueryValue(const wxChar *szValue, long *plValue) const

   Retrieves the numeric value.

=head2 Wx::RegKey::Rename

   bool Rename(const wxChar * szNewName)

   Renames the key.

=head2 Wx::RegKey::RenameValue

   bool RenameValue(const wxChar *szValueOld, const wxChar *szValueNew)

   Renames a value.

=head2 Wx::RegKey::SetValue

   bool SetValue(const wxChar *szValue, long lValue)

   bool SetValue(const wxChar *szValue, const wxString& strValue)

   bool SetValue(const wxChar *szValue, const wxMemoryBuffer& buf)

   Sets the given szValue which must be numeric, string or binary
   depending on the overload used. If the value doesn't exist, it is
   created.

=head1 Wx::RendererNative

=head2 Wx::RendererNative::DESTROY

   ~wxRendererNative()

   Virtual destructor as for any base class.

=head2 Wx::RendererNative::DrawCheckBox

   void DrawCheckBox(wxWindow *win, wxDC& dc, const wxRect& rect, int
   flags)

   Draw a check box (used by wxDataViewCtrl).

   flags may have the wxCONTROL_CHECKED, wxCONTROL_CURRENT or
   wxCONTROL_UNDETERMINED bit set.

=head2 Wx::RendererNative::DrawComboBoxDropButton

   void DrawComboBoxDropButton(wxWindow *win, wxDC& dc, const wxRect&
   rect, int flags)

   Draw a button like the one used by wxComboBox to show a drop down
   window. The usual appearance is a downwards pointing arrow.

   flags may have the wxCONTROL_PRESSED or wxCONTROL_CURRENT bit set.

=head2 Wx::RendererNative::DrawDropArrow

   void DrawDropArrow(wxWindow *win, wxDC& dc, const wxRect& rect, int
   flags)

   Draw a drop down arrow that is suitable for use outside a combo box.
   Arrow will have transparent background.

   rect is not entirely filled by the arrow. Instead, you should use
   bounding rectangle of a drop down button which arrow matches the size
   you need. flags may have the wxCONTROL_PRESSED or wxCONTROL_CURRENT
   bit set.

=head2 Wx::RendererNative::DrawHeaderButton

   int DrawHeaderButton(wxWindow* win, wxDC& dc, const wxRect& rect, int
   flags = 0, wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE,
   wxHeaderButtonParams* params = NULL)

   Draw the header control button (used, for example, by wxListCtrl).
   Depending on platforms the flags parameter may support the
   wxCONTROL_SELECTED wxCONTROL_DISABLED and wxCONTROL_CURRENT bits. The
   sortArrow parameter can be one of wxHDR_SORT_ICON_NONE,
   wxHDR_SORT_ICON_UP, or wxHDR_SORT_ICON_DOWN. Additional values
   controlling the drawing of a text or bitmap label can be passed in
   params. The value returned is the optimal width to contain the the
   unabreviated label text or bitmap, the sort arrow if present, and
   internal margins.

=head2 Wx::RendererNative::DrawItemSelectionRect

   void DrawItemSelectionRect(wxWindow* win, wxDC& dc, const wxRect& rect,
   int flags = 0)

   Draw a selection rectangle underneath the text as used e.g. in a
   wxListCtrl. The supported flags are wxCONTROL_SELECTED for items which
   are selected (e.g. often a blue rectangle) and wxCONTROL_CURRENT for
   the item that has the focus (often a dotted line around the item's
   text). wxCONTROL_FOCUSED may be used to indicate if the control has
   the focus (othewise the the selection rectangle is e.g. often grey and
   not blue). This may be ignored by the renderer or deduced by the code
   directly from the win.

=head2 Wx::RendererNative::DrawPushButton

   void DrawPushButton(wxWindow *win, wxDC& dc, const wxRect& rect, int
   flags)

   Draw a blank push button that looks very similar to wxButton.

   flags may have the wxCONTROL_PRESSED, wxCONTROL_CURRENT or
   wxCONTROL_ISDEFAULT bit set.

=head2 Wx::RendererNative::DrawSplitterBorder

   void DrawSplitterBorder(wxWindow* win, wxDC& dc, const wxRect& rect,
   int flags = 0)

   Draw the border for sash window: this border must be such that the
   sash drawn by DrawSash blends into it well.

=head2 Wx::RendererNative::DrawSplitterSash

   void DrawSplitterSash(wxWindow* win, wxDC& dc, const wxSize& size,
   wxCoord position, wxOrientation orient, int flags = 0)

   Draw a sash. The orient parameter defines whether the sash should be
   vertical or horizontal and how the position should be interpreted.

=head2 Wx::RendererNative::DrawTreeItemButton

   void DrawTreeItemButton(wxWindow* win, wxDC& dc, const wxRect& rect,
   int flags = 0)

   Draw the expanded/collapsed icon for a tree control item. To draw an
   expanded button the flags parameter must contain wxCONTROL_EXPANDED
   bit.

=head2 Wx::RendererNative::Get

   wxRendererNative& Get()

   Return the currently used renderer.

=head2 Wx::RendererNative::GetDefault

   wxRendererNative& GetDefault()

   Return the default (native) implementation for this platform -- this
   is also the one used by default but this may be changed by calling Set
   in which case the return value of this method may be different from
   the return value of Get.

=head2 Wx::RendererNative::GetGeneric

   wxRendererNative& GetGeneric()

   Return the generic implementation of the renderer. Under some
   platforms, this is the default renderer implementation, others have
   platform-specific default renderer which can be retrieved by calling
   GetDefault.

=head2 Wx::RendererNative::GetHeaderButtonHeight

   int GetHeaderButtonHeight(const wxWindow* win)

   Returns the height of a header button, either a fixed platform height
   if available, or a generic height based on the window's font.

=head2 Wx::RendererNative::GetSplitterParams

   wxSplitterRenderParams GetSplitterParams(const wxWindow* win)

   Get the splitter parameters, see wxSplitterRenderParams.

=head2 Wx::RendererNative::GetVersion

   wxRendererVersion GetVersion() const

   This function is used for version checking: Load refuses to load any
   shared libraries implementing an older or incompatible version.

   The implementation of this method is always the same in all renderers
   (simply construct wxRendererVersion using the
   wxRendererVersion::Current_XXX values), but it has to be in the
   derived, not base, class, to detect mismatches between the renderers
   versions and so you have to implement it anew in all renderers.

=head2 Wx::RendererNative::Load

   wxRendererNative* Load(const wxString& name)

   Load the renderer from the specified DLL, the returned pointer must be
   deleted by caller if not NULL when it is not used any more.

   The name should be just the base name of the renderer and not the full
   name of the DLL file which is constructed differently (using
   wxDynamicLibrary::CanonicalizePluginName) on different systems.

=head2 Wx::RendererNative::Set

   wxRendererNative* Set(wxRendererNative* renderer)

   Set the renderer to use, passing NULL reverts to using the default
   renderer (the global renderer must always exist).

   Return the previous renderer used with Set() or NULL if none.

=head1 Wx::RendererVersion

=head2 Wx::RendererVersion::IsCompatible

   static bool IsCompatible(const wxRendererVersion& ver)

   Checks if the main program is compatible with the renderer having the
   version ver, returns true if it is and false otherwise.

   This method is used by wxRendererNative::Load to determine whether a
   renderer can be used.

=head2 Wx::RendererVersion::version

   const int version

   The version component.

=head2 Wx::RendererVersion::age

   const int age

   The age component.

=head1 Wx::RichTextAttr

=head2 Wx::RichTextAttr::new

   wxRichTextAttr()

   wxRichTextAttr(const wxColour& colText, const wxColour& colBack =
   wxNullColour, wxTextAttrAlignment alignment = wxTEXT_ALIGNMENT_DEFAULT)

   wxRichTextAttr(const wxTextAttrEx& attr)

   Constructors.

=head2 Wx::RichTextAttr::Apply

   bool Apply(const wxRichTextAttr& style, const wxRichTextAttr*
   compareWith = NULL)

   Applies the attributes in style to the original object, but not those
   attributes from style that are the same as those in compareWith (if
   passed).

   See also wxRichTextAttr::Combine for a function that does almost the
   same but returns a new object instead of modifying the original
   object.

=head2 Wx::RichTextAttr::Combine

   wxRichTextAttr Combine(const wxRichTextAttr& style, const
   wxRichTextAttr* compareWith = NULL) const

   Combines 'this' with style, but not applying attributes from style
   that are the same as those in compareWith (if passed). A
   wxRichTextAttr object is returned and the original object is not
   changed.

   See also wxRichTextAttr::Apply for a function that does almost the
   same but modifies the original object instead of returning a new one.

=head2 Wx::RichTextAttr::CreateFont

   wxFont CreateFont() const

   Creates a font from the font attributes.

=head2 Wx::RichTextAttr::GetAlignment

   wxTextAttrAlignment GetAlignment() const

   Returns the alignment flags. See wxRichTextAttr::SetAlignment for a
   list of available styles.

=head2 Wx::RichTextAttr::GetBackgroundColour

   const wxColour& GetBackgroundColour() const

   Returns the background colour.

=head2 Wx::RichTextAttr::GetBulletFont

   const wxString& GetBulletFont() const

   Returns a string containing the name of the font associated with the
   bullet symbol. Only valid for attributes with
   wxTEXT_ATTR_BULLET_SYMBOL.

=head2 Wx::RichTextAttr::GetBulletName

   const wxString& GetBulletName() const

   Returns the standard bullet name, applicable if the bullet style is
   wxTEXT_ATTR_BULLET_STYLE_STANDARD. Currently the following standard
   bullet names are supported:

=head2 Wx::RichTextAttr::GetBulletNumber

   int GetBulletNumber() const

   Returns the bullet number.

=head2 Wx::RichTextAttr::GetBulletStyle

   int GetBulletStyle() const

   Returns the bullet style. See wxRichTextAttr::SetBulletStyle for a
   list of available styles.

=head2 Wx::RichTextAttr::GetBulletText

   const wxString& GetBulletText() const

   Returns the bullet text, which could be a symbol, or (for example)
   cached outline text.

=head2 Wx::RichTextAttr::GetCharacterStyleName

   const wxString& GetCharacterStyleName() const

   Returns the name of the character style.

=head2 Wx::RichTextAttr::GetFlags

   long GetFlags() const

   Returns flags indicating which attributes are applicable. See
   wxRichTextAttr::SetFlags for a list of available flags.

=head2 Wx::RichTextAttr::GetFontAttributes

   bool GetFontAttributes(const wxFont& font)

   Sets the font attributes from the given font.

=head2 Wx::RichTextAttr::GetFontFaceName

   const wxString& GetFontFaceName() const

   Returns the font face name.

=head2 Wx::RichTextAttr::GetFontSize

   int GetFontSize() const

   Returns the font size in points.

=head2 Wx::RichTextAttr::GetFontStyle

   int GetFontStyle() const

   Returns the font style.

=head2 Wx::RichTextAttr::GetFontUnderlined

   bool GetFontUnderlined() const

   Returns true if the font is underlined.

=head2 Wx::RichTextAttr::GetFontWeight

   int GetFontWeight() const

   Returns the font weight.

=head2 Wx::RichTextAttr::GetLeftIndent

   long GetLeftIndent() const

   Returns the left indent in tenths of a millimetre.

=head2 Wx::RichTextAttr::GetLeftSubIndent

   long GetLeftSubIndent() const

   Returns the left sub-indent in tenths of a millimetre.

=head2 Wx::RichTextAttr::GetLineSpacing

   int GetLineSpacing() const

   Returns the line spacing value, one of
   wxTEXT_ATTR_LINE_SPACING_NORMAL, wxTEXT_ATTR_LINE_SPACING_HALF, and
   wxTEXT_ATTR_LINE_SPACING_TWICE.

=head2 Wx::RichTextAttr::GetListStyleName

   const wxString& GetListStyleName() const

   Returns the name of the list style.

=head2 Wx::RichTextAttr::GetOutlineLevel

   int GetOutlineLevel() const

   Returns the outline level.

=head2 Wx::RichTextAttr::GetParagraphSpacingAfter

   int GetParagraphSpacingAfter() const

   Returns the space in tenths of a millimeter after the paragraph.

=head2 Wx::RichTextAttr::GetParagraphSpacingBefore

   int GetParagraphSpacingBefore() const

   Returns the space in tenths of a millimeter before the paragraph.

=head2 Wx::RichTextAttr::GetParagraphStyleName

   const wxString& GetParagraphStyleName() const

   Returns the name of the paragraph style.

=head2 Wx::RichTextAttr::GetRightIndent

   long GetRightIndent() const

   Returns the right indent in tenths of a millimeter.

=head2 Wx::RichTextAttr::GetTabs

   const wxArrayInt& GetTabs() const

   Returns an array of tab stops, each expressed in tenths of a
   millimeter. Each stop is measured from the left margin and therefore
   each value must be larger than the last.

=head2 Wx::RichTextAttr::GetTextColour

   const wxColour& GetTextColour() const

   Returns the text foreground colour.

=head2 Wx::RichTextAttr::GetTextEffectFlags

   int GetTextEffectFlags() const

   Returns the text effect bits of interest. See wxRichTextAttr::SetFlags
   for further information.

=head2 Wx::RichTextAttr::GetTextEffects

   int GetTextEffects() const

   Returns the text effects, a bit list of styles. See
   wxRichTextAttr::SetTextEffects for details.

=head2 Wx::RichTextAttr::GetURL

   const wxString& GetURL() const

   Returns the URL for the content. Content with wxTEXT_ATTR_URL style
   causes wxRichTextCtrl to show a hand cursor over it, and
   wxRichTextCtrl generates a wxTextUrlEvent when the content is clicked.

=head2 Wx::RichTextAttr::HasAlignment

   bool HasAlignment() const

   Returns true if the attribute object specifies alignment.

=head2 Wx::RichTextAttr::HasBackgroundColour

   bool HasBackgroundColour() const

   Returns true if the attribute object specifies a background colour.

=head2 Wx::RichTextAttr::HasBulletName

   bool HasBulletName() const

   Returns true if the attribute object specifies a standard bullet name.

=head2 Wx::RichTextAttr::HasBulletNumber

   bool HasBulletNumber() const

   Returns true if the attribute object specifies a bullet number.

=head2 Wx::RichTextAttr::HasBulletStyle

   bool HasBulletStyle() const

   Returns true if the attribute object specifies a bullet style.

=head2 Wx::RichTextAttr::HasBulletText

   bool HasBulletText() const

   Returns true if the attribute object specifies bullet text (usually
   specifying a symbol).

=head2 Wx::RichTextAttr::HasCharacterStyleName

   bool HasCharacterStyleName() const

   Returns true if the attribute object specifies a character style name.

=head2 Wx::RichTextAttr::HasFontFaceName

   bool HasFontFaceName() const

   Returns true if the attribute object specifies a font face name.

=head2 Wx::RichTextAttr::HasFlag

   bool HasFlag(long flag) const

   Returns true if the flag is present in the attribute object's flag
   bitlist.

=head2 Wx::RichTextAttr::HasFont

   bool HasFont() const

   Returns true if the attribute object specifies any font attributes.

=head2 Wx::RichTextAttr::HasFontItalic

   bool HasFontItalic() const

   Returns true if the attribute object specifies italic style.

=head2 Wx::RichTextAttr::HasLeftIndent

   bool HasLeftIndent() const

   Returns true if the attribute object specifies a left indent.

=head2 Wx::RichTextAttr::HasLineSpacing

   bool HasLineSpacing() const

   Returns true if the attribute object specifies line spacing.

=head2 Wx::RichTextAttr::HasListStyleName

   bool HasListStyleName() const

   Returns true if the attribute object specifies a list style name.

=head2 Wx::RichTextAttr::HasOutlineLevel

   bool HasOutlineLevel() const

   Returns true if the attribute object specifies an outline level.

=head2 Wx::RichTextAttr::HasPageBreak

   bool HasPageBreak() const

   Returns true if the attribute object specifies a page break before
   this paragraph.

=head2 Wx::RichTextAttr::HasParagraphSpacingAfter

   bool HasParagraphSpacingAfter() const

   Returns true if the attribute object specifies spacing after a
   paragraph.

=head2 Wx::RichTextAttr::HasParagraphSpacingBefore

   bool HasParagraphSpacingBefore() const

   Returns true if the attribute object specifies spacing before a
   paragraph.

=head2 Wx::RichTextAttr::HasParagraphStyleName

   bool HasParagraphStyleName() const

   Returns true if the attribute object specifies a paragraph style name.

=head2 Wx::RichTextAttr::HasRightIndent

   bool HasRightIndent() const

   Returns true if the attribute object specifies a right indent.

=head2 Wx::RichTextAttr::HasFontSize

   bool HasFontSize() const

   Returns true if the attribute object specifies a font point size.

=head2 Wx::RichTextAttr::HasTabs

   bool HasTabs() const

   Returns true if the attribute object specifies tab stops.

=head2 Wx::RichTextAttr::HasTextColour

   bool HasTextColour() const

   Returns true if the attribute object specifies a text foreground
   colour.

=head2 Wx::RichTextAttr::HasTextEffects

   bool HasTextEffects() const

   Returns true if the attribute object specifies text effects.

=head2 Wx::RichTextAttr::HasFontUnderlined

   bool HasFontUnderlined() const

   Returns true if the attribute object specifies either underlining or
   no underlining.

=head2 Wx::RichTextAttr::HasURL

   bool HasURL() const

   Returns true if the attribute object specifies a URL.

=head2 Wx::RichTextAttr::HasFontWeight

   bool HasFontWeight() const

   Returns true if the attribute object specifies font weight (bold,
   light or normal).

=head2 Wx::RichTextAttr::IsCharacterStyle

   bool IsCharacterStyle() const

   Returns true if the object represents a character style, that is, the
   flags specify a font or a text background or foreground colour.

=head2 Wx::RichTextAttr::IsDefault

   bool IsDefault() const

   Returns false if we have any attributes set, true otherwise.

=head2 Wx::RichTextAttr::IsParagraphStyle

   bool IsParagraphStyle() const

   Returns true if the object represents a paragraph style, that is, the
   flags specify alignment, indentation, tabs, paragraph spacing, or
   bullet style.

=head2 Wx::RichTextAttr::SetAlignment

   void SetAlignment(wxTextAttrAlignment alignment)

   Sets the paragraph alignment. These are the possible values for
   alignment:

   enum wxTextAttrAlignment
   {
       wxTEXT_ALIGNMENT_DEFAULT,
       wxTEXT_ALIGNMENT_LEFT,
       wxTEXT_ALIGNMENT_CENTRE,
       wxTEXT_ALIGNMENT_CENTER = wxTEXT_ALIGNMENT_CENTRE,
       wxTEXT_ALIGNMENT_RIGHT,
       wxTEXT_ALIGNMENT_JUSTIFIED
   };

   Of these, wxTEXT_ALIGNMENT_JUSTIFIED is unimplemented. In future
   justification may be supported when printing or previewing, only.

=head2 Wx::RichTextAttr::SetBackgroundColour

   void SetBackgroundColour(const wxColour& colBack)

   Sets the background colour.

=head2 Wx::RichTextAttr::SetBulletFont

   void SetBulletFont(const wxString& font)

   Sets the name of the font associated with the bullet symbol. Only
   valid for attributes with wxTEXT_ATTR_BULLET_SYMBOL.

=head2 Wx::RichTextAttr::SetBulletName

   void SetBulletName(const wxString& name)

   Sets the standard bullet name, applicable if the bullet style is
   wxTEXT_ATTR_BULLET_STYLE_STANDARD. See wxRichTextAttr::GetBulletName
   for a list of supported names, and how to expand the range of
   supported types.

=head2 Wx::RichTextAttr::SetBulletNumber

   void SetBulletNumber(int n)

   Sets the bullet number.

=head2 Wx::RichTextAttr::SetBulletStyle

   void SetBulletStyle(int style)

   Sets the bullet style. The following styles can be passed:

   #define wxTEXT_ATTR_BULLET_STYLE_NONE               0x00000000
   #define wxTEXT_ATTR_BULLET_STYLE_ARABIC             0x00000001
   #define wxTEXT_ATTR_BULLET_STYLE_LETTERS_UPPER      0x00000002
   #define wxTEXT_ATTR_BULLET_STYLE_LETTERS_LOWER      0x00000004
   #define wxTEXT_ATTR_BULLET_STYLE_ROMAN_UPPER        0x00000008
   #define wxTEXT_ATTR_BULLET_STYLE_ROMAN_LOWER        0x00000010
   #define wxTEXT_ATTR_BULLET_STYLE_SYMBOL             0x00000020
   #define wxTEXT_ATTR_BULLET_STYLE_BITMAP             0x00000040
   #define wxTEXT_ATTR_BULLET_STYLE_PARENTHESES        0x00000080
   #define wxTEXT_ATTR_BULLET_STYLE_PERIOD             0x00000100
   #define wxTEXT_ATTR_BULLET_STYLE_STANDARD           0x00000200
   #define wxTEXT_ATTR_BULLET_STYLE_RIGHT_PARENTHESIS  0x00000400
   #define wxTEXT_ATTR_BULLET_STYLE_OUTLINE            0x00000800
   #define wxTEXT_ATTR_BULLET_STYLE_ALIGN_LEFT         0x00000000
   #define wxTEXT_ATTR_BULLET_STYLE_ALIGN_RIGHT        0x00001000
   #define wxTEXT_ATTR_BULLET_STYLE_ALIGN_CENTRE       0x00002000

   Currently wxTEXT_ATTR_BULLET_STYLE_BITMAP is not supported.

=head2 Wx::RichTextAttr::SetBulletText

   void SetBulletText(const wxStringtext)

   Sets the bullet text, which could be a symbol, or (for example) cached
   outline text.

=head2 Wx::RichTextAttr::SetCharacterStyleName

   void SetCharacterStyleName(const wxString& name)

   Sets the character style name.

=head2 Wx::RichTextAttr::SetFlags

   void SetFlags(long flags)

   Sets the flags determining which styles are being specified. The
   following flags can be passed in a bitlist:

   // Standard wxTextAttr constants

=head2 Wx::RichTextAttr::SetFontFaceName

   void SetFontFaceName(const wxString& faceName)

   Sets the paragraph alignment.

=head2 Wx::RichTextAttr::SetFontSize

   void SetFontSize(int pointSize)

   Sets the font size in points.

=head2 Wx::RichTextAttr::SetFontStyle

   void SetFontStyle(int fontStyle)

   Sets the font style (normal, italic or slanted).

=head2 Wx::RichTextAttr::SetFontUnderlined

   void SetFontUnderlined(bool underlined)

   Sets the font underlining.

=head2 Wx::RichTextAttr::SetFontWeight

   void SetFontWeight(int fontWeight)

   Sets the font weight.

=head2 Wx::RichTextAttr::SetLeftIndent

   void SetLeftIndent(int indent, int subIndent = 0)

   Sets the left indent and left subindent in tenths of a millimetre.

   The sub-indent is an offset from the left of the paragraph, and is
   used for all but the first line in a paragraph. A positive value will
   cause the first line to appear to the left of the subsequent lines,
   and a negative value will cause the first line to be indented relative
   to the subsequent lines.

   wxRichTextBuffer uses indentation to render a bulleted item. The left
   indent is the distance between the margin and the bullet. The content
   of the paragraph, including the first line, starts at leftMargin +
   leftSubIndent. So the distance between the left edge of the bullet and
   the left of the actual paragraph is leftSubIndent.

=head2 Wx::RichTextAttr::SetLineSpacing

   void SetLineSpacing(int spacing)

   Sets the line spacing. spacing is a multiple, where 10 means
   single-spacing, 15 means 1.5 spacing, and 20 means double spacing. The
   following constants are defined for convenience:

   #define wxTEXT_ATTR_LINE_SPACING_NORMAL         10
   #define wxTEXT_ATTR_LINE_SPACING_HALF           15
   #define wxTEXT_ATTR_LINE_SPACING_TWICE          20

=head2 Wx::RichTextAttr::SetListStyleName

   void SetListStyleName(const wxString& name)

   Sets the list style name.

=head2 Wx::RichTextAttr::SetOutlineLevel

   void SetOutlineLevel(int level)

   Specifies the outline level. Zero represents normal text. At present,
   the outline level is not used, but may be used in future for
   determining list levels and for applications that need to store
   document structure information.

=head2 Wx::RichTextAttr::SetPageBreak

   void SetPageBreak(bool pageBreak = true)

   Specifies a page break before this paragraph.

=head2 Wx::RichTextAttr::SetParagraphSpacingAfter

   void SetParagraphSpacingAfter(int spacing)

   Sets the spacing after a paragraph, in tenths of a millimetre.

=head2 Wx::RichTextAttr::SetParagraphSpacingBefore

   void SetParagraphSpacingBefore(int spacing)

   Sets the spacing before a paragraph, in tenths of a millimetre.

=head2 Wx::RichTextAttr::SetParagraphStyleName

   void SetParagraphStyleName(const wxString& name)

   Sets the name of the paragraph style.

=head2 Wx::RichTextAttr::SetRightIndent

   void SetRightIndent(int indent)

   Sets the right indent in tenths of a millimetre.

=head2 Wx::RichTextAttr::SetTabs

   void SetTabs(const wxArrayInt& tabs)

   Sets the tab stops, expressed in tenths of a millimetre. Each stop is
   measured from the left margin and therefore each value must be larger
   than the last.

=head2 Wx::RichTextAttr::SetTextColour

   void SetTextColour(const wxColour& colText)

   Sets the text foreground colout.

=head2 Wx::RichTextAttr::SetTextEffectFlags

   void SetTextEffectFlags(int flags)

   Sets the text effect bits of interest. You should also pass
   wxTEXT_ATTR_EFFECTS to wxRichTextAttr::SetFlags. See
   wxRichTextAttr::SetFlags for further information.

=head2 Wx::RichTextAttr::SetTextEffects

   void SetTextEffects(int effects)

   Sets the text effects, a bit list of styles.

   The following styles can be passed:

   #define wxTEXT_ATTR_EFFECT_NONE                     0x00000000
   #define wxTEXT_ATTR_EFFECT_CAPITALS                 0x00000001
   #define wxTEXT_ATTR_EFFECT_SMALL_CAPITALS           0x00000002
   #define wxTEXT_ATTR_EFFECT_STRIKETHROUGH            0x00000004
   #define wxTEXT_ATTR_EFFECT_DOUBLE_STRIKETHROUGH     0x00000008
   #define wxTEXT_ATTR_EFFECT_SHADOW                   0x00000010
   #define wxTEXT_ATTR_EFFECT_EMBOSS                   0x00000020
   #define wxTEXT_ATTR_EFFECT_OUTLINE                  0x00000040
   #define wxTEXT_ATTR_EFFECT_ENGRAVE                  0x00000080
   #define wxTEXT_ATTR_EFFECT_SUPERSCRIPT              0x00000100
   #define wxTEXT_ATTR_EFFECT_SUBSCRIPT                0x00000200

   Of these, only wxTEXT_ATTR_EFFECT_CAPITALS and
   wxTEXT_ATTR_EFFECT_STRIKETHROUGH are implemented.
   wxTEXT_ATTR_EFFECT_CAPITALS capitalises text when displayed (leaving
   the case of the actual buffer text unchanged), and
   wxTEXT_ATTR_EFFECT_STRIKETHROUGH draws a line through text.

   To set effects, you should also pass wxTEXT_ATTR_EFFECTS to
   wxRichTextAttr::SetFlags, and call wxRichTextAttr::SetTextEffectFlags
   with the styles (taken from the above set) that you are interested in
   setting.

=head2 Wx::RichTextAttr::SetURL

   void SetURL(const wxString& url)

   Sets the URL for the content. Sets the wxTEXT_ATTR_URL style; content
   with this style causes wxRichTextCtrl to show a hand cursor over it,
   and wxRichTextCtrl generates a wxTextUrlEvent when the content is
   clicked.

=head2 Wx::RichTextAttr::wxTextAttrEx

   operator wxTextAttrEx() const

   Makes a wxTextAttrEx object from this object.

=head1 Wx::RichTextBuffer

=head2 Wx::RichTextBuffer::new

   wxRichTextBuffer(const wxRichTextBuffer& obj)

   Copy constructor.

   wxRichTextBuffer()

   Default constructors.

=head2 Wx::RichTextBuffer::DESTROY

   ~wxRichTextBuffer()

   Destructor.

=head2 Wx::RichTextBuffer::AddEventHandler

   bool AddEventHandler(wxEvtHandler* handler)

   Adds an event handler to the buffer's list of handlers. A buffer
   associated with a contol has the control as the only event handler,
   but the application is free to add more if further notification is
   required. All handlers are notified of an event originating from the
   buffer, such as the replacement of a style sheet during loading. The
   buffer never deletes any of the event handlers, unless
   wxRichTextBuffer::RemoveEventHandler is called with true as the second
   argument.

=head2 Wx::RichTextBuffer::AddHandler

   void AddHandler(wxRichTextFileHandler* handler)

   Adds a file handler.

=head2 Wx::RichTextBuffer::AddParagraph

   wxRichTextRange AddParagraph(const wxString& text)

   Adds a paragraph of text.

=head2 Wx::RichTextBuffer::BatchingUndo

   bool BatchingUndo() const

   Returns true if the buffer is currently collapsing commands into a
   single notional command.

=head2 Wx::RichTextBuffer::BeginAlignment

   bool BeginAlignment(wxTextAttrAlignment alignment)

   Begins using alignment.

=head2 Wx::RichTextBuffer::BeginBatchUndo

   bool BeginBatchUndo(const wxString& cmdName)

   Begins collapsing undo/redo commands. Note that this may not work
   properly if combining commands that delete or insert content, changing
   ranges for subsequent actions.

   cmdName should be the name of the combined command that will appear
   next to Undo and Redo in the edit menu.

=head2 Wx::RichTextBuffer::BeginBold

   bool BeginBold()

   Begin applying bold.

=head2 Wx::RichTextBuffer::BeginCharacterStyle

   bool BeginCharacterStyle(const wxString& characterStyle)

   Begins applying the named character style.

=head2 Wx::RichTextBuffer::BeginFont

   bool BeginFont(const wxFont& font)

   Begins using this font.

=head2 Wx::RichTextBuffer::BeginFontSize

   bool BeginFontSize(int pointSize)

   Begins using the given point size.

=head2 Wx::RichTextBuffer::BeginItalic

   bool BeginItalic()

   Begins using italic.

=head2 Wx::RichTextBuffer::BeginLeftIndent

   bool BeginLeftIndent(int leftIndent, int leftSubIndent = 0)

   Begin using leftIndent for the left indent, and optionally
   leftSubIndent for the sub-indent. Both are expressed in tenths of a
   millimetre.

   The sub-indent is an offset from the left of the paragraph, and is
   used for all but the first line in a paragraph. A positive value will
   cause the first line to appear to the left of the subsequent lines,
   and a negative value will cause the first line to be indented relative
   to the subsequent lines.

=head2 Wx::RichTextBuffer::BeginLineSpacing

   bool BeginLineSpacing(int lineSpacing)

   Begins line spacing using the specified value. spacing is a multiple,
   where 10 means single-spacing, 15 means 1.5 spacing, and 20 means
   double spacing. The following constants are defined for convenience:

   #define wxTEXT_ATTR_LINE_SPACING_NORMAL         10
   #define wxTEXT_ATTR_LINE_SPACING_HALF           15
   #define wxTEXT_ATTR_LINE_SPACING_TWICE          20

=head2 Wx::RichTextBuffer::BeginListStyle

   bool BeginListStyle(const wxString& listStyle, int level=1, int
   number=1)

   Begins using a specified list style. Optionally, you can also pass a
   level and a number.

=head2 Wx::RichTextBuffer::BeginNumberedBullet

   bool BeginNumberedBullet(int bulletNumber, int leftIndent, int
   leftSubIndent, int bulletStyle =
   wxTEXT_ATTR_BULLET_STYLE_ARABIC|wxTEXT_ATTR_BULLET_STYLE_PERIOD)

   Begins a numbered bullet. This call will be needed for each item in
   the list, and the application should take care of incrementing the
   numbering.

   bulletNumber is a number, usually starting with 1.

   leftIndent and leftSubIndent are values in tenths of a millimetre.

   bulletStyle is a bitlist of the following values:

   #define wxTEXT_ATTR_BULLET_STYLE_NONE               0x00000000
   #define wxTEXT_ATTR_BULLET_STYLE_ARABIC             0x00000001
   #define wxTEXT_ATTR_BULLET_STYLE_LETTERS_UPPER      0x00000002
   #define wxTEXT_ATTR_BULLET_STYLE_LETTERS_LOWER      0x00000004
   #define wxTEXT_ATTR_BULLET_STYLE_ROMAN_UPPER        0x00000008
   #define wxTEXT_ATTR_BULLET_STYLE_ROMAN_LOWER        0x00000010
   #define wxTEXT_ATTR_BULLET_STYLE_SYMBOL             0x00000020
   #define wxTEXT_ATTR_BULLET_STYLE_BITMAP             0x00000040
   #define wxTEXT_ATTR_BULLET_STYLE_PARENTHESES        0x00000080
   #define wxTEXT_ATTR_BULLET_STYLE_PERIOD             0x00000100
   #define wxTEXT_ATTR_BULLET_STYLE_STANDARD           0x00000200
   #define wxTEXT_ATTR_BULLET_STYLE_RIGHT_PARENTHESIS  0x00000400
   #define wxTEXT_ATTR_BULLET_STYLE_OUTLINE            0x00000800
   #define wxTEXT_ATTR_BULLET_STYLE_ALIGN_LEFT         0x00000000
   #define wxTEXT_ATTR_BULLET_STYLE_ALIGN_RIGHT        0x00001000
   #define wxTEXT_ATTR_BULLET_STYLE_ALIGN_CENTRE       0x00002000

   wxRichTextBuffer uses indentation to render a bulleted item. The left
   indent is the distance between the margin and the bullet. The content
   of the paragraph, including the first line, starts at leftMargin +
   leftSubIndent. So the distance between the left edge of the bullet and
   the left of the actual paragraph is leftSubIndent.

=head2 Wx::RichTextBuffer::BeginParagraphSpacing

   bool BeginParagraphSpacing(int before, int after)

   Begins paragraph spacing; pass the before-paragraph and
   after-paragraph spacing in tenths of a millimetre.

=head2 Wx::RichTextBuffer::BeginParagraphStyle

   bool BeginParagraphStyle(const wxString& paragraphStyle)

   Begins applying the named paragraph style.

=head2 Wx::RichTextBuffer::BeginRightIndent

   bool BeginRightIndent(int rightIndent)

   Begins a right indent, specified in tenths of a millimetre.

=head2 Wx::RichTextBuffer::BeginStyle

   bool BeginStyle(const wxTextAttrEx& style)

   Begins using a specified style.

=head2 Wx::RichTextBuffer::BeginSuppressUndo

   bool BeginSuppressUndo()

   Begins suppressing undo/redo commands. The way undo is suppressed may
   be implemented differently by each command. If not dealt with by a
   command implementation, then it will be implemented automatically by
   not storing the command in the undo history when the action is
   submitted to the command processor.

=head2 Wx::RichTextBuffer::BeginStandardBullet

   bool BeginStandardBullet(const wxString& bulletName, int leftIndent,
   int leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_STANDARD)

   Begins applying a standard bullet, using one of the standard bullet
   names (currently standard/circle or standard/square. See
   BeginNumberedBullet for an explanation of how indentation is used to
   render the bulleted paragraph.

=head2 Wx::RichTextBuffer::BeginSymbolBullet

   bool BeginSymbolBullet(wxChar symbol, int leftIndent, int
   leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_SYMBOL)

   Begins applying a symbol bullet, using a character from the current
   font. See BeginNumberedBullet for an explanation of how indentation is
   used to render the bulleted paragraph.

=head2 Wx::RichTextBuffer::BeginTextColour

   bool BeginTextColour(const wxColour& colour)

   Begins using the specified text foreground colour.

=head2 Wx::RichTextBuffer::BeginUnderline

   bool BeginUnderline()

   Begins using underline.

=head2 Wx::RichTextBuffer::BeginURL

   bool BeginURL(const wxString& url, const wxString& characterStyle =
   wxEmptyString)

   Begins applying wxTEXT_ATTR_URL to the content. Pass a URL and
   optionally, a character style to apply, since it is common to mark a
   URL with a familiar style such as blue text with underlining.

=head2 Wx::RichTextBuffer::CanPasteFromClipboard

   bool CanPasteFromClipboard() const

   Returns true if content can be pasted from the clipboard.

=head2 Wx::RichTextBuffer::CleanUpHandlers

   void CleanUpHandlers()

   Cleans up the file handlers.

=head2 Wx::RichTextBuffer::Clear

   void Clear()

   Clears the buffer.

=head2 Wx::RichTextBuffer::ClearListStyle

   bool ClearListStyle(const wxRichTextRange& range, int flags =
   wxRICHTEXT_SETSTYLE_WITH_UNDO)

   bool ClearListStyle(const wxRichTextRange& range, int flags =
   wxRICHTEXT_SETSTYLE_WITH_UNDO)

   Clears the list style from the given range, clearing list-related
   attributes and applying any named paragraph style associated with each
   paragraph.

   flags is a bit list of the following:

=head2 Wx::RichTextBuffer::ClearStyleStack

   void ClearStyleStack()

   Clears the style stack.

=head2 Wx::RichTextBuffer::Clone

   wxRichTextObject* Clone() const

   Clones the object.

=head2 Wx::RichTextBuffer::Copy

   void Copy(const wxRichTextBuffer& obj)

   Copies the given buffer.

=head2 Wx::RichTextBuffer::CopyToClipboard

   bool CopyToClipboard(const wxRichTextRange& range)

   Copy the given range to the clipboard.

=head2 Wx::RichTextBuffer::DeleteRangeWithUndo

   bool DeleteRangeWithUndo(const wxRichTextRange& range, wxRichTextCtrl*
   ctrl)

   Submits a command to delete the given range.

=head2 Wx::RichTextBuffer::Dump

   void Dump()

   void Dump(wxTextOutputStream& stream)

   Dumps the contents of the buffer for debugging purposes.

=head2 Wx::RichTextBuffer::EndAlignment

   bool EndAlignment()

   Ends alignment.

=head2 Wx::RichTextBuffer::EndAllStyles

   bool EndAllStyles()

   Ends all styles that have been started with a Begin... command.

=head2 Wx::RichTextBuffer::EndBatchUndo

   bool EndBatchUndo()

   Ends collapsing undo/redo commands, and submits the combined command.

=head2 Wx::RichTextBuffer::EndBold

   bool EndBold()

   Ends using bold.

=head2 Wx::RichTextBuffer::EndCharacterStyle

   bool EndCharacterStyle()

   Ends using the named character style.

=head2 Wx::RichTextBuffer::EndFont

   bool EndFont()

   Ends using a font.

=head2 Wx::RichTextBuffer::EndFontSize

   bool EndFontSize()

   Ends using a point size.

=head2 Wx::RichTextBuffer::EndItalic

   bool EndItalic()

   Ends using italic.

=head2 Wx::RichTextBuffer::EndLeftIndent

   bool EndLeftIndent()

   Ends using a left indent.

=head2 Wx::RichTextBuffer::EndLineSpacing

   bool EndLineSpacing()

   Ends using a line spacing.

=head2 Wx::RichTextBuffer::EndListStyle

   bool EndListStyle()

   Ends using a specified list style.

=head2 Wx::RichTextBuffer::EndNumberedBullet

   bool EndNumberedBullet()

   Ends a numbered bullet.

=head2 Wx::RichTextBuffer::EndParagraphSpacing

   bool EndParagraphSpacing()

   Ends paragraph spacing.

=head2 Wx::RichTextBuffer::EndParagraphStyle

   bool EndParagraphStyle()

   Ends applying a named character style.

=head2 Wx::RichTextBuffer::EndRightIndent

   bool EndRightIndent()

   Ends using a right indent.

=head2 Wx::RichTextBuffer::EndStyle

   bool EndStyle()

   Ends the current style.

=head2 Wx::RichTextBuffer::EndSuppressUndo

   bool EndSuppressUndo()

   Ends suppressing undo/redo commands.

=head2 Wx::RichTextBuffer::EndSymbolBullet

   bool EndSymbolBullet()

   Ends using a symbol bullet.

=head2 Wx::RichTextBuffer::EndStandardBullet

   bool EndStandardBullet()

   Ends using a standard bullet.

=head2 Wx::RichTextBuffer::EndTextColour

   bool EndTextColour()

   Ends using a text foreground colour.

=head2 Wx::RichTextBuffer::EndUnderline

   bool EndUnderline()

   Ends using underline.

=head2 Wx::RichTextBuffer::EndURL

   bool EndURL()

   Ends applying a URL.

=head2 Wx::RichTextBuffer::FindHandler

   wxRichTextFileHandler* FindHandler(int imageType)

   Finds a handler by type.

   wxRichTextFileHandler* FindHandler(const wxString& extension, int
   imageType)

   Finds a handler by extension and type.

   wxRichTextFileHandler* FindHandler(const wxString& name)

   Finds a handler by name.

=head2 Wx::RichTextBuffer::FindHandlerFilenameOrType

   wxRichTextFileHandler* FindHandlerFilenameOrType(const wxString&
   filename, int imageType)

   Finds a handler by filename or, if supplied, type.

=head2 Wx::RichTextBuffer::GetBasicStyle

   const wxTextAttrEx& GetBasicStyle() const

   Gets the basic (overall) style. This is the style of the whole buffer
   before further styles are applied, unlike the default style, which
   only affects the style currently being applied (for example, setting
   the default style to bold will cause subsequently inserted text to be
   bold).

=head2 Wx::RichTextBuffer::GetBatchedCommand

   wxRichTextCommand* GetBatchedCommand() const

   Gets the collapsed command.

=head2 Wx::RichTextBuffer::GetCommandProcessor

   wxCommandProcessor* GetCommandProcessor() const

   Gets the command processor. A text buffer always creates its own
   command processor when it is initialized.

=head2 Wx::RichTextBuffer::GetDefaultStyle

   const wxTextAttrEx& GetDefaultStyle() const

   Returns the current default style, affecting the style currently being
   applied (for example, setting the default style to bold will cause
   subsequently inserted text to be bold).

=head2 Wx::RichTextBuffer::GetExtWildcard

   wxString GetExtWildcard(bool combine = false, bool save = false,
   wxArrayInt* types = NULL)

   Gets a wildcard incorporating all visible handlers. If types is
   present, it will be filled with the file type corresponding to each
   filter. This can be used to determine the type to pass to LoadFile
   given a selected filter.

=head2 Wx::RichTextBuffer::GetHandlers

   wxList& GetHandlers()

   Returns the list of file handlers.

=head2 Wx::RichTextBuffer::GetRenderer

   static wxRichTextRenderer* GetRenderer()

   Returns the object to be used to render certain aspects of the
   content, such as bullets.

=head2 Wx::RichTextBuffer::GetStyle

   bool GetStyle(long position, wxRichTextAttr& style)

   bool GetStyle(long position, wxTextAttrEx& style)

   Gets the attributes at the given position.

   This function gets the combined style - that is, the style you see on
   the screen as a result of combining base style, paragraph style and
   character style attributes. To get the character or paragraph style
   alone, use GetUncombinedStyle.

=head2 Wx::RichTextBuffer::GetStyleForRange

   bool GetStyleForRange(const wxRichTextRange& range, wxTextAttrEx&
   style)

   This function gets a style representing the common, combined
   attributes in the given range. Attributes which have different values
   within the specified range will not be included the style flags.

   The function is used to get the attributes to display in the
   formatting dialog: the user can edit the attributes common to the
   selection, and optionally specify the values of further attributes to
   be applied uniformly.

   To apply the edited attributes, you can use SetStyle specifying the
   wxRICHTEXT_SETSTYLE_OPTIMIZE flag, which will only apply attributes
   that are different from the combined attributes within the range. So,
   the user edits the effective, displayed attributes for the range, but
   his choice won't be applied unnecessarily to content. As an example,
   say the style for a paragraph specifies bold, but the paragraph text
   doesn't specify a weight. The combined style is bold, and this is what
   the user will see on-screen and in the formatting dialog. The user now
   specifies red text, in addition to bold. When applying with SetStyle,
   the content font weight attributes won't be changed to bold because
   this is already specified by the paragraph. However the text colour
   attributes will be changed to show red.

=head2 Wx::RichTextBuffer::GetStyleSheet

   wxRichTextStyleSheet* GetStyleSheet() const

   Returns the current style sheet associated with the buffer, if any.

=head2 Wx::RichTextBuffer::GetStyleStackSize

   size_t GetStyleStackSize() const

   Get the size of the style stack, for example to check correct nesting.

=head2 Wx::RichTextBuffer::GetUncombinedStyle

   bool GetUncombinedStyle(long position, wxRichTextAttr& style)

   bool GetUncombinedStyle(long position, wxTextAttrEx& style)

   Gets the attributes at the given position.

   This function gets the uncombined style - that is, the attributes
   associated with the paragraph or character content, and not
   necessarily the combined attributes you see on the screen. To get the
   combined attributes, use GetStyle.

   If you specify (any) paragraph attribute in style's flags, this
   function will fetch the paragraph attributes. Otherwise, it will
   return the character attributes.

=head2 Wx::RichTextBuffer::HitTest

   int HitTest(wxDC& dc, const wxPoint& pt, long& textPosition)

   Finds the text position for the given position, putting the position
   in textPosition if one is found. pt is in logical units (a zero y
   position is at the beginning of the buffer).

   The function returns one of the following values:

   // The point was not on this object
   #define wxRICHTEXT_HITTEST_NONE     0x01
   // The point was before the position returned from HitTest
   #define wxRICHTEXT_HITTEST_BEFORE   0x02
   // The point was after the position returned from HitTest
   #define wxRICHTEXT_HITTEST_AFTER    0x04
   // The point was on the position returned from HitTest
   #define wxRICHTEXT_HITTEST_ON       0x08
   // The point was on space outside content
   #define wxRICHTEXT_HITTEST_OUTSIDE  0x10

=head2 Wx::RichTextBuffer::Init

   void Init()

   Initialisation.

=head2 Wx::RichTextBuffer::InitStandardHandlers

   void InitStandardHandlers()

   Initialises the standard handlers. Currently, only the plain text
   loading/saving handler is initialised by default.

=head2 Wx::RichTextBuffer::InsertHandler

   void InsertHandler(wxRichTextFileHandler* handler)

   Inserts a handler at the front of the list.

=head2 Wx::RichTextBuffer::InsertImageWithUndo

   bool InsertImageWithUndo(long pos, const wxRichTextImageBlock&
   imageBlock, wxRichTextCtrl* ctrl)

   Submits a command to insert the given image.

=head2 Wx::RichTextBuffer::InsertNewlineWithUndo

   bool InsertNewlineWithUndo(long pos, wxRichTextCtrl* ctrl)

   Submits a command to insert a newline.

=head2 Wx::RichTextBuffer::InsertTextWithUndo

   bool InsertTextWithUndo(long pos, const wxString& text, wxRichTextCtrl*
   ctrl)

   Submits a command to insert the given text.

=head2 Wx::RichTextBuffer::IsModified

   bool IsModified() const

   Returns true if the buffer has been modified.

=head2 Wx::RichTextBuffer::LoadFile

   bool LoadFile(wxInputStream& stream, int type = wxRICHTEXT_TYPE_ANY)

   Loads content from a stream.

   bool LoadFile(const wxString& filename, int type = wxRICHTEXT_TYPE_ANY)

   Loads content from a file.

=head2 Wx::RichTextBuffer::Modify

   void Modify(bool modify = true)

   Marks the buffer as modified or unmodified.

=head2 Wx::RichTextBuffer::NumberList

   bool NumberList(const wxRichTextRange& range, const
   wxRichTextListStyleDefinition* style, int flags =
   wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = -1, int listLevel = -1)

   bool Number(const wxRichTextRange& range, const wxString& styleName,
   int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = -1, int
   listLevel = -1)

   Numbers the paragraphs in the given range. Pass flags to determine how
   the attributes are set. Either the style definition or the name of the
   style definition (in the current sheet) can be passed.

   flags is a bit list of the following:

=head2 Wx::RichTextBuffer::PasteFromClipboard

   bool PasteFromClipboard(long position)

   Pastes the clipboard content to the buffer at the given position.

=head2 Wx::RichTextBuffer::PromoteList

   bool PromoteList(int promoteBy, const wxRichTextRange& range, const
   wxRichTextListStyleDefinition* style, int flags =
   wxRICHTEXT_SETSTYLE_WITH_UNDO, int listLevel = -1)

   bool PromoteList(int promoteBy, const wxRichTextRange& range, const
   wxString& styleName, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int
   listLevel = -1)

   Promotes or demotes the paragraphs in the given range. A positive
   promoteBy produces a smaller indent, and a negative number produces a
   larger indent. Pass flags to determine how the attributes are set.
   Either the style definition or the name of the style definition (in
   the current sheet) can be passed.

   flags is a bit list of the following:

=head2 Wx::RichTextBuffer::RemoveEventHandler

   bool RemoveEventHandler(wxEvtHandler* handler, bool deleteHandler =
   false)

   Removes an event handler from the buffer's list of handlers, deleting
   the object if deleteHandler is true.

=head2 Wx::RichTextBuffer::RemoveHandler

   bool RemoveHandler(const wxString& name)

   Removes a handler.

=head2 Wx::RichTextBuffer::ResetAndClearCommands

   void ResetAndClearCommands()

   Clears the buffer, adds a new blank paragraph, and clears the command
   history.

=head2 Wx::RichTextBuffer::SaveFile

   bool SaveFile(wxOutputStream& stream, int type = wxRICHTEXT_TYPE_ANY)

   Saves content to a stream.

   bool SaveFile(const wxString& filename, int type = wxRICHTEXT_TYPE_ANY)

   Saves content to a file.

=head2 Wx::RichTextBuffer::SetBasicStyle

   void SetBasicStyle(const wxRichTextAttr& style)

   void SetBasicStyle(const wxTextAttrEx& style)

   Sets the basic (overall) style. This is the style of the whole buffer
   before further styles are applied, unlike the default style, which
   only affects the style currently being applied (for example, setting
   the default style to bold will cause subsequently inserted text to be
   bold).

=head2 Wx::RichTextBuffer::SetDefaultStyle

   void SetDefaultStyle(const wxTextAttrEx& style)

   Sets the default style, affecting the style currently being applied
   (for example, setting the default style to bold will cause
   subsequently inserted text to be bold).

   This is not cumulative - setting the default style will replace the
   previous default style.

=head2 Wx::RichTextBuffer::SetListStyle

   bool SetListStyle(const wxRichTextRange& range, const
   wxRichTextListStyleDefinition* style, int flags =
   wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = -1, int listLevel = -1)

   bool SetListStyle(const wxRichTextRange& range, const wxString&
   styleName, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom =
   -1, int listLevel = -1)

   Sets the list attributes for the given range, passing flags to
   determine how the attributes are set. Either the style definition or
   the name of the style definition (in the current sheet) can be passed.

   flags is a bit list of the following:

=head2 Wx::RichTextBuffer::SetRenderer

   static void SetRenderer(wxRichTextRenderer* renderer)

   Sets renderer as the object to be used to render certain aspects of
   the content, such as bullets. You can override default rendering by
   deriving a new class from wxRichTextRenderer or wxRichTextStdRenderer,
   overriding one or more virtual functions, and setting an instance of
   the class using this function.

=head2 Wx::RichTextBuffer::SetStyle

   bool SetStyle(const wxRichTextRange& range, const wxRichTextAttr&
   style, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO)

   bool SetStyle(const wxRichTextRange& range, const wxTextAttrEx& style,
   int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO)

   Sets the attributes for the given range. Pass flags to determine how
   the attributes are set.

   The end point of range is specified as the last character position of
   the span of text. So, for example, to set the style for a character at
   position 5, use the range (5,5). This differs from the wxRichTextCtrl
   API, where you would specify (5,6).

   flags may contain a bit list of the following values:

=head2 Wx::RichTextBuffer::SetStyleSheet

   void SetStyleSheet(wxRichTextStyleSheet* styleSheet)

   Sets the current style sheet, if any. This will allow the application
   to use named character and paragraph styles found in the style sheet.

=head2 Wx::RichTextBuffer::SubmitAction

   bool SubmitAction(wxRichTextAction* action)

   Submit an action immediately, or delay it according to whether
   collapsing is on.

=head2 Wx::RichTextBuffer::SuppressingUndo

   bool SuppressingUndo() const

   Returns true if undo suppression is currently on.

=head1 Wx::RichTextCharacterStyleDefinition

=head2 Wx::RichTextCharacterStyleDefinition::new

   wxRichTextCharacterStyleDefinition(const wxString& name =
   wxEmptyString)

   Constructor.

=head2 Wx::RichTextCharacterStyleDefinition::DESTROY

   ~wxRichTextCharacterStyleDefinition()

   Destructor.

=head1 Wx::RichTextCtrl

=head2 Wx::RichTextCtrl::new

   wxRichTextCtrl()

   wxRichTextCtrl(wxWindow* parent, wxWindowID id = wxID_ANY, const
   wxString& value = wxEmptyString, const wxPoint& pos =
   wxDefaultPosition, const wxSize& size = wxDefaultSize, long style =
   wxRE_MULTILINE, const wxValidator& validator = wxDefaultValidator,
   const wxString& name = wxTextCtrlNameStr)

   Constructors.

=head2 Wx::RichTextCtrl::DESTROY

   ~wxRichTextCtrl()

   Destructor.

=head2 Wx::RichTextCtrl::AddImage

   wxRichTextRange AddImage(const wxImage& image)

   Adds an image to the control's buffer.

=head2 Wx::RichTextCtrl::AddParagraph

   wxRichTextRange AddParagraph(const wxString& text)

   Adds a new paragraph of text to the end of the buffer.

=head2 Wx::RichTextCtrl::AppendText

   void AppendText(const wxString& text)

   Sets the insertion point to the end of the buffer and writes the text.

=head2 Wx::RichTextCtrl::ApplyAlignmentToSelection

   bool ApplyAlignmentToSelection(wxTextAttrAlignment alignment)

   Applies the given alignment to the selection (undoable).

   For alignment values, see wxTextAttrEx.

=head2 Wx::RichTextCtrl::ApplyBoldToSelection

   bool ApplyBoldToSelection()

   Apples bold to the selection (undoable).

=head2 Wx::RichTextCtrl::ApplyItalicToSelection

   bool ApplyItalicToSelection()

   Applies italic to the selection (undoable).

=head2 Wx::RichTextCtrl::ApplyStyle

   bool ApplyStyle(wxRichTextStyleDefinition* def)

   Applies the given style to the selection.

=head2 Wx::RichTextCtrl::ApplyStyleSheet

   bool ApplyStyleSheet(wxRichTextStyleSheet* sheet = NULL)

   Applies the style sheet to the buffer, matching paragraph styles in
   the sheet against named styles in the buffer. This might be useful if
   the styles have changed. If sheet is NULL, the sheet set with
   SetStyleSheet is used.

   Currently this applies paragraph styles only.

=head2 Wx::RichTextCtrl::ApplyUnderlineToSelection

   bool ApplyUnderlineToSelection()

   Applies underline to the selection (undoable).

=head2 Wx::RichTextCtrl::BatchingUndo

   bool BatchingUndo() const

   Returns true if undo commands are being batched.

=head2 Wx::RichTextCtrl::BeginAlignment

   bool BeginAlignment(wxTextAttrAlignment alignment)

   Begins using alignment

   For alignment values, see wxTextAttrEx.

=head2 Wx::RichTextCtrl::BeginBatchUndo

   bool BeginBatchUndo(const wxString& cmdName)

   Starts batching undo history for commands.

=head2 Wx::RichTextCtrl::BeginBold

   bool BeginBold()

   Begins using bold.

=head2 Wx::RichTextCtrl::BeginCharacterStyle

   bool BeginCharacterStyle(const wxString& characterStyle)

   Begins using the named character style.

=head2 Wx::RichTextCtrl::BeginFont

   bool BeginFont(const wxFont& font)

   Begins using this font.

=head2 Wx::RichTextCtrl::BeginFontSize

   bool BeginFontSize(int pointSize)

   Begins using the given point size.

=head2 Wx::RichTextCtrl::BeginItalic

   bool BeginItalic()

   Begins using italic.

=head2 Wx::RichTextCtrl::BeginLeftIndent

   bool BeginLeftIndent(int leftIndent, int leftSubIndent = 0)

   Begins applying a left indent and subindent in tenths of a millimetre.

   The sub-indent is an offset from the left of the paragraph, and is
   used for all but the first line in a paragraph. A positive value will
   cause the first line to appear to the left of the subsequent lines,
   and a negative value will cause the first line to be indented relative
   to the subsequent lines.

   wxRichTextBuffer uses indentation to render a bulleted item. The left
   indent is the distance between the margin and the bullet. The content
   of the paragraph, including the first line, starts at leftMargin +
   leftSubIndent. So the distance between the left edge of the bullet and
   the left of the actual paragraph is leftSubIndent.

=head2 Wx::RichTextCtrl::BeginLineSpacing

   bool BeginLineSpacing(int lineSpacing)

   Begins appling line spacing. spacing is a multiple, where 10 means
   single-spacing, 15 means 1.5 spacing, and 20 means double spacing. The
   following constants are defined for convenience:

   #define wxTEXT_ATTR_LINE_SPACING_NORMAL         10
   #define wxTEXT_ATTR_LINE_SPACING_HALF           15
   #define wxTEXT_ATTR_LINE_SPACING_TWICE          20

=head2 Wx::RichTextCtrl::BeginListStyle

   bool BeginListStyle(const wxString& listStyle, int level=1, int
   number=1)

   Begins using a specified list style. Optionally, you can also pass a
   level and a number.

=head2 Wx::RichTextCtrl::BeginNumberedBullet

   bool BeginNumberedBullet(int bulletNumber, int leftIndent, int
   leftSubIndent, int bulletStyle =
   wxTEXT_ATTR_BULLET_STYLE_ARABIC|wxTEXT_ATTR_BULLET_STYLE_PERIOD)

   Begins a numbered bullet. This call will be needed for each item in
   the list, and the application should take care of incrementing the
   numbering.

   bulletNumber is a number, usually starting with 1.

   leftIndent and leftSubIndent are values in tenths of a millimetre.

   bulletStyle is a bitlist of the following values:

   #define wxTEXT_ATTR_BULLET_STYLE_NONE               0x00000000
   #define wxTEXT_ATTR_BULLET_STYLE_ARABIC             0x00000001
   #define wxTEXT_ATTR_BULLET_STYLE_LETTERS_UPPER      0x00000002
   #define wxTEXT_ATTR_BULLET_STYLE_LETTERS_LOWER      0x00000004
   #define wxTEXT_ATTR_BULLET_STYLE_ROMAN_UPPER        0x00000008
   #define wxTEXT_ATTR_BULLET_STYLE_ROMAN_LOWER        0x00000010
   #define wxTEXT_ATTR_BULLET_STYLE_SYMBOL             0x00000020
   #define wxTEXT_ATTR_BULLET_STYLE_BITMAP             0x00000040
   #define wxTEXT_ATTR_BULLET_STYLE_PARENTHESES        0x00000080
   #define wxTEXT_ATTR_BULLET_STYLE_PERIOD             0x00000100
   #define wxTEXT_ATTR_BULLET_STYLE_STANDARD           0x00000200
   #define wxTEXT_ATTR_BULLET_STYLE_RIGHT_PARENTHESIS  0x00000400
   #define wxTEXT_ATTR_BULLET_STYLE_OUTLINE            0x00000800
   #define wxTEXT_ATTR_BULLET_STYLE_ALIGN_LEFT         0x00000000
   #define wxTEXT_ATTR_BULLET_STYLE_ALIGN_RIGHT        0x00001000
   #define wxTEXT_ATTR_BULLET_STYLE_ALIGN_CENTRE       0x00002000

   wxRichTextBuffer uses indentation to render a bulleted item. The left
   indent is the distance between the margin and the bullet. The content
   of the paragraph, including the first line, starts at leftMargin +
   leftSubIndent. So the distance between the left edge of the bullet and
   the left of the actual paragraph is leftSubIndent.

=head2 Wx::RichTextCtrl::BeginParagraphSpacing

   bool BeginParagraphSpacing(int before, int after)

   Begins paragraph spacing; pass the before-paragraph and
   after-paragraph spacing in tenths of a millimetre.

=head2 Wx::RichTextCtrl::BeginParagraphStyle

   bool BeginParagraphStyle(const wxString& paragraphStyle)

   Begins applying the named paragraph style.

=head2 Wx::RichTextCtrl::BeginRightIndent

   bool BeginRightIndent(int rightIndent)

   Begins a right indent, specified in tenths of a millimetre.

=head2 Wx::RichTextCtrl::BeginStyle

   bool BeginStyle(const wxTextAttrEx& style)

   Begins applying a style.

=head2 Wx::RichTextCtrl::BeginSuppressUndo

   bool BeginSuppressUndo()

   Starts suppressing undo history for commands.

=head2 Wx::RichTextCtrl::BeginSymbolBullet

   bool BeginSymbolBullet(wxChar symbol, int leftIndent, int
   leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_SYMBOL)

   Begins applying a symbol bullet, using a character from the current
   font. See BeginNumberedBullet for an explanation of how indentation is
   used to render the bulleted paragraph.

=head2 Wx::RichTextCtrl::BeginTextColour

   bool BeginTextColour(const wxColour& colour)

   Begins using this colour.

=head2 Wx::RichTextCtrl::BeginUnderline

   bool BeginUnderline()

   Begins using underlining.

=head2 Wx::RichTextCtrl::BeginURL

   bool BeginURL(const wxString& url, const wxString& characterStyle =
   wxEmptyString)

   Begins applying wxTEXT_ATTR_URL to the content. Pass a URL and
   optionally, a character style to apply, since it is common to mark a
   URL with a familiar style such as blue text with underlining.

=head2 Wx::RichTextCtrl::CanCopy

   bool CanCopy() const

   Returns true if selected content can be copied to the clipboard.

=head2 Wx::RichTextCtrl::CanCut

   bool CanCut() const

   Returns true if selected content can be copied to the clipboard and
   deleted.

=head2 Wx::RichTextCtrl::CanDeleteSelection

   bool CanDeleteSelection() const

   Returns true if selected content can be deleted.

=head2 Wx::RichTextCtrl::CanPaste

   bool CanPaste() const

   Returns true if the clipboard content can be pasted to the buffer.

=head2 Wx::RichTextCtrl::CanRedo

   bool CanRedo() const

   Returns true if there is a command in the command history that can be
   redone.

=head2 Wx::RichTextCtrl::CanUndo

   bool CanUndo() const

   Returns true if there is a command in the command history that can be
   undone.

=head2 Wx::RichTextCtrl::Clear

   void Clear()

   Clears the buffer content, leaving a single empty paragraph. Cannot be
   undone.

=head2 Wx::RichTextCtrl::ClearListStyle

   bool ClearListStyle(const wxRichTextRange& range, int flags =
   wxRICHTEXT_SETSTYLE_WITH_UNDO)

   bool ClearListStyle(const wxRichTextRange& range, int flags =
   wxRICHTEXT_SETSTYLE_WITH_UNDO)

   Clears the list style from the given range, clearing list-related
   attributes and applying any named paragraph style associated with each
   paragraph.

   flags is a bit list of the following:

=head2 Wx::RichTextCtrl::Command

   void Command(wxCommandEvent& event)

   Sends the event to the control.

=head2 Wx::RichTextCtrl::Copy

   void Copy()

   Copies the selected content (if any) to the clipboard.

=head2 Wx::RichTextCtrl::Create

   bool Create(wxWindow* parent, wxWindowID id = wxID_ANY, const wxString&
   value = wxEmptyString, const wxPoint& pos = wxDefaultPosition, const
   wxSize& size = wxDefaultSize, long style = wxRE_MULTILINE, const
   wxValidator& validator = wxDefaultValidator, const wxString& name =
   wxTextCtrlNameStr)

   Creates the underlying window.

=head2 Wx::RichTextCtrl::Cut

   void Cut()

   Copies the selected content (if any) to the clipboard and deletes the
   selection. This is undoable.

=head2 Wx::RichTextCtrl::Delete

   bool Delete(const wxRichTextRange& range)

   Deletes the content within the given range.

=head2 Wx::RichTextCtrl::DeleteSelectedContent

   bool DeleteSelectedContent(long* newPos = NULL)

   Deletes content if there is a selection, e.g. when pressing a key.
   Returns the new caret position in newPos, or leaves it if there was no
   action. This is undoable.

   wxPerl note: In wxPerl this method takes no arguments and returns a
   2-element list ( ok, newPos ).

=head2 Wx::RichTextCtrl::DeleteSelection

   void DeleteSelection()

   Deletes the content in the selection, if any. This is undoable.

=head2 Wx::RichTextCtrl::DiscardEdits

   void DiscardEdits()

   Sets the buffer's modified status to false, and clears the buffer's
   command history.

=head2 Wx::RichTextCtrl::DoGetBestSize

   wxSize DoGetBestSize() const

   Currently this simply returns wxSize(10, 10).

=head2 Wx::RichTextCtrl::EndAlignment

   bool EndAlignment()

   Ends alignment.

=head2 Wx::RichTextCtrl::EndAllStyles

   bool EndAllStyles()

   Ends application of all styles in the current style stack.

=head2 Wx::RichTextCtrl::EndBatchUndo

   bool EndBatchUndo()

   Ends batching undo command history.

=head2 Wx::RichTextCtrl::EndBold

   bool EndBold()

   Ends using bold.

=head2 Wx::RichTextCtrl::EndCharacterStyle

   bool EndCharacterStyle()

   Ends application of a named character style.

=head2 Wx::RichTextCtrl::EndFont

   bool EndFont()

   Ends using a font.

=head2 Wx::RichTextCtrl::EndFontSize

   bool EndFontSize()

   Ends using a point size.

=head2 Wx::RichTextCtrl::EndItalic

   bool EndItalic()

   Ends using italic.

=head2 Wx::RichTextCtrl::EndLeftIndent

   bool EndLeftIndent()

   Ends left indent.

=head2 Wx::RichTextCtrl::EndLineSpacing

   bool EndLineSpacing()

   Ends line spacing.

=head2 Wx::RichTextCtrl::EndListStyle

   bool EndListStyle()

   Ends using a specified list style.

=head2 Wx::RichTextCtrl::EndNumberedBullet

   bool EndNumberedBullet()

   Ends application of a numbered bullet.

=head2 Wx::RichTextCtrl::EndParagraphSpacing

   bool EndParagraphSpacing()

   Ends paragraph spacing.

=head2 Wx::RichTextCtrl::EndParagraphStyle

   bool EndParagraphStyle()

   Ends application of a named character style.

=head2 Wx::RichTextCtrl::EndRightIndent

   bool EndRightIndent()

   Ends right indent.

=head2 Wx::RichTextCtrl::EndStyle

   bool EndStyle()

   Ends the current style.

=head2 Wx::RichTextCtrl::EndSuppressUndo

   bool EndSuppressUndo()

   Ends suppressing undo command history.

=head2 Wx::RichTextCtrl::EndSymbolBullet

   bool EndSymbolBullet()

   Ends applying a symbol bullet.

=head2 Wx::RichTextCtrl::EndTextColour

   bool EndTextColour()

   Ends applying a text colour.

=head2 Wx::RichTextCtrl::EndUnderline

   bool EndUnderline()

   End applying underlining.

=head2 Wx::RichTextCtrl::EndURL

   bool EndURL()

   Ends applying a URL.

=head2 Wx::RichTextCtrl::ExtendSelection

   bool ExtendSelection(long oldPosition, long newPosition, int flags)

   Helper function for extending the selection, returning true if the
   selection was changed. Selections are in caret positions.

=head2 Wx::RichTextCtrl::FindNextWordPosition

   long FindNextWordPosition(int direction = 1) const

   Helper function for finding the caret position for the next word.
   Direction is 1 (forward) or -1 (backwards).

=head2 Wx::RichTextCtrl::Freeze

   void Freeze()

   Call this function to prevent refresh and allow fast updates, and then
   Thaw to refresh the control.

=head2 Wx::RichTextCtrl::GetBasicStyle

   const wxTextAttrEx& GetBasicStyle() const

   Gets the basic (overall) style. This is the style of the whole buffer
   before further styles are applied, unlike the default style, which
   only affects the style currently being applied (for example, setting
   the default style to bold will cause subsequently inserted text to be
   bold).

=head2 Wx::RichTextCtrl::GetBuffer

   const wxRichTextBuffer& GetBuffer() const

   wxRichTextBuffer& GetBuffer()

   Returns the buffer associated with the control.

=head2 Wx::RichTextCtrl::GetCaretPosition

   long GetCaretPosition() const

   Returns the current caret position.

=head2 Wx::RichTextCtrl::GetCaretPositionForIndex

   bool GetCaretPositionForIndex(long position, wxRect& rect)

   Returns the caret height and position for the given character position

   wxPerl note: In wxPerl this method takes the position as argument and
   returns a 2-element list ( ok, rect ).

=head2 Wx::RichTextCtrl::GetCommandProcessor

   wxCommandProcessor* GetCommandProcessor() const

   Gets the command processor associated with the control's buffer.

=head2 Wx::RichTextCtrl::GetDefaultStyleEx

   const wxTextAttrEx& GetDefaultStyleEx() const

   Returns the current default style, which can be used to change how
   subsequently inserted text is displayed. When wxTextAttrEx is merged
   with wxTextAttr, this function will become GetDefaultStyle.

=head2 Wx::RichTextCtrl::GetDelayedLayoutThreshold

   long GetDelayedLayoutThreshold() const

   Gets the size of the buffer beyond which layout is delayed during
   resizing. This optimizes sizing for large buffers. The default is
   20000.

=head2 Wx::RichTextCtrl::GetFilename

   wxString GetFilename() const

   Gets the current filename associated with the control.

=head2 Wx::RichTextCtrl::GetFirstVisiblePosition

   long GetFirstVisiblePosition() const

   Returns the first visible position in the current view.

=head2 Wx::RichTextCtrl::GetHandlerFlags

   int GetHandlerFlags() const

   Returns flags that change the behaviour of loading or saving. See the
   documentation for each handler class to see what flags are relevant
   for each handler.

=head2 Wx::RichTextCtrl::GetInsertionPoint

   long GetInsertionPoint() const

   Returns the current insertion point.

=head2 Wx::RichTextCtrl::GetLastPosition

   wxTextPos GetLastPosition() const

   Returns the last position in the buffer.

=head2 Wx::RichTextCtrl::GetLineLength

   int GetLineLength(long lineNo) const

   Returns the length of the specified line in characters.

=head2 Wx::RichTextCtrl::GetLineText

   wxString GetLineText(long lineNo) const

   Returns the text for the given line.

=head2 Wx::RichTextCtrl::GetLogicalPoint

   wxPoint GetLogicalPoint(const wxPoint& ptPhysical) const

   Transforms physical window position to logical (unscrolled) position.

=head2 Wx::RichTextCtrl::GetNumberOfLines

   int GetNumberOfLines() const

   Returns the number of lines in the buffer.

=head2 Wx::RichTextCtrl::GetPhysicalPoint

   wxPoint GetPhysicalPoint(const wxPoint& ptLogical) const

   Transforms logical (unscrolled) position to physical window position.

=head2 Wx::RichTextCtrl::GetRange

   wxString GetRange(long from, long to) const

   Gets the text for the given range.

   The end point of range is specified as the last character position of
   the span of text, plus one.

=head2 Wx::RichTextCtrl::GetSelection

   void GetSelection(long* from, long* to) const

   Returns the range of the current selection.

   The end point of range is specified as the last character position of
   the span of text, plus one.

   If the return values from and to are the same, there is no selection.

=head2 Wx::RichTextCtrl::GetSelectionRange

   const wxRichTextRange& GetSelectionRange() const

   Returns the selection range in character positions. -1, -1 means no
   selection.

=head2 Wx::RichTextCtrl::GetStringSelection

   wxString GetStringSelection() const

   Returns the text within the current selection range, if any.

=head2 Wx::RichTextCtrl::GetStyle

   bool GetStyle(long position, wxRichTextAttr& style)

   bool GetStyle(long position, wxTextAttrEx& style)

   bool GetStyle(long position, wxTextAttr& style)

   Gets the attributes at the given position. The wxRichTextAttr version
   is generally more efficient because it does not use wxFont objects.

   This function gets the combined style - that is, the style you see on
   the screen as a result of combining base style, paragraph style and
   character style attributes. To get the character or paragraph style
   alone, use GetUncombinedStyle.

   wxPerl note: In place of a single overloaded method, wxPerl uses:

=head2 Wx::RichTextCtrl::GetStyleForRange

   bool GetStyleForRange(const wxRichTextRange& range, wxRichTextAttr&
   style)

   bool GetStyleForRange(const wxRichTextRange& range, wxTextAttrEx&
   style)

   Gets the attributes common to the specified range. Attributes that
   differ in value within the range will not be included in style's
   flags.

   wxPerl note: In place of a single overloaded method, wxPerl uses:

=head2 Wx::RichTextCtrl::GetStyleSheet

   wxRichTextStyleSheet* GetStyleSheet() const

   Returns the style sheet associated with the control, if any. A style
   sheet allows named character and paragraph styles to be applied.

=head2 Wx::RichTextCtrl::GetUncombinedStyle

   bool GetUncombinedStyle(long position, wxRichTextAttr& style)

   bool GetUncombinedStyle(long position, wxTextAttrEx& style)

   bool GetUncombinedStyle(long position, wxTextAttr& style)

   Gets the attributes at the given position. The wxRichTextAttr version
   is generally more efficient because it does not use wxFont objects.

   This function gets the uncombined style - that is, the attributes
   associated with the paragraph or character content, and not
   necessarily the combined attributes you see on the screen. To get the
   combined attributes, use GetStyle.

   If you specify (any) paragraph attribute in style's flags, this
   function will fetch the paragraph attributes. Otherwise, it will
   return the character attributes.

   wxPerl note: In place of a single overloaded method, wxPerl uses:

=head2 Wx::RichTextCtrl::GetValue

   wxString GetValue() const

   Returns the content of the entire control as a string.

=head2 Wx::RichTextCtrl::GetVisibleLineForCaretPosition

   wxRichTextLine* GetVisibleLineForCaretPosition(long caretPosition)
   const

   Internal helper function returning the line for the visible caret
   position. If the caret is shown at the very end of the line, it means
   the next character is actually on the following line. So this function
   gets the line we're expecting to find if this is the case.

=head2 Wx::RichTextCtrl::HasCharacterAttributes

   bool HasCharacterAttributes(const wxRichTextRange& range, const
   wxTextAttrEx& style) const

   bool HasCharacterAttributes(const wxRichTextRange& range, const
   wxRichTextAttr& style) const

   Test if this whole range has character attributes of the specified
   kind. If any of the attributes are different within the range, the
   test fails. You can use this to implement, for example, bold button
   updating. style must have flags indicating which attributes are of
   interest.

=head2 Wx::RichTextCtrl::HasParagraphAttributes

   bool HasParagraphAttributes(const wxRichTextRange& range, const
   wxTextAttrEx& style) const

   bool HasParagraphAttributes(const wxRichTextRange& range, const
   wxRichTextAttr& style) const

   Test if this whole range has paragraph attributes of the specified
   kind. If any of the attributes are different within the range, the
   test fails. You can use this to implement, for example, centering
   button updating. style must have flags indicating which attributes are
   of interest.

=head2 Wx::RichTextCtrl::HasSelection

   bool HasSelection() const

   Returns true if there is a selection.

=head2 Wx::RichTextCtrl::HitTest

   wxTextCtrlHitTestResult HitTest(const wxPoint& pt, long* pos) const

   wxTextCtrlHitTestResult HitTest(const wxPoint& pt, wxTextCoord* col,
   wxTextCoord* row) const

   Finds the character at the given position in pixels.

   pt is in device coords (not adjusted for the client area origin nor
   for scrolling).

=head2 Wx::RichTextCtrl::Init

   void Init()

   Initialises the members of the control.

=head2 Wx::RichTextCtrl::InitCommandEvent

   void InitCommandEvent(wxCommandEvent& event) const

   Initialises the command event.

=head2 Wx::RichTextCtrl::IsDefaultStyleShowing

   bool IsDefaultStyleShowing() const

   Returns true if the user has recently set the default style without
   moving the caret, and therefore the UI needs to reflect the default
   style and not the style at the caret.

   Below is an example of code that uses this function to determine
   whether the UI should show that the current style is bold.

   /// Is all of the selection bold?
   bool wxRichTextCtrl::IsSelectionBold()
   {
       if (HasSelection())
       {
           wxRichTextAttr attr;
           wxRichTextRange range = GetInternalSelectionRange();
           attr.SetFlags(wxTEXT_ATTR_FONT_WEIGHT);
           attr.SetFontWeight(wxBOLD);

=head2 Wx::RichTextCtrl::IsEditable

   bool IsEditable() const

   Returns true if the control is editable.

=head2 Wx::RichTextCtrl::IsFrozen

   bool IsFrozen() const

   Returns true if Freeze has been called without a Thaw.

=head2 Wx::RichTextCtrl::IsModified

   bool IsModified() const

   Returns true if the buffer has been modified.

=head2 Wx::RichTextCtrl::IsMultiLine

   bool IsMultiLine() const

   Returns true if the control is multiline.

=head2 Wx::RichTextCtrl::IsPositionVisible

   bool IsPositionVisible(long pos) const

   Returns true if the given position is visible on the screen.

=head2 Wx::RichTextCtrl::IsSelectionAligned

   bool IsSelectionAligned(wxTextAttrAlignment alignment) const

   Returns true if all of the selection is aligned according to the
   specified flag.

=head2 Wx::RichTextCtrl::IsSelectionBold

   bool IsSelectionBold() const

   Returns true if all of the selection is bold.

=head2 Wx::RichTextCtrl::IsSelectionItalics

   bool IsSelectionItalics() const

   Returns true if all of the selection is italic.

=head2 Wx::RichTextCtrl::IsSelectionUnderlined

   bool IsSelectionUnderlined() const

   Returns true if all of the selection is underlined.

=head2 Wx::RichTextCtrl::IsSingleLine

   bool IsSingleLine() const

   Returns true if the control is single-line. Currently wxRichTextCtrl
   does not support single-line editing.

=head2 Wx::RichTextCtrl::KeyboardNavigate

   bool KeyboardNavigate(int keyCode, int flags)

   Helper function implementing keyboard navigation.

=head2 Wx::RichTextCtrl::LayoutContent

   bool LayoutContent(bool onlyVisibleRect = false)

   Lays out the buffer, which must be done before certain operations,
   such as setting the caret position. This function should not normally
   be required by the application.

=head2 Wx::RichTextCtrl::LineBreak

   bool LineBreak()

   Inserts a line break at the current insertion point. A line break
   forces wrapping within a paragraph, and can be introduced by using
   this function, by appending the wxChar value wxRichTextLineBreakChar
   to text content, or by typing Shift-Return.

=head2 Wx::RichTextCtrl::LoadFile

   bool LoadFile(const wxString& file, int type = wxRICHTEXT_TYPE_ANY)

   Loads content into the control's buffer using the given type. If the
   specified type is wxRICHTEXT_TYPE_ANY, the type is deduced from the
   filename extension.

   This function looks for a suitable wxRichTextFileHandler object.

=head2 Wx::RichTextCtrl::MarkDirty

   void MarkDirty()

   Marks the buffer as modified.

=head2 Wx::RichTextCtrl::MoveCaret

   bool MoveCaret(long pos, bool showAtLineStart = false)

   Move the caret to the given character position.

=head2 Wx::RichTextCtrl::MoveCaretBack

   void MoveCaretBack(long oldPosition)

   Move the caret one visual step forward: this may mean setting a flag
   and keeping the same position if we're going from the end of one line
   to the start of the next, which may be the exact same caret position.

=head2 Wx::RichTextCtrl::MoveCaretForward

   void MoveCaretForward(long oldPosition)

   Move the caret one visual step forward: this may mean setting a flag
   and keeping the same position if we're going from the end of one line
   to the start of the next, which may be the exact same caret position.

=head2 Wx::RichTextCtrl::MoveDown

   bool MoveDown(int noLines = 1, int flags = 0)

   Moves the caret down.

=head2 Wx::RichTextCtrl::MoveEnd

   bool MoveEnd(int flags = 0)

   Moves to the end of the buffer.

=head2 Wx::RichTextCtrl::MoveHome

   bool MoveHome(int flags = 0)

   Moves to the start of the buffer.

=head2 Wx::RichTextCtrl::MoveLeft

   bool MoveLeft(int noPositions = 1, int flags = 0)

   Moves left.

=head2 Wx::RichTextCtrl::MoveRight

   bool MoveRight(int noPositions = 1, int flags = 0)

   Moves right.

=head2 Wx::RichTextCtrl::MoveToLineEnd

   bool MoveToLineEnd(int flags = 0)

   Moves to the end of the line.

=head2 Wx::RichTextCtrl::MoveToLineStart

   bool MoveToLineStart(int flags = 0)

   Moves to the start of the line.

=head2 Wx::RichTextCtrl::MoveToParagraphEnd

   bool MoveToParagraphEnd(int flags = 0)

   Moves to the end of the paragraph.

=head2 Wx::RichTextCtrl::MoveToParagraphStart

   bool MoveToParagraphStart(int flags = 0)

   Moves to the start of the paragraph.

=head2 Wx::RichTextCtrl::MoveUp

   bool MoveUp(int noLines = 1, int flags = 0)

   Moves up.

=head2 Wx::RichTextCtrl::Newline

   bool Newline()

   Inserts a new paragraph at the current insertion point. See also
   wxRichTextCtrl::LineBreak.

=head2 Wx::RichTextCtrl::NumberList

   bool NumberList(const wxRichTextRange& range, const
   wxRichTextListStyleDefinition* style, int flags =
   wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = -1, int listLevel = -1)

   bool Number(const wxRichTextRange& range, const wxString& styleName,
   int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = -1, int
   listLevel = -1)

   Numbers the paragraphs in the given range. Pass flags to determine how
   the attributes are set. Either the style definition or the name of the
   style definition (in the current sheet) can be passed.

   flags is a bit list of the following:

=head2 Wx::RichTextCtrl::OnClear

   void OnClear(wxCommandEvent& event)

   Standard handler for the wxID_CLEAR command.

=head2 Wx::RichTextCtrl::OnContextMenu

   void OnContextMenu(wxContextMenuEvent& event)

   Shows a standard context menu with undo, redo, cut, copy, paste,
   clear, and select all commands.

=head2 Wx::RichTextCtrl::OnCopy

   void OnCopy(wxCommandEvent& event)

   Standard handler for the wxID_COPY command.

=head2 Wx::RichTextCtrl::OnCut

   void OnCut(wxCommandEvent& event)

   Standard handler for the wxID_CUT command.

=head2 Wx::RichTextCtrl::OnDropFiles

   void OnDropFiles(wxDropFilesEvent& event)

   Loads the first dropped file.

=head2 Wx::RichTextCtrl::OnPaste

   void OnPaste(wxCommandEvent& event)

   Standard handler for the wxID_PASTE command.

=head2 Wx::RichTextCtrl::OnRedo

   void OnRedo(wxCommandEvent& event)

   Standard handler for the wxID_REDO command.

=head2 Wx::RichTextCtrl::OnSelectAll

   void OnSelectAll(wxCommandEvent& event)

   Standard handler for the wxID_SELECTALL command.

=head2 Wx::RichTextCtrl::OnUndo

   void OnUndo(wxCommandEvent& event)

   Standard handler for the wxID_PASTE command.

=head2 Wx::RichTextCtrl::OnUpdateClear

   void OnUpdateClear(wxUpdateUIEvent& event)

   Standard update handler for the wxID_CLEAR command.

=head2 Wx::RichTextCtrl::OnUpdateCopy

   void OnUpdateCopy(wxUpdateUIEvent& event)

   Standard update handler for the wxID_COPY command.

=head2 Wx::RichTextCtrl::OnUpdateCut

   void OnUpdateCut(wxUpdateUIEvent& event)

   Standard update handler for the wxID_CUT command.

=head2 Wx::RichTextCtrl::OnUpdatePaste

   void OnUpdatePaste(wxUpdateUIEvent& event)

   Standard update handler for the wxID_PASTE command.

=head2 Wx::RichTextCtrl::OnUpdateRedo

   void OnUpdateRedo(wxUpdateUIEvent& event)

   Standard update handler for the wxID_REDO command.

=head2 Wx::RichTextCtrl::OnUpdateSelectAll

   void OnUpdateSelectAll(wxUpdateUIEvent& event)

   Standard update handler for the wxID_SELECTALL command.

=head2 Wx::RichTextCtrl::OnUpdateUndo

   void OnUpdateUndo(wxUpdateUIEvent& event)

   Standard update handler for the wxID_UNDO command.

=head2 Wx::RichTextCtrl::PageDown

   bool PageDown(int noPages = 1, int flags = 0)

   Moves one or more pages down.

=head2 Wx::RichTextCtrl::PageUp

   bool PageUp(int noPages = 1, int flags = 0)

   Moves one or more pages up.

=head2 Wx::RichTextCtrl::PaintBackground

   void PaintBackground(wxDC& dc)

   Paints the background.

=head2 Wx::RichTextCtrl::Paste

   void Paste()

   Pastes content from the clipboard to the buffer.

=head2 Wx::RichTextCtrl::PositionCaret

   void PositionCaret()

   Internal function to position the visible caret according to the
   current caret position.

=head2 Wx::RichTextCtrl::PositionToXY

   bool PositionToXY(long pos, long* x, long* y) const

   Converts a text position to zero-based column and line numbers.

=head2 Wx::RichTextCtrl::PromoteList

   bool PromoteList(int promoteBy, const wxRichTextRange& range, const
   wxRichTextListStyleDefinition* style, int flags =
   wxRICHTEXT_SETSTYLE_WITH_UNDO, int listLevel = -1)

   bool PromoteList(int promoteBy, const wxRichTextRange& range, const
   wxString& styleName, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int
   listLevel = -1)

   Promotes or demotes the paragraphs in the given range. A positive
   promoteBy produces a smaller indent, and a negative number produces a
   larger indent. Pass flags to determine how the attributes are set.
   Either the style definition or the name of the style definition (in
   the current sheet) can be passed.

   flags is a bit list of the following:

=head2 Wx::RichTextCtrl::Redo

   void Redo()

   Redoes the current command.

=head2 Wx::RichTextCtrl::Remove

   void Remove(long from, long to)

   Removes the content in the specified range.

=head2 Wx::RichTextCtrl::Replace

   void Replace(long from, long to, const wxString& value)

   Replaces the content in the specified range with the string specified
   by value.

=head2 Wx::RichTextCtrl::SaveFile

   bool SaveFile(const wxString& file = wxEmptyString, int type =
   wxRICHTEXT_TYPE_ANY)

   Saves the buffer content using the given type. If the specified type
   is wxRICHTEXT_TYPE_ANY, the type is deduced from the filename
   extension.

   This function looks for a suitable wxRichTextFileHandler object.

=head2 Wx::RichTextCtrl::ScrollIntoView

   bool ScrollIntoView(long position, int keyCode)

   Scrolls position into view. This function takes a caret position.

=head2 Wx::RichTextCtrl::SelectAll

   void SelectAll()

   Selects all the text in the buffer.

=head2 Wx::RichTextCtrl::SelectNone

   void SelectNone()

   Cancels any selection.

=head2 Wx::RichTextCtrl::SetAndShowDefaultStyle

   void SetAndShowDefaultStyle(const wxRichTextAttr& attr)

   Sets attr as the default style and tells the control that the UI
   should reflect this attribute until the user moves the caret.

   See also IsDefaultStyleShowing.

=head2 Wx::RichTextCtrl::SetBasicStyle

   void SetBasicStyle(const wxRichTextAttr& style)

   void SetBasicStyle(const wxTextAttrEx& style)

   Sets the basic (overall) style. This is the style of the whole buffer
   before further styles are applied, unlike the default style, which
   only affects the style currently being applied (for example, setting
   the default style to bold will cause subsequently inserted text to be
   bold).

=head2 Wx::RichTextCtrl::SetCaretPosition

   void SetCaretPosition(long position, bool showAtLineStart = false)

   The caret position is the character position just before the caret. A
   value of -1 means the caret is at the start of the buffer.

=head2 Wx::RichTextCtrl::SetDefaultStyle

   bool SetDefaultStyle(const wxTextAttrEx& style)

   Sets the current default style, which can be used to change how
   subsequently inserted text is displayed.

=head2 Wx::RichTextCtrl::SetDefaultStyleToCursorStyle

   bool SetDefaultStyleToCursorStyle()

   Sets the default style to the style under the cursor.

=head2 Wx::RichTextCtrl::SetDelayedLayoutThreshold

   void SetDelayedLayoutThreshold(long threshold)

   Sets the size of the buffer beyond which layout is delayed during
   resizing. This optimizes sizing for large buffers. The default is
   20000.

=head2 Wx::RichTextCtrl::SetEditable

   void SetEditable(bool editable)

   Makes the control editable, or not.

=head2 Wx::RichTextCtrl::SetFilename

   void SetFilename(const wxString& filename)

   Sets the current filename.

=head2 Wx::RichTextCtrl::SetFont

   bool SetFont(const wxFont& font)

   Sets the font, and also the basic and default attributes (see
   SetDefaultStyle).

=head2 Wx::RichTextCtrl::SetHandlerFlags

   void SetHandlerFlags(int flags)

   Sets flags that change the behaviour of loading or saving. See the
   documentation for each handler class to see what flags are relevant
   for each handler.

=head2 Wx::RichTextCtrl::SetInsertionPoint

   void SetInsertionPoint(long pos)

   Sets the insertion point.

=head2 Wx::RichTextCtrl::SetInsertionPointEnd

   void SetInsertionPointEnd()

   Sets the insertion point to the end of the text control.

=head2 Wx::RichTextCtrl::SetListStyle

   bool SetListStyle(const wxRichTextRange& range, const
   wxRichTextListStyleDefinition* style, int flags =
   wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = -1, int listLevel = -1)

   bool SetListStyle(const wxRichTextRange& range, const wxString&
   styleName, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom =
   -1, int listLevel = -1)

   Sets the list attributes for the given range, passing flags to
   determine how the attributes are set. Either the style definition or
   the name of the style definition (in the current sheet) can be passed.

   flags is a bit list of the following:

=head2 Wx::RichTextCtrl::SetSelection

   void SetSelection(long from, long to)

   Sets the selection to the given range.

   The end point of range is specified as the last character position of
   the span of text, plus one. So, for example, to set the selection for
   a character at position 5, use the range (5,6).

=head2 Wx::RichTextCtrl::SetSelectionRange

   void SetSelectionRange(const wxRichTextRange& range)

   Sets the selection to the given range.

   The end point of range is specified as the last character position of
   the span of text, plus one. So, for example, to set the selection for
   a character at position 5, use the range (5,6).

=head2 Wx::RichTextCtrl::SetStyle

   bool SetStyle(const wxRichTextRange& range, const wxRichTextAttr&
   style)

   bool SetStyle(long start, long end, const wxTextAttrEx& style)

   bool SetStyle(long start, long end, const wxTextAttr& style)

   Sets the attributes for the given range. The wxRichTextAttr version is
   more efficient because it does not use wxFont objects.

   The end point of range is specified as the last character position of
   the span of text, plus one. So, for example, to set the style for a
   character at position 5, use the range (5,6).

=head2 Wx::RichTextCtrl::SetStyleEx

   bool SetStyleEx(const wxRichTextRange& range, const wxRichTextAttr&
   style, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO)

   bool SetStyleEx(const wxRichTextRange& range, const wxTextAttrEx&
   style, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO)

   bool SetStyleEx(long start, long end, const wxTextAttrEx& style, int
   flags = wxRICHTEXT_SETSTYLE_WITH_UNDO)

   Sets the attributes for the given range, passing flags to determine
   how the attributes are set. The wxRichTextAttr version is more
   efficient because it does not use wxFont objects.

   The end point of range is specified as the last character position of
   the span of text, plus one. So, for example, to set the style for a
   character at position 5, use the range (5,6).

   flags may contain a bit list of the following values:

=head2 Wx::RichTextCtrl::SetStyleSheet

   void SetStyleSheet(wxRichTextStyleSheet* styleSheet)

   Sets the style sheet associated with the control. A style sheet allows
   named character and paragraph styles to be applied.

=head2 Wx::RichTextCtrl::SetValue

   void SetValue(const wxString& value)

   Replaces existing content with the given text.

=head2 Wx::RichTextCtrl::SetupScrollbars

   void SetupScrollbars(bool atTop = false)

   A helper function setting up scrollbars, for example after a resize.

=head2 Wx::RichTextCtrl::ShowPosition

   void ShowPosition(long pos)

   Scrolls the buffer so that the given position is in view.

=head2 Wx::RichTextCtrl::SuppressingUndo

   bool SuppressingUndo() const

   Returns true if undo history suppression is on.

=head2 Wx::RichTextCtrl::Thaw

   void Thaw()

   Call this function to end a Freeze and refresh the display.

=head2 Wx::RichTextCtrl::Undo

   void Undo()

   Undoes the command at the top of the command history, if there is one.

=head2 Wx::RichTextCtrl::WordLeft

   bool WordLeft(int noWords = 1, int flags = 0)

   Moves a number of words to the left.

=head2 Wx::RichTextCtrl::WordRight

   bool WordRight(int noWords = 1, int flags = 0)

   Move a nuber of words to the right.

=head2 Wx::RichTextCtrl::WriteImage

   bool WriteImage(const wxString& filename, int bitmapType)

   Loads an image from a file and writes it at the current insertion
   point.

   bool WriteImage(const wxRichTextImageBlock& imageBlock)

   Writes an image block at the current insertion point.

   bool WriteImage(const wxBitmap& bitmap, int bitmapType =
   wxBITMAP_TYPE_PNG)

   bool WriteImage(const wxImage& image, int bitmapType =
   wxBITMAP_TYPE_PNG)

   Write a bitmap or image at the current insertion point. Supply an
   optional type to use for internal and file storage of the raw data.

=head2 Wx::RichTextCtrl::WriteText

   void WriteText(const wxString& text)

   Writes text at the current position.

=head2 Wx::RichTextCtrl::XYToPosition

   long XYToPosition(long x, long y) const

   Translates from column and line number to position.

=head1 Wx::RichTextEvent

=head2 Wx::RichTextEvent::new

   wxRichTextEvent(const wxRichTextEvent& event)

   wxRichTextEvent(wxEventType commandType = wxEVT_NULL, int winid = 0)

   Constructors.

=head2 Wx::RichTextEvent::Clone

   wxEvent* Clone() const

   Clones the event.

=head2 Wx::RichTextEvent::GetCharacter

   wxChar GetCharacter() const

   Returns the character pressed, within a
   wxEVT_COMMAND_RICHTEXT_CHARACTER event.

=head2 Wx::RichTextEvent::GetFlags

   int GetFlags() const

   Returns flags indicating modifier keys pressed. Possible values are
   wxRICHTEXT_CTRL_DOWN, wxRICHTEXT_SHIFT_DOWN, and wxRICHTEXT_ALT_DOWN.

=head2 Wx::RichTextEvent::GetNewStyleSheet

   wxRichTextStyleSheet* GetNewStyleSheet() const

   Returns the new style sheet. Can be used in a
   wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGING or
   wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGED event handler.

=head2 Wx::RichTextEvent::GetOldStyleSheet

   wxRichTextStyleSheet* GetOldStyleSheet() const

   Returns the old style sheet. Can be used in a
   wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGING or
   wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGED event handler.

=head2 Wx::RichTextEvent::GetPosition

   long GetPosition() const

   Returns the buffer position at which the event occured.

=head2 Wx::RichTextEvent::GetRange

   wxRichTextRange GetRange() const

   Gets the range for the current operation.

=head2 Wx::RichTextEvent::SetCharacter

   void SetCharacter(wxChar ch)

   Sets the character variable.

=head2 Wx::RichTextEvent::SetFlags

   void SetFlags(int flags)

   Sets flags indicating modifier keys pressed. Possible values are
   wxRICHTEXT_CTRL_DOWN, wxRICHTEXT_SHIFT_DOWN, and wxRICHTEXT_ALT_DOWN.

=head2 Wx::RichTextEvent::SetNewStyleSheet

   void SetNewStyleSheet(wxRichTextStyleSheet* sheet)

   Sets the new style sheet variable.

=head2 Wx::RichTextEvent::SetOldStyleSheet

   void SetOldStyleSheet(wxRichTextStyleSheet* sheet)

   Sets the old style sheet variable.

=head2 Wx::RichTextEvent::SetPosition

   void SetPosition(long pos)

   Sets the buffer position variable.

=head2 Wx::RichTextEvent::SetRange

   void SetRange(const wxRichTextRange& range)

   Sets the range variable.

=head1 Wx::RichTextFileHandler

=head2 Wx::RichTextFileHandler::new

   wxRichTextFileHandler(const wxString& name = wxEmptyString, const
   wxString& ext = wxEmptyString, int type = 0)

   Constructor.

=head2 Wx::RichTextFileHandler::CanHandle

   bool CanHandle(const wxString& filename) const

   Override this function and return true if this handler can we handle
   filename. By default, this function checks the extension.

=head2 Wx::RichTextFileHandler::CanLoad

   bool CanLoad() const

   Override and return true if this handler can load content.

=head2 Wx::RichTextFileHandler::CanSave

   bool CanSave() const

   Override and return true if this handler can save content.

=head2 Wx::RichTextFileHandler::DoLoadFile

   bool DoLoadFile(wxRichTextBuffer* buffer, wxInputStream& stream)

   Override to load content from stream into buffer.

=head2 Wx::RichTextFileHandler::DoSaveFile

   bool DoSaveFile(wxRichTextBuffer* buffer, wxOutputStream& stream)

   Override to save content to stream from buffer.

=head2 Wx::RichTextFileHandler::GetEncoding

   const wxString& GetEncoding() const

   Returns the encoding associated with the handler (if any).

=head2 Wx::RichTextFileHandler::GetExtension

   wxString GetExtension() const

   Returns the extension associated with the handler.

=head2 Wx::RichTextFileHandler::GetFlags

   int GetFlags() const

   Returns flags that change the behaviour of loading or saving. See the
   documentation for each handler class to see what flags are relevant
   for each handler.

=head2 Wx::RichTextFileHandler::GetName

   wxString GetName() const

   Returns the name of the handler.

=head2 Wx::RichTextFileHandler::GetType

   int GetType() const

   Returns the type of the handler.

=head2 Wx::RichTextFileHandler::IsVisible

   bool IsVisible() const

   Returns true if this handler should be visible to the user.

=head2 Wx::RichTextFileHandler::LoadFile

   bool LoadFile(wxRichTextBuffer* buffer, wxInputStream& stream)

   bool LoadFile(wxRichTextBuffer* buffer, const wxString& filename)

   Loads content from a stream or file. Not all handlers will implement
   file loading.

=head2 Wx::RichTextFileHandler::SaveFile

   bool SaveFile(wxRichTextBuffer* buffer, wxOutputStream& stream)

   bool SaveFile(wxRichTextBuffer* buffer, const wxString& filename)

   Saves content to a stream or file. Not all handlers will implement
   file saving.

=head2 Wx::RichTextFileHandler::SetEncoding

   void SetEncoding(const wxString& encoding)

   Sets the encoding to use when saving a file. If empty, a suitable
   encoding is chosen.

=head2 Wx::RichTextFileHandler::SetExtension

   void SetExtension(const wxString& ext)

   Sets the default extension to recognise.

=head2 Wx::RichTextFileHandler::SetFlags

   void SetFlags(int flags)

   Sets flags that change the behaviour of loading or saving. See the
   documentation for each handler class to see what flags are relevant
   for each handler.

   You call this function directly if you are using a file handler
   explicitly (without going through the text control or buffer
   LoadFile/SaveFile API). Or, you can call the control or buffer's
   SetHandlerFlags function to set the flags that will be used for
   subsequent load and save operations.

=head2 Wx::RichTextFileHandler::SetName

   void SetName(const wxString& name)

   Sets the name of the handler.

=head2 Wx::RichTextFileHandler::SetType

   void SetType(int type)

   Sets the handler type.

=head2 Wx::RichTextFileHandler::SetVisible

   void SetVisible(bool visible)

   Sets whether the handler should be visible to the user (via the
   application's load and save dialogs).

=head1 Wx::RichTextFormattingDialog

=head2 Wx::RichTextFormattingDialog::new

   wxRichTextFormattingDialog(long flags, wxWindow* parent, const
   wxString& title = _("Formatting"), wxWindowID id = wxID_ANY, const
   wxPoint& pos = wxDefaultPosition, const wxSize& sz = wxDefaultSize,
   long style = wxDEFAULT_DIALOG_STYLE)

   wxRichTextFormattingDialog()

   Constructors.

   Parameters

   flags

       The pages to show.

   parent

       The dialog's parent.

   id  

       The dialog's identifier.

   title

       The dialog's caption.

   pos 

       The dialog's position.

   size

       The dialog's size.

   style

       The dialog's window style.

=head2 Wx::RichTextFormattingDialog::DESTROY

   ~wxRichTextFormattingDialog()

   Destructor.

=head2 Wx::RichTextFormattingDialog::ApplyStyle

   bool ApplyStyle(wxRichTextCtrl* ctrl, const wxRichTextRange& range,
   int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO|wxRICHTEXT_SETSTYLE_OPTIMIZE)

   Apply attributes to the given range, only changing attributes that
   need to be changed.

=head2 Wx::RichTextFormattingDialog::Create

   bool Create(long flags, wxWindow* parent, const wxString& title,
   wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize&
   sz = wxDefaultSize, long style = wxDEFAULT_DIALOG_STYLE)

   Creation: see the constructor for details about the parameters.

=head2 Wx::RichTextFormattingDialog::GetAttributes

   const wxTextAttrEx& GetAttributes() const

   wxTextAttrEx& GetAttributes()

   Gets the attributes being edited.

=head2 Wx::RichTextFormattingDialog::GetDialog

   wxRichTextFormattingDialog* GetDialog(wxWindow* win)

   Helper for pages to get the top-level dialog.

=head2 Wx::RichTextFormattingDialog::GetDialogAttributes

   wxTextAttrEx* GetDialogAttributes(wxWindow* win)

   Helper for pages to get the attributes.

=head2 Wx::RichTextFormattingDialog::GetDialogStyleDefinition

   wxRichTextStyleDefinition* GetDialogStyleDefinition(wxWindow* win)

   Helper for pages to get the style.

=head2 Wx::RichTextFormattingDialog::GetFormattingDialogFactory

   wxRichTextFormattingDialogFactory* GetFormattingDialogFactory()

   Returns the object to be used to customize the dialog and provide
   pages.

=head2 Wx::RichTextFormattingDialog::GetImageList

   wxImageList* GetImageList() const

   Returns the image list associated with the dialog, used for example if
   showing the dialog as a toolbook.

=head2 Wx::RichTextFormattingDialog::GetStyle

   bool GetStyle(wxRichTextCtrl* ctrl, const wxRichTextRange& range)

   Gets common attributes from the given range and calls SetAttributes.
   Attributes that do not have common values in the given range will be
   omitted from the style's flags.

=head2 Wx::RichTextFormattingDialog::GetStyleDefinition

   wxRichTextStyleDefinition* GetStyleDefinition() const

   Gets the associated style definition, if any.

=head2 Wx::RichTextFormattingDialog::GetStyleSheet

   wxRichTextStyleSheet* GetStyleSheet() const

   Gets the associated style sheet, if any.

=head2 Wx::RichTextFormattingDialog::SetAttributes

   void SetAttributes(const wxTextAttrEx& attr)

   Sets the attributes to be edited.

=head2 Wx::RichTextFormattingDialog::SetFormattingDialogFactory

   void SetFormattingDialogFactory(wxRichTextFormattingDialogFactory*
   factory)

   Sets the formatting factory object to be used for customization and
   page creation. It deletes the existing factory object.

=head2 Wx::RichTextFormattingDialog::SetImageList

   void SetImageList(wxImageList* imageList)

   Sets the image list associated with the dialog's property sheet.

=head2 Wx::RichTextFormattingDialog::SetStyle

   bool SetStyle(const wxTextAttrEx& style, bool update = true)

   Sets the attributes and optionally updates the display, if update is
   true.

=head2 Wx::RichTextFormattingDialog::SetStyleDefinition

   bool SetStyleDefinition(const wxRichTextStyleDefinition& styleDef,
   wxRichTextStyleSheet* sheet, bool update = true)

   Sets the style definition and optionally update the display, if update
   is true.

=head2 Wx::RichTextFormattingDialog::UpdateDisplay

   bool UpdateDisplay()

   Updates the display.

=head1 Wx::RichTextFormattingDialogFactory

=head2 Wx::RichTextFormattingDialogFactory::new

   wxRichTextFormattingDialogFactory()

   Constructor.

=head2 Wx::RichTextFormattingDialogFactory::DESTROY

   ~wxRichTextFormattingDialogFactory()

   Destructor.

=head2 Wx::RichTextFormattingDialogFactory::CreateButtons

   virtual bool CreateButtons(wxRichTextFormattingDialog* dialog)

   Creates the main dialog buttons.

=head2 Wx::RichTextFormattingDialogFactory::CreatePage

   virtual wxPanel* CreatePage(int page, wxString& title,
   wxRichTextFormattingDialog* dialog)

   Creates a page, given a page identifier.

=head2 Wx::RichTextFormattingDialogFactory::CreatePages

   virtual bool CreatePages(long pages, wxRichTextFormattingDialog*
   dialog)

   Creates all pages under the dialog's book control, also calling
   AddPage.

=head2 Wx::RichTextFormattingDialogFactory::GetPageId

   virtual int GetPageId(int i) const

   Enumerate all available page identifiers.

=head2 Wx::RichTextFormattingDialogFactory::GetPageIdCount

   virtual int GetPageIdCount() const

   Gets the number of available page identifiers.

=head2 Wx::RichTextFormattingDialogFactory::GetPageImage

   virtual int GetPageImage(int id) const

   Gets the image index for the given page identifier.

=head2 Wx::RichTextFormattingDialogFactory::SetSheetStyle

   virtual bool SetSheetStyle(wxRichTextFormattingDialog* dialog)

   Set the property sheet style, called at the start of
   wxRichTextFormattingDialog::Create.

=head2 Wx::RichTextFormattingDialogFactory::ShowHelp

   virtual bool ShowHelp(int page, wxRichTextFormattingDialog* dialog)

   Invokes help for the dialog.

=head1 Wx::RichTextHeaderFooterData

=head2 Wx::RichTextHeaderFooterData::new

   wxRichTextHeaderFooterData()

   wxRichTextHeaderFooterData(const wxRichTextHeaderFooterData& data)

   Constructors.

=head2 Wx::RichTextHeaderFooterData::Clear

   void Clear()

   Clears all text.

=head2 Wx::RichTextHeaderFooterData::Copy

   void Copy(const wxRichTextHeaderFooterData& data)

   Copies the data.

=head2 Wx::RichTextHeaderFooterData::GetFont

   const wxFont& GetFont() const

   Returns the font specified for printing the header and footer.

=head2 Wx::RichTextHeaderFooterData::GetFooterMargin

   int GetFooterMargin() const

   Returns the margin between the text and the footer.

=head2 Wx::RichTextHeaderFooterData::GetFooterText

   wxString GetFooterText(wxRichTextOddEvenPage page =
   wxRICHTEXT_PAGE_EVEN, wxRichTextPageLocation location =
   wxRICHTEXT_PAGE_CENTRE) const

   Returns the footer text on odd or even pages, and at a given position
   on the page (left, centre or right).

=head2 Wx::RichTextHeaderFooterData::GetHeaderMargin

   int GetHeaderMargin() const

   Returns the margin between the text and the header.

=head2 Wx::RichTextHeaderFooterData::GetHeaderText

   wxString GetHeaderText(wxRichTextOddEvenPage page =
   wxRICHTEXT_PAGE_EVEN, wxRichTextPageLocation location =
   wxRICHTEXT_PAGE_CENTRE) const

   Returns the header text on odd or even pages, and at a given position
   on the page (left, centre or right).

=head2 Wx::RichTextHeaderFooterData::GetShowOnFirstPage

   bool GetShowOnFirstPage() const

   Returns true if the header and footer will be shown on the first page.

=head2 Wx::RichTextHeaderFooterData::GetText

   wxString GetText(int headerFooter, wxRichTextOddEvenPage page,
   wxRichTextPageLocation location) const

   Helper function for getting the header or footer text, odd or even
   pages, and at a given position on the page (left, centre or right).

=head2 Wx::RichTextHeaderFooterData::GetTextColour

   const wxColour& GetTextColour() const

   Returns the text colour for drawing the header and footer.

=head2 Wx::RichTextHeaderFooterData::Init

   void Init()

   Initialises the object.

=head2 Wx::RichTextHeaderFooterData::SetFont

   void SetFont(const wxFont& font)

   Sets the font for drawing the header and footer.

=head2 Wx::RichTextHeaderFooterData::SetFooterText

   void SetFooterText(const wxString& text, wxRichTextOddEvenPage page =
   wxRICHTEXT_PAGE_ALL, wxRichTextPageLocation location =
   wxRICHTEXT_PAGE_CENTRE)

   Sets the footer text on odd or even pages, and at a given position on
   the page (left, centre or right).

=head2 Wx::RichTextHeaderFooterData::SetHeaderText

   void SetHeaderText(const wxString& text, wxRichTextOddEvenPage page =
   wxRICHTEXT_PAGE_ALL, wxRichTextPageLocation location =
   wxRICHTEXT_PAGE_CENTRE)

   Sets the header text on odd or even pages, and at a given position on
   the page (left, centre or right).

=head2 Wx::RichTextHeaderFooterData::SetMargins

   void SetMargins(int headerMargin, int footerMargin)

   Sets the margins between text and header or footer, in tenths of a
   millimeter.

=head2 Wx::RichTextHeaderFooterData::SetShowOnFirstPage

   void SetShowOnFirstPage(bool showOnFirstPage)

   Pass true to show the header or footer on first page (the default).

=head2 Wx::RichTextHeaderFooterData::SetText

   void SetText(const wxString& text, int headerFooter,
   wxRichTextOddEvenPage page, wxRichTextPageLocation location)

   Helper function for setting the header or footer text, odd or even
   pages, and at a given position on the page (left, centre or right).

=head2 Wx::RichTextHeaderFooterData::SetTextColour

   void SetTextColour(const wxColour& col)

   Sets the text colour for drawing the header and footer.

=head1 Wx::RichTextHTMLHandler

=head2 Wx::RichTextHTMLHandler::new

   wxRichTextHTMLHandler(const wxString& name = wxT("HTML"), const
   wxString& ext = wxT("html"), int type = wxRICHTEXT_TYPE_HTML)

   Constructor.

=head2 Wx::RichTextHTMLHandler::ClearTemporaryImageLocations

   void ClearTemporaryImageLocations()

   Clears the image locations generated by the last operation.

=head2 Wx::RichTextHTMLHandler::DeleteTemporaryImages

   bool DeleteTemporaryImages()

   Deletes the in-memory or temporary files generated by the last
   operation.

   bool DeleteTemporaryImages(int flags, const wxArrayString&
   imageLocations)

   Delete the in-memory or temporary files generated by the last
   operation. This is a static function that can be used to delete the
   saved locations from an earlier operation, for example after the user
   has viewed the HTML file.

=head2 Wx::RichTextHTMLHandler::DoSaveFile

   bool DoSaveFile(wxRichTextBuffer* buffer, wxOutputStream& stream)

   Saves the buffer content to the HTML stream.

=head2 Wx::RichTextHTMLHandler::GetFontSizeMapping

   wxArrayInt GetFontSizeMapping()

   Returns the mapping for converting point sizes to HTML font sizes.

=head2 Wx::RichTextHTMLHandler::GetTempDir

   const wxString& GetTempDir() const

   Returns the directory used to store temporary image files.

=head2 Wx::RichTextHTMLHandler::GetTemporaryImageLocations

   const wxArrayString& GetTemporaryImageLocations() const

   Returns the image locations for the last operation.

=head2 Wx::RichTextHTMLHandler::SetFileCounter

   void SetFileCounter(int counter)

   Reset the file counter, in case, for example, the same names are
   required each time

=head2 Wx::RichTextHTMLHandler::SetFontSizeMapping

   void SetFontSizeMapping(const wxArrayInt& fontSizeMapping)

   Sets the mapping for converting point sizes to HTML font sizes. There
   should be 7 elements, one for each HTML font size, each element
   specifying the maximum point size for that HTML font size.

   For example:

       wxArrayInt fontSizeMapping;
       fontSizeMapping.Add(7);
       fontSizeMapping.Add(9);
       fontSizeMapping.Add(11);
       fontSizeMapping.Add(12);
       fontSizeMapping.Add(14);
       fontSizeMapping.Add(22);
       fontSizeMapping.Add(100);

=head2 Wx::RichTextHTMLHandler::SetTempDir

   void SetTempDir(const wxString& tempDir)

   Sets the directory for storing temporary files. If empty, the system
   temporary directory will be used.

=head2 Wx::RichTextHTMLHandler::SetTemporaryImageLocations

   void SetTemporaryImageLocations(const wxArrayString& locations)

   Sets the list of image locations generated by the last operation.

=head1 Wx::RichTextListStyleDefinition

=head2 Wx::RichTextListStyleDefinition::new

   wxRichTextListStyleDefinition(const wxString& name = wxEmptyString)

   Constructor.

=head2 Wx::RichTextListStyleDefinition::DESTROY

   ~wxRichTextListStyleDefinition()

   Destructor.

=head2 Wx::RichTextListStyleDefinition::CombineWithParagraphStyle

   wxRichTextAttr CombineWithParagraphStyle(int indent, const
   wxRichTextAttr& paraStyle, wxRichTextStyleSheet* styleSheet = NULL)

   This function combines the given paragraph style with the list style's
   base attributes and level style matching the given indent, returning
   the combined attributes. If styleSheet is specified, the base style
   for this definition will also be included in the result.

=head2 Wx::RichTextListStyleDefinition::FindLevelForIndent

   int FindLevelForIndent(int indent) const

   This function finds the level (from 0 to 9) whose indentation
   attribute mostly closely matches indent (expressed in tenths of a
   millimetre).

=head2 Wx::RichTextListStyleDefinition::GetCombinedStyle

   wxRichTextAttr GetCombinedStyle(int indent, wxRichTextStyleSheet*
   styleSheet = NULL) const

   This function combines the list style's base attributes and the level
   style matching the given indent, returning the combined attributes. If
   styleSheet is specified, the base style for this definition will also
   be included in the result.

=head2 Wx::RichTextListStyleDefinition::GetCombinedStyleForLevel

   wxRichTextAttr GetCombinedStyleLevel(int level, wxRichTextStyleSheet*
   styleSheet = NULL) const

   This function combines the list style's base attributes and the style
   for the specified level, returning the combined attributes. If
   styleSheet is specified, the base style for this definition will also
   be included in the result.

=head2 Wx::RichTextListStyleDefinition::GetLevelAttributes

   const wxRichTextAttr* GetLevelAttributes(int level) const

   Returns the style for the given level. level is a number between 0 and
   9.

=head2 Wx::RichTextListStyleDefinition::GetLevelCount

   int GetLevelCount() const

   Returns the number of levels. This is hard-wired to 10.

   Returns the style for the given level. level is a number between 0 and
   9.

=head2 Wx::RichTextListStyleDefinition::IsNumbered

   int IsNumbered(int level) const

   Returns true if the given level has numbered list attributes.

=head2 Wx::RichTextListStyleDefinition::SetLevelAttributes

   void SetLevelAttributes(int level, const wxRichTextAttr& attr)

   void SetLevelAttributes(int level, int leftIndent, int leftSubIndent,
   int bulletStyle, const wxString& bulletSymbol = wxEmptyString)

   Sets the style for the given level. level is a number between 0 and 9.

   The first and most flexible form uses a wxRichTextAttr object, while
   the second form is for convenient setting of the most commonly-used
   attributes.

=head1 Wx::RichTextParagraphStyleDefinition

=head2 Wx::RichTextParagraphStyleDefinition::new

   wxRichTextParagraphStyleDefinition(const wxString& name =
   wxEmptyString)

   Constructor.

=head2 Wx::RichTextParagraphStyleDefinition::DESTROY

   ~wxRichTextParagraphStyleDefinition()

   Destructor.

=head2 Wx::RichTextParagraphStyleDefinition::GetNextStyle

   const wxString& GetNextStyle() const

   Returns the style that should normally follow this style.

=head2 Wx::RichTextParagraphStyleDefinition::SetNextStyle

   void SetNextStyle(const wxString& name)

   Sets the style that should normally follow this style.

=head1 Wx::RichTextPrinting

=head2 Wx::RichTextPrinting::new

   wxRichTextPrinting(const wxString& name = wxT("Printing"), wxWindow*
   parentWindow = NULL)

   Constructor. Optionally pass a title to be used in the preview frame
   and printing wait dialog, and also a parent window for these windows.

=head2 Wx::RichTextPrinting::GetFooterText

   wxString GetFooterText(wxRichTextOddEvenPage page =
   wxRICHTEXT_PAGE_EVEN, wxRichTextPageLocation location =
   wxRICHTEXT_PAGE_CENTRE) const

   A convenience function to get the footer text. See
   wxRichTextHeaderFooterData for details.

=head2 Wx::RichTextPrinting::GetHeaderFooterData

   const wxRichTextHeaderFooterData& GetHeaderFooterData() const

   Returns the internal wxRichTextHeaderFooterData object.

=head2 Wx::RichTextPrinting::GetHeaderText

   wxString GetHeaderText(wxRichTextOddEvenPage page =
   wxRICHTEXT_PAGE_EVEN, wxRichTextPageLocation location =
   wxRICHTEXT_PAGE_CENTRE) const

   A convenience function to get the header text. See
   wxRichTextHeaderFooterData for details.

=head2 Wx::RichTextPrinting::GetPageSetupData

   wxPageSetupDialogData* GetPageSetupData()

   Returns a pointer to the internal page setup data.

=head2 Wx::RichTextPrinting::GetParentWindow

   wxWindow* GetParentWindow() const

   Returns the parent window to be used for the preview window and
   printing wait dialog.

=head2 Wx::RichTextPrinting::GetPreviewRect

   const wxRect& GetPreviewRect() const

   Returns the dimensions to be used for the preview window.

=head2 Wx::RichTextPrinting::GetPrintData

   wxPrintData* GetPrintData()

   Returns a pointer to the internal print data.

=head2 Wx::RichTextPrinting::GetTitle

   const wxString& GetTitle() const

   Returns the title of the preview window or printing wait caption.

=head2 Wx::RichTextPrinting::PageSetup

   void PageSetup()

   Shows the page setup dialog.

=head2 Wx::RichTextPrinting::PreviewBuffer

   bool PreviewBuffer(const wxRichTextBuffer& buffer)

   Shows a preview window for the given buffer. The function takes its
   own copy of buffer.

=head2 Wx::RichTextPrinting::PreviewFile

   bool PreviewFile(const wxString& richTextFile)

   Shows a preview window for the given file. richTextFile can be a text
   file or XML file, or other file depending on the available file
   handlers.

=head2 Wx::RichTextPrinting::PrintBuffer

   bool PrintBuffer(const wxRichTextBuffer& buffer)

   Prints the given buffer. The function takes its own copy of buffer.

=head2 Wx::RichTextPrinting::PrintFile

   bool PrintFile(const wxString& richTextFile)

   Prints the given file. richTextFile can be a text file or XML file, or
   other file depending on the available file handlers.

=head2 Wx::RichTextPrinting::SetFooterText

   void SetFooterText(const wxString& text, wxRichTextOddEvenPage page =
   wxRICHTEXT_PAGE_ALL, wxRichTextPageLocation location =
   wxRICHTEXT_PAGE_CENTRE)

   A convenience function to set the footer text. See
   wxRichTextHeaderFooterData for details.

=head2 Wx::RichTextPrinting::SetHeaderFooterData

   void SetHeaderFooterData(const wxRichTextHeaderFooterData& data)

   Sets the internal wxRichTextHeaderFooterData object.

=head2 Wx::RichTextPrinting::SetHeaderFooterFont

   void SetHeaderFooterFont(const wxFont& font)

   Sets the wxRichTextHeaderFooterData font.

=head2 Wx::RichTextPrinting::SetHeaderFooterTextColour

   void SetHeaderFooterTextColour(const wxColour& colour)

   Sets the wxRichTextHeaderFooterData text colour.

=head2 Wx::RichTextPrinting::SetHeaderText

   void SetHeaderText(const wxString& text, wxRichTextOddEvenPage page =
   wxRICHTEXT_PAGE_ALL, wxRichTextPageLocation location =
   wxRICHTEXT_PAGE_CENTRE)

   A convenience function to set the header text. See
   wxRichTextHeaderFooterData for details.

=head2 Wx::RichTextPrinting::SetPageSetupData

   void SetPageSetupData(const wxPageSetupData& pageSetupData)

   Sets the page setup data.

=head2 Wx::RichTextPrinting::SetParentWindow

   void SetParentWindow(wxWindow* parent)

   Sets the parent window to be used for the preview window and printing
   wait dialog.

=head2 Wx::RichTextPrinting::SetPreviewRect

   void SetPreviewRect(const wxRect& rect)

   Sets the dimensions to be used for the preview window.

=head2 Wx::RichTextPrinting::SetPrintData

   void SetPrintData(const wxPrintData& printData)

   Sets the print data.

=head2 Wx::RichTextPrinting::SetShowOnFirstPage

   void SetShowOnFirstPage(bool show)

   Pass true to show the header and footer on the first page.

=head2 Wx::RichTextPrinting::SetTitle

   void SetTitle(const wxString& title)

   Pass the title of the preview window or printing wait caption.

=head1 Wx::RichTextPrintout

=head2 Wx::RichTextPrintout::new

   wxRichTextPrintout(const wxString& title = wxT("Printout"))

   Constructor.

=head2 Wx::RichTextPrintout::CalculateScaling

   void CalculateScaling(wxDC* dc, wxRect& textRect, wxRect& headerRect,
   wxRect& footerRect)

   Calculates scaling and text, header and footer rectangles.

=head2 Wx::RichTextPrintout::GetHeaderFooterData

   const wxRichTextHeaderFooterData& GetHeaderFooterData() const

   Returns the header and footer data associated with the printout.

=head2 Wx::RichTextPrintout::GetPageInfo

   void GetPageInfo(int* minPage, int* maxPage, int* selPageFrom, int*
   selPageTo)

   Gets the page information.

=head2 Wx::RichTextPrintout::GetRichTextBuffer

   wxRichTextBuffer* GetRichTextBuffer() const

   Returns a pointer to the buffer being rendered.

=head2 Wx::RichTextPrintout::HasPage

   bool HasPage(int page)

   Returns true if the given page exists in the printout.

=head2 Wx::RichTextPrintout::OnPreparePrinting

   void OnPreparePrinting()

   Prepares for printing, laying out the buffer and calculating
   pagination.

=head2 Wx::RichTextPrintout::OnPrintPage

   bool OnPrintPage(int page)

   Does the actual printing for this page.

=head2 Wx::RichTextPrintout::SetHeaderFooterData

   void SetHeaderFooterData(const wxRichTextHeaderFooterData& data)

   Sets the header and footer data associated with the printout.

=head2 Wx::RichTextPrintout::SetMargins

   void SetMargins(int top = 252, int bottom = 252, int left = 252, int
   right = 252)

   Sets margins in 10ths of millimetre. Defaults to 1 inch for margins.

=head2 Wx::RichTextPrintout::SetRichTextBuffer

   void SetRichTextBuffer(wxRichTextBuffer* buffer)

   Sets the buffer to print. wxRichTextPrintout does not manage this
   pointer; it should be managed by the calling code, such as
   wxRichTextPrinting.

=head1 Wx::RichTextRange

=head2 Wx::RichTextRange::new

   wxRichTextRange(long start, long end)

   wxRichTextRange(const wxRichTextRange& range)

   wxRichTextRange()

   Constructors.

=head2 Wx::RichTextRange::DESTROY

   ~wxRichTextRange()

   Destructor.

=head2 Wx::RichTextRange::Contains

   bool Contains(long pos) const

   Returns true if the given position is within this range. Does not
   match if the range is empty.

=head2 Wx::RichTextRange::GetEnd

   long GetEnd() const

   Returns the end position.

=head2 Wx::RichTextRange::GetLength

   long GetLength() const

   Returns the length of the range.

=head2 Wx::RichTextRange::GetStart

   long GetStart() const

   Returns the start of the range.

=head2 Wx::RichTextRange::FromInternal

   wxRichTextRange FromInternal() const

   Converts the internal range, which uses the first and last character
   positions of the range, to the API-standard range, whose end is one
   past the last character in the range. In other words, one is added to
   the end position.

=head2 Wx::RichTextRange::IsOutside

   bool IsOutside(const wxRichTextRange& range) const

   Returns true if this range is completely outside range.

=head2 Wx::RichTextRange::IsWithin

   bool IsWithin(const wxRichTextRange& range) const

   Returns true if this range is completely within range.

=head2 Wx::RichTextRange::LimitTo

   bool LimitTo(const wxRichTextRange& range)

   Limits this range to be within range.

=head2 Wx::RichTextRange::SetEnd

   void SetEnd(long end)

   Sets the end of the range.

=head2 Wx::RichTextRange::SetRange

   void SetRange(long start, long end)

   Sets the range.

=head2 Wx::RichTextRange::SetStart

   void SetStart(long start)

   Sets the start of the range.

=head2 Wx::RichTextRange::Swap

   void Swap()

   Swaps the start and end.

=head2 Wx::RichTextRange::ToInternal

   wxRichTextRange ToInternal() const

   Converts the API-standard range, whose end is one past the last
   character in the range, to the internal form, which uses the first and
   last character positions of the range. In other words, one is
   subtracted from the end position.

=head1 Wx::RichTextStyleDefinition

=head2 Wx::RichTextStyleDefinition::new

   wxRichTextStyleDefinition(const wxString& name = wxEmptyString)

   Constructor.

=head2 Wx::RichTextStyleDefinition::DESTROY

   ~wxRichTextStyleDefinition()

   Destructor.

=head2 Wx::RichTextStyleDefinition::GetBaseStyle

   const wxString& GetBaseStyle() const

   Returns the style on which this style is based.

=head2 Wx::RichTextStyleDefinition::GetDescription

   const wxString& GetDescription() const

   Returns the style's description.

=head2 Wx::RichTextStyleDefinition::GetName

   const wxString& GetName() const

   Returns the style name.

=head2 Wx::RichTextStyleDefinition::GetStyle

   wxRichTextAttr& GetStyle()

   const wxRichTextAttr& GetStyle() const

   Returns the attributes associated with this style.

=head2 Wx::RichTextStyleDefinition::GetStyleMergedWithBase

   wxRichTextAttr GetStyleMergedWithBase(wxRichTextStyleSheet* sheet)
   const

   Returns the style attributes combined with the attributes of the
   specified base style, if any. This function works recursively.

=head2 Wx::RichTextStyleDefinition::SetBaseStyle

   void SetBaseStyle(const wxString& name)

   Sets the name of the style that this style is based on.

=head2 Wx::RichTextStyleDefinition::SetDescription

   void SetDescription(const wxString& descr)

   Sets the style description.

=head2 Wx::RichTextStyleDefinition::SetName

   void SetName(const wxString& name)

   Sets the name of the style.

=head2 Wx::RichTextStyleDefinition::SetStyle

   void SetStyle(const wxRichTextAttr& style)

   Sets the attributes for this style.

=head1 Wx::RichTextStyleComboCtrl

=head2 Wx::RichTextStyleComboCtrl::new

   wxRichTextStyleComboCtrl(wxWindow* parent, wxWindowID id = wxID_ANY,
   const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = 0)

   Constructor.

=head2 Wx::RichTextStyleComboCtrl::DESTROY

   ~wxRichTextStyleComboCtrl()

   Destructor.

=head2 Wx::RichTextStyleComboCtrl::GetRichTextCtrl

   wxRichTextCtrl* GetRichTextCtrl() const

   Returns the wxRichTextCtrl associated with this control.

=head2 Wx::RichTextStyleComboCtrl::GetStyleSheet

   wxRichTextStyleSheet* GetStyleSheet() const

   Returns the style sheet associated with this control.

=head2 Wx::RichTextStyleComboCtrl::SetRichTextCtrl

   void SetRichTextCtrl(wxRichTextCtrl* ctrl)

   Associates the control with a wxRichTextCtrl.

=head2 Wx::RichTextStyleComboCtrl::SetStyleSheet

   void SetStyleSheet(wxRichTextStyleSheet* styleSheet)

   Associates the control with a style sheet.

=head2 Wx::RichTextStyleComboCtrl::UpdateStyles

   void UpdateStyles()

   Updates the combo control from the associated style sheet.

=head1 Wx::RichTextStyleListBox

=head2 Wx::RichTextStyleListBox::new

   wxRichTextStyleListBox(wxWindow* parent, wxWindowID id = wxID_ANY,
   const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = 0)

   Constructor.

=head2 Wx::RichTextStyleListBox::DESTROY

   ~wxRichTextStyleListBox()

   Destructor.

=head2 Wx::RichTextStyleListBox::ApplyStyle

   void ApplyStyle(int i)

   Applies the ith style to the associated rich text control.

=head2 Wx::RichTextStyleListBox::ConvertTenthsMMToPixels

   int ConvertTenthsMMToPixels(wxDC& dc, int units) const

   Converts units in tenths of a millimetre to device units.

=head2 Wx::RichTextStyleListBox::CreateHTML

   wxString CreateHTML(wxRichTextStyleDefinition* def) const

   Creates a suitable HTML fragment for a definition.

=head2 Wx::RichTextStyleListBox::GetApplyOnSelection

   bool GetApplyOnSelection() const

   If the return value is true, clicking on a style name in the list will
   immediately apply the style to the associated rich text control.

=head2 Wx::RichTextStyleListBox::GetRichTextCtrl

   wxRichTextCtrl* GetRichTextCtrl() const

   Returns the wxRichTextCtrl associated with this listbox.

=head2 Wx::RichTextStyleListBox::GetStyle

   wxRichTextStyleDefinition* GetStyle(size_t i) const

   Gets a style for a listbox index.

=head2 Wx::RichTextStyleListBox::GetStyleSheet

   wxRichTextStyleSheet* GetStyleSheet() const

   Returns the style sheet associated with this listbox.

=head2 Wx::RichTextStyleListBox::GetStyleType

   wxRichTextStyleListBox::wxRichTextStyleType GetStyleType() const

   Returns the type of style to show in the list box.

=head2 Wx::RichTextStyleListBox::OnGetItem

   wxString OnGetItem(size_t n) const

   Returns the HTML for this item.

=head2 Wx::RichTextStyleListBox::OnLeftDown

   void OnLeftDown(wxMouseEvent& event)

   Implements left click behaviour, applying the clicked style to the
   wxRichTextCtrl.

=head2 Wx::RichTextStyleListBox::OnSelect

   void OnSelect(wxCommandEvent& event)

   Reacts to selection.

=head2 Wx::RichTextStyleListBox::SetApplyOnSelection

   void SetApplyOnSelection(bool applyOnSelection)

   If applyOnSelection is true, clicking on a style name in the list will
   immediately apply the style to the associated rich text control.

=head2 Wx::RichTextStyleListBox::SetRichTextCtrl

   void SetRichTextCtrl(wxRichTextCtrl* ctrl)

   Associates the listbox with a wxRichTextCtrl.

=head2 Wx::RichTextStyleListBox::SetStyleSheet

   void SetStyleSheet(wxRichTextStyleSheet* styleSheet)

   Associates the control with a style sheet.

=head2 Wx::RichTextStyleListBox::SetStyleType

   void SetStyleType(wxRichTextStyleListBox::wxRichTextStyleType
   styleType)

   Sets the style type to display. One of
   wxRichTextStyleListBox::wxRICHTEXT_STYLE_ALL,
   wxRichTextStyleListBox::wxRICHTEXT_STYLE_PARAGRAPH,
   wxRichTextStyleListBox::wxRICHTEXT_STYLE_CHARACTER and
   wxRichTextStyleListBox::wxRICHTEXT_STYLE_LIST.

=head2 Wx::RichTextStyleListBox::UpdateStyles

   void UpdateStyles()

   Updates the list from the associated style sheet.

=head1 Wx::RichTextStyleListCtrl

=head2 Wx::RichTextStyleListCtrl::new

   wxRichTextStyleListCtrl(wxWindow* parent, wxWindowID id = wxID_ANY,
   const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = 0)

   wxRichTextStyleListCtrl()

   Constructors.

=head2 Wx::RichTextStyleListCtrl::Create

   bool Create(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint&
   pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long
   style = 0)

   Creates the windows.

=head2 Wx::RichTextStyleListCtrl::GetRichTextCtrl

   wxRichTextCtrl* GetRichTextCtrl() const

   Returns the associated rich text control, if any.

=head2 Wx::RichTextStyleListCtrl::GetStyleChoice

   wxChoice* GetStyleChoice() const

   Returns the wxChoice control used for selecting the style category.

=head2 Wx::RichTextStyleListCtrl::GetStyleListBox

   wxRichTextStyleListBox* GetStyleListBox() const

   Returns the wxListBox control used to view the style list.

=head2 Wx::RichTextStyleListCtrl::GetStyleSheet

   wxRichTextStyleSheet* GetStyleSheet() const

   Returns the associated style sheet, if any.

=head2 Wx::RichTextStyleListCtrl::GetStyleType

   wxRichTextStyleListBox::wxRichTextStyleType GetStyleType() const

   Returns the type of style to show in the list box.

=head2 Wx::RichTextStyleListCtrl::SetRichTextCtrl

   void SetRichTextCtrl(wxRichTextCtrl* ctrl)

   Associates the control with a wxRichTextCtrl.

=head2 Wx::RichTextStyleListCtrl::SetStyleSheet

   void SetStyleSheet(wxRichTextStyleSheet* styleSheet)

   Associates the control with a style sheet.

=head2 Wx::RichTextStyleListCtrl::SetStyleType

   void SetStyleType(wxRichTextStyleListBox::wxRichTextStyleType
   styleType)

   Sets the style type to display. One of
   wxRichTextStyleListBox::wxRICHTEXT_STYLE_ALL,
   wxRichTextStyleListBox::wxRICHTEXT_STYLE_PARAGRAPH,
   wxRichTextStyleListBox::wxRICHTEXT_STYLE_CHARACTER and
   wxRichTextStyleListBox::wxRICHTEXT_STYLE_LIST.

=head2 Wx::RichTextStyleListCtrl::UpdateStyles

   void UpdateStyles()

   Updates the style list box.

=head1 Wx::RichTextStyleOrganiserDialog

=head2 Wx::RichTextStyleOrganiserDialog::new

   wxRichTextStyleOrganiserDialog(int flags, wxRichTextStyleSheet* sheet,
   wxRichTextCtrl* ctrl, wxWindow* parent, wxWindowID id = wxID_ANY,
   const wxString& caption = _("Style Organiser"), const wxPoint& pos =
   wxDefaultPosition, const wxSize& size = wxDefaultSize, long style =
   wxDEFAULT_DIALOG_STYLE|wxRESIZE_BORDER|wxSYSTEM_MENU|wxCLOSE_BOX)

   wxRichTextStyleOrganiserDialog()

   Constructors.

   To create a dialog, pass a bitlist of flags (see below), a style
   sheet, a text control to apply a selected style to (or NULL), followed
   by the usual window parameters.

   To specify the operations available to the user, pass a combination of
   these values to flags:

=head2 Wx::RichTextStyleOrganiserDialog::ApplyStyle

   bool ApplyStyle(wxRichTextCtrl* ctrl = NULL)

   Applies the selected style to selection in the given control or the
   control passed to the constructor.

=head2 Wx::RichTextStyleOrganiserDialog::new

wxrichtextstyleorganiserdialogwxrichtextstyleorganiserdialog for details.

=head2 Wx::RichTextStyleOrganiserDialog::GetFlags

   int GetFlags() const

   Returns the flags used to control the interface presented to the user.

=head2 Wx::RichTextStyleOrganiserDialog::GetRestartNumbering

   bool GetRestartNumbering() const

   Returns true if the user has opted to restart numbering.

=head2 Wx::RichTextStyleOrganiserDialog::GetRichTextCtrl

   wxRichTextCtrl* GetRichTextCtrl() const

   Returns the associated rich text control (if any).

=head2 Wx::RichTextStyleOrganiserDialog::GetSelectedStyle

   wxString GetSelectedStyle() const

   Returns selected style name.

=head2 Wx::RichTextStyleOrganiserDialog::GetSelectedStyleDefinition

   wxRichTextStyleDefinition* GetSelectedStyleDefinition() const

   Returns selected style definition.

=head2 Wx::RichTextStyleOrganiserDialog::GetStyleSheet

   wxRichTextStyleSheet* GetStyleSheet() const

   Returns the associated style sheet.

=head2 Wx::RichTextStyleOrganiserDialog::SetFlags

   void SetFlags(int flags)

   Sets the flags used to control the interface presented to the user.

=head2 Wx::RichTextStyleOrganiserDialog::SetRestartNumbering

   void SetRestartNumbering(bool restartNumbering)

   Checks or unchecks the restart numbering checkbox.

=head2 Wx::RichTextStyleOrganiserDialog::SetRichTextCtrl

   void SetRichTextCtrl(wxRichTextCtrl* ctrl)

   Sets the control to be associated with the dialog, for the purposes of
   applying a style to the selection.

=head2 Wx::RichTextStyleOrganiserDialog::SetShowToolTips

   void SetShowToolTips(bool show)

   Determines whether tooltips will be shown.

=head2 Wx::RichTextStyleOrganiserDialog::SetStyleSheet

   void SetStyleSheet(wxRichTextStyleSheet* sheet)

   Sets the associated style sheet.

=head1 Wx::RichTextStyleSheet

=head2 Wx::RichTextStyleSheet::new

   wxRichTextStyleSheet()

   Constructor.

=head2 Wx::RichTextStyleSheet::DESTROY

   ~wxRichTextStyleSheet()

   Destructor.

=head2 Wx::RichTextStyleSheet::AddCharacterStyle

   bool AddCharacterStyle(wxRichTextCharacterStyleDefinition* def)

   Adds a definition to the character style list.

=head2 Wx::RichTextStyleSheet::AddListStyle

   bool AddListStyle(wxRichTextListStyleDefinition* def)

   Adds a definition to the list style list.

=head2 Wx::RichTextStyleSheet::AddParagraphStyle

   bool AddParagraphStyle(wxRichTextParagraphStyleDefinition* def)

   Adds a definition to the paragraph style list.

=head2 Wx::RichTextStyleSheet::AddStyle

   bool AddStyle(wxRichTextStyleDefinition* def)

   Adds a definition to the appropriate style list.

=head2 Wx::RichTextStyleSheet::DeleteStyles

   void DeleteStyles()

   Deletes all styles.

=head2 Wx::RichTextStyleSheet::FindCharacterStyle

   wxRichTextCharacterStyleDefinition* FindCharacterStyle(const wxString&
   name) const

   Finds a character definition by name.

=head2 Wx::RichTextStyleSheet::FindListStyle

   wxRichTextListStyleDefinition* FindListStyle(const wxString& name)
   const

   Finds a list definition by name.

=head2 Wx::RichTextStyleSheet::FindParagraphStyle

   wxRichTextParagraphStyleDefinition* FindParagraphStyle(const wxString&
   name) const

   Finds a paragraph definition by name.

=head2 Wx::RichTextStyleSheet::FindStyle

   wxRichTextStyleDefinition* FindStyle(const wxString& name) const

   Finds a style definition by name.

=head2 Wx::RichTextStyleSheet::GetCharacterStyle

   wxRichTextCharacterStyleDefinition* GetCharacterStyle(size_t n) const

   Returns the nth character style.

=head2 Wx::RichTextStyleSheet::GetCharacterStyleCount

   size_t GetCharacterStyleCount() const

   Returns the number of character styles.

=head2 Wx::RichTextStyleSheet::GetDescription

   const wxString& GetDescription() const

   Returns the style sheet's description.

=head2 Wx::RichTextStyleSheet::GetListStyle

   wxRichTextListStyleDefinition* GetListStyle(size_t n) const

   Returns the nth list style.

=head2 Wx::RichTextStyleSheet::GetListStyleCount

   size_t GetListStyleCount() const

   Returns the number of list styles.

=head2 Wx::RichTextStyleSheet::GetName

   const wxString& GetName() const

   Returns the style sheet's name.

=head2 Wx::RichTextStyleSheet::GetParagraphStyle

   wxRichTextParagraphStyleDefinition* GetParagraphStyle(size_t n) const

   Returns the nth paragraph style.

=head2 Wx::RichTextStyleSheet::GetParagraphStyleCount

   size_t GetParagraphStyleCount() const

   Returns the number of paragraph styles.

=head2 Wx::RichTextStyleSheet::RemoveCharacterStyle

   bool RemoveCharacterStyle(wxRichTextStyleDefinition* def, bool
   deleteStyle = false)

   Removes a character style.

=head2 Wx::RichTextStyleSheet::RemoveListStyle

   bool RemoveListStyle(wxRichTextStyleDefinition* def, bool deleteStyle
   = false)

   Removes a list style.

=head2 Wx::RichTextStyleSheet::RemoveParagraphStyle

   bool RemoveParagraphStyle(wxRichTextStyleDefinition* def, bool
   deleteStyle = false)

   Removes a paragraph style.

=head2 Wx::RichTextStyleSheet::RemoveStyle

   bool RemoveStyle(wxRichTextStyleDefinition* def, bool deleteStyle =
   false)

   Removes a style.

=head2 Wx::RichTextStyleSheet::SetDescription

   void SetDescription(const wxString& descr)

   Sets the style sheet's description.

=head2 Wx::RichTextStyleSheet::SetName

   void SetName(const wxString& name)

   Sets the style sheet's name.

=head1 Wx::RichTextXMLHandler

=head2 Wx::RichTextXMLHandler::new

   wxRichTextXMLHandler(const wxString& name = wxT("XML"), const wxString&
   ext = wxT("xml"), int type = wxRICHTEXT_TYPE_XML)

   Constructor.

=head2 Wx::RichTextXMLHandler::CanLoad

   bool CanLoad() const

   Returns true.

=head2 Wx::RichTextXMLHandler::CanSave

   bool CanSave() const

   Returns true.

=head2 Wx::RichTextXMLHandler::CreateStyle

   wxString CreateStyle(const wxTextAttrEx& attr, bool isPara = false)

   Creates XML code for a given character or paragraph style.

=head2 Wx::RichTextXMLHandler::DoLoadFile

   bool DoLoadFile(wxRichTextBuffer* buffer, wxInputStream& stream)

   Loads buffer context from the given stream.

=head2 Wx::RichTextXMLHandler::DoSaveFile

   bool DoSaveFile(wxRichTextBuffer* buffer, wxOutputStream& stream)

   Saves buffer context to the given stream.

=head2 Wx::RichTextXMLHandler::ExportXML

   bool ExportXML(wxOutputStream& stream, wxMBConv* convMem, wxMBConv*
   convFile, wxRichTextObject& obj, int level)

   Recursively exports an object to the stream.

=head2 Wx::RichTextXMLHandler::GetNodeContent

   wxString GetNodeContent(wxXmlNode* node)

   Helper function: gets node context.

=head2 Wx::RichTextXMLHandler::GetParamNode

   wxXmlNode* GetParamNode(wxXmlNode* node, const wxString& param)

   Helper function: gets a named parameter from the XML node.

=head2 Wx::RichTextXMLHandler::GetParamValue

   wxString GetParamValue(wxXmlNode* node, const wxString& param)

   Helper function: gets a named parameter from the XML node.

=head2 Wx::RichTextXMLHandler::GetStyle

   bool GetStyle(wxTextAttrEx& attr, wxXmlNode* node, bool isPara = false)

   Helper function: gets style parameters from the given XML node.

=head2 Wx::RichTextXMLHandler::GetText

   wxString GetText(wxXmlNode* node, const wxString& param =
   wxEmptyString, bool translate = false)

   Helper function: gets text from the node.

=head2 Wx::RichTextXMLHandler::HasParam

   bool HasParam(wxXmlNode* node, const wxString& param)

   Helper function: returns true if the node has the given parameter.

=head2 Wx::RichTextXMLHandler::ImportXML

   bool ImportXML(wxRichTextBuffer* buffer, wxXmlNode* node)

   Recursively imports an object.

=head1 Wx::SashEvent

=head2 Wx::SashEvent::new

   wxSashEvent(int id = 0, wxSashEdgePosition edge = wxSASH_NONE)

   Constructor.

=head2 Wx::SashEvent::GetEdge

   wxSashEdgePosition GetEdge() const

   Returns the dragged edge. The return value is one of wxSASH_TOP,
   wxSASH_RIGHT, wxSASH_BOTTOM, wxSASH_LEFT.

=head2 Wx::SashEvent::GetDragRect

   wxRect GetDragRect() const

   Returns the rectangle representing the new size the window would be if
   the resize was applied. It is up to the application to set the window
   size if required.

=head2 Wx::SashEvent::GetDragStatus

   wxSashDragStatus GetDragStatus() const

   Returns the status of the sash: one of wxSASH_STATUS_OK,
   wxSASH_STATUS_OUT_OF_RANGE. If the drag caused the notional bounding
   box of the window to flip over, for example, the drag will be out of
   rage.

=head1 Wx::SashLayoutWindow

=head2 Wx::SashLayoutWindow::new

   wxSashLayoutWindow()

   Default constructor.

   wxSashLayoutWindow(wxSashLayoutWindow* parent, wxWindowID id, const
   wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
   long style = wxCLIP_CHILDREN | wxSW_3D, const wxString& name =
   "layoutWindow")

   Constructs a sash layout window, which can be a child of a frame,
   dialog or any other non-control window.

   Parameters

   parent

       Pointer to a parent window.

   id  

       Window identifier. If -1, will automatically create an identifier.

   pos 

       Window position. wxDefaultPosition is (-1, -1) which indicates
       that wxSashLayoutWindows should generate a default position for
       the window. If using the wxSashLayoutWindow class directly, supply
       an actual position.

   size

       Window size. wxDefaultSize is (-1, -1) which indicates that
       wxSashLayoutWindows should generate a default size for the window.

   style

       Window style. For window styles, please see wxSashLayoutWindow.

   name

       Window name.

=head2 Wx::SashLayoutWindow::Create

   bool Create(wxSashLayoutWindow* parent, wxWindowID id, const wxPoint&
   pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long
   style = wxCLIP_CHILDREN | wxSW_3D, const wxString& name =
   "layoutWindow")

   Initializes a sash layout window, which can be a child of a frame,
   dialog or any other non-control window.

   Parameters

   parent

       Pointer to a parent window.

   id  

       Window identifier. If -1, will automatically create an identifier.

   pos 

       Window position. wxDefaultPosition is (-1, -1) which indicates
       that wxSashLayoutWindows should generate a default position for
       the window. If using the wxSashLayoutWindow class directly, supply
       an actual position.

   size

       Window size. wxDefaultSize is (-1, -1) which indicates that
       wxSashLayoutWindows should generate a default size for the window.

   style

       Window style. For window styles, please see wxSashLayoutWindow.

   name

       Window name.

=head2 Wx::SashLayoutWindow::GetAlignment

   wxLayoutAlignment GetAlignment() const

   Returns the alignment of the window: one of wxLAYOUT_TOP,
   wxLAYOUT_LEFT, wxLAYOUT_RIGHT, wxLAYOUT_BOTTOM.

=head2 Wx::SashLayoutWindow::GetOrientation

   wxLayoutOrientation GetOrientation() const

   Returns the orientation of the window: one of wxLAYOUT_HORIZONTAL,
   wxLAYOUT_VERTICAL.

=head2 Wx::SashLayoutWindow::OnCalculateLayout

   void OnCalculateLayout(wxCalculateLayoutEvent& event)

   The default handler for the event that is generated by
   wxLayoutAlgorithm. The implementation of this function calls
   wxCalculateLayoutEvent::SetRect to shrink the provided size according
   to how much space this window takes up. For further details, see
   wxLayoutAlgorithm and wxCalculateLayoutEvent.

=head2 Wx::SashLayoutWindow::OnQueryLayoutInfo

   void OnQueryLayoutInfo(wxQueryLayoutInfoEvent& event)

   The default handler for the event that is generated by
   OnCalculateLayout to get size, alignment and orientation information
   for the window. The implementation of this function uses member
   variables as set by accessors called by the application. For further
   details, see wxLayoutAlgorithm and wxQueryLayoutInfoEvent.

=head2 Wx::SashLayoutWindow::SetAlignment

   void SetAlignment(wxLayoutAlignment alignment)

   Sets the alignment of the window (which edge of the available parent
   client area the window is attached to). alignment is one of
   wxLAYOUT_TOP, wxLAYOUT_LEFT, wxLAYOUT_RIGHT, wxLAYOUT_BOTTOM.

=head2 Wx::SashLayoutWindow::SetDefaultSize

   void SetDefaultSize(const wxSize& size)

   Sets the default dimensions of the window. The dimension other than
   the orientation will be fixed to this value, and the orientation
   dimension will be ignored and the window stretched to fit the
   available space.

=head2 Wx::SashLayoutWindow::SetOrientation

   void SetOrientation(wxLayoutOrientation orientation)

   Sets the orientation of the window (the direction the window will
   stretch in, to fill the available parent client area). orientation is
   one of wxLAYOUT_HORIZONTAL, wxLAYOUT_VERTICAL.

=head1 Wx::SashWindow

=head2 Wx::SashWindow::new

   wxSashWindow()

   Default constructor.

   wxSashWindow(wxWindow* parent, wxWindowID id, const wxPoint& pos =
   wxDefaultPosition, const wxSize& size = wxDefaultSize, long style =
   wxCLIP_CHILDREN | wxSW_3D, const wxString& name = "sashWindow")

   Constructs a sash window, which can be a child of a frame, dialog or
   any other non-control window.

   Parameters

   parent

       Pointer to a parent window.

   id  

       Window identifier. If -1, will automatically create an identifier.

   pos 

       Window position. wxDefaultPosition is (-1, -1) which indicates
       that wxSashWindows should generate a default position for the
       window. If using the wxSashWindow class directly, supply an actual
       position.

   size

       Window size. wxDefaultSize is (-1, -1) which indicates that
       wxSashWindows should generate a default size for the window.

   style

       Window style. For window styles, please see wxSashWindow.

   name

       Window name.

=head2 Wx::SashWindow::DESTROY

   ~wxSashWindow()

   Destructor.

=head2 Wx::SashWindow::GetSashVisible

   bool GetSashVisible(wxSashEdgePosition edge) const

   Returns true if a sash is visible on the given edge, false otherwise.

   Parameters

   edge

       Edge. One of wxSASH_TOP, wxSASH_RIGHT, wxSASH_BOTTOM, wxSASH_LEFT.

   See also

   wxSashWindow::SetSashVisible

=head2 Wx::SashWindow::GetMaximumSizeX

   int GetMaximumSizeX() const

   Gets the maximum window size in the x direction.

=head2 Wx::SashWindow::GetMaximumSizeY

   int GetMaximumSizeY() const

   Gets the maximum window size in the y direction.

=head2 Wx::SashWindow::GetMinimumSizeX

   int GetMinimumSizeX()

   Gets the minimum window size in the x direction.

=head2 Wx::SashWindow::GetMinimumSizeY

   int GetMinimumSizeY() const

   Gets the minimum window size in the y direction.

=head2 Wx::SashWindow::HasBorder

   bool HasBorder(wxSashEdgePosition edge) const

   Returns true if the sash has a border, false otherwise. This function
   is obsolete since the sash border property is unused.

   Parameters

   edge

       Edge. One of wxSASH_TOP, wxSASH_RIGHT, wxSASH_BOTTOM, wxSASH_LEFT.

   See also

   wxSashWindow::SetSashBorder

=head2 Wx::SashWindow::SetMaximumSizeX

   void SetMaximumSizeX(int min)

   Sets the maximum window size in the x direction.

=head2 Wx::SashWindow::SetMaximumSizeY

   void SetMaximumSizeY(int min)

   Sets the maximum window size in the y direction.

=head2 Wx::SashWindow::SetMinimumSizeX

   void SetMinimumSizeX(int min)

   Sets the minimum window size in the x direction.

=head2 Wx::SashWindow::SetMinimumSizeY

   void SetMinimumSizeY(int min)

   Sets the minimum window size in the y direction.

=head2 Wx::SashWindow::SetSashVisible

   void SetSashVisible(wxSashEdgePosition edge, bool visible)

   Call this function to make a sash visible or invisible on a particular
   edge.

   Parameters

   edge

       Edge to change. One of wxSASH_TOP, wxSASH_RIGHT, wxSASH_BOTTOM,
       wxSASH_LEFT.

   visible

       true to make the sash visible, false to make it invisible.

   See also

   wxSashWindow::GetSashVisible

=head2 Wx::SashWindow::SetSashBorder

   void SetSashBorder(wxSashEdgePosition edge, bool hasBorder)

   Call this function to give the sash a border, or remove the border.
   This function is obsolete since the sash border property is unused.

   Parameters

   edge

       Edge to change. One of wxSASH_TOP, wxSASH_RIGHT, wxSASH_BOTTOM,
       wxSASH_LEFT.

   hasBorder

       true to give the sash a border visible, false to remove it.

   See also

   wxSashWindow::HasBorder

=head1 Wx::ScopedArray

=head2 Wx::ScopedArray::new

   wxScopedArray(type * T = NULL)

   Creates the smart pointer with the given pointer or none if NULL. On
   compilers that support it, this uses the explicit keyword.

=head2 Wx::ScopedArray::reset

   reset(T p * = NULL)

   Deletes the currently held pointer and sets it to 'p' or to NULL if no
   arguments are specified. This function does check to make sure that
   the pointer you are assigning is not the same pointer that is already
   stored.

=head2 Wx::ScopedArray::get

   const T* get()

   This operator gets the pointer stored in the smart pointer or returns
   NULL if there is none.

=head2 Wx::ScopedArray::swap

   swap(wxScopedPtr & ot)

   Swap the pointer inside the smart pointer with 'ot'. The pointer being
   swapped must be of the same type (hence the same class name).

=head1 Wx::ScopedPtr

=head2 Wx::ScopedPtr::new

   explicit wxScopedPtr(type * T = NULL)

   Creates the smart pointer with the given pointer or none if NULL. On
   compilers that support it, this uses the explicit keyword.

=head2 Wx::ScopedPtr::DESTROY

   ~wxScopedPtr()

   Destructor frees the pointer help by this object if it is not NULL.

=head2 Wx::ScopedPtr::release

   T * release()

   Returns the currently hold pointer and resets the smart pointer object
   to NULL. After a call to this function the caller is responsible for
   deleting the pointer.

=head2 Wx::ScopedPtr::reset

   reset(T p * = NULL)

   Deletes the currently held pointer and sets it to p or to NULL if no
   arguments are specified. This function does check to make sure that
   the pointer you are assigning is not the same pointer that is already
   stored.

=head2 Wx::ScopedPtr::get

   const T* get()

   This operator gets the pointer stored in the smart pointer or returns
   NULL if there is none.

=head2 Wx::ScopedPtr::swap

   swap(wxScopedPtr & other)

   Swap the pointer inside the smart pointer with other. The pointer
   being swapped must be of the same type (hence the same class name).

=head1 Wx::ScopedTiedPtr

=head2 Wx::ScopedTiedPtr::new

   wxScopedTiedPtr(T **ppTie, T *ptr)

   Constructor creates a smart pointer initialized with ptr and stores
   ptr in the location specified by ppTie which must not be NULL.

=head2 Wx::ScopedTiedPtr::DESTROY

   ~wxScopedTiedPtr()

   Destructor frees the pointer help by this object and restores the
   value stored at the tied location (as specified in the constructor) to
   the old value.

   Warning: this location may now contain an uninitialized value if it
   hadn't been initialized previously, in particular don't count on it
   magically being NULL!

=head1 Wx::ScreenDC

=head2 Wx::ScreenDC::new

   wxScreenDC()

   Constructor.

=head2 Wx::ScreenDC::StartDrawingOnTop

   bool StartDrawingOnTop(wxWindow* window)

   bool StartDrawingOnTop(wxRect* rect = NULL)

   Use this in conjunction with EndDrawingOnTop to ensure that drawing to
   the screen occurs on top of existing windows. Without this, some
   window systems (such as X) only allow drawing to take place underneath
   other windows.

   By using the first form of this function, an application is specifying
   that the area that will be drawn on coincides with the given window.

   By using the second form, an application can specify an area of the
   screen which is to be drawn on. If NULL is passed, the whole screen is
   available.

   It is recommended that an area of the screen is specified because with
   large regions, flickering effects are noticeable when destroying the
   temporary transparent window used to implement this feature.

   You might use this pair of functions when implementing a drag feature,
   for example as in the wxSplitterWindow implementation.

   Remarks

   This function is probably obsolete since the X implementations allow
   drawing directly on the screen now. However, the fact that this
   function allows the screen to be refreshed afterwards, may be useful
   to some applications.

=head2 Wx::ScreenDC::EndDrawingOnTop

   bool EndDrawingOnTop()

   Use this in conjunction with StartDrawingOnTop.

   This function destroys the temporary window created to implement
   on-top drawing (X only).

=head1 Wx::ScrollBar

=head2 Wx::ScrollBar::new

   wxScrollBar()

   Default constructor.

   wxScrollBar(wxWindow* parent, wxWindowID id, const wxPoint& pos =
   wxDefaultPosition, const wxSize& size = wxDefaultSize, long style =
   wxSB_HORIZONTAL, const wxValidator& validator = wxDefaultValidator,
   const wxString& name = "scrollBar")

   Constructor, creating and showing a scrollbar.

   Parameters

   parent

       Parent window. Must be non-NULL.

   id  

       Window identifier. A value of -1 indicates a default value.

   pos 

       Window position. If the position (-1, -1) is specified then a
       default position is chosen.

   size

       Window size. If the default size (-1, -1) is specified then a
       default size is chosen.

   style

       Window style. See wxScrollBar.

   validator

       Window validator.

   name

       Window name.

   See also

   wxScrollBar::Create, wxValidator

=head2 Wx::ScrollBar::DESTROY

   void ~wxScrollBar()

   Destructor, destroying the scrollbar.

=head2 Wx::ScrollBar::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxPoint& pos =
   wxDefaultPosition, const wxSize& size = wxDefaultSize, long style =
   wxSB_HORIZONTAL, const wxValidator& validator = wxDefaultValidator,
   const wxString& name = "scrollBar")

   Scrollbar creation function called by the scrollbar constructor. See
   wxScrollBar::wxScrollBar for details.

=head2 Wx::ScrollBar::GetRange

   int GetRange() const

   Returns the length of the scrollbar.

   See also

   wxScrollBar::SetScrollbar

=head2 Wx::ScrollBar::GetPageSize

   int GetPageSize() const

   Returns the page size of the scrollbar. This is the number of scroll
   units that will be scrolled when the user pages up or down. Often it
   is the same as the thumb size.

   See also

   wxScrollBar::SetScrollbar

=head2 Wx::ScrollBar::GetThumbPosition

   int GetThumbPosition() const

   Returns the current position of the scrollbar thumb.

   See also

   wxScrollBar::SetThumbPosition

=head2 Wx::ScrollBar::GetThumbSize

   int GetThumbSize() const

   Returns the thumb or 'view' size.

   See also

   wxScrollBar::SetScrollbar

=head2 Wx::ScrollBar::SetThumbPosition

   void SetThumbPosition(int viewStart)

   Sets the position of the scrollbar.

   Parameters

   viewStart

       The position of the scrollbar thumb.

   See also

   wxScrollBar::GetThumbPosition

=head2 Wx::ScrollBar::SetScrollbar

   virtual void SetScrollbar(int position, int thumbSize, int range, int
   pageSize, const bool refresh = true)

   Sets the scrollbar properties.

   Parameters

   position

       The position of the scrollbar in scroll units.

   thumbSize

       The size of the thumb, or visible portion of the scrollbar, in
       scroll units.

   range

       The maximum position of the scrollbar.

   pageSize

       The size of the page size in scroll units. This is the number of
       units the scrollbar will scroll when it is paged up or down. Often
       it is the same as the thumb size.

   refresh

       true to redraw the scrollbar, false otherwise.

   Remarks

   Let's say you wish to display 50 lines of text, using the same font.
   The window is sized so that you can only see 16 lines at a time.

   You would use:

     scrollbar->SetScrollbar(0, 16, 50, 15);

   The page size is 1 less than the thumb size so that the last line of
   the previous page will be visible on the next page, to help orient the
   user.

   Note that with the window at this size, the thumb position can never
   go above 50 minus 16, or 34.

   You can determine how many lines are currently visible by dividing the
   current view size by the character height in pixels.

   When defining your own scrollbar behaviour, you will always need to
   recalculate the scrollbar settings when the window size changes. You
   could therefore put your scrollbar calculations and SetScrollbar call
   into a function named AdjustScrollbars, which can be called initially
   and also from a wxSizeEvent event handler function.

   See also

   Scrolling overview, wxWindow::SetScrollbar, wxScrolledWindow

=head1 Wx::ScrolledWindow

=head2 Wx::ScrolledWindow::new

   wxScrolledWindow()

   Default constructor.

   wxScrolledWindow(wxWindow* parent, wxWindowID id = -1, const wxPoint&
   pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long
   style = wxHSCROLL | wxVSCROLL, const wxString& name = "scrolledWindow")

   Constructor.

   Parameters

   parent

       Parent window.

   id  

       Window identifier. A value of -1 indicates a default value.

   pos 

       Window position. If a position of (-1, -1) is specified then a
       default position is chosen.

   size

       Window size. If a size of (-1, -1) is specified then the window is
       sized appropriately.

   style

       Window style. See wxScrolledWindow.

   name

       Window name.

   Remarks

   The window is initially created without visible scrollbars. Call
   wxScrolledWindow::SetScrollbars to specify how big the virtual window
   size should be.

=head2 Wx::ScrolledWindow::DESTROY

   ~wxScrolledWindow()

   Destructor.

=head2 Wx::ScrolledWindow::CalcScrolledPosition

   void CalcScrolledPosition( int x, int y, int *xx int *yy) const

   Translates the logical coordinates to the device ones. For example, if
   a window is scrolled 10 pixels to the bottom, the device coordinates
   of the origin are (0, 0) (as always), but the logical coordinates are
   (0, 10) and so the call to CalcScrolledPosition(0, 10, &xx, &yy) will
   return 0 in yy.

   See also

   CalcUnscrolledPosition

   wxPython note: The wxPython version of this methods accepts only two
   parameters and returns xx and yy as a tuple of values.

   wxPerl note: In wxPerl this method takes two parameters and returns a
   2-element list ( xx, yy ).

=head2 Wx::ScrolledWindow::CalcUnscrolledPosition

   void CalcUnscrolledPosition( int x, int y, int *xx int *yy) const

   Translates the device coordinates to the logical ones. For example, if
   a window is scrolled 10 pixels to the bottom, the device coordinates
   of the origin are (0, 0) (as always), but the logical coordinates are
   (0, 10) and so the call to CalcUnscrolledPosition(0, 0, &xx, &yy) will
   return 10 in yy.

   See also

   CalcScrolledPosition

   wxPython note: The wxPython version of this methods accepts only two
   parameters and returns xx and yy as a tuple of values.

   wxPerl note: In wxPerl this method takes two parameters and returns a
   2-element list ( xx, yy ).

=head2 Wx::ScrolledWindow::Create

   bool Create(wxWindow* parent, wxWindowID id = -1, const wxPoint& pos =
   wxDefaultPosition, const wxSize& size = wxDefaultSize, long style =
   wxHSCROLL | wxVSCROLL, const wxString& name = "scrolledWindow")

   Creates the window for two-step construction. Derived classes should
   call or replace this function. See wxScrolledWindow::wxScrolledWindow
   for details.

=head2 Wx::ScrolledWindow::EnableScrolling

   void EnableScrolling(const bool xScrolling, const bool yScrolling)

   Enable or disable physical scrolling in the given direction. Physical
   scrolling is the physical transfer of bits up or down the screen when
   a scroll event occurs. If the application scrolls by a variable amount
   (e.g. if there are different font sizes) then physical scrolling will
   not work, and you should switch it off. Note that you will have to
   reposition child windows yourself, if physical scrolling is disabled.

   Parameters

   xScrolling

       If true, enables physical scrolling in the x direction.

   yScrolling

       If true, enables physical scrolling in the y direction.

   Remarks

   Physical scrolling may not be available on all platforms. Where it is
   available, it is enabled by default.

=head2 Wx::ScrolledWindow::GetScrollPixelsPerUnit

   void GetScrollPixelsPerUnit(int* xUnit, int* yUnit) const

   Get the number of pixels per scroll unit (line), in each direction, as
   set by wxScrolledWindow::SetScrollbars. A value of zero indicates no
   scrolling in that direction.

   Parameters

   xUnit

       Receives the number of pixels per horizontal unit.

   yUnit

       Receives the number of pixels per vertical unit.

   See also

   wxScrolledWindow::SetScrollbars, wxScrolledWindow::GetVirtualSize

   wxPython note: The wxPython version of this methods accepts no
   parameters and returns a tuple of values for xUnit and yUnit.

   wxPerl note: In wxPerl this method takes no parameters and returns a
   2-element list ( xUnit, yUnit ).

=head2 Wx::ScrolledWindow::GetViewStart

   void GetViewStart(int* x, int* y) const

   Get the position at which the visible portion of the window starts.

   Parameters

   x   

       Receives the first visible x position in scroll units.

   y   

       Receives the first visible y position in scroll units.

   Remarks

   If either of the scrollbars is not at the home position, x and/or y
   will be greater than zero. Combined with wxWindow::GetClientSize, the
   application can use this function to efficiently redraw only the
   visible portion of the window. The positions are in logical scroll
   units, not pixels, so to convert to pixels you will have to multiply
   by the number of pixels per scroll increment.

   See also

   wxScrolledWindow::SetScrollbars

   wxPython note: The wxPython version of this methods accepts no
   parameters and returns a tuple of values for x and y.

   wxPerl note: In wxPerl this method takes no parameters and returns a
   2-element list ( x, y ).

=head2 Wx::ScrolledWindow::GetVirtualSize

   void GetVirtualSize(int* x, int* y) const

   Gets the size in device units of the scrollable window area (as
   opposed to the client size, which is the area of the window currently
   visible).

   Parameters

   x   

       Receives the length of the scrollable window, in pixels.

   y   

       Receives the height of the scrollable window, in pixels.

   Remarks

   Use wxDC::DeviceToLogicalX and wxDC::DeviceToLogicalY to translate
   these units to logical units.

   See also

   wxScrolledWindow::SetScrollbars,
   wxScrolledWindow::GetScrollPixelsPerUnit

   wxPython note: The wxPython version of this methods accepts no
   parameters and returns a tuple of values for x and y.

   wxPerl note: In wxPerl this method takes no parameters and returns a
   2-element list ( x, y ).

=head2 Wx::ScrolledWindow::IsRetained

   bool IsRetained() const

   Motif only: true if the window has a backing bitmap.

=head2 Wx::ScrolledWindow::DoPrepareDC

   void DoPrepareDC(wxDC& dc)

   Call this function to prepare the device context for drawing a
   scrolled image. It sets the device origin according to the current
   scroll position.

   DoPrepareDC is called automatically within the default
   wxScrolledWindow::OnPaint event handler, so your
   wxScrolledWindow::OnDraw override will be passed a 'pre-scrolled'
   device context. However, if you wish to draw from outside of OnDraw
   (via OnPaint), or you wish to implement OnPaint yourself, you must
   call this function yourself. For example:

   void MyWindow::OnEvent(wxMouseEvent& event)
   {
     wxClientDC dc(this);
     DoPrepareDC(dc);

=head2 Wx::ScrolledWindow::OnDraw

   virtual void OnDraw(wxDC& dc)

   Called by the default paint event handler to allow the application to
   define painting behaviour without having to worry about calling
   wxScrolledWindow::DoPrepareDC.

   Instead of overriding this function you may also just process the
   paint event in the derived class as usual, but then you will have to
   call DoPrepareDC() yourself.

=head2 Wx::ScrolledWindow::PrepareDC

   void PrepareDC(wxDC& dc)

   This function is for backwards compatibility only and simply calls
   DoPrepareDC now. Notice that it is not called by the default paint
   event handle (DoPrepareDC() is), so overriding this method in your
   derived class is useless.

=head2 Wx::ScrolledWindow::Scroll

   void Scroll(int x, int y)

   Scrolls a window so the view start is at the given point.

   Parameters

   x   

       The x position to scroll to, in scroll units.

   y   

       The y position to scroll to, in scroll units.

   Remarks

   The positions are in scroll units, not pixels, so to convert to pixels
   you will have to multiply by the number of pixels per scroll
   increment. If either parameter is -1, that position will be ignored
   (no change in that direction).

   See also

   wxScrolledWindow::SetScrollbars,
   wxScrolledWindow::GetScrollPixelsPerUnit

=head2 Wx::ScrolledWindow::SetScrollbars

   void SetScrollbars(int pixelsPerUnitX, int pixelsPerUnitY, int
   noUnitsX, int noUnitsY, int xPos = 0, int yPos = 0, bool noRefresh =
   false)

   Sets up vertical and/or horizontal scrollbars.

   Parameters

   pixelsPerUnitX

       Pixels per scroll unit in the horizontal direction.

   pixelsPerUnitY

       Pixels per scroll unit in the vertical direction.

   noUnitsX

       Number of units in the horizontal direction.

   noUnitsY

       Number of units in the vertical direction.

   xPos

       Position to initialize the scrollbars in the horizontal direction,
       in scroll units.

   yPos

       Position to initialize the scrollbars in the vertical direction,
       in scroll units.

   noRefresh

       Will not refresh window if true.

   Remarks

   The first pair of parameters give the number of pixels per 'scroll
   step', i.e. amount moved when the up or down scroll arrows are
   pressed. The second pair gives the length of scrollbar in scroll
   steps, which sets the size of the virtual window.

   xPos and yPos optionally specify a position to scroll to immediately.

   For example, the following gives a window horizontal and vertical
   scrollbars with 20 pixels per scroll step, and a size of 50 steps
   (1000 pixels) in each direction.

     window->SetScrollbars(20, 20, 50, 50);

   wxScrolledWindow manages the page size itself, using the current
   client window size as the page size.

   Note that for more sophisticated scrolling applications, for example
   where scroll steps may be variable according to the position in the
   document, it will be necessary to derive a new class from wxWindow,
   overriding OnSize and adjusting the scrollbars appropriately.

   See also

   wxWindow::SetVirtualSize

=head2 Wx::ScrolledWindow::SetScrollRate

   void SetScrollRate(int xstep, int ystep)

   Set the horizontal and vertical scrolling increment only. See the
   pixelsPerUnit parameter in SetScrollbars.

=head2 Wx::ScrolledWindow::SetTargetWindow

   void SetTargetWindow(wxWindow* window)

   Call this function to tell wxScrolledWindow to perform the actual
   scrolling on a different window (and not on itself).

=head1 Wx::ScrollEvent

=head2 Wx::ScrollEvent::new

   wxScrollEvent(WXTYPE commandType = 0, int id = 0, int pos = 0, int
   orientation = 0)

   Constructor.

=head2 Wx::ScrollEvent::GetOrientation

   int GetOrientation() const

   Returns wxHORIZONTAL or wxVERTICAL, depending on the orientation of
   the scrollbar.

=head2 Wx::ScrollEvent::GetPosition

   int GetPosition() const

   Returns the position of the scrollbar.

=head1 Wx::ScrollWinEvent

=head2 Wx::ScrollWinEvent::new

   wxScrollWinEvent(WXTYPE commandType = 0, int pos = 0, int orientation
   = 0)

   Constructor.

=head2 Wx::ScrollWinEvent::GetOrientation

   int GetOrientation() const

   Returns wxHORIZONTAL or wxVERTICAL, depending on the orientation of
   the scrollbar.

=head2 Wx::ScrollWinEvent::GetPosition

   int GetPosition() const

   Returns the position of the scrollbar for the thumb track and release
   events. Note that this field can't be used for the other events, you
   need to query the window itself for the current position in that case.

=head1 Wx::Semaphore

=head2 Wx::Semaphore::new

   wxSemaphore(int initialcount = 0, int maxcount = 0)

   Specifying a maxcount of 0 actually makes wxSemaphore behave as if
   there is no upper limit. If maxcount is 1, the semaphore behaves
   exactly as a mutex.

   initialcount is the initial value of the semaphore which must be
   between 0 and maxcount (if it is not set to 0).

=head2 Wx::Semaphore::DESTROY

   ~wxSemaphore()

   Destructor is not virtual, don't use this class polymorphically.

=head2 Wx::Semaphore::Post

   wxSemaError Post()

   Increments the semaphore count and signals one of the waiting threads
   in an atomic way. Returns wxSEMA_OVERFLOW if the count would increase
   the counter past the maximum.

   Return value

   One of:

=head2 Wx::Semaphore::TryWait

   wxSemaError TryWait()

   Same as Wait(), but returns immediately.

   Return value

   One of:

=head2 Wx::Semaphore::Wait

   wxSemaError Wait()

   Wait indefinitely until the semaphore count becomes strictly positive
   and then decrement it and return.

   Return value

   One of:

=head2 Wx::Semaphore::WaitTimeout

   wxSemaError WaitTimeout(unsigned longtimeout_millis)

   Same as Wait(), but with a timeout limit.

   Return value

   One of:

=head1 Wx::SetCursorEvent

=head2 Wx::SetCursorEvent::new

   wxSetCursorEvent(wxCoordx = 0, wxCoordy = 0)

   Constructor, used by the library itself internally to initialize the
   event object.

=head2 Wx::SetCursorEvent::GetCursor

   wxCursor GetCursor() const

   Returns a reference to the cursor specified by this event.

=head2 Wx::SetCursorEvent::GetX

   wxCoord GetX() const

   Returns the X coordinate of the mouse in client coordinates.

=head2 Wx::SetCursorEvent::GetY

   wxCoord GetY() const

   Returns the Y coordinate of the mouse in client coordinates.

=head2 Wx::SetCursorEvent::HasCursor

   bool HasCursor() const

   Returns true if the cursor specified by this event is a valid cursor.

   Remarks

   You cannot specify wxNullCursor with this event, as it is not
   considered a valid cursor.

=head2 Wx::SetCursorEvent::SetCursor

   void SetCursor(const wxCursor&cursor)

   Sets the cursor associated with this event.

=head1 Wx::Server

=head2 Wx::Server::new

   wxServer()

   Constructs a server object.

=head2 Wx::Server::Create

   bool Create(const wxString& service)

   Registers the server using the given service name. Under Unix, the
   service name may be either an integer port identifier in which case an
   Internet domain socket will be used for the communications, or a valid
   file name (which shouldn't exist and will be deleted afterwards) in
   which case a Unix domain socket is created. false is returned if the
   call failed (for example, the port number is already in use).

=head2 Wx::Server::OnAcceptConnection

   virtual wxConnectionBase * OnAcceptConnection(const wxString& topic)

   When a client calls MakeConnection, the server receives the message
   and this member is called. The application should derive a member to
   intercept this message and return a connection object of either the
   standard wxConnection type, or (more likely) of a user-derived type.

   If the topic is STDIO, the application may wish to refuse the
   connection. Under UNIX, when a server is created the
   OnAcceptConnection message is always sent for standard input and
   output, but in the context of DDE messages it doesn't make a lot of
   sense.

=head1 Wx::SearchCtrl

=head2 Wx::SearchCtrl::new

   wxSearchCtrl()

   Default constructor.

   wxSearchCtrl(wxWindow* parent, wxWindowID id, const wxString& value =
   "", const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = 0, const wxValidator& validator =
   wxDefaultValidator, const wxString& name = wxSearchCtrlNameStr)

   Constructor, creating and showing a text control.

   Parameters

   parent

       Parent window. Should not be NULL.

   id  

       Control identifier. A value of -1 denotes a default value.

   value

       Default text value.

   pos 

       Text control position.

   size

       Text control size.

   style

       Window style. See wxSearchCtrl.

   validator

       Window validator.

   name

       Window name.

   See also

   wxTextCtrl::Create, wxValidator

=head2 Wx::SearchCtrl::DESTROY

   ~wxSearchCtrl()

   Destructor, destroying the search control.

=head2 Wx::SearchCtrl::SetMenu

   virtual void SetMenu(wxMenu* menu)

   Sets the search control's menu object. If there is already a menu
   associated with the search control it is deleted.

=head2 Wx::SearchCtrl::GetMenu

   virtual wxMenu* GetMenu()

   Returns a pointer to the search control's menu object or NULL if there
   is no menu attached.

=head2 Wx::SearchCtrl::ShowSearchButton

   virtual void ShowSearchButton(bool show)

   Sets the search button visibility value on the search control. If
   there is a menu attached, the search button will be visible regardless
   of the search button visibility value.

   This has no effect in Mac OS X v10.3

=head2 Wx::SearchCtrl::IsSearchButtonVisible

   virtual bool IsSearchButtonVisible()

   Returns the search button visibility value. If there is a menu
   attached, the search button will be visible regardless of the search
   button visibility value.

   This always returns false in Mac OS X v10.3

=head2 Wx::SearchCtrl::ShowCancelButton

   virtual void ShowCancelButton(bool show)

   Shows or hides the cancel button.

=head2 Wx::SearchCtrl::IsCancelButtonVisible

   virtual bool IsCancelButtonVisible()

   Indicates whether the cancel button is visible.

=head1 Wx::SingleChoiceDialog

=head2 Wx::SingleChoiceDialog::new

   wxSingleChoiceDialog(wxWindow* parent, const wxString& message, const
   wxString& caption, int n, const wxString* choices, void** clientData =
   NULL, long style = wxCHOICEDLG_STYLE, const wxPoint& pos =
   wxDefaultPosition)

   wxSingleChoiceDialog(wxWindow* parent, const wxString& message, const
   wxString& caption, const wxArrayString& choices, void** clientData =
   NULL, long style = wxCHOICEDLG_STYLE, const wxPoint& pos =
   wxDefaultPosition)

   Constructor, taking an array of wxString choices and optional client
   data.

   Parameters

   parent

       Parent window.

   message

       Message to show on the dialog.

   caption

       The dialog caption.

   n   

       The number of choices.

   choices

       An array of strings, or a string list, containing the choices.

   clientData

       An array of client data to be associated with the items. See
       GetSelectionClientData.

   style

       A dialog style (bitlist) containing flags chosen from standard
       dialog styles and the following:

=head2 Wx::SingleChoiceDialog::GetSelection

   int GetSelection() const

   Returns the index of selected item.

=head2 Wx::SingleChoiceDialog::GetSelectionClientData

   char* GetSelectionClientData() const

   Returns the client data associated with the selection.

=head2 Wx::SingleChoiceDialog::GetStringSelection

   wxString GetStringSelection() const

   Returns the selected string.

=head2 Wx::SingleChoiceDialog::SetSelection

   void SetSelection(int selection) const

   Sets the index of the initially selected item.

=head2 Wx::SingleChoiceDialog::ShowModal

   int ShowModal()

   Shows the dialog, returning either wxID_OK or wxID_CANCEL.

=head1 Wx::SingleInstanceChecker

=head2 Wx::SingleInstanceChecker::new

   wxSingleInstanceChecker()

   Default ctor, use Create() after it.

=head2 Wx::SingleInstanceChecker::new

   wxSingleInstanceChecker(const wxString& name, const wxString& path =
   wxEmptyString)

   Like Create() but without error checking.

=head2 Wx::SingleInstanceChecker::Create

   bool Create(const wxString& name, const wxString& path = wxEmptyString)

   Initialize the object if it had been created using the default
   constructor. Note that you can't call Create() more than once, so
   calling it if the non default ctor had been used is an error.

   Parameters

   name

       must be given and be as unique as possible. It is used as the
       mutex name under Win32 and the lock file name under Unix.
       GetAppName() and wxGetUserId() are commonly used to construct this
       parameter.

   path

       is optional and is ignored under Win32 and used as the directory
       to create the lock file in under Unix (default is wxGetHomeDir())

   Return value

   Returns false if initialization failed, it doesn't mean that another
   instance is running - use IsAnotherRunning() to check for it.

   Note

   One of possible reasons while Create may fail on Unix is that the lock
   file used for checking already exists but was not created by the user.
   Therefore applications shouldn't treat failure of this function as
   fatal condition, because doing so would open them to the possibility
   of a Denial of Service attack. Instead, they should alert the user
   about the problem and offer to continue execution without checking if
   another instance is running.

=head2 Wx::SingleInstanceChecker::IsAnotherRunning

   bool IsAnotherRunning() const

   Returns true if another copy of this program is already running, false
   otherwise.

=head2 Wx::SingleInstanceChecker::DESTROY

   ~wxSingleInstanceChecker()

   Destructor frees the associated resources.

   Note that it is not virtual, this class is not meant to be used
   polymorphically

=head1 Wx::Size

=head2 Wx::Size::new

   wxSize()

   wxSize(int width, int height)

   Creates a size object.

=head2 Wx::Size::DecBy

   void DecBy(const wxSize& size)

   void DecBy(int dx, int dy)

   void DecBy(int d)

   Decreases the size in x- and y- directions

=head2 Wx::Size::DecTo

   void DecTo(const wxSize& size)

   Decrements this object so that both of its dimensions are not greater
   than the corresponding dimensions of the size.

   See also

   IncTo

=head2 Wx::Size::IsFullySpecified

   bool IsFullySpecified() const

   Returns true if neither of the size object components is equal to -1,
   which is used as default for the size values in wxWidgets (hence the
   predefined wxDefaultSize has both of its components equal to -1).

   This method is typically used before calling SetDefaults.

=head2 Wx::Size::GetWidth

   int GetWidth() const

   Gets the width member.

=head2 Wx::Size::GetHeight

   int GetHeight() const

   Gets the height member.

=head2 Wx::Size::IncBy

   void IncBy(const wxSize& size)

   void IncBy(int dx, int dy)

   void IncBy(int d)

   Increases the size in x- and y- directions

=head2 Wx::Size::IncTo

   void IncTo(const wxSize& size)

   Increments this object so that both of its dimensions are not less
   than the corresponding dimensions of the size.

   See also

   DecTo

=head2 Wx::Size::Scale

   wxSize& Scale(float xscale, float yscale)

   Scales the dimensions of this object by the given factors. If you want
   to scale both dimensions by the same factor you can also use the
   operator *=

   Returns a reference to this object (so that you can concatenate other
   operations in the same line).

=head2 Wx::Size::Set

   void Set(int width, int height)

   Sets the width and height members.

=head2 Wx::Size::SetDefaults

   void SetDefaults(const wxSize& sizeDefault)

   Combine this size object with another one replacing the default (i.e.
   equal to -1) components of this object with those of the other. It is
   typically used like this:

       if ( !size.IsFullySpecified() )
       {
           size.SetDefaults(GetDefaultSize());
       }

   See also

   IsFullySpecified

=head2 Wx::Size::SetHeight

   void SetHeight(int height)

   Sets the height.

=head2 Wx::Size::SetWidth

   void SetWidth(int width)

   Sets the width.

=head2 Operators

   void operator =(const wxSize& sz)

   Assignment operator.

=head1 Wx::SizeEvent

=head2 Wx::SizeEvent::new

   wxSizeEvent(const wxSize& sz, int id = 0)

   Constructor.

=head2 Wx::SizeEvent::GetSize

   wxSize GetSize() const

   Returns the entire size of the window generating the size change
   event.

=head1 Wx::Sizer

=head2 Wx::Sizer::new

   wxSizer()

   The constructor. Note that wxSizer is an abstract base class and may
   not be instantiated.

=head2 Wx::Sizer::DESTROY

   ~wxSizer()

   The destructor.

=head2 Wx::Sizer::Add

   wxSizerItem* Add(wxWindow* window, const wxSizerFlags& flags)

   wxSizerItem* Add(wxWindow* window, int proportion = 0,int flag = 0,
   int border = 0, wxObject* userData = NULL)

   wxSizerItem* Add(wxSizer* sizer, const wxSizerFlags& flags)

   wxSizerItem* Add(wxSizer* sizer, int proportion = 0, int flag = 0, int
   border = 0, wxObject* userData = NULL)

   wxSizerItem* Add(int width, int height, int proportion = 0, int flag =
   0, int border = 0, wxObject* userData = NULL)

   Appends a child to the sizer. wxSizer itself is an abstract class, but
   the parameters are equivalent in the derived classes that you will
   instantiate to use it so they are described here:

   window

       The window to be added to the sizer. Its initial size (either set
       explicitly by the user or calculated internally when using
       wxDefaultSize) is interpreted as the minimal and in many cases
       also the initial size.

   sizer

       The (child-)sizer to be added to the sizer. This allows placing a
       child sizer in a sizer and thus to create hierarchies of sizers
       (typically a vertical box as the top sizer and several horizontal
       boxes on the level beneath).

   width and height

       The dimension of a spacer to be added to the sizer. Adding spacers
       to sizers gives more flexibility in the design of dialogs; imagine
       for example a horizontal box with two buttons at the bottom of a
       dialog: you might want to insert a space between the two buttons
       and make that space stretchable using the proportion flag and the
       result will be that the left button will be aligned with the left
       side of the dialog and the right button with the right side - the
       space in between will shrink and grow with the dialog.

   proportion

       Although the meaning of this parameter is undefined in wxSizer, it
       is used in wxBoxSizer to indicate if a child of a sizer can change
       its size in the main orientation of the wxBoxSizer - where 0
       stands for not changeable and a value of more than zero is
       interpreted relative to the value of other children of the same
       wxBoxSizer. For example, you might have a horizontal wxBoxSizer
       with three children, two of which are supposed to change their
       size with the sizer. Then the two stretchable windows would get a
       value of 1 each to make them grow and shrink equally with the
       sizer's horizontal dimension.

   flag

       This parameter can be used to set a number of flags which can be
       combined using the binary OR operator |. Two main behaviours are
       defined using these flags. One is the border around a window: the
       border parameter determines the border width whereas the flags
       given here determine which side(s) of the item that the border
       will be added. The other flags determine how the sizer item
       behaves when the space allotted to the sizer changes, and is
       somewhat dependent on the specific kind of sizer used.

=head2 Wx::Sizer::AddSpacer

   wxSizerItem* AddSpacer(int size)

   Adds non-stretchable space to the sizer. More readable way of calling
   Add(size, size, 0).

=head2 Wx::Sizer::AddStretchSpacer

   wxSizerItem* AddStretchSpacer(int prop = 1)

   Adds stretchable space to the sizer. More readable way of calling Add(0,
   0, prop).

=head2 Wx::Sizer::CalcMin

   wxSize CalcMin()

   This method is abstract and has to be overwritten by any derived
   class. Here, the sizer will do the actual calculation of its children
   minimal sizes.

=head2 Wx::Sizer::Clear

   void Clear(bool delete_windows = false)

   Detaches all children from the sizer. If delete_windows is true then
   child windows will also be deleted.

=head2 Wx::Sizer::ComputeFittingClientSize

   wxSize ComputeFittingClientSize(wxWindow* window)

   Computes client area size for window so that it matches the sizer's
   minimal size. Unlike GetMinSize, this method accounts for other
   constraints imposed on window, namely display's size (returned size
   will never be too large for the display) and maximum window size if
   previously set by wxWindow::SetMaxSize.

   The returned value is suitable for passing to wxWindow::SetClientSize.

   This function is new since wxWidgets version 2.8.8

   See also

   ComputeFittingWindowSize, Fit

=head2 Wx::Sizer::ComputeFittingWindowSize

   wxSize ComputeFittingWindowSize(wxWindow* window)

   Like ComputeFittingClientSize, but converts the result into window
   size.

   The returned value is suitable for passing to wxWindow::SetSize or
   wxWindow::SetMinSize.

   This function is new since wxWidgets version 2.8.8

   See also

   ComputeFittingClientSize, Fit

=head2 Wx::Sizer::Detach

   bool Detach(wxWindow* window)

   bool Detach(wxSizer* sizer)

   bool Detach(size_t index)

   Detach a child from the sizer without destroying it. window is the
   window to be detached, sizer is the equivalent sizer and index is the
   position of the child in the sizer, typically 0 for the first item.
   This method does not cause any layout or resizing to take place, call
   wxSizer::Layout to update the layout "on screen" after detaching a
   child from the sizer.

   Returns true if the child item was found and detached, false
   otherwise.

   See also

   wxSizer::Remove

=head2 Wx::Sizer::Fit

   wxSize Fit(wxWindow* window)

   Tell the sizer to resize the window to match the sizer's minimal size.
   This is commonly done in the constructor of the window itself, see
   sample in the description of wxBoxSizer. Returns the new size.

   For a top level window this is the total window size, not client size.

   See also

   ComputeFittingClientSize, ComputeFittingWindowSize

=head2 Wx::Sizer::FitInside

   void FitInside(wxWindow* window)

   Tell the sizer to resize the virtual size of the window to match the
   sizer's minimal size. This will not alter the on screen size of the
   window, but may cause the addition/removal/alteration of scrollbars
   required to view the virtual area in windows which manage it.

   See also

   wxScrolledWindow::SetScrollbars, wxSizer::SetVirtualSizeHints

=head2 Wx::Sizer::GetChildren

   wxSizerItemList& GetChildren()

   Returns the list of the items in this sizer. The elements of type-safe
   wxList wxSizerItemList are objects of type wxSizerItem *.

=head2 Wx::Sizer::GetContainingWindow

   wxWindow * GetContainingWindow() const

   Returns the window this sizer is used in or NULL if none.

=head2 Wx::Sizer::GetItem

   wxSizerItem * GetItem(wxWindow* window, bool recursive = false)

   wxSizerItem * GetItem(wxSizer* sizer, bool recursive = false)

   wxSizerItem * GetItem(size_t index)

   Finds item of the sizer which holds given window, sizer or is located
   in sizer at position index. Use parameter recursive to search in
   subsizers too.

   Returns pointer to item or NULL.

=head2 Wx::Sizer::GetSize

   wxSize GetSize()

   Returns the current size of the sizer.

=head2 Wx::Sizer::GetPosition

   wxPoint GetPosition()

   Returns the current position of the sizer.

=head2 Wx::Sizer::GetMinSize

   wxSize GetMinSize()

   Returns the minimal size of the sizer. This is either the combined
   minimal size of all the children and their borders or the minimal size
   set by SetMinSize, depending on which is bigger.

   Note that the returned value is client size, not window size. In
   particular, if you use the value to set toplevel window's minimal or
   actual size, you should convert it using wxWindow::ClientToWindowSize
   before passing it to wxWindow::SetMinSize or wxWindow::SetSize.

=head2 Wx::Sizer::Hide

   bool Hide(wxWindow* window, bool recursive = false)

   bool Hide(wxSizer* sizer, bool recursive = false)

   bool Hide(size_t index)

   Hides the window, sizer, or item at index. To make a sizer item
   disappear, use Hide() followed by Layout(). Use parameter recursive to
   hide elements found in subsizers.

   Returns true if the child item was found, false otherwise.

   See also

   wxSizer::IsShown, wxSizer::Show

=head2 Wx::Sizer::Insert

   wxSizerItem* Insert(size_t index, wxWindow* window, const wxSizerFlags&
   flags)

   wxSizerItem* Insert(size_t index, wxWindow* window, int proportion = 0,int
   flag = 0, int border = 0, wxObject* userData = NULL)

   wxSizerItem* Insert(size_t index, wxSizer* sizer, const wxSizerFlags&
   flags)

   wxSizerItem* Insert(size_t index, wxSizer* sizer, int proportion = 0,
   int flag = 0, int border = 0, wxObject* userData = NULL)

   wxSizerItem* Insert(size_t index, int width, int height, int
   proportion = 0, int flag = 0, int border = 0, wxObject* userData =
   NULL)

   Insert a child into the sizer before any existing item at index.

   index

       The position this child should assume in the sizer.

   See wxSizer::Add for the meaning of the other parameters.

=head2 Wx::Sizer::InsertSpacer

   wxSizerItem* InsertSpacer(size_t index, int size)

   Inserts non-stretchable space to the sizer. More readable way of
   calling Insert(size, size, 0).

=head2 Wx::Sizer::InsertStretchSpacer

   wxSizerItem* InsertStretchSpacer(size_t index, int prop = 1)

   Inserts stretchable space to the sizer. More readable way of calling
   Insert(0, 0, prop).

=head2 Wx::Sizer::IsShown

   bool IsShown(wxWindow* window) const

   bool IsShown(wxSizer* sizer) const

   bool IsShown(size_t index) const

   Returns true if the window, sizer, or item at index is shown.

   See also

   wxSizer::Hide, wxSizer::Show

=head2 Wx::Sizer::Layout

   void Layout()

   Call this to force layout of the children anew, e.g. after having
   added a child to or removed a child (window, other sizer or space)
   from the sizer while keeping the current dimension.

=head2 Wx::Sizer::Prepend

   wxSizerItem* Prepend(wxWindow* window, const wxSizerFlags& flags)

   wxSizerItem* Prepend(wxWindow* window, int proportion = 0, int flag =
   0, int border = 0, wxObject* userData = NULL)

   wxSizerItem* Prepend(wxSizer* sizer, const wxSizerFlags& flags)

   wxSizerItem* Prepend(wxSizer* sizer, int proportion = 0, int flag = 0,
   int border = 0, wxObject* userData = NULL)

   wxSizerItem* Prepend(int width, int height, int proportion = 0, int
   flag = 0, int border= 0, wxObject* userData = NULL)

   Same as wxSizer::Add, but prepends the items to the beginning of the
   list of items (windows, subsizers or spaces) owned by this sizer.

=head2 Wx::Sizer::PrependSpacer

   wxSizerItem* PrependSpacer(int size)

   Prepends non-stretchable space to the sizer. More readable way of
   calling Prepend(size, size, 0).

=head2 Wx::Sizer::PrependStretchSpacer

   wxSizerItem* PrependStretchSpacer(int prop = 1)

   Prepends stretchable space to the sizer. More readable way of calling
   Prepend(0, 0, prop).

=head2 Wx::Sizer::RecalcSizes

   void RecalcSizes()

   This method is abstract and has to be overwritten by any derived
   class. Here, the sizer will do the actual calculation of its
   children's positions and sizes.

=head2 Wx::Sizer::Remove

   bool Remove(wxWindow* window)

   bool Remove(wxSizer* sizer)

   bool Remove(size_t index)

   Removes a child from the sizer and destroys it if it is a sizer or a
   spacer, but not if it is a window (because windows are owned by their
   parent window, not the sizer). sizer is the wxSizer to be removed,
   index is the position of the child in the sizer, e.g. 0 for the first
   item. This method does not cause any layout or resizing to take place,
   call wxSizer::Layout to update the layout "on screen" after removing a
   child from the sizer.

   NB: The method taking a wxWindow* parameter is deprecated as it does
   not destroy the window as would usually be expected from Remove. You
   should use wxSizer::Detach in new code instead. There is currently no
   wxSizer method that will both detach and destroy a wxWindow item.

   Returns true if the child item was found and removed, false otherwise.

=head2 Wx::Sizer::Replace

   bool Replace(wxWindow* oldwin, wxWindow* newwin, bool recursive =
   false)

   bool Replace(wxSizer* oldsz, wxSizer* newsz, bool recursive = false)

   bool Remove(size_t oldindex, wxSizerItem* newitem)

   Detaches the given oldwin, oldsz child from the sizer and replaces it
   with the given window, sizer, or wxSizerItem.

   The detached child is removed only if it is a sizer or a spacer
   (because windows are owned by their parent window, not the sizer).

   Use parameter recursive to search the given element recursively in
   subsizers.

=head2 Wx::Sizer::SetDimension

   void SetDimension(int x, int y, int width, int height)

   Call this to force the sizer to take the given dimension and thus
   force the items owned by the sizer to resize themselves according to
   the rules defined by the parameter in the Add and Prepend methods.

=head2 Wx::Sizer::SetMinSize

   void SetMinSize(int width, int height)

   void SetMinSize(const wxSize& size)

   Call this to give the sizer a minimal size. Normally, the sizer will
   calculate its minimal size based purely on how much space its children
   need. After calling this method GetMinSize will return either the
   minimal size as requested by its children or the minimal size set
   here, depending on which is bigger.

=head2 Wx::Sizer::SetItemMinSize

   void SetItemMinSize(wxWindow* window, int width, int height)

   void SetItemMinSize(wxSizer* sizer, int width, int height)

   void SetItemMinSize(size_t index, int width, int height)

   Set an item's minimum size by window, sizer, or position. The item
   will be found recursively in the sizer's descendants. This function
   enables an application to set the size of an item after initial
   creation.

=head2 Wx::Sizer::SetSizeHints

   void SetSizeHints(wxWindow* window)

   This method first calls wxSizer::Fit and then SetSizeHints on the
   window passed to it. This only makes sense when window is actually a
   wxTopLevelWindow such as a wxFrame or a wxDialog, since SetSizeHints
   only has any effect in these classes. It does nothing in normal
   windows or controls.

   This method is commonly invoked in the constructor of a toplevel
   window itself (see the sample in the description of wxBoxSizer) if the
   toplevel window is resizable.

=head2 Wx::Sizer::SetVirtualSizeHints

   void SetVirtualSizeHints(wxWindow* window)

   Tell the sizer to set the minimal size of the window virtual area to
   match the sizer's minimal size. For windows with managed scrollbars
   this will set them appropriately.

   See also

   wxScrolledWindow::SetScrollbars

=head2 Wx::Sizer::Show

   bool Show(wxWindow* window, bool show = true, bool recursive = false)

   bool Show(wxSizer* sizer, bool show = true, bool recursive = false)

   bool Show(size_t index, bool show = true)

   Shows or hides the window, sizer, or item at index. To make a sizer
   item disappear or reappear, use Show() followed by Layout(). Use
   parameter recursive to show or hide elements found in subsizers.

   Returns true if the child item was found, false otherwise.

   See also

   wxSizer::Hide, wxSizer::IsShown

=head1 Wx::SizerFlags

=head2 Wx::SizerFlags::new

   wxSizerFlags(int proportion = 0)

   Creates the wxSizer with the proportion specified by proportion.

=head2 Wx::SizerFlags::Align

   wxSizerFlags& Align(int align = 0)

   Sets the alignment of this wxSizerFlags to align.

   Note that if this method is not called, the wxSizerFlags has no
   specified alignment.

   See also

   Left,

=head2 Wx::SizerFlags::Border

   wxSizerFlags& Border(int direction, int borderinpixels)

   wxSizerFlags& Border(int direction = wxALL)

   Sets the wxSizerFlags to have a border of a number of pixels specified
   by borderinpixels with the directions specified by direction.

   In the overloaded version without borderinpixels parameter, the border
   of default size, as returned by GetDefaultBorder, is used.

=head2 Wx::SizerFlags::Center

   wxSizerFlags& Center()

   Sets the object of the wxSizerFlags to center itself in the area it is
   given.

=head2 Wx::SizerFlags::Centre

   wxSizerFlags& Centre()

   wxSizerFlags::Center for people with the other dialect of english.

=head2 Wx::SizerFlags::DoubleBorder

   wxSizerFlags& DoubleBorder(int direction = wxALL)

   Sets the border in the given direction having twice the default border
   size.

=head2 Wx::SizerFlags::DoubleHorzBorder

   wxSizerFlags& DoubleHorzBorder()

   Sets the border in left and right directions having twice the default
   border size.

=head2 Wx::SizerFlags::Expand

   wxSizerFlags& Expand()

   Sets the object of the wxSizerFlags to expand to fill as much area as
   it can.

=head2 Wx::SizerFlags::GetDefaultBorder

   static int GetDefaultBorder()

   Returns the border used by default in Border method.

=head2 Wx::SizerFlags::Left

   wxSizerFlags& Left()

   Aligns the object to the left, shortcut for Align(wxALIGN_LEFT)

   See also

   Align

=head2 Wx::SizerFlags::FixedMinSize

   wxSizerFlags& FixedMinSize()

   Set the wxFIXED_MINSIZE flag which indicates that the initial size of
   the window should be also set as its minimal size.

=head2 Wx::SizerFlags::Proportion

   wxSizerFlags& Proportion(int proportion = 0)

   Sets the proportion of this wxSizerFlags to proportion

=head2 Wx::SizerFlags::ReserveSpaceEvenIfHidden

   wxSizerFlags& ReserveSpaceEvenIfHidden()

   Set the wxRESERVE_SPACE_EVEN_IF_HIDDEN flag. Normally wxSizers don't
   allocate space for hidden windows or other items. This flag overrides
   this behavior so that sufficient space is allocated for the window
   even if it isn't visible. This makes it possible to dynamically show
   and hide controls without resizing parent dialog, for example. This
   function is new since wxWidgets version 2.8.8

=head2 Wx::SizerFlags::Right

   wxSizerFlags& Right()

   Aligns the object to the right, shortcut for Align(wxALIGN_RIGHT)

   See also

   Align

=head2 Wx::SizerFlags::Shaped

   wxSizerFlags& Shaped()

   Set the wx_SHAPED flag which indicates that the elements should always
   keep the fixed width to height ratio equal to its original value.

=head2 Wx::SizerFlags::TripleBorder

   wxSizerFlags& TripleBorder(int direction = wxALL)

   Sets the border in the given direction having thrice the default
   border size.

=head1 Wx::SizerItem

=head2 Wx::SizerItem::new

   wxSizerItem(int width, int height, int proportion, int flag, int
   border, wxObject* userData)

   Construct a sizer item for tracking a spacer.

=head2 Wx::SizerItem::DESTROY

   ~wxSizerItem()

   Deletes the user data and subsizer, if any.

=head2 Wx::SizerItem::CalcMin

   wxSize CalcMin()

   Calculates the minimum desired size for the item, including any space
   needed by borders.

=head2 Wx::SizerItem::DeleteWindows

   void DeleteWindows()

   Destroy the window or the windows in a subsizer, depending on the type
   of item.

=head2 Wx::SizerItem::DetachSizer

   void DetachSizer()

   Enable deleting the SizerItem without destroying the contained sizer.

=head2 Wx::SizerItem::GetBorder

   int GetBorder() const

   Return the border attribute.

=head2 Wx::SizerItem::GetFlag

   int GetFlag() const

   Return the flags attribute.

=head2 Wx::SizerItem::GetMinSize

   wxSize GetMinSize() const

   Get the minimum size needed for the item.

=head2 Wx::SizerItem::GetPosition

   wxPoint GetPosition() const

   What is the current position of the item, as set in the last Layout.

=head2 Wx::SizerItem::GetProportion

   int GetProportion() const

   Get the proportion item attribute.

=head2 Wx::SizerItem::GetRatio

   float GetRatio() const

   Get the ration item attribute.

=head2 Wx::SizerItem::GetRect

   wxRect GetRect()

   Get the rectangle of the item on the parent window, excluding borders.

=head2 Wx::SizerItem::GetSize

   wxSize GetSize() const

   Get the current size of the item, as set in the last Layout.

=head2 Wx::SizerItem::GetSizer

   wxSizer* GetSizer() const

   If this item is tracking a sizer, return it. NULL otherwise.

=head2 Wx::SizerItem::GetSpacer

   const wxSize& GetSpacer() const

   If this item is tracking a spacer, return its size.

=head2 Wx::SizerItem::GetUserData

   wxObject* GetUserData() const

   Get the userData item attribute.

=head2 Wx::SizerItem::GetWindow

   wxWindow* GetWindow() const

   If this item is tracking a window then return it. NULL otherwise.

=head2 Wx::SizerItem::IsSizer

   bool IsSizer() const

   Is this item a sizer?

=head2 Wx::SizerItem::IsShown

   bool IsShown() const

   Returns true if this item is a window or a spacer and it is shown or
   if this item is a sizer and not all its elements are hidden. In other
   words, for sizer items, all of the child elements must be hidden for
   the sizer itself to be considered hidden.

=head2 Wx::SizerItem::IsSpacer

   bool IsSpacer() const

   Is this item a spacer?

=head2 Wx::SizerItem::IsWindow

   bool IsWindow() const

   Is this item a window?

=head2 Wx::SizerItem::SetBorder

   void SetBorder(int border)

   Set the border item attribute.

=head2 Wx::SizerItem::SetDimension

   void SetDimension(const wxPoint& pos, const wxSize& size)

   Set the position and size of the space allocated to the sizer, and
   adjust the position and size of the item to be within that space
   taking alignment and borders into account.

=head2 Wx::SizerItem::SetFlag

   void SetFlag(int flag)

   Set the flag item attribute.

=head2 Wx::SizerItem::SetInitSize

   void SetInitSize(int x, int y)

=head2 Wx::SizerItem::SetProportion

   void SetProportion(int proportion)

   Set the proportion item attribute.

=head2 Wx::SizerItem::SetRatio

   void SetRatio(int width, int height)

   void SetRatio(wxSize size)

   void SetRatio(float ratio)

   Set the ratio item attribute.

=head2 Wx::SizerItem::SetSizer

   void SetSizer(wxSizer* sizer)

   Set the sizer tracked by this item.

=head2 Wx::SizerItem::SetSpacer

   void SetSpacer(const wxSize& size)

   Set the size of the spacer tracked by this item.

=head2 Wx::SizerItem::SetWindow

   void SetWindow(wxWindow* window)

   Set the window to be tracked by thsi item.

=head2 Wx::SizerItem::Show

   void Show(bool show)

   Set the show item attribute, which sizers use to determine if the item
   is to be made part of the layout or not. If the item is tracking a
   window then it is shown or hidden as needed.

=head1 Wx::Slider

=head2 Wx::Slider::new

   wxSlider()

   Default slider.

   wxSlider(wxWindow* parent, wxWindowID id, int value , int minValue,
   int maxValue, const wxPoint& point = wxDefaultPosition, const wxSize&
   size = wxDefaultSize, long style = wxSL_HORIZONTAL, const wxValidator&
   validator = wxDefaultValidator, const wxString& name = "slider")

   Constructor, creating and showing a slider.

   Parameters

   parent

       Parent window. Must not be NULL.

   id  

       Window identifier. A value of -1 indicates a default value.

   value

       Initial position for the slider.

   minValue

       Minimum slider position.

   maxValue

       Maximum slider position.

   size

       Window size. If the default size (-1, -1) is specified then a
       default size is chosen.

   style

       Window style. See wxSlider.

   validator

       Window validator.

   name

       Window name.

   See also

   wxSlider::Create, wxValidator

=head2 Wx::Slider::DESTROY

   void ~wxSlider()

   Destructor, destroying the slider.

=head2 Wx::Slider::ClearSel

   void ClearSel()

   Clears the selection, for a slider with the wxSL_SELRANGE style.

   Remarks

   Windows 95 only.

=head2 Wx::Slider::ClearTicks

   void ClearTicks()

   Clears the ticks.

   Remarks

   Windows 95 only.

=head2 Wx::Slider::Create

   bool Create(wxWindow* parent, wxWindowID id, int value , int minValue,
   int maxValue, const wxPoint& point = wxDefaultPosition, const wxSize&
   size = wxDefaultSize, long style = wxSL_HORIZONTAL, const wxValidator&
   validator = wxDefaultValidator, const wxString& name = "slider")

   Used for two-step slider construction. See wxSlider::wxSlider for
   further details.

=head2 Wx::Slider::GetLineSize

   int GetLineSize() const

   Returns the line size.

   See also

   wxSlider::SetLineSize

=head2 Wx::Slider::GetMax

   int GetMax() const

   Gets the maximum slider value.

   See also

   wxSlider::GetMin, wxSlider::SetRange

=head2 Wx::Slider::GetMin

   int GetMin() const

   Gets the minimum slider value.

   See also

   wxSlider::GetMin, wxSlider::SetRange

=head2 Wx::Slider::GetPageSize

   int GetPageSize() const

   Returns the page size.

   See also

   wxSlider::SetPageSize

=head2 Wx::Slider::GetSelEnd

   int GetSelEnd() const

   Returns the selection end point.

   Remarks

   Windows 95 only.

   See also

   wxSlider::GetSelStart, wxSlider::SetSelection

=head2 Wx::Slider::GetSelStart

   int GetSelStart() const

   Returns the selection start point.

   Remarks

   Windows 95 only.

   See also

   wxSlider::GetSelEnd, wxSlider::SetSelection

=head2 Wx::Slider::GetThumbLength

   int GetThumbLength() const

   Returns the thumb length.

   Remarks

   Windows 95 only.

   See also

   wxSlider::SetThumbLength

=head2 Wx::Slider::GetTickFreq

   int GetTickFreq() const

   Returns the tick frequency.

   Remarks

   Windows 95 only.

   See also

   wxSlider::SetTickFreq

=head2 Wx::Slider::GetValue

   int GetValue() const

   Gets the current slider value.

   See also

   wxSlider::GetMin, wxSlider::GetMax, wxSlider::SetValue

=head2 Wx::Slider::SetLineSize

   void SetLineSize(int lineSize)

   Sets the line size for the slider.

   Parameters

   lineSize

       The number of steps the slider moves when the user moves it up or
       down a line.

   See also

   wxSlider::GetLineSize

=head2 Wx::Slider::SetPageSize

   void SetPageSize(int pageSize)

   Sets the page size for the slider.

   Parameters

   pageSize

       The number of steps the slider moves when the user pages up or
       down.

   See also

   wxSlider::GetPageSize

=head2 Wx::Slider::SetRange

   void SetRange(int minValue, int maxValue)

   Sets the minimum and maximum slider values.

   See also

   wxSlider::GetMin, wxSlider::GetMax

=head2 Wx::Slider::SetSelection

   void SetSelection(int startPos, int endPos)

   Sets the selection.

   Parameters

   startPos

       The selection start position.

   endPos

       The selection end position.

   Remarks

   Windows 95 only.

   See also

   wxSlider::GetSelStart, wxSlider::GetSelEnd

=head2 Wx::Slider::SetThumbLength

   void SetThumbLength(int len)

   Sets the slider thumb length.

   Parameters

   len 

       The thumb length.

   Remarks

   Windows 95 only.

   See also

   wxSlider::GetThumbLength

=head2 Wx::Slider::SetTick

   void SetTick(int tickPos)

   Sets a tick position.

   Parameters

   tickPos

       The tick position.

   Remarks

   Windows 95 only.

   See also

   wxSlider::SetTickFreq

=head2 Wx::Slider::SetTickFreq

   void SetTickFreq(int n, int pos)

   Sets the tick mark frequency and position.

   Parameters

   n   

       Frequency. For example, if the frequency is set to two, a tick
       mark is displayed for every other increment in the slider's range.

   pos 

       Position. Must be greater than zero. TODO: what is this for?

   Remarks

   Windows 95 only.

   See also

   wxSlider::GetTickFreq

=head2 Wx::Slider::SetValue

   void SetValue(int value)

   Sets the slider position.

   Parameters

   value

       The slider position.

   See also

   wxSlider::GetValue

=head1 Wx::SockAddress

=head2 Wx::SockAddress::new

   wxSockAddress()

   Default constructor.

=head2 Wx::SockAddress::DESTROY

   ~wxSockAddress()

   Default destructor.

=head2 Wx::SockAddress::Clear

   void Clear()

   Delete all informations about the address.

=head1 Wx::SocketBase

=head2 Construction and destruction

   wxSocketBase

=head2 Socket state

   Functions to retrieve current state and miscellaneous info.

   Error

=head2 Basic IO

   Functions that perform basic IO functionality.

   Close

=head2 Handling socket events

   Functions that allow applications to receive socket events.

   Notify

=head2 Wx::SocketBase::new

   wxSocketBase()

   Default constructor. Don't use it directly; instead, use
   wxSocketClient to construct a socket client, or wxSocketServer to
   construct a socket server.

=head2 Wx::SocketBase::DESTROY

   ~wxSocketBase()

   Destructor. Do not destroy a socket using the delete operator
   directly; use Destroy instead. Also, do not create socket objects in
   the stack.

=head2 Wx::SocketBase::Close

   void Close()

   This function shuts down the socket, disabling further transmission
   and reception of data; it also disables events for the socket and
   frees the associated system resources. Upon socket destruction, Close
   is automatically called, so in most cases you won't need to do it
   yourself, unless you explicitly want to shut down the socket,
   typically to notify the peer that you are closing the connection.

   Remark/Warning

   Although Close immediately disables events for the socket, it is
   possible that event messages may be waiting in the application's event
   queue. The application must therefore be prepared to handle socket
   event messages even after calling Close.

=head2 Wx::SocketBase::Destroy

   bool Destroy()

   Destroys the socket safely. Use this function instead of the delete
   operator, since otherwise socket events could reach the application
   even after the socket has been destroyed. To prevent this problem,
   this function appends the wxSocket to a list of object to be deleted
   on idle time, after all events have been processed. For the same
   reason, you should avoid creating socket objects in the stack.

   Destroy calls Close automatically.

   Return value

   Always true.

=head2 Wx::SocketBase::Discard

   wxSocketBase& Discard()

   This function simply deletes all bytes in the incoming queue. This
   function always returns immediately and its operation is not affected
   by IO flags.

   Use LastCount to verify the number of bytes actually discarded.

   If you use Error, it will always return false.

=head2 Wx::SocketBase::Error

   bool Error() const

   Returns true if an error occurred in the last IO operation.

   Use this function to check for an error condition after one of the
   following calls: Discard, Peek, Read, ReadMsg, Unread, Write,
   WriteMsg.

=head2 Wx::SocketBase::GetClientData

   void * GetClientData() const

   Returns a pointer of the client data for this socket, as set with
   SetClientData

=head2 Wx::SocketBase::GetLocal

   bool GetLocal(wxSockAddress& addr) const

   This function returns the local address field of the socket. The local
   address field contains the complete local address of the socket (local
   address, local port, ...).

   Return value

   true if no error happened, false otherwise.

=head2 Wx::SocketBase::GetFlags

   wxSocketFlags GetFlags() const

   Returns current IO flags, as set with SetFlags

=head2 Wx::SocketBase::GetPeer

   bool GetPeer(wxSockAddress& addr) const

   This function returns the peer address field of the socket. The peer
   address field contains the complete peer host address of the socket
   (address, port, ...).

   Return value

   true if no error happened, false otherwise.

=head2 Wx::SocketBase::InterruptWait

   void InterruptWait()

   Use this function to interrupt any wait operation currently in
   progress. Note that this is not intended as a regular way to interrupt
   a Wait call, but only as an escape mechanism for exceptional
   situations where it is absolutely necessary to use it, for example to
   abort an operation due to some exception or abnormal problem.
   InterruptWait is automatically called when you Close a socket (and
   thus also upon socket destruction), so you don't need to use it in
   these cases.

   wxSocketBase::Wait, wxSocketServer::WaitForAccept,
   wxSocketBase::WaitForLost, wxSocketBase::WaitForRead,
   wxSocketBase::WaitForWrite, wxSocketClient::WaitOnConnect

=head2 Wx::SocketBase::IsConnected

   bool IsConnected() const

   Returns true if the socket is connected.

=head2 Wx::SocketBase::IsData

   bool IsData() const

   This function waits until the socket is readable. This might mean that
   queued data is available for reading or, for streamed sockets, that
   the connection has been closed, so that a read operation will complete
   immediately without blocking (unless the wxSOCKET_WAITALL flag is set,
   in which case the operation might still block).

=head2 Wx::SocketBase::IsDisconnected

   bool IsDisconnected() const

   Returns true if the socket is not connected.

=head2 Wx::SocketBase::LastCount

   wxUint32 LastCount() const

   Returns the number of bytes read or written by the last IO call.

   Use this function to get the number of bytes actually transferred
   after using one of the following IO calls: Discard, Peek, Read,
   ReadMsg, Unread, Write, WriteMsg.

=head2 Wx::SocketBase::LastError

   wxSocketError LastError() const

   Returns the last wxSocket error. See wxSocket errors.

   Please note that this function merely returns the last error code, but
   it should not be used to determine if an error has occurred (this is
   because successful operations do not change the LastError value). Use
   Error first, in order to determine if the last IO call failed. If this
   returns true, use LastError to discover the cause of the error.

=head2 Wx::SocketBase::Notify

   void Notify(bool notify)

   According to the notify value, this function enables or disables
   socket events. If notify is true, the events configured with SetNotify
   will be sent to the application. If notify is false; no events will be
   sent.

=head2 Wx::SocketBase::IsOk

   bool IsOk() const

   Returns true if the socket is initialized and ready and false in other
   cases.

   Remark/Warning

   For wxSocketClient, Ok won't return true unless the client is
   connected to a server.

   For wxSocketServer, Ok will return true if the server could bind to
   the specified address and is already listening for new connections.

   Ok does not check for IO errors; use Error instead for that purpose.

=head2 Wx::SocketBase::RestoreState

   void RestoreState()

   This function restores the previous state of the socket, as saved with
   SaveState

   Calls to SaveState and RestoreState can be nested.

   See also

   wxSocketBase::SaveState

=head2 Wx::SocketBase::SaveState

   void SaveState()

   This function saves the current state of the socket in a stack. Socket
   state includes flags, as set with SetFlags, event mask, as set with
   SetNotify and Notify, user data, as set with SetClientData.

   Calls to SaveState and RestoreState can be nested.

   See also

   wxSocketBase::RestoreState

=head2 Wx::SocketBase::SetClientData

   void SetClientData(void *data)

   Sets user-supplied client data for this socket. All socket events will
   contain a pointer to this data, which can be retrieved with the
   wxSocketEvent::GetClientData function.

=head2 Wx::SocketBase::SetEventHandler

   void SetEventHandler(wxEvtHandler& handler, int id = -1)

   Sets an event handler to be called when a socket event occurs. The
   handler will be called for those events for which notification is
   enabled with SetNotify and Notify.

   Parameters

   handler

       Specifies the event handler you want to use.

   id  

       The id of socket event.

   See also

   wxSocketBase::SetNotify, wxSocketBase::Notify, wxSocketEvent,
   wxEvtHandler

=head2 Wx::SocketBase::SetFlags

   void SetFlags(wxSocketFlags flags)

   Use SetFlags to customize IO operation for this socket. The flags
   parameter may be a combination of flags ORed together. The following
   flags can be used:

=head2 Wx::SocketBase::SetLocal

   bool SetLocal(wxIPV4address& local)

   This function allows you to set the local address and port, useful
   when an application needs to reuse a particular port. When a local
   port is set for a wxSocketClient, bind will be called before connect.

=head2 Wx::SocketBase::SetNotify

   void SetNotify(wxSocketEventFlags flags)

   SetNotify specifies which socket events are to be sent to the event
   handler. The flags parameter may be combination of flags ORed
   together. The following flags can be used:

=head2 Wx::SocketBase::SetTimeout

   void SetTimeout(int seconds)

   This function sets the default socket timeout in seconds. This timeout
   applies to all IO calls, and also to the Wait family of functions if
   you don't specify a wait interval. Initially, the default timeout is
   10 minutes.

=head2 Wx::SocketBase::Peek

   wxSocketBase& Peek(void * buffer, wxUint32 nbytes)

   This function peeks a buffer of nbytes bytes from the socket. Peeking
   a buffer doesn't delete it from the socket input queue.

   Use LastCount to verify the number of bytes actually peeked.

   Use Error to determine if the operation succeeded.

   Parameters

   buffer

       Buffer where to put peeked data.

   nbytes

       Number of bytes.

   Return value

   Returns a reference to the current object.

   Remark/Warning

   The exact behaviour of wxSocketBase::Peek depends on the combination
   of flags being used. For a detailed explanation, see
   wxSocketBase::SetFlags

   See also

   wxSocketBase::Error, wxSocketBase::LastError, wxSocketBase::LastCount,
   wxSocketBase::SetFlags

=head2 Wx::SocketBase::Read

   wxSocketBase& Read(void * buffer, wxUint32 nbytes)

   This function reads a buffer of nbytes bytes from the socket.

   Use LastCount to verify the number of bytes actually read.

   Use Error to determine if the operation succeeded.

   Parameters

   buffer

       Buffer where to put read data.

   nbytes

       Number of bytes.

   Return value

   Returns a reference to the current object.

   Remark/Warning

   The exact behaviour of wxSocketBase::Read depends on the combination
   of flags being used. For a detailed explanation, see
   wxSocketBase::SetFlags.

   See also

   wxSocketBase::Error, wxSocketBase::LastError, wxSocketBase::LastCount,
   wxSocketBase::SetFlags

=head2 Wx::SocketBase::ReadMsg

   wxSocketBase& ReadMsg(void * buffer, wxUint32 nbytes)

   This function reads a buffer sent by WriteMsg on a socket. If the
   buffer passed to the function isn't big enough, the remaining bytes
   will be discarded. This function always waits for the buffer to be
   entirely filled, unless an error occurs.

   Use LastCount to verify the number of bytes actually read.

   Use Error to determine if the operation succeeded.

   Parameters

   buffer

       Buffer where to put read data.

   nbytes

       Size of the buffer.

   Return value

   Returns a reference to the current object.

   Remark/Warning

   wxSocketBase::ReadMsg will behave as if the wxSOCKET_WAITALL flag was
   always set and it will always ignore the wxSOCKET_NOWAIT flag. The
   exact behaviour of ReadMsg depends on the wxSOCKET_BLOCK flag. For a
   detailed explanation, see wxSocketBase::SetFlags.

   See also

   wxSocketBase::Error, wxSocketBase::LastError, wxSocketBase::LastCount,
   wxSocketBase::SetFlags, wxSocketBase::WriteMsg

=head2 Wx::SocketBase::Unread

   wxSocketBase& Unread(const void * buffer, wxUint32 nbytes)

   This function unreads a buffer. That is, the data in the buffer is put
   back in the incoming queue. This function is not affected by wxSocket
   flags.

   If you use LastCount, it will always return nbytes.

   If you use Error, it will always return false.

   Parameters

   buffer

       Buffer to be unread.

   nbytes

       Number of bytes.

   Return value

   Returns a reference to the current object.

   See also

   wxSocketBase::Error, wxSocketBase::LastCount, wxSocketBase::LastError

=head2 Wx::SocketBase::Wait

   bool Wait(long seconds = -1, long millisecond = 0)

   This function waits until any of the following conditions is true:

=head2 Wx::SocketBase::WaitForLost

   bool Wait(long seconds = -1, long millisecond = 0)

   This function waits until the connection is lost. This may happen if
   the peer gracefully closes the connection or if the connection breaks.

   Parameters

   seconds

       Number of seconds to wait. If -1, it will wait for the default
       timeout, as set with SetTimeout.

   millisecond

       Number of milliseconds to wait.

   Return value

   Returns true if the connection was lost, false if the timeout was
   reached.

   See also

   wxSocketBase::InterruptWait, wxSocketBase::Wait

=head2 Wx::SocketBase::WaitForRead

   bool WaitForRead(long seconds = -1, long millisecond = 0)

   This function waits until the socket is readable. This might mean that
   queued data is available for reading or, for streamed sockets, that
   the connection has been closed, so that a read operation will complete
   immediately without blocking (unless the wxSOCKET_WAITALL flag is set,
   in which case the operation might still block).

   Parameters

   seconds

       Number of seconds to wait. If -1, it will wait for the default
       timeout, as set with SetTimeout.

   millisecond

       Number of milliseconds to wait.

   Return value

   Returns true if the socket becomes readable, false on timeout.

   See also

   wxSocketBase::InterruptWait, wxSocketBase::Wait

=head2 Wx::SocketBase::WaitForWrite

   bool WaitForWrite(long seconds = -1, long millisecond = 0)

   This function waits until the socket becomes writable. This might mean
   that the socket is ready to send new data, or for streamed sockets,
   that the connection has been closed, so that a write operation is
   guaranteed to complete immediately (unless the wxSOCKET_WAITALL flag
   is set, in which case the operation might still block).

   Parameters

   seconds

       Number of seconds to wait. If -1, it will wait for the default
       timeout, as set with SetTimeout.

   millisecond

       Number of milliseconds to wait.

   Return value

   Returns true if the socket becomes writable, false on timeout.

   See also

   wxSocketBase::InterruptWait, wxSocketBase::Wait

=head2 Wx::SocketBase::Write

   wxSocketBase& Write(const void * buffer, wxUint32 nbytes)

   This function writes a buffer of nbytes bytes to the socket.

   Use LastCount to verify the number of bytes actually written.

   Use Error to determine if the operation succeeded.

   Parameters

   buffer

       Buffer with the data to be sent.

   nbytes

       Number of bytes.

   Return value

   Returns a reference to the current object.

   Remark/Warning

   The exact behaviour of wxSocketBase::Write depends on the combination
   of flags being used. For a detailed explanation, see
   wxSocketBase::SetFlags.

   See also

   wxSocketBase::Error, wxSocketBase::LastError, wxSocketBase::LastCount,
   wxSocketBase::SetFlags

=head2 Wx::SocketBase::WriteMsg

   wxSocketBase& WriteMsg(const void * buffer, wxUint32 nbytes)

   This function writes a buffer of nbytes bytes from the socket, but it
   writes a short header before so that ReadMsg knows how much data
   should it actually read. So, a buffer sent with WriteMsg must be read
   with ReadMsg. This function always waits for the entire buffer to be
   sent, unless an error occurs.

   Use LastCount to verify the number of bytes actually written.

   Use Error to determine if the operation succeeded.

   Parameters

   buffer

       Buffer with the data to be sent.

   nbytes

       Number of bytes to send.

   Return value

   Returns a reference to the current object.

   Remark/Warning

   wxSocketBase::WriteMsg will behave as if the wxSOCKET_WAITALL flag was
   always set and it will always ignore the wxSOCKET_NOWAIT flag. The
   exact behaviour of WriteMsg depends on the wxSOCKET_BLOCK flag. For a
   detailed explanation, see wxSocketBase::SetFlags.

   See also

   wxSocketBase::Error, wxSocketBase::LastError, wxSocketBase::LastCount,
   wxSocketBase::SetFlags, wxSocketBase::ReadMsg

=head1 Wx::SocketClient

=head2 Wx::SocketClient::new

   wxSocketClient(wxSocketFlags flags = wxSOCKET_NONE)

   Constructor.

   Parameters

   flags

       Socket flags (See wxSocketBase::SetFlags)

=head2 Wx::SocketClient::DESTROY

   ~wxSocketClient()

   Destructor. Please see wxSocketBase::Destroy.

=head2 Wx::SocketClient::Connect

   bool Connect(wxSockAddress& address, bool wait = true)

   bool Connect(wxSockAddress& address, wxSockAddress& local, bool wait =
   true)

   Connects to a server using the specified address.

   If wait is true, Connect will wait until the connection completes.
   Warning: This will block the GUI.

   If wait is false, Connect will try to establish the connection and
   return immediately, without blocking the GUI. When used this way, even
   if Connect returns false, the connection request can be completed
   later. To detect this, use WaitOnConnect, or catch wxSOCKET_CONNECTION
   events (for successful establishment) and wxSOCKET_LOST events (for
   connection failure).

   Parameters

   address

       Address of the server.

   local

       Bind to the specified local address and port before connecting.
       The local address and port can also be set using SetLocal, and
       then using the 2-parameter Connect method.

   wait

       If true, waits for the connection to complete.

   Return value

   Returns true if the connection is established and no error occurs.

   If wait was true, and Connect returns false, an error occurred and the
   connection failed.

   If wait was false, and Connect returns false, you should still be
   prepared to handle the completion of this connection request, either
   with WaitOnConnect or by watching wxSOCKET_CONNECTION and
   wxSOCKET_LOST events.

   See also

   wxSocketClient::WaitOnConnect, wxSocketBase::SetNotify,
   wxSocketBase::Notify

=head2 Wx::SocketClient::WaitOnConnect

   bool WaitOnConnect(long seconds = -1, long milliseconds = 0)

   Wait until a connection request completes, or until the specified
   timeout elapses. Use this function after issuing a call to Connect
   with wait set to false.

   Parameters

   seconds

       Number of seconds to wait. If -1, it will wait for the default
       timeout, as set with SetTimeout.

   millisecond

       Number of milliseconds to wait.

   Return value

   WaitOnConnect returns true if the connection request completes. This
   does not necessarily mean that the connection was successfully
   established; it might also happen that the connection was refused by
   the peer. Use IsConnected to distinguish between these two situations.

   If the timeout elapses, WaitOnConnect returns false.

   These semantics allow code like this:

   // Issue the connection request
   client->Connect(addr, false);

=head1 Wx::SocketEvent

=head2 Wx::SocketEvent::new

   wxSocketEvent(int id = 0)

   Constructor.

=head2 Wx::SocketEvent::GetClientData

   void * GetClientData()

   Gets the client data of the socket which generated this event, as set
   with wxSocketBase::SetClientData.

=head2 Wx::SocketEvent::GetSocket

   wxSocketBase * GetSocket() const

   Returns the socket object to which this event refers to. This makes it
   possible to use the same event handler for different sockets.

=head2 Wx::SocketEvent::GetSocketEvent

   wxSocketNotify GetSocketEvent() const

   Returns the socket event type.

=head1 Wx::SocketInputStream

=head2 Wx::SocketInputStream::new

   wxSocketInputStream(wxSocketBase& s)

   Creates a new read-only socket stream using the specified initialized
   socket connection.

=head1 Wx::SocketOutputStream

=head2 Wx::SocketOutputStream::new

   wxSocketOutputStream(wxSocketBase& s)

   Creates a new write-only socket stream using the specified initialized
   socket connection.

=head1 Wx::SocketServer

=head2 Wx::SocketServer::new

   wxSocketServer(const wxSockAddress& address, wxSocketFlags flags =
   wxSOCKET_NONE)

   Constructs a new server and tries to bind to the specified address.
   Before trying to accept new connections, test whether it succeeded
   with wxSocketBase:IsOk.

   Parameters

   address

       Specifies the local address for the server (e.g. port number).

   flags

       Socket flags (See wxSocketBase::SetFlags)

=head2 Wx::SocketServer::DESTROY

   ~wxSocketServer()

   Destructor (it doesn't close the accepted connections).

=head2 Wx::SocketServer::Accept

   wxSocketBase * Accept(bool wait = true)

   Accepts an incoming connection request, and creates a new wxSocketBase
   object which represents the server-side of the connection.

   If wait is true and there are no pending connections to be accepted,
   it will wait for the next incoming connection to arrive. Warning: This
   will block the GUI.

   If wait is false, it will try to accept a pending connection if there
   is one, but it will always return immediately without blocking the
   GUI. If you want to use Accept in this way, you can either check for
   incoming connections with WaitForAccept or catch wxSOCKET_CONNECTION
   events, then call Accept once you know that there is an incoming
   connection waiting to be accepted.

   Return value

   Returns an opened socket connection, or NULL if an error occurred or
   if the wait parameter was false and there were no pending connections.

   See also

   wxSocketServer::WaitForAccept, wxSocketBase::SetNotify,
   wxSocketBase::Notify, wxSocketServer::AcceptWith

=head2 Wx::SocketServer::AcceptWith

   bool AcceptWith(wxSocketBase& socket, bool wait = true)

   Accept an incoming connection using the specified socket object.

   Parameters

   socket

       Socket to be initialized

   Return value

   Returns true on success, or false if an error occurred or if the wait
   parameter was false and there were no pending connections.

   wxSocketServer::WaitForAccept, wxSocketBase::SetNotify,
   wxSocketBase::Notify, wxSocketServer::Accept

=head2 Wx::SocketServer::WaitForAccept

   bool WaitForAccept(long seconds = -1, long millisecond = 0)

   This function waits for an incoming connection. Use it if you want to
   call Accept or AcceptWith with wait set to false, to detect when an
   incoming connection is waiting to be accepted.

   Parameters

   seconds

       Number of seconds to wait. If -1, it will wait for the default
       timeout, as set with SetTimeout.

   millisecond

       Number of milliseconds to wait.

   Return value

   Returns true if an incoming connection arrived, false if the timeout
   elapsed.

   See also

   wxSocketServer::Accept, wxSocketServer::AcceptWith,
   wxSocketBase::InterruptWait

=head1 Wx::Sound

=head2 Wx::Sound::new

   wxSound()

   Default constructor.

   wxSound(const wxString& fileName, bool isResource = false)

   Constructs a wave object from a file or, under Windows, from a Windows
   resource. Call wxSound::IsOk to determine whether this succeeded.

   Parameters

   fileName

       The filename or Windows resource.

   isResource

       true if fileName is a resource, false if it is a filename.

=head2 Wx::Sound::DESTROY

   ~wxSound()

   Destroys the wxSound object.

=head2 Wx::Sound::Create

   bool Create(const wxString& fileName, bool isResource = false)

   Constructs a wave object from a file or resource.

   Parameters

   fileName

       The filename or Windows resource.

   isResource

       true if fileName is a resource, false if it is a filename.

   Return value

   true if the call was successful, false otherwise.

=head2 Wx::Sound::IsOk

   bool IsOk() const

   Returns true if the object contains a successfully loaded file or
   resource, false otherwise.

=head2 Wx::Sound::IsPlaying

   static bool IsPlaying() const

   Returns true if a sound is played at the moment.

   This method is currently not implemented under Windows.

=head2 Wx::Sound::Play

   bool Play(unsigned flags = wxSOUND_ASYNC) const

   static bool Play(const wxString& filename, unsigned flags =
   wxSOUND_ASYNC)

   Plays the sound file. If another sound is playing, it will be
   interrupted. Returns true on success, false otherwise. Note that in
   general it is possible to delete the object which is being
   asynchronously played any time after calling this function and the
   sound would continue playing, however this currently doesn't work
   under Windows for sound objects loaded from memory data.

   The possible values for flags are:

=head2 Wx::Sound::Stop

   static void Stop()

   If a sound is played, this function stops it.

=head1 Wx::SpinButton

=head2 Wx::SpinButton::new

   wxSpinButton()

   Default constructor.

   wxSpinButton(wxWindow* parent, wxWindowID id, const wxPoint& pos =
   wxDefaultPosition, const wxSize& size = wxDefaultSize, long style =
   wxSP_HORIZONTAL, const wxString& name = "spinButton")

   Constructor, creating and showing a spin button.

   Parameters

   parent

       Parent window. Must not be NULL.

   id  

       Window identifier. A value of -1 indicates a default value.

   pos 

       Window position. If the position (-1, -1) is specified then a
       default position is chosen.

   size

       Window size. If the default size (-1, -1) is specified then a
       default size is chosen.

   style

       Window style. See wxSpinButton.

   name

       Window name.

   See also

   wxSpinButton::Create

=head2 Wx::SpinButton::DESTROY

   void ~wxSpinButton()

   Destructor, destroys the spin button control.

=head2 Wx::SpinButton::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxPoint& pos =
   wxDefaultPosition, const wxSize& size = wxDefaultSize, long style =
   wxSP_HORIZONTAL, const wxString& name = "spinButton")

   Scrollbar creation function called by the spin button constructor. See
   wxSpinButton::wxSpinButton for details.

=head2 Wx::SpinButton::GetMax

   int GetMax() const

   Returns the maximum permissible value.

   See also

   wxSpinButton::SetRange

=head2 Wx::SpinButton::GetMin

   int GetMin() const

   Returns the minimum permissible value.

   See also

   wxSpinButton::SetRange

=head2 Wx::SpinButton::GetValue

   int GetValue() const

   Returns the current spin button value.

   See also

   wxSpinButton::SetValue

=head2 Wx::SpinButton::SetRange

   void SetRange(int min, int max)

   Sets the range of the spin button.

   Parameters

   min 

       The minimum value for the spin button.

   max 

       The maximum value for the spin button.

   See also

   wxSpinButton::GetMin, wxSpinButton::GetMax

=head2 Wx::SpinButton::SetValue

   void SetValue(int value)

   Sets the value of the spin button.

   Parameters

   value

       The value for the spin button.

   See also

   wxSpinButton::GetValue

=head1 Wx::SpinCtrl

=head2 Wx::SpinCtrl::new

   wxSpinCtrl()

   Default constructor.

   wxSpinCtrl(wxWindow* parent, wxWindowID id = -1, const wxString& value
   = wxEmptyString, const wxPoint& pos = wxDefaultPosition, const wxSize&
   size = wxDefaultSize, long style = wxSP_ARROW_KEYS, int min = 0, int
   max = 100, int initial = 0, const wxString& name = _T("wxSpinCtrl"))

   Constructor, creating and showing a spin control.

   Parameters

   parent

       Parent window. Must not be NULL.

   value

       Default value.

   id  

       Window identifier. A value of -1 indicates a default value.

   pos 

       Window position. If the position (-1, -1) is specified then a
       default position is chosen.

   size

       Window size. If the default size (-1, -1) is specified then a
       default size is chosen.

   style

       Window style. See wxSpinButton.

   min 

       Minimal value.

   max 

       Maximal value.

   initial

       Initial value.

   name

       Window name.

   See also

   wxSpinCtrl::Create

=head2 Wx::SpinCtrl::Create

   bool Create(wxWindow* parent, wxWindowID id = -1, const wxString&
   value = wxEmptyString, const wxPoint& pos = wxDefaultPosition, const
   wxSize& size = wxDefaultSize, long style = wxSP_ARROW_KEYS, int min =
   0, int max = 100, int initial = 0, const wxString& name =
   _T("wxSpinCtrl"))

   Creation function called by the spin control constructor.

   See wxSpinCtrl::wxSpinCtrl for details.

=head2 Wx::SpinCtrl::SetValue

   void SetValue(const wxString& text)

   void SetValue(int value)

   Sets the value of the spin control.

=head2 Wx::SpinCtrl::GetValue

   int GetValue() const

   Gets the value of the spin control.

=head2 Wx::SpinCtrl::SetRange

   void SetRange(int minVal, int maxVal)

   Sets range of allowable values.

=head2 Wx::SpinCtrl::SetSelection

   void SetSelection(long from, long to)

   Select the text in the text part of the control between positions from
   (inclusive) and to (exclusive). This is similar to
   wxTextCtrl::SetSelection.

   NB: this is currently only implemented for Windows and generic
   versions of the control.

=head2 Wx::SpinCtrl::GetMin

   int GetMin() const

   Gets minimal allowable value.

=head2 Wx::SpinCtrl::GetMax

   int GetMax() const

   Gets maximal allowable value.

=head1 Wx::SpinEvent

=head2 Wx::SpinEvent::new

   wxSpinEvent(wxEventType commandType = wxEVT_NULL, int id = 0)

   The constructor is not normally used by the user code.

=head2 Wx::SpinEvent::GetPosition

   int GetPosition() const

   Retrieve the current spin button or control value.

=head2 Wx::SpinEvent::SetPosition

   void SetPosition(int pos)

   Set the value associated with the event.

=head1 Wx::SplashScreen

=head2 Wx::SplashScreen::new

   wxSplashScreen(const wxBitmap& bitmap, long splashStyle, int
   milliseconds, wxWindow* parent, wxWindowID id, const wxPoint& pos =
   wxDefaultPosition, const wxSize& size = wxDefaultSize, long style =
   wxSIMPLE_BORDER|wxFRAME_NO_TASKBAR|wxSTAY_ON_TOP)

   Construct the splash screen passing a bitmap, a style, a timeout, a
   window id, optional position and size, and a window style.

   splashStyle is a bitlist of some of the following:

=head2 Wx::SplashScreen::DESTROY

   ~wxSplashScreen()

   Destroys the splash screen.

=head2 Wx::SplashScreen::OnCloseWindow

   void OnCloseWindow(wxCloseEvent& event)

   Reimplement this event handler if you want to set an application
   variable on window destruction, for example.

=head2 Wx::SplashScreen::GetSplashStyle

   long GetSplashStyle() const

   Returns the splash style (see wxSplashScreen::wxSplashScreen for
   details).

=head2 Wx::SplashScreen::GetSplashWindow

   wxSplashScreenWindow* GetSplashWindow() const

   Returns the window used to display the bitmap.

=head2 Wx::SplashScreen::GetTimeout

   int GetTimeout() const

   Returns the timeout in milliseconds.

=head1 Wx::SplitterEvent

=head2 Wx::SplitterEvent::new

   wxSplitterEvent(wxEventType eventType = wxEVT_NULL, wxSplitterWindow *
   splitter = NULL)

   Constructor. Used internally by wxWidgets only.

=head2 Wx::SplitterEvent::GetSashPosition

   int GetSashPosition() const

   Returns the new sash position.

   May only be called while processing
   wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING and
   wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGED events.

=head2 Wx::SplitterEvent::GetX

   int GetX() const

   Returns the x coordinate of the double-click point.

   May only be called while processing
   wxEVT_COMMAND_SPLITTER_DOUBLECLICKED events.

=head2 Wx::SplitterEvent::GetY

   int GetY() const

   Returns the y coordinate of the double-click point.

   May only be called while processing
   wxEVT_COMMAND_SPLITTER_DOUBLECLICKED events.

=head2 Wx::SplitterEvent::GetWindowBeingRemoved

   wxWindow* GetWindowBeingRemoved() const

   Returns a pointer to the window being removed when a splitter window
   is unsplit.

   May only be called while processing wxEVT_COMMAND_SPLITTER_UNSPLIT
   events.

=head2 Wx::SplitterEvent::SetSashPosition

   void SetSashPosition(int pos)

   In the case of wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGED events, sets
   the new sash position. In the case of
   wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING events, sets the new tracking
   bar position so visual feedback during dragging will represent that
   change that will actually take place. Set to -1 from the event handler
   code to prevent repositioning.

   May only be called while processing
   wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING and
   wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGED events.

   Parameters

   pos 

       New sash position.

=head1 Wx::SplitterWindow

=head2 Wx::SplitterWindow::new

   wxSplitterWindow()

   Default constructor.

   wxSplitterWindow(wxWindow* parent, wxWindowID id, const wxPoint& point
   = wxDefaultPosition, const wxSize& size = wxDefaultSize, long
   style=wxSP_3D, const wxString& name = "splitterWindow")

   Constructor for creating the window.

   Parameters

   parent

       The parent of the splitter window.

   id  

       The window identifier.

   pos 

       The window position.

   size

       The window size.

   style

       The window style. See wxSplitterWindow.

   name

       The window name.

   Remarks

   After using this constructor, you must create either one or two
   subwindows with the splitter window as parent, and then call one of
   wxSplitterWindow::Initialize, wxSplitterWindow::SplitVertically and
   wxSplitterWindow::SplitHorizontally in order to set the pane(s).

   You can create two windows, with one hidden when not being shown; or
   you can create and delete the second pane on demand.

   See also

   wxSplitterWindow::Initialize, wxSplitterWindow::SplitVertically,
   wxSplitterWindow::SplitHorizontally, wxSplitterWindow::Create

=head2 Wx::SplitterWindow::DESTROY

   ~wxSplitterWindow()

   Destroys the wxSplitterWindow and its children.

=head2 Wx::SplitterWindow::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxPoint& point =
   wxDefaultPosition, const wxSize& size = wxDefaultSize, long
   style=wxSP_3D, const wxString& name = "splitterWindow")

   Creation function, for two-step construction. See
   wxSplitterWindow::wxSplitterWindow for details.

=head2 Wx::SplitterWindow::GetMinimumPaneSize

   int GetMinimumPaneSize() const

   Returns the current minimum pane size (defaults to zero).

   See also

   wxSplitterWindow::SetMinimumPaneSize

=head2 Wx::SplitterWindow::GetSashGravity

   double GetSashGravity()

   Returns the current sash gravity.

   See also

   wxSplitterWindow::SetSashGravity

=head2 Wx::SplitterWindow::GetSashPosition

   int GetSashPosition()

   Returns the current sash position.

   See also

   wxSplitterWindow::SetSashPosition

=head2 Wx::SplitterWindow::GetSplitMode

   int GetSplitMode() const

   Gets the split mode.

   See also

   wxSplitterWindow::SetSplitMode, wxSplitterWindow::SplitVertically,
   wxSplitterWindow::SplitHorizontally.

=head2 Wx::SplitterWindow::GetWindow1

   wxWindow* GetWindow1() const

   Returns the left/top or only pane.

=head2 Wx::SplitterWindow::GetWindow2

   wxWindow* GetWindow2() const

   Returns the right/bottom pane.

=head2 Wx::SplitterWindow::Initialize

   void Initialize(wxWindow* window)

   Initializes the splitter window to have one pane. The child window is
   shown if it is currently hidden.

   Parameters

   window

       The pane for the unsplit window.

   Remarks

   This should be called if you wish to initially view only a single pane
   in the splitter window.

   See also

   wxSplitterWindow::SplitVertically, wxSplitterWindow::SplitHorizontally

=head2 Wx::SplitterWindow::IsSplit

   bool IsSplit() const

   Returns true if the window is split, false otherwise.

=head2 Wx::SplitterWindow::OnDoubleClickSash

   virtual void OnDoubleClickSash(int x, int y)

   Application-overridable function called when the sash is
   double-clicked with the left mouse button.

   Parameters

   x   

       The x position of the mouse cursor.

   y   

       The y position of the mouse cursor.

   Remarks

   The default implementation of this function calls Unsplit if the
   minimum pane size is zero.

   See also

   wxSplitterWindow::Unsplit

=head2 Wx::SplitterWindow::OnUnsplit

   virtual void OnUnsplit(wxWindow* removed)

   Application-overridable function called when the window is unsplit,
   either programmatically or using the wxSplitterWindow user interface.

   Parameters

   removed

       The window being removed.

   Remarks

   The default implementation of this function simply hides removed. You
   may wish to delete the window.

=head2 Wx::SplitterWindow::OnSashPositionChange

   virtual bool OnSashPositionChange(int newSashPosition)

   Application-overridable function called when the sash position is
   changed by user. It may return false to prevent the change or true to
   allow it.

   Parameters

   newSashPosition

       The new sash position (always positive or zero)

   Remarks

   The default implementation of this function verifies that the sizes of
   both panes of the splitter are greater than minimum pane size.

=head2 Wx::SplitterWindow::ReplaceWindow

   bool ReplaceWindow(wxWindow * winOld, wxWindow * winNew)

   This function replaces one of the windows managed by the
   wxSplitterWindow with another one. It is in general better to use it
   instead of calling Unsplit() and then resplitting the window back
   because it will provoke much less flicker (if any). It is valid to
   call this function whether the splitter has two windows or only one.

   Both parameters should be non-NULL and winOld must specify one of the
   windows managed by the splitter. If the parameters are incorrect or
   the window couldn't be replaced, false is returned. Otherwise the
   function will return true, but please notice that it will not delete
   the replaced window and you may wish to do it yourself.

   See also

   wxSplitterWindow::GetMinimumPaneSize

   See also

   wxSplitterWindow::Unsplit

=head2 Wx::SplitterWindow::SetSashGravity

   void SetSashGravity(double gravity)

   Sets the sash gravity.

   Parameters

   gravity

       The sash gravity. Value between 0.0 and 1.0.

=head2 Wx::SplitterWindow::SetSashPosition

   void SetSashPosition(int position, const bool redraw = true)

   Sets the sash position.

   Parameters

   position

       The sash position in pixels.

   redraw

       If true, resizes the panes and redraws the sash and border.

   Remarks

   Does not currently check for an out-of-range value.

   See also

   wxSplitterWindow::GetSashPosition

=head2 Wx::SplitterWindow::SetSashSize

   void SetSashSize(int size)

   Sets the sash size. Normally, the sash size is determined according to
   the metrics of each platform, but the application can override this,
   for example to show a thin sash that the user is not expected to drag.
   If size is more -1, the custom sash size will be used.

=head2 Wx::SplitterWindow::SetMinimumPaneSize

   void SetMinimumPaneSize(int paneSize)

   Sets the minimum pane size.

   Parameters

   paneSize

       Minimum pane size in pixels.

   Remarks

   The default minimum pane size is zero, which means that either pane
   can be reduced to zero by dragging the sash, thus removing one of the
   panes. To prevent this behaviour (and veto out-of-range sash
   dragging), set a minimum size, for example 20 pixels. If the
   wxSP_PERMIT_UNSPLIT style is used when a splitter window is created,
   the window may be unsplit even if minimum size is non-zero.

   See also

   wxSplitterWindow::GetMinimumPaneSize

=head2 Wx::SplitterWindow::SetSplitMode

   void SetSplitMode(int mode)

   Sets the split mode.

   Parameters

   mode

       Can be wxSPLIT_VERTICAL or wxSPLIT_HORIZONTAL.

   Remarks

   Only sets the internal variable; does not update the display.

   See also

   wxSplitterWindow::GetSplitMode, wxSplitterWindow::SplitVertically,
   wxSplitterWindow::SplitHorizontally.

=head2 Wx::SplitterWindow::SplitHorizontally

   bool SplitHorizontally(wxWindow* window1, wxWindow* window2, int
   sashPosition = 0)

   Initializes the top and bottom panes of the splitter window. The child
   windows are shown if they are currently hidden.

   Parameters

   window1

       The top pane.

   window2

       The bottom pane.

   sashPosition

       The initial position of the sash. If this value is positive, it
       specifies the size of the upper pane. If it is negative, its
       absolute value gives the size of the lower pane. Finally, specify
       0 (default) to choose the default position (half of the total
       window height).

   Return value

   true if successful, false otherwise (the window was already split).

   Remarks

   This should be called if you wish to initially view two panes. It can
   also be called at any subsequent time, but the application should
   check that the window is not currently split using IsSplit.

   See also

   wxSplitterWindow::SplitVertically, wxSplitterWindow::IsSplit,
   wxSplitterWindow::Unsplit

=head2 Wx::SplitterWindow::SplitVertically

   bool SplitVertically(wxWindow* window1, wxWindow* window2, int
   sashPosition = 0)

   Initializes the left and right panes of the splitter window. The child
   windows are shown if they are currently hidden.

   Parameters

   window1

       The left pane.

   window2

       The right pane.

   sashPosition

       The initial position of the sash. If this value is positive, it
       specifies the size of the left pane. If it is negative, it is
       absolute value gives the size of the right pane. Finally, specify
       0 (default) to choose the default position (half of the total
       window width).

   Return value

   true if successful, false otherwise (the window was already split).

   Remarks

   This should be called if you wish to initially view two panes. It can
   also be called at any subsequent time, but the application should
   check that the window is not currently split using IsSplit.

   See also

   wxSplitterWindow::SplitHorizontally, wxSplitterWindow::IsSplit,
   wxSplitterWindow::Unsplit.

=head2 Wx::SplitterWindow::Unsplit

   bool Unsplit(wxWindow* toRemove = NULL)

   Unsplits the window.

   Parameters

   toRemove

       The pane to remove, or NULL to remove the right or bottom pane.

   Return value

   true if successful, false otherwise (the window was not split).

   Remarks

   This call will not actually delete the pane being removed; it calls
   OnUnsplit which can be overridden for the desired behaviour. By
   default, the pane being removed is hidden.

   See also

   wxSplitterWindow::SplitHorizontally, wxSplitterWindow::SplitVertically,
   wxSplitterWindow::IsSplit, wxSplitterWindow::OnUnsplit

=head2 Wx::SplitterWindow::UpdateSize

   void UpdateSize()

   Causes any pending sizing of the sash and child panes to take place
   immediately.

   Such resizing normally takes place in idle time, in order to wait for
   layout to be completed. However, this can cause unacceptable flicker
   as the panes are resized after the window has been shown. To work
   around this, you can perform window layout (for example by sending a
   size event to the parent window), and then call this function, before
   showing the top-level window.

=head1 Wx::SplitterRenderParams

=head2 Wx::Event::widthSash

   const wxCoord widthSash

   The width of the splitter sash.

=head2 Wx::SplitterRenderParams::border

   const wxCoord border

   The width of the border drawn by the splitter inside it, may be 0.

=head2 Wx::SplitterRenderParams::isHotSensitive

   const bool isHotSensitive

   true if the sash changes appearance when the mouse passes over it,
   false otherwise.

=head1 Wx::StackFrame

=head2 Wx::StackFrame::GetAddress

   void* GetAddress() const

   Return the address of this frame.

=head2 Wx::StackFrame::GetFileName

   wxString GetFileName() const

   Return the name of the file containing this frame, empty if
   unavailable (typically because debug info is missing).

   Use HasSourceLocation to check whether the file name is available.

=head2 Wx::StackFrame::GetLevel

   size_t GetLevel() const

   Get the level of this frame (deepest/innermost one is 0).

=head2 Wx::StackFrame::GetLine

   size_t GetLine() const

   Return the line number of this frame, 0 if unavailable.

   See also

   GetFileName

=head2 Wx::StackFrame::GetModule

   wxString GetModule() const

   Get the module this function belongs to (empty if not available).

=head2 Wx::StackFrame::GetName

   wxString GetName() const

   Return the unmangled (if possible) name of the function containing
   this frame.

=head2 Wx::StackFrame::GetOffset

   size_t GetOffset() const

   Return the return address of this frame.

=head2 Wx::StackFrame::GetParam

   bool GetParam(size_t n, wxString * type, wxString * name, wxString *
   value) const

   Get the name, type and value (in text form) of the given parameter.
   Any pointer may be NULL if you're not interested in the corresponding
   value.

   Return true if at least some values could be retrieved.

   This function currently is only implemented under Win32 and requires a
   PDB file.

=head2 Wx::StackFrame::GetParamCount

   size_t GetParamCount() const

   Return the number of parameters of this function (may return 0 if we
   can't retrieve the parameters info even although the function does
   have parameters).

=head2 Wx::StackFrame::HasSourceLocation

   bool HasSourceLocation() const

   Return true if we have the file name and line number for this frame.

=head1 Wx::StackWalker

=head2 Wx::StackWalker::new

   wxStackWalker()

   Constructor does nothing, use Walk() to walk the stack.

=head2 Wx::StackWalker::DESTROY

   ~wxStackWalker()

   Destructor does nothing neither but should be virtual as this class is
   used as a base one.

=head2 Wx::StackWalker::OnStackFrame

   void OnStackFrame(const wxStackFrame& frame)

   This function must be overrided to process the given frame.

=head2 Wx::StackWalker::Walk

   void Walk(size_t skip = 1, size_t maxDepth = 200)

   Enumerate stack frames from the current location, skipping the initial
   number of them (this can be useful when Walk() is called from some
   known location and you don't want to see the first few frames anyhow;
   also notice that Walk() frame itself is not included if skip >= 1).

   Up to maxDepth frames are walked from the innermost to the outermost
   one.

=head2 Wx::StackWalker::WalkFromException

   void WalkFromException()

   Enumerate stack frames from the location of uncaught exception. This
   method can only be called from wxApp::OnFatalException().

=head1 Wx::StandardPaths

=head2 Wx::StandardPaths::Get

   static wxStandardPathsBase& Get()

   Returns reference to the unique global standard paths object.

=head2 Wx::StandardPaths::GetConfigDir

   wxString GetConfigDir() const

   Return the directory containing the system config files.

   Example return values:

=head2 Wx::StandardPaths::GetDataDir

   wxString GetDataDir() const

   Return the location of the applications global, i.e. not
   user-specific, data files.

   Example return values:

=head2 Wx::StandardPaths::GetDocumentsDir

   wxString GetDocumentsDir() const

   Return the directory containing the current user's documents.

   Example return values:

=head2 Wx::StandardPaths::GetExecutablePath

   wxString GetExecutablePath() const

   Return the directory and the filename for the current executable.

   Example return values:

=head2 Wx::StandardPaths::GetInstallPrefix

   wxString GetInstallPrefix() const

   Note: This function is only available under Unix.

   Return the program installation prefix, e.g. /usr, /opt or
   /home/zeitlin.

   If the prefix had been previously by SetInstallPrefix, returns that
   value, otherwise tries to determine it automatically (Linux only right
   now) and finally returns the default /usr/local value if it failed.

=head2 Wx::StandardPaths::GetLocalDataDir

   wxString GetLocalDataDir() const

   Return the location for application data files which are host-specific
   and can't, or shouldn't, be shared with the other machines.

   This is the same as GetDataDir() except under Unix where it returns
   /etc/appname.

=head2 Wx::StandardPaths::GetLocalizedResourcesDir

   wxString GetLocalizedResourcesDir(const wxChar* lang, ResourceCat
   category = ResourceCat_None) const

   Return the localized resources directory containing the resource files
   of the specified category for the given language.

   In general this is just the same as lang subdirectory of
   GetResourcesDir() (or lang.lproj under Mac OS X) but is something
   quite different for message catalog category under Unix where it
   returns the standard prefix/share/locale/lang/LC_MESSAGES directory.

   This function is new since wxWidgets version 2.7.0

=head2 Wx::StandardPaths::GetPluginsDir

   wxString GetPluginsDir() const

   Return the directory where the loadable modules (plugins) live.

   Example return values:

=head2 Wx::StandardPaths::GetResourcesDir

   wxString GetResourcesDir() const

   Return the directory where the application resource files are located.
   The resources are the auxiliary data files needed for the application
   to run and include, for example, image and sound files it might use.

   This function is the same as GetDataDir for all platforms except Mac
   OS X.

   Example return values:

=head2 Wx::StandardPaths::GetTempDir

   wxString GetTempDir() const

   Return the directory for storing temporary files. To create unique
   temporary files, it is best to use wxFileName::CreateTempFileName for
   correct behaviour when multiple processes are attempting to create
   temporary files.

   This function is new since wxWidgets version 2.7.2

=head2 Wx::StandardPaths::GetUserConfigDir

   wxString GetUserConfigDir() const

   Return the directory for the user config files:

=head2 Wx::StandardPaths::GetUserDataDir

   wxString GetUserDataDir() const

   Return the directory for the user-dependent application data files:

=head2 Wx::StandardPaths::GetUserLocalDataDir

   wxString GetUserLocalDataDir() const

   Return the directory for user data files which shouldn't be shared
   with the other machines.

   This is the same as GetUserDataDir() for all platforms except Windows
   where it returns C:\Documents and Settings\username\Local
   Settings\Application Data\appname

=head2 Wx::StandardPaths::SetInstallPrefix

   void SetInstallPrefix(const wxString& prefix)

   Note: This function is only available under Unix.

   Lets wxStandardPaths know about the real program installation prefix
   on a Unix system. By default, the value returned by GetInstallPrefix
   is used.

   Although under Linux systems the program prefix may usually be
   determined automatically, portable programs should call this function.
   Usually the prefix is set during program configuration if using GNU
   autotools and so it is enough to pass its value defined in config.h to
   this function.

=head1 Wx::StaticBitmap

=head2 Wx::StaticBitmap::new

   wxStaticBitmap()

   Default constructor.

   wxStaticBitmap(wxWindow* parent, wxWindowID id, const wxBitmap& label,
   const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = 0, const wxString& name = "staticBitmap")

   Constructor, creating and showing a static bitmap control.

   Parameters

   parent

       Parent window. Should not be NULL.

   id  

       Control identifier. A value of -1 denotes a default value.

   label

       Bitmap label.

   pos 

       Window position.

   size

       Window size.

   style

       Window style. See wxStaticBitmap.

   name

       Window name.

   See also

   wxStaticBitmap::Create

=head2 Wx::StaticBitmap::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxBitmap& label,
   const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = 0, const wxString& name = "staticBitmap")

   Creation function, for two-step construction. For details see
   wxStaticBitmap::wxStaticBitmap.

=head2 Wx::StaticBitmap::GetBitmap

   wxBitmap GetBitmap() const

   Returns the bitmap currently used in the control. Notice that this
   method can be called even if SetIcon had been used.

   See also

   wxStaticBitmap::SetBitmap

=head2 Wx::StaticBitmap::GetIcon

   wxIcon GetIcon() const

   Returns the icon currently used in the control. Notice that this
   method can only be called if SetIcon had been used: an icon can't be
   retrieved from the control if a bitmap had been set (using SetBitmap).

   See also

   wxStaticBitmap::SetIcon

=head2 Wx::StaticBitmap::SetBitmap

   virtual void SetBitmap(const wxBitmap& label)

   Sets the bitmap label.

   Parameters

   label

       The new bitmap.

   See also

   wxStaticBitmap::GetBitmap

=head2 Wx::StaticBitmap::SetIcon

   virtual void SetIcon(const wxIcon& label)

   Sets the label to the given icon.

   Parameters

   label

       The new icon.

   See also

   wxStaticBitmap::GetIcon

=head1 Wx::StaticBox

=head2 Wx::StaticBox::new

   wxStaticBox()

   Default constructor.

   wxStaticBox(wxWindow* parent, wxWindowID id, const wxString& label,
   const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = 0, const wxString& name = "staticBox")

   Constructor, creating and showing a static box.

   Parameters

   parent

       Parent window. Must not be NULL.

   id  

       Window identifier. A value of -1 indicates a default value.

   label

       Text to be displayed in the static box, the empty string for no
       label.

   pos 

       Window position. If the position (-1, -1) is specified then a
       default position is chosen.

   size

       Checkbox size. If the size (-1, -1) is specified then a default
       size is chosen.

   style

       Window style. See wxStaticBox.

   name

       Window name.

   See also

   wxStaticBox::Create

=head2 Wx::StaticBox::DESTROY

   void ~wxStaticBox()

   Destructor, destroying the group box.

=head2 Wx::StaticBox::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxString& label,
   const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = 0, const wxString& name = "staticBox")

   Creates the static box for two-step construction. See
   wxStaticBox::wxStaticBox for further details.

=head1 Wx::StaticBoxSizer

=head2 Wx::StaticBoxSizer::new

   wxStaticBoxSizer(wxStaticBox* box, int orient)

   wxStaticBoxSizer(int orient, wxWindow *parent, const wxString& label =
   wxEmptyString)

   The first constructor uses an already existing static box. It takes
   the associated static box and the orientation orient, which can be
   either wxVERTICAL or wxHORIZONTAL as parameters.

   The second one creates a new static box with the given label and
   parent window.

=head2 Wx::StaticBoxSizer::GetStaticBox

   wxStaticBox* GetStaticBox()

   Returns the static box associated with the sizer.

=head1 Wx::StaticLine

=head2 Wx::StaticLine::new

   wxStaticLine()

   Default constructor.

   wxStaticLine(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint&
   pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long
   style = wxLI_HORIZONTAL, const wxString& name = "staticLine")

   Constructor, creating and showing a static line.

   Parameters

   parent

       Parent window. Must not be NULL.

   id  

       Window identifier. A value of -1 indicates a default value.

   pos 

       Window position. If the position (-1, -1) is specified then a
       default position is chosen.

   size

       Size. Note that either the height or the width (depending on
       whether the line if horizontal or vertical) is ignored.

   style

       Window style (either wxLI_HORIZONTAL or wxLI_VERTICAL).

   name

       Window name.

   See also

   wxStaticLine::Create

=head2 Wx::StaticLine::Create

   bool Create(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint&
   pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long
   style = 0, const wxString& name = "staticLine")

   Creates the static line for two-step construction. See
   wxStaticLine::wxStaticLine for further details.

=head2 Wx::StaticLine::IsVertical

   bool IsVertical() const

   Returns true if the line is vertical, false if horizontal.

=head2 Wx::StaticLine::GetDefaultSize

   int GetDefaultSize()

   This static function returns the size which will be given to the
   smaller dimension of the static line, i.e. its height for a horizontal
   line or its width for a vertical one.

=head1 Wx::StaticText

=head2 Wx::StaticText::new

   wxStaticText()

   Default constructor.

   wxStaticText(wxWindow* parent, wxWindowID id, const wxString& label,
   const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = 0, const wxString& name = "staticText")

   Constructor, creating and showing a text control.

   Parameters

   parent

       Parent window. Should not be NULL.

   id  

       Control identifier. A value of -1 denotes a default value.

   label

       Text label.

   pos 

       Window position.

   size

       Window size.

   style

       Window style. See wxStaticText.

   name

       Window name.

   See also

   wxStaticText::Create

=head2 Wx::StaticText::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxString& label,
   const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = 0, const wxString& name = "staticText")

   Creation function, for two-step construction. For details see
   wxStaticText::wxStaticText.

=head2 Wx::StaticText::GetLabel

   wxString GetLabel() const

   Returns the contents of the control.

=head2 Wx::StaticText::SetLabel

   virtual void SetLabel(const wxString& label)

   Sets the static text label and updates the controls size to exactly
   fit the label unless the control has wxST_NO_AUTORESIZE flag.

   Parameters

   label

       The new label to set. It may contain newline characters.

=head2 Wx::StaticText::Wrap

   void Wrap(int width)

   This functions wraps the controls label so that each of its lines
   becomes at most width pixels wide if possible (the lines are broken at
   words boundaries so it might not be the case if words are too long).
   If width is negative, no wrapping is done.

   This function is new since wxWidgets version 2.6.2

=head1 Wx::StatusBar

=head2 Wx::StatusBar::new

   wxStatusBar()

   Default constructor.

   wxStatusBar(wxWindow* parent, wxWindowID id = wxID_ANY, long style =
   wxST_SIZEGRIP, const wxString& name = "statusBar")

   Constructor, creating the window.

   Parameters

   parent

       The window parent, usually a frame.

   id  

       The window identifier. It may take a value of -1 to indicate a
       default value.

   style

       The window style. See wxStatusBar.

   name

       The name of the window. This parameter is used to associate a name
       with the item, allowing the application user to set Motif resource
       values for individual windows.

   See also

   wxStatusBar::Create

=head2 Wx::StatusBar::DESTROY

   void ~wxStatusBar()

   Destructor.

=head2 Wx::StatusBar::Create

   bool Create(wxWindow* parent, wxWindowID id = wxID_ANY, long style =
   wxST_SIZEGRIP, const wxString& name = "statusBar")

   Creates the window, for two-step construction.

   See wxStatusBar::wxStatusBar for details.

=head2 Wx::StatusBar::GetFieldRect

   virtual bool GetFieldRect(int i, wxRect& rect) const

   Returns the size and position of a field's internal bounding
   rectangle.

   Parameters

   i   

       The field in question.

   rect

       The rectangle values are placed in this variable.

   Return value

   true if the field index is valid, false otherwise.

   See also

   wxRect

   wxPerl note: In wxPerl this function returns a Wx::Rect if the field
   index is valid, undef otherwise.

=head2 Wx::StatusBar::GetFieldsCount

   int GetFieldsCount() const

   Returns the number of fields in the status bar.

=head2 Wx::StatusBar::GetStatusText

   virtual wxString GetStatusText(int i = 0) const

   Returns the string associated with a status bar field.

   Parameters

   i   

       The number of the status field to retrieve, starting from zero.

   Return value

   The status field string if the field is valid, otherwise the empty
   string.

   See also

   wxStatusBar::SetStatusText

=head2 Wx::StatusBar::PopStatusText

   void PopStatusText(int field = 0)

   Sets the field text to the top of the stack, and pops the stack of
   saved strings.

   See also

   wxStatusBar::PushStatusText

=head2 Wx::StatusBar::PushStatusText

   void PushStatusText(const wxString& string, int field = 0)

   Saves the current field text in a per field stack, and sets the field
   text to the string passed as argument.

=head2 Wx::StatusBar::SetFieldsCount

   virtual void SetFieldsCount(int number = 1, int* widths = NULL)

   Sets the number of fields, and optionally the field widths.

   wxPython note: Only the first parameter is accepted. Use
   SetStatusWidths to set the widths of the fields.

   wxPerl note: In wxPerl this function accepts only the n parameter. Use
   SetStatusWidths to set the field widths.

   Parameters

   number

       The number of fields.

   widths

       An array of n integers interpreted in the same way as in
       SetStatusWidths

=head2 Wx::StatusBar::SetMinHeight

   void SetMinHeight(int height)

   Sets the minimal possible height for the status bar. The real height
   may be bigger than the height specified here depending on the size of
   the font used by the status bar.

=head2 Wx::StatusBar::SetStatusText

   virtual void SetStatusText(const wxString& text, int i = 0)

   Sets the text for one field.

   Parameters

   text

       The text to be set. Use an empty string ("") to clear the field.

   i   

       The field to set, starting from zero.

   See also

   wxStatusBar::GetStatusText, wxFrame::SetStatusText

=head2 Wx::StatusBar::SetStatusWidths

   virtual void SetStatusWidths(int n, int *widths)

   Sets the widths of the fields in the status line. There are two types
   of fields: fixed widths one and variable width fields. For the fixed
   width fields you should specify their (constant) width in pixels. For
   the variable width fields, specify a negative number which indicates
   how the field should expand: the space left for all variable width
   fields is divided between them according to the absolute value of this
   number. A variable width field with width of -2 gets twice as much of
   it as a field with width -1 and so on.

   For example, to create one fixed width field of width 100 in the right
   part of the status bar and two more fields which get 66% and 33% of
   the remaining space correspondingly, you should use an array
   containing -2, -1 and 100.

   Parameters

   n   

       The number of fields in the status bar. Must be equal to the
       number passed to SetFieldsCount the last time it was called.

   widths

       Contains an array of n integers, each of which is either an
       absolute status field width in pixels if positive or indicates a
       variable width field if negative.

   Remarks

   The widths of the variable fields are calculated from the total width
   of all fields, minus the sum of widths of the non-variable fields,
   divided by the number of variable fields.

   See also

   wxStatusBar::SetFieldsCount, wxFrame::SetStatusWidths

   wxPython note: Only a single parameter is required, a Python list of
   integers.

   wxPerl note: In wxPerl this method takes as parameters the field
   widths.

=head2 Wx::StatusBar::SetStatusStyles

   virtual void SetStatusStyles(int n, int *styles)

   Sets the styles of the fields in the status line which can make fields
   appear flat or raised instead of the standard sunken 3D border.

   Parameters

   n   

       The number of fields in the status bar. Must be equal to the
       number passed to SetFieldsCount the last time it was called.

   styles

       Contains an array of n integers with the styles for each field.
       There are three possible styles:

=head1 Wx::StdDialogButtonSizer

=head2 Wx::StdDialogButtonSizer::new

   wxStdDialogButtonSizer()

   Constructor for a wxStdDialogButtonSizer.

=head2 Wx::StdDialogButtonSizer::AddButton

   void AddButton(wxButton* button)

   Adds a button to the wxStdDialogButtonSizer. The button must have one
   of the following identifiers:

=head2 Wx::StdDialogButtonSizer::Realize

   void Realize()

   Rearranges the buttons and applies proper spacing between buttons to
   make them match the platform or toolkit's interface guidelines.

=head2 Wx::StdDialogButtonSizer::SetAffirmativeButton

   void SetAffirmativeButton(wxButton* button)

   Sets the affirmative button for the sizer. This allows you to use
   identifiers other than the standard identifiers outlined above.

=head2 Wx::StdDialogButtonSizer::SetCancelButton

   void SetCancelButton(wxButton* button)

   Sets the cancel button for the sizer. This allows you to use
   identifiers other than the standard identifiers outlined above.

=head2 Wx::StdDialogButtonSizer::SetNegativeButton

   void SetNegativeButton(wxButton* button)

   Sets the negative button for the sizer. This allows you to use
   identifiers other than the standard identifiers outlined above.

=head1 Wx::StopWatch

=head2 Wx::StopWatch::new

   wxStopWatch()

   Constructor. This starts the stop watch.

=head2 Wx::StopWatch::Pause

   void Pause()

   Pauses the stop watch. Call wxStopWatch::Resume to resume time
   measuring again.

   If this method is called several times, Resume() must be called the
   same number of times to really resume the stop watch. You may,
   however, call Start to resume it unconditionally.

=head2 Wx::StopWatch::Resume

   void Resume()

   Resumes the stop watch which had been paused with wxStopWatch::Pause.

=head2 Wx::StopWatch::Start

   void Start(long milliseconds = 0)

   (Re)starts the stop watch with a given initial value.

=head2 Wx::StopWatch::Time

   long Time() const

   Returns the time in milliseconds since the start (or restart) or the
   last call of wxStopWatch::Pause.

=head1 Wx::StreamBase

=head2 Wx::StreamBase::new

   wxStreamBase()

   Creates a dummy stream object. It doesn't do anything.

=head2 Wx::StreamBase::DESTROY

   ~wxStreamBase()

   Destructor.

=head2 Wx::StreamBase::GetLength

   wxFileOffset GetLength() const

   Returns the length of the stream in bytes. If the length cannot be
   determined (this is always the case for socket streams for example),
   returns wxInvalidOffset.

   This function is new since wxWidgets version 2.5.4

=head2 Wx::StreamBase::GetLastError

   wxStreamError GetLastError() const

   This function returns the last error.

=head2 Wx::StreamBase::GetSize

   size_t GetSize() const

   GetLength

   This function returns the size of the stream. For example, for a file
   it is the size of the file.

   Warning

   There are streams which do not have size by definition, such as socket
   streams. In that cases, GetSize returns 0 so you should always test
   its return value.

=head2 Wx::StreamBase::IsOk

   virtual bool IsOk() const

   Returns true if no error occurred on the stream.

   See also

   GetLastError

=head2 Wx::StreamBase::IsSeekable

   bool IsSeekable() const

   Returns true if the streams supports seeking to arbitrary offsets.

=head2 Wx::StreamBase::OnSysRead

   size_t OnSysRead(void* buffer, size_t bufsize)

   Internal function. It is called when the stream wants to read data of
   the specified size. It should return the size that was actually read.

=head2 Wx::StreamBase::OnSysSeek

   off_t OnSysSeek(off_t pos, wxSeekMode mode)

   Internal function. It is called when the stream needs to change the
   current position.

=head2 Wx::StreamBase::OnSysTell

   off_t OnSysTell() const

   Internal function. Is is called when the stream needs to know the real
   position.

=head2 Wx::StreamBase::OnSysWrite

   size_t OnSysWrite(const void *buffer, size_t bufsize)

   See OnSysRead.

=head1 Wx::StreamBuffer

=head2 Wx::StreamBuffer::new

   wxStreamBuffer(wxStreamBase& stream, BufMode mode)

   Constructor, creates a new stream buffer using stream as a parent
   stream and mode as the IO mode. mode can be: wxStreamBuffer::read,
   wxStreamBuffer::write, wxStreamBuffer::read_write.

   One stream can have many stream buffers but only one is used
   internally to pass IO call (e.g. wxInputStream::Read() ->
   wxStreamBuffer::Read()), but you can call directly
   wxStreamBuffer::Read without any problems. Note that all errors and
   messages linked to the stream are stored in the stream, not the stream
   buffers:

     streambuffer.Read(...);
     streambuffer2.Read(...); /* This call erases previous error messages set by 
                                 ``streambuffer'' */

   wxStreamBuffer(BufMode mode)

   Constructor, creates a new empty stream buffer which won't flush any
   data to a stream. mode specifies the type of the buffer (read, write,
   read_write). This stream buffer has the advantage to be stream
   independent and to work only on memory buffers but it is still
   compatible with the rest of the wxStream classes. You can write, read
   to this special stream and it will grow (if it is allowed by the user)
   its internal buffer. Briefly, it has all functionality of a "normal''
   stream.

   Warning

   The "read_write" mode doesn't currently work for standalone stream
   buffers.

   wxStreamBuffer(const wxStreamBuffer&buffer)

   Constructor. It initializes the stream buffer with the data of the
   specified stream buffer. The new stream buffer has the same
   attributes, size, position and they share the same buffer. This will
   cause problems if the stream to which the stream buffer belong is
   destroyed and the newly cloned stream buffer continues to be used,
   trying to call functions in the (destroyed) stream. It is advised to
   use this feature only in very local area of the program.

   See also

   wxStreamBuffer:SetBufferIO

=head2 Wx::StreamBuffer::DESTROY

   wxStreamBuffer(~wxStreamBuffer)

   Destructor. It finalizes all IO calls and frees all internal buffers
   if necessary.

=head2 Wx::StreamBuffer::Read

   size_t Read(void *buffer, size_t size)

   Reads a block of the specified size and stores the data in buffer.
   This function tries to read from the buffer first and if more data has
   been requested, reads more data from the associated stream and updates
   the buffer accordingly until all requested data is read.

   Return value

   It returns the size of the data read. If the returned size is
   different of the specified size, an error has occurred and should be
   tested using GetLastError.

   size_t Read(wxStreamBuffer *buffer)

   Copies data to buffer. The function returns when buffer is full or
   when there isn't any more data in the current buffer.

   See also

   wxStreamBuffer::Write

=head2 Wx::StreamBuffer::Write

   size_t Write(const void *buffer, size_t size)

   Writes a block of the specified size using data of buffer. The data
   are cached in a buffer before being sent in one block to the stream.

   size_t Write(wxStreamBuffer *buffer)

   See Read.

=head2 Wx::StreamBuffer::GetChar

   char GetChar()

   Gets a single char from the stream buffer. It acts like the Read call.

   Problem

   You aren't directly notified if an error occurred during the IO call.

   See also

   wxStreamBuffer::Read

=head2 Wx::StreamBuffer::PutChar

   void PutChar(char c)

   Puts a single char to the stream buffer.

   Problem

   You aren't directly notified if an error occurred during the IO call.

   See also

   wxStreamBuffer::Read

=head2 Wx::StreamBuffer::Tell

   off_t Tell() const

   Gets the current position in the stream. This position is calculated
   from the real position in the stream and from the internal buffer
   position: so it gives you the position in the real stream counted from
   the start of the stream.

   Return value

   Returns the current position in the stream if possible,
   wxInvalidOffset in the other case.

=head2 Wx::StreamBuffer::Seek

   off_t Seek(off_t pos, wxSeekMode mode)

   Changes the current position.

   mode may be one of the following:

=head2 Wx::StreamBuffer::ResetBuffer

   void ResetBuffer()

   Resets to the initial state variables concerning the buffer.

=head2 Wx::StreamBuffer::SetBufferIO

   void SetBufferIO(char* buffer_start, char* buffer_end)

   Specifies which pointers to use for stream buffering. You need to pass
   a pointer on the start of the buffer end and another on the end. The
   object will use this buffer to cache stream data. It may be used also
   as a source/destination buffer when you create an empty stream buffer
   (See wxStreamBuffer::wxStreamBuffer).

   Remarks

   When you use this function, you will have to destroy the IO buffers
   yourself after the stream buffer is destroyed or don't use it anymore.
   In the case you use it with an empty buffer, the stream buffer will
   not resize it when it is full.

   See also

   wxStreamBuffer constructor

=head2 Wx::StreamBuffer::GetBufferStart

   void * GetBufferStart() const

   Returns a pointer on the start of the stream buffer.

=head2 Wx::StreamBuffer::GetBufferEnd

   void * GetBufferEnd() const

   Returns a pointer on the end of the stream buffer.

=head2 Wx::StreamBuffer::GetBufferPos

   void * GetBufferPos() const

   Returns a pointer on the current position of the stream buffer.

=head2 Wx::StreamBuffer::GetIntPosition

   off_t GetIntPosition() const

   Returns the current position (counted in bytes) in the stream buffer.

=head2 Wx::StreamBuffer::SetIntPosition

   void SetIntPosition(size_t pos)

   Sets the current position (in bytes) in the stream buffer.

   Warning

   Since it is a very low-level function, there is no check on the
   position: specifying an invalid position can induce unexpected
   results.

=head2 Wx::StreamBuffer::GetLastAccess

   size_t GetLastAccess() const

   Returns the amount of bytes read during the last IO call to the parent
   stream.

=head2 Wx::StreamBuffer::Fixed

   void Fixed(bool fixed)

   Toggles the fixed flag. Usually this flag is toggled at the same time
   as flushable. This flag allows (when it has the false value) or
   forbids (when it has the true value) the stream buffer to resize
   dynamically the IO buffer.

   See also

   wxStreamBuffer::SetBufferIO

=head2 Wx::StreamBuffer::Flushable

   void Flushable(bool flushable)

   Toggles the flushable flag. If flushable is disabled, no data are sent
   to the parent stream.

=head2 Wx::StreamBuffer::FlushBuffer

   bool FlushBuffer()

   Flushes the IO buffer.

=head2 Wx::StreamBuffer::FillBuffer

   bool FillBuffer()

   Fill the IO buffer.

=head2 Wx::StreamBuffer::GetDataLeft

   size_t GetDataLeft()

   Returns the amount of available data in the buffer.

=head2 Wx::StreamBuffer::Stream

   wxStreamBase* Stream()

   Returns the parent stream of the stream buffer.

=head1 Wx::StreamToTextRedirector

=head2 Wx::StreamToTextRedirector::new

   wxStreamToTextRedirector(wxTextCtrl *text, ostream *ostr = NULL)

   The constructor starts redirecting output sent to ostr or cout for the
   default parameter value to the text control text.

   Parameters

   text

       The text control to append output too, must be non-NULL

   ostr

       The C++ stream to redirect, cout is used if it is NULL

=head2 Wx::StreamToTextRedirector::DESTROY

   ~wxStreamToTextRedirector()

   When a wxStreamToTextRedirector object is destroyed, the redirection
   is ended and any output sent to the C++ ostream which had been
   specified at the time of the object construction will go to its
   original destination.

=head1 Wx::String

=head2 Constructors and assignment operators

   A string may be constructed either from a C string, (some number of
   copies of) a single character or a wide (UNICODE) string. For all
   constructors (except the default which creates an empty string) there
   is also a corresponding assignment operator.

   wxString

=head2 String length

   These functions return the string length and check whether the string
   is empty or empty it.

   Len

=head2 Character access

   Many functions in this section take a character index in the string.
   As with C strings and/or arrays, the indices start from 0, so the
   first character of a string is string[0]. Attempt to access a
   character beyond the end of the string (which may be even 0 if the
   string is empty) will provoke an assert failure in debug build, but no
   checks are done in release builds.

   This section also contains both implicit and explicit conversions to C
   style strings. Although implicit conversion is quite convenient, it is
   advised to use explicit c_str() method for the sake of clarity. Also
   see overview for the cases where it is necessary to use it.

   GetChar

=head2 Concatenation

   Anything may be concatenated (appended to) with a string. However, you
   can't append something to a C string (including literal constants), so
   to do this it should be converted to a wxString first.

   operator <<

=head2 Comparison

   The default comparison function Cmp is case-sensitive and so is the
   default version of IsSameAs. For case insensitive comparisons you
   should use CmpNoCase or give a second parameter to IsSameAs. This last
   function is may be more convenient if only equality of the strings
   matters because it returns a boolean true value if the strings are the
   same and not 0 (which is usually false in C) as Cmp() does.

   Matches is a poor man's regular expression matcher: it only
   understands '*' and '?' metacharacters in the sense of DOS command
   line interpreter.

   StartsWith is helpful when parsing a line of text which should start
   with some predefined prefix and is more efficient than doing direct
   string comparison as you would also have to precalculate the length of
   the prefix then.

   Cmp

=head2 Substring extraction

   These functions allow to extract substring from this string. All of
   them don't modify the original string and return a new string
   containing the extracted substring.

   Mid

=head2 Case conversion

   The MakeXXX() variants modify the string in place, while the other
   functions return a new string which contains the original text
   converted to the upper or lower case and leave the original string
   unchanged.

   MakeUpper

=head2 Searching and replacing

   These functions replace the standard strchr() and strstr() functions.

   Find

=head2 Conversion to numbers

   The string provides functions for conversion to signed and unsigned
   integer and floating point numbers. All three functions take a pointer
   to the variable to put the numeric value in and return true if the
   entire string could be converted to a number.

   ToLong

=head2 Writing values into the string

   Both formatted versions (Printf) and stream-like insertion operators
   exist (for basic types only). Additionally, the Format function allows
   to use simply append formatted value to a string:

       // the following 2 snippets are equivalent

=head2 Memory management

   These are "advanced" functions and they will be needed quite rarely.
   Alloc and Shrink are only interesting for optimization purposes.
   GetWriteBuf may be very useful when working with some external API
   which requires the caller to provide a writable buffer, but extreme
   care should be taken when using it: before performing any other
   operation on the string UngetWriteBuf must be called!

   Alloc

=head2 Miscellaneous

   Other string functions.

   Trim

=head2 Wx::Widgets 1.xx compatibility functions

   These functions are deprecated, please consider using new wxWidgets
   2.0 functions instead of them (or, even better, std::string compatible
   variants).

   CompareTo

=head2 std::string compatibility functions

   The supported functions are only listed here, please see any STL
   reference for their documentation.

       // take nLen chars starting at nPos
     wxString(const wxString& str, size_t nPos, size_t nLen);
       // take all characters from pStart to pEnd (poor man's iterators)
     wxString(const void *pStart, const void *pEnd);

=head2 Wx::String::new

   wxString()

   Default constructor. Initializes the string to "" (empty string).

   wxString(const wxString& x)

   Copy constructor.

   wxString(wxChar ch, size_t n = 1)

   Constructs a string of n copies of character ch.

   wxString(const wxChar* psz, size_t nLength = wxSTRING_MAXLEN)

   Takes first nLength characters from the C string psz. The default
   value of wxSTRING_MAXLEN means to take all the string.

   Note that this constructor may be used even if psz points to a buffer
   with binary data (i.e. containing NUL characters) as long as you
   provide the correct value for nLength. However, the default form of it
   works only with strings without intermediate NULs because it uses
   strlen() to calculate the effective length and it would not give
   correct results otherwise.

   wxString(const unsigned char* psz, size_t nLength = wxSTRING_MAXLEN)

   For compilers using unsigned char: takes first nLength characters from
   the C string psz. The default value of wxSTRING_MAXLEN means take all
   the string. For ANSI builds only (note the use of char instead of
   wxChar).

   Constructors with conversion

   The following constructors allow you to construct wxString from a wide
   string in ANSI build or from a C string in Unicode build.

   wxString(const wchar_t* psz, wxMBConv& conv, size_t nLength =
   wxSTRING_MAXLEN)

   Initializes the string from first nLength characters of wide string.
   The default value of wxSTRING_MAXLEN means take all the string. In
   ANSI build, conv's WC2MB method is called to convert psz to wide
   string. It is ignored in Unicode build.

   wxString(const char* psz, wxMBConv& conv, size_t nLength =
   wxSTRING_MAXLEN)

   Initializes the string from first nLength characters of C string. The
   default value of wxSTRING_MAXLEN means take all the string. In Unicode
   build, conv's MB2WC method is called to convert psz to wide string. It
   is ignored in ANSI build.

   See also

   wxMBConv classes, mb_str, wc_str

=head2 Wx::String::DESTROY

   ~wxString()

   String destructor. Note that this is not virtual, so wxString must not
   be inherited from.

=head2 Wx::String::Alloc

   void Alloc(size_t nLen)

   Preallocate enough space for wxString to store nLen characters. This
   function may be used to increase speed when the string is constructed
   by repeated concatenation as in

   // delete all vowels from the string
   wxString DeleteAllVowels(const wxString& original)
   {
       wxString result;

=head2 Wx::String::Append

   wxString& Append(const wxChar* psz)

   Concatenates psz to this string, returning a reference to it.

   wxString& Append(wxChar ch, int count = 1)

   Concatenates character ch to this string, count times, returning a
   reference to it.

=head2 Wx::String::AfterFirst

   wxString AfterFirst(wxChar ch) const

   Gets all the characters after the first occurrence of ch. Returns the
   empty string if ch is not found.

=head2 Wx::String::AfterLast

   wxString AfterLast(wxChar ch) const

   Gets all the characters after the last occurrence of ch. Returns the
   whole string if ch is not found.

=head2 Wx::String::BeforeFirst

   wxString BeforeFirst(wxChar ch) const

   Gets all characters before the first occurrence of ch. Returns the
   whole string if ch is not found.

=head2 Wx::String::BeforeLast

   wxString BeforeLast(wxChar ch) const

   Gets all characters before the last occurrence of ch. Returns the
   empty string if ch is not found.

=head2 Wx::String::c_str

   const wxChar * c_str() const

   Returns a pointer to the string data (const char* in ANSI build, const
   wchar_t* in Unicode build).

   Note that the returned value will not be convertible to char* or
   wchar_t* in wxWidgets 3, consider using char_str or wchar_string if
   you need to pass string value to a function expecting non-const
   pointer.

   See also

   mb_str, wc_str, fn_str, char_str, wchar_string

=head2 Wx::String::char_str

   wxWritableCharBuffer char_str(wxMBConv& conv = wxConvLibc) const

   Returns an object with string data that is implicitly convertible to
   char* pointer. Note that any change to the returned buffer is lost and
   so this function is only usable for passing strings to legacy
   libraries that don't have const-correct API. Use wxStringBuffer if you
   want to modify the string.

   This function is new since wxWidgets version 2.8.4

   See also

   mb_str, wc_str, fn_str, c_str, wchar_str

=head2 Wx::String::Clear

   void Clear()

   Empties the string and frees memory occupied by it.

   See also: Empty

=head2 Wx::String::Cmp

   int Cmp(const wxString& s) const

   int Cmp(const wxChar* psz) const

   Case-sensitive comparison.

   Returns a positive value if the string is greater than the argument,
   zero if it is equal to it or a negative value if it is less than the
   argument (same semantics as the standard strcmp() function).

   See also CmpNoCase, IsSameAs.

=head2 Wx::String::CmpNoCase

   int CmpNoCase(const wxString& s) const

   int CmpNoCase(const wxChar* psz) const

   Case-insensitive comparison.

   Returns a positive value if the string is greater than the argument,
   zero if it is equal to it or a negative value if it is less than the
   argument (same semantics as the standard strcmp() function).

   See also Cmp, IsSameAs.

=head2 Wx::String::CompareTo

   enum wxString::caseCompare {exact, ignoreCase};

   int CompareTo(const wxChar* psz, caseCompare cmp = exact) const

   Case-sensitive comparison. Returns 0 if equal, 1 if greater or -1 if
   less.

   This is a wxWidgets 1.xx compatibility function; use Cmp instead.

=head2 Wx::String::Contains

   bool Contains(const wxString& str) const

   Returns true if target appears anywhere in wxString; else false.

   This is a wxWidgets 1.xx compatibility function; you should not use it
   in new code.

=head2 Wx::String::Empty

   void Empty()

   Makes the string empty, but doesn't free memory occupied by the
   string.

   See also: Clear().

=head2 Wx::String::Find

   int Find(wxChar ch, bool fromEnd = false) const

   Searches for the given character. Returns the starting index, or
   wxNOT_FOUND if not found.

   int Find(const wxChar* sz) const

   Searches for the given string. Returns the starting index, or
   wxNOT_FOUND if not found.

=head2 Wx::String::First

   int First(wxChar c)

   int First(const wxChar* psz) const

   int First(const wxString& str) const

   Same as Find.

   This is a wxWidgets 1.xx compatibility function; you should not use it
   in new code.

=head2 Wx::String::fn_str

   const wchar_t* fn_str() const

   const char* fn_str() const

   const wxCharBuffer fn_str() const

   Returns string representation suitable for passing to OS' functions
   for file handling. In ANSI build, this is same as c_str. In Unicode
   build, returned value can be either wide character string or C string
   in charset matching the wxConvFileName object, depending on the OS.

   See also

   wxMBConv, wc_str, mb_str

=head2 Wx::String::Format

   static wxString Format(const wxChar *format, ...)

   This static function returns the string containing the result of
   calling Printf with the passed parameters on it.

   See also

   FormatV, Printf

=head2 Wx::String::FormatV

   static wxString FormatV(const wxChar *format, va_list argptr)

   This static function returns the string containing the result of
   calling PrintfV with the passed parameters on it.

   See also

   Format, PrintfV

=head2 Wx::String::Freq

   int Freq(wxChar ch) const

   Returns the number of occurrences of ch in the string.

   This is a wxWidgets 1.xx compatibility function; you should not use it
   in new code.

=head2 Wx::String::From8BitData

   static wxString From8BitData(const char* buf, size_tlen)

   static wxString From8BitData(const char* buf)

   Converts given buffer of binary data from 8-bit string to wxString. In
   Unicode build, the string is interpreted as being in ISO-8859-1
   encoding. The version without len parameter takes NUL-terminated data.

   This is a convenience method useful when storing binary data in
   wxString. It should be used only for that purpose and only in
   conjunction with To8BitData. Use mb_str() for conversion of character
   data to known encoding.

   This function is new since wxWidgets version 2.8.4

   See also

   To8BitData

=head2 Wx::String::FromAscii

   static wxString FromAscii(const char* s)

   static wxString FromAscii(const char c)

   Converts the string or character from an ASCII, 7-bit form to the
   native wxString representation. Most useful when using a Unicode build
   of wxWidgets (note the use of char instead of wxChar). Use wxString
   constructors if you need to convert from another charset.

=head2 Wx::String::FromUTF8

   static wxString FromUTF8(const char* s)

   static wxString FromUTF8(const char* s, size_t len)

   Converts C string encoded in UTF-8 to wxString.

   Note that this method assumes that s is a valid UTF-8 sequence and
   doesn't do any validation in release builds, it's validity is only
   checked in debug builds.

=head2 Wx::String::GetChar

   wxChar GetChar(size_t n) const

   Returns the character at position n (read-only).

=head2 Wx::String::GetData

   const wxChar* GetData() const

   wxWidgets compatibility conversion. Returns a constant pointer to the
   data in the string.

=head2 Wx::String::GetWritableChar

   wxChar& GetWritableChar(size_t n)

   Returns a reference to the character at position n.

=head2 Wx::String::GetWriteBuf

   wxChar* GetWriteBuf(size_t len)

   Returns a writable buffer of at least len bytes. It returns a pointer
   to a new memory block, and the existing data will not be copied.

   Call wxString::UngetWriteBuf as soon as possible to put the string
   back into a reasonable state.

=head2 Wx::String::Index

   size_t Index(wxChar ch) const

   size_t Index(const wxChar* sz) const

   Same as wxString::Find.

   This is a wxWidgets 1.xx compatibility function; you should not use it
   in new code.

=head2 Wx::String::IsAscii

   bool IsAscii() const

   Returns true if the string contains only ASCII characters.

   This is a wxWidgets 1.xx compatibility function; you should not use it
   in new code.

=head2 Wx::String::IsEmpty

   bool IsEmpty() const

   Returns true if the string is empty.

=head2 Wx::String::IsNull

   bool IsNull() const

   Returns true if the string is empty (same as IsEmpty).

   This is a wxWidgets 1.xx compatibility function; you should not use it
   in new code.

=head2 Wx::String::IsNumber

   bool IsNumber() const

   Returns true if the string is an integer (with possible sign).

   This is a wxWidgets 1.xx compatibility function; you should not use it
   in new code.

=head2 Wx::String::IsSameAs

   bool IsSameAs(const wxChar* psz, bool caseSensitive = true) const

   Test for string equality, case-sensitive (default) or not.

   caseSensitive is true by default (case matters).

   Returns true if strings are equal, false otherwise.

   See also Cmp, CmpNoCase

   bool IsSameAs(wxChar c, bool caseSensitive = true) const

   Test whether the string is equal to the single character c. The test
   is case-sensitive if caseSensitive is true (default) or not if it is
   false.

   Returns true if the string is equal to the character, false otherwise.

   See also Cmp, CmpNoCase

=head2 Wx::String::IsWord

   bool IsWord() const

   Returns true if the string is a word.

   This is a wxWidgets 1.xx compatibility function; you should not use it
   in new code.

=head2 Wx::String::Last

   wxChar Last() const

   Returns the last character.

   wxChar& Last()

   Returns a reference to the last character (writable).

   This is a wxWidgets 1.xx compatibility function; you should not use it
   in new code.

=head2 Wx::String::Left

   wxString Left(size_t count) const

   Returns the first count characters of the string.

=head2 Wx::String::Len

   size_t Len() const

   Returns the length of the string.

=head2 Wx::String::Length

   size_t Length() const

   Returns the length of the string (same as Len).

   This is a wxWidgets 1.xx compatibility function; you should not use it
   in new code.

=head2 Wx::String::Lower

   wxString Lower() const

   Returns this string converted to the lower case.

=head2 Wx::String::LowerCase

   void LowerCase()

   Same as MakeLower.

   This is a wxWidgets 1.xx compatibility function; you should not use it
   in new code.

=head2 Wx::String::MakeLower

   wxString& MakeLower()

   Converts all characters to lower case and returns the result.

=head2 Wx::String::MakeUpper

   wxString& MakeUpper()

   Converts all characters to upper case and returns the result.

=head2 Wx::String::Matches

   bool Matches(const wxChar* szMask) const

   Returns true if the string contents matches a mask containing '*' and
   '?'.

=head2 Wx::String::mb_str

   const char* mb_str(wxMBConv& conv) const

   const wxCharBuffer mb_str(wxMBConv& conv) const

   Returns multibyte (C string) representation of the string. In Unicode
   build, converts using conv's cWC2MB method and returns wxCharBuffer.
   In ANSI build, this function is same as c_str. The macro wxWX2MBbuf is
   defined as the correct return type (without const).

   See also

   wxMBConv, c_str, wc_str, fn_str, char_str

=head2 Wx::String::Mid

   wxString Mid(size_t first, size_t count = wxSTRING_MAXLEN) const

   Returns a substring starting at first, with length count, or the rest
   of the string if count is the default value.

=head2 Wx::String::Pad

   wxString& Pad(size_t count, wxChar pad = ' ', bool fromRight = true)

   Adds count copies of pad to the beginning, or to the end of the string
   (the default).

   Removes spaces from the left or from the right (default).

=head2 Wx::String::Prepend

   wxString& Prepend(const wxString& str)

   Prepends str to this string, returning a reference to this string.

=head2 Wx::String::Printf

   int Printf(const wxChar* pszFormat, ...)

   Similar to the standard function sprintf(). Returns the number of
   characters written, or an integer less than zero on error.

   Note that if wxUSE_PRINTF_POS_PARAMS is set to 1, then this function
   supports Unix98-style positional parameters:

       wxString str;

=head2 Wx::String::PrintfV

   int PrintfV(const wxChar* pszFormat, va_list argPtr)

   Similar to vprintf. Returns the number of characters written, or an
   integer less than zero on error.

=head2 Wx::String::Remove

   wxString& Remove(size_t pos)

   Same as Truncate. Removes the portion from pos to the end of the
   string.

   wxString& Remove(size_t pos, size_t len)

   Removes len characters from the string, starting at pos.

   This is a wxWidgets 1.xx compatibility function; you should not use it
   in new code.

=head2 Wx::String::RemoveLast

   wxString& RemoveLast()

   Removes the last character.

=head2 Wx::String::Replace

   size_t Replace(const wxChar* szOld, const wxChar* szNew, bool
   replaceAll = true)

   Replace first (or all) occurrences of substring with another one.

   replaceAll: global replace (default), or only the first occurrence.

   Returns the number of replacements made.

=head2 Wx::String::Right

   wxString Right(size_t count) const

   Returns the last count characters.

=head2 Wx::String::SetChar

   void SetChar(size_t n, wxCharch)

   Sets the character at position n.

=head2 Wx::String::Shrink

   void Shrink()

   Minimizes the string's memory. This can be useful after a call to
   Alloc() if too much memory were preallocated.

=head2 Wx::String::StartsWith

   bool StartsWith(const wxChar *prefix, wxString *rest = NULL) const

   This function can be used to test if the string starts with the
   specified prefix. If it does, the function will return true and put
   the rest of the string (i.e. after the prefix) into rest string if it
   is not NULL. Otherwise, the function returns false and doesn't modify
   the rest.

=head2 Wx::String::EndsWith

   bool EndsWith(const wxChar *suffix, wxString *rest = NULL) const

   This function can be used to test if the string ends with the
   specified suffix. If it does, the function will return true and put
   the beginning of the string before the suffix into rest string if it
   is not NULL. Otherwise, the function returns false and doesn't modify
   the rest.

=head2 Wx::String::Strip

   enum wxString::stripType {leading = 0x1, trailing = 0x2, both = 0x3};

   wxString Strip(stripType s = trailing) const

   Strip characters at the front and/or end. The same as Trim except that
   it doesn't change this string.

   This is a wxWidgets 1.xx compatibility function; you should not use it
   in new code.

=head2 Wx::String::SubString

   wxString SubString(size_t from, size_t to) const

   Returns the part of the string between the indices from and to
   inclusive.

   This is a wxWidgets 1.xx compatibility function, use Mid instead (but
   note that parameters have different meaning).

=head2 Wx::String::To8BitData

   const char* To8BitData() const

   Converts the string to an 8-bit string (ANSI builds only).

   const wxCharBuffer To8BitData() const

   Converts the string to an 8-bit string in ISO-8859-1 encoding in the
   form of a wxCharBuffer (Unicode builds only).

   This is a convenience method useful when storing binary data in
   wxString. It should be used only for this purpose. It is only valid to
   call this method on strings created using From8BitData.

   This function is new since wxWidgets version 2.8.4

   See also

   From8BitData

=head2 Wx::String::ToAscii

   const char* ToAscii() const

   const wxCharBuffer ToAscii() const

   Converts the string to an ASCII, 7-bit string in the form of a
   wxCharBuffer (Unicode builds only) or a C string (ANSI builds).

   Note that this conversion only works if the string contains only ASCII
   characters. The mb_str method provides more powerful means of
   converting wxString to C string.

=head2 Wx::String::ToDouble

   bool ToDouble(double *val) const

   Attempts to convert the string to a floating point number. Returns
   true on success (the number is stored in the location pointed to by
   val) or false if the string does not represent such number.

   See also

   wxString::ToLong,

=head2 Wx::String::ToLong

   bool ToLong(long *val, int base = 10) const

   Attempts to convert the string to a signed integer in base base.
   Returns true on success in which case the number is stored in the
   location pointed to by val or false if the string does not represent a
   valid number in the given base.

   The value of base must be comprised between 2 and 36, inclusive, or be
   a special value 0 which means that the usual rules of C numbers are
   applied: if the number starts with 0x it is considered to be in base
   16, if it starts with 0 - in base 8 and in base 10 otherwise. Note
   that you may not want to specify the base 0 if you are parsing the
   numbers which may have leading zeroes as they can yield unexpected (to
   the user not familiar with C) results.

   See also

   wxString::ToDouble,

=head2 Wx::String::ToLongLong

   bool ToLongLong(wxLongLong_t *val, int base = 10) const

   This is exactly the same as ToLong but works with 64 bit integer
   numbers.

   Notice that currently it doesn't work (always returns false) if
   parsing of 64 bit numbers is not supported by the underlying C
   run-time library. Compilers with C99 support and Microsoft Visual C++
   version 7 and higher do support this.

   See also

   wxString::ToLong,

=head2 Wx::String::ToULong

   bool ToULong(unsigned long *val, int base = 10) const

   Attempts to convert the string to an unsigned integer in base base.
   Returns true on success in which case the number is stored in the
   location pointed to by val or false if the string does not represent a
   valid number in the given base. Please notice that this function
   behaves in the same way as the standard strtoul() and so it simply
   converts negative numbers to unsigned representation instead of
   rejecting them (e.g. -1 is returned as ULONG_MAX).

   See wxString::ToLong for the more detailed description of the base
   parameter.

   See also

   wxString::ToDouble,

=head2 Wx::String::ToULongLong

   bool ToULongLong(wxULongLong_t *val, int base = 10) const

   This is exactly the same as ToULong but works with 64 bit integer
   numbers.

   Please see ToLongLong for additional remarks.

=head2 Wx::String::ToUTF8

   const wxCharBuffer ToUF8() const

   Same as utf8_str.

   This function is new since wxWidgets version 2.8.4

=head2 Wx::String::Trim

   wxString& Trim(bool fromRight = true)

   Removes white-space (space, tabs, form feed, newline and carriage
   return) from the left or from the right end of the string (right is
   default).

=head2 Wx::String::Truncate

   wxString& Truncate(size_t len)

   Truncate the string to the given length.

=head2 Wx::String::UngetWriteBuf

   void UngetWriteBuf()

   void UngetWriteBuf(size_t len)

   Puts the string back into a reasonable state (in which it can be used
   normally), after wxString::GetWriteBuf was called.

   The version of the function without the len parameter will calculate
   the new string length itself assuming that the string is terminated by
   the first NUL character in it while the second one will use the
   specified length and thus is the only version which should be used
   with the strings with embedded NULs (it is also slightly more
   efficient as strlen() doesn't have to be called).

=head2 Wx::String::Upper

   wxString Upper() const

   Returns this string converted to upper case.

=head2 Wx::String::UpperCase

   void UpperCase()

   The same as MakeUpper.

   This is a wxWidgets 1.xx compatibility function; you should not use it
   in new code.

=head2 Wx::String::utf8_str

   const wxCharBuffer utf8_str() const

   Converts the strings contents to UTF-8 and returns it as a temporary
   wxCharBuffer object.

   This function is new since wxWidgets version 2.8.4

=head2 Wx::String::wc_str

   const wchar_t* wc_str(wxMBConv& conv) const

   const wxWCharBuffer wc_str(wxMBConv& conv) const

   Returns wide character representation of the string. In ANSI build,
   converts using conv's cMB2WC method and returns wxWCharBuffer. In
   Unicode build, this function is same as c_str. The macro wxWX2WCbuf is
   defined as the correct return type (without const).

   See also

   wxMBConv, c_str, mb_str, fn_str, wchar_str

=head2 Wx::String::wchar_str

   wxWritableWCharBuffer wchar_str() const

   Returns an object with string data that is implicitly convertible to
   char* pointer. Note that any change to the returned buffer is lost and
   so this function is only usable for passing strings to legacy
   libraries that don't have const-correct API. Use wxStringBuffer if you
   want to modify the string.

   This function is new since wxWidgets version 2.8.4

   See also

   mb_str, wc_str, fn_str, c_str, char_str

=head2 Comparison operators

   bool operator ==(const wxString& x, const wxString& y)

   bool operator ==(const wxString& x, const wxChar* t)

   bool operator !=(const wxString& x, const wxString& y)

   bool operator !=(const wxString& x, const wxChar* t)

   bool operator >(const wxString& x, const wxString& y)

   bool operator >(const wxString& x, const wxChar* t)

   bool operator >=(const wxString& x, const wxString& y)

   bool operator >=(const wxString& x, const wxChar* t)

   bool operator <(const wxString& x, const wxString& y)

   bool operator <(const wxString& x, const wxChar* t)

   bool operator <=(const wxString& x, const wxString& y)

   bool operator <=(const wxString& x, const wxChar* t)

   Remarks

   These comparisons are case-sensitive.

=head1 Wx::StringBuffer

=head2 Wx::StringBuffer::new

   wxStringBuffer(const wxString& str, size_t len)

   Constructs a writable string buffer object associated with the given
   string and containing enough space for at least len characters.
   Basically, this is equivalent to calling GetWriteBuf and saving the
   result.

=head2 Wx::StringBuffer::DESTROY

   ~wxStringBuffer()

   Restores the string passed to the constructor to the usable state by
   calling UngetWriteBuf on it.

=head1 Wx::StringBufferLength

=head2 Wx::StringBufferLength::new

   wxStringBufferLength(const wxString& str, size_t len)

   Constructs a writable string buffer object associated with the given
   string and containing enough space for at least len characters.
   Basically, this is equivalent to calling GetWriteBuf and saving the
   result.

=head2 Wx::StringBufferLength::DESTROY

   ~wxStringBufferLength()

   Restores the string passed to the constructor to the usable state by
   calling UngetWriteBuf on it.

=head2 Wx::StringBufferLength::SetLength

   void SetLength(size_t nLength)

   Sets the internal length of the string referred to by
   wxStringBufferLength to nLength characters.

   Must be called before wxStringBufferLength destructs.

=head1 Wx::StringClientData

=head2 Wx::StringClientData::new

   wxStringClientData()

   Empty constructor.

   wxStringClientData(const wxString& data)

   Create client data with string.

=head2 Wx::StringClientData::GetData

   const wxString& GetData() const

   Get string client data.

=head2 Wx::StringClientData::SetData

   void SetData(const wxString& data)

   Set string client data.

=head1 Wx::StringInputStream

=head2 Wx::StringInputStream::new

   wxStringInputStream(const wxString& s)

   Creates a new read-only stream using the specified string. Note that
   the string is copied by the stream so if the original string is
   modified after using this constructor, changes to it are not reflected
   when reading from stream.

=head1 Wx::StringOutputStream

=head2 Wx::StringOutputStream::new

   wxStringOutputStream(wxString *str = NULL)

   If the provided pointer is non-NULL, data will be written to it.
   Otherwise, an internal string is used for the data written to this
   stream, use GetString() to get access to it.

   If str is used, data written to the stream is appended to the current
   contents of it, i.e. the string is not cleared here. However if it is
   not empty, the positions returned by TellO will be offset by the
   initial string length, i.e. initial stream position will be the
   initial length of the string and not 0.

=head2 Wx::StringOutputStream::GetString

   const wxString& GetString() const

   Returns the string containing all the data written to the stream so
   far.

=head1 Wx::StringTokenizer

=head2 Wx::StringTokenizer::new

   wxStringTokenizer()

   Default constructor. You must call SetString before calling any other
   methods.

   wxStringTokenizer(const wxString& str, const wxString& delims = "
   \t\r\n", wxStringTokenizerMode mode = wxTOKEN_DEFAULT)

   Constructor. Pass the string to tokenize, a string containing
   delimiters and the mode specifying how the string should be tokenized.

=head2 Wx::StringTokenizer::CountTokens

   int CountTokens() const

   Returns the number of tokens remaining in the input string. The number
   of tokens returned by this function is decremented each time
   GetNextToken is called and when it reaches 0 HasMoreTokens returns
   false.

=head2 Wx::StringTokenizer::HasMoreTokens

   bool HasMoreTokens() const

   Returns true if the tokenizer has further tokens, false if none are
   left.

=head2 Wx::StringTokenizer::GetLastDelimiter

   wxChar GetLastDelimiter()

   Returns the delimiter which ended scan for the last token returned by
   GetNextToken() or NUL if there had been no calls to this function yet
   or if it returned the trailing empty token in wxTOKEN_RET_EMPTY_ALL
   mode.

   This function is new since wxWidgets version 2.7.0

=head2 Wx::StringTokenizer::GetNextToken

   wxString GetNextToken() const

   Returns the next token or empty string if the end of string was
   reached.

=head2 Wx::StringTokenizer::GetPosition

   size_t GetPosition() const

   Returns the current position (i.e. one index after the last returned
   token or 0 if GetNextToken() has never been called) in the original
   string.

=head2 Wx::StringTokenizer::GetString

   wxString GetString() const

   Returns the part of the starting string without all token already
   extracted.

=head2 Wx::StringTokenizer::SetString

   void SetString(const wxString& to_tokenize, const wxString& delims = "
   \t\r\n", wxStringTokenizerMode mode = wxTOKEN_DEFAULT)

   Initializes the tokenizer.

   Pass the string to tokenize, a string containing delimiters, and the
   mode specifying how the string should be tokenized.

=head1 Wx::SymbolPickerDialog

=head2 Wx::SymbolPickerDialog::new

   wxSymbolPickerDialog(const wxString& symbol, const wxString&
   initialFont, const wxString& normalTextFont, wxWindow* parent,
   wxWindowID id = wxID_ANY, const wxString& title = _("Symbols"), const
   wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
   long style = wxDEFAULT_DIALOG_STYLE|wxRESIZE_BORDER|wxCLOSE_BOX)

   wxSymbolPickerDialog()

   Constructors.

   Parameters

   symbol

       The initial symbol to show. Specify a single character in a
       string, or an empty string.

   initialFont

       The initial font to be displayed in the font list. If empty, the
       item normal text will be selected.

   normalTextFont

       The font the dialog will use to display the symbols if the initial
       font is empty.

   parent

       The dialog's parent.

   id  

       The dialog's identifier.

   title

       The dialog's caption.

   pos 

       The dialog's position.

   size

       The dialog's size.

   style

       The dialog's window style.

=head2 Wx::SymbolPickerDialog::Create

   bool Create(const wxString& symbol, const wxString& initialFont, const
   wxString& normalTextFont, wxWindow* parent, wxWindowID id = wxID_ANY,
   const wxString& title = _("Symbols"), const wxPoint& pos =
   wxDefaultPosition, const wxSize& size = wxDefaultSize, long style =
   wxDEFAULT_DIALOG_STYLE|wxRESIZE_BORDER|wxCLOSE_BOX)

   Creation: see the constructor for details about the parameters.

=head2 Wx::SymbolPickerDialog::GetFontName

   wxString GetFontName() const

   Returns the font name (the font reflected in the font list).

=head2 Wx::SymbolPickerDialog::GetFromUnicode

   bool GetFromUnicode() const

   Returns true if the dialog is showing the full range of Unicode
   characters.

=head2 Wx::SymbolPickerDialog::GetNormalTextFontName

   wxString GetNormalTextFontName() const

   Gets the font name used for displaying symbols in the absence of a
   selected font.

=head2 Wx::SymbolPickerDialog::GetSymbol

   wxString GetSymbol() const

   Gets the current or initial symbol as a string.

=head2 Wx::SymbolPickerDialog::GetSymbolChar

   int GetSymbolChar() const

   Gets the selected symbol character as an integer.

=head2 Wx::SymbolPickerDialog::HasSelection

   bool HasSelection() const

   Returns true if a symbol is selected.

=head2 Wx::SymbolPickerDialog::SetFontName

   void SetFontName(const wxString& value)

   Sets the initial/selected font name.

=head2 Wx::SymbolPickerDialog::SetFromUnicode

   void SetFromUnicode(bool value)

   Sets the internal flag indicating that the full Unicode range should
   be displayed.

=head2 Wx::SymbolPickerDialog::SetNormalTextFontName

   void SetNormalTextFontName(const wxString& value)

   Sets the name of the font to be used in the absence of a selected
   font.

=head2 Wx::SymbolPickerDialog::SetSymbol

   void SetSymbol(const wxString& value)

   Sets the symbol as a one or zero character string.

=head2 Wx::SymbolPickerDialog::SetUnicodeMode

   void SetUnicodeMode(bool unicodeMode)

   Sets Unicode display mode.

=head2 Wx::SymbolPickerDialog::UseNormalFont

   bool UseNormalFont() const

   Returns true if the has specified normal text - that is, there is no
   selected font.

=head1 Wx::SysColourChangedEvent

=head2 Wx::SysColourChangedEvent::new

   wxSysColourChangedEvent()

   Constructor.

=head1 Wx::SystemOptions

=head2 Wx::SystemOptions::new

   wxSystemOptions()

   Default constructor. You don't need to create an instance of
   wxSystemOptions since all of its functions are static.

=head2 Wx::SystemOptions::GetOption

   wxString GetOption(const wxString& name) const

   Gets an option. The function is case-insensitive to name.

   Returns empty string if the option hasn't been set.

   See also

   wxSystemOptions::SetOption, wxSystemOptions::GetOptionInt,
   wxSystemOptions::HasOption

=head2 Wx::SystemOptions::GetOptionInt

   int GetOptionInt(const wxString& name) const

   Gets an option as an integer. The function is case-insensitive to name.

   If the option hasn't been set, this function returns 0.

   See also

   wxSystemOptions::SetOption, wxSystemOptions::GetOption,
   wxSystemOptions::HasOption

=head2 Wx::SystemOptions::HasOption

   bool HasOption(const wxString& name) const

   Returns true if the given option is present. The function is
   case-insensitive to name.

   See also

   wxSystemOptions::SetOption, wxSystemOptions::GetOption,
   wxSystemOptions::GetOptionInt

=head2 Wx::SystemOptions::IsFalse

   bool IsFalse(const wxString& name) const

   Returns true if the option with the given name had been set to 0
   value. This is mostly useful for boolean options for which you can't
   use GetOptionInt(name) == 0 as this would also be true if the option
   hadn't been set at all.

=head2 Wx::SystemOptions::SetOption

   void SetOption(const wxString& name, const wxString& value)

   void SetOption(const wxString& name, int value)

   Sets an option. The function is case-insensitive to name.

   See also

   wxSystemOptions::GetOption, wxSystemOptions::GetOptionInt,
   wxSystemOptions::HasOption

=head1 Wx::SystemSettings

=head2 Wx::SystemSettings::new

   wxSystemSettings()

   Default constructor. You don't need to create an instance of
   wxSystemSettings since all of its functions are static.

=head2 Wx::SystemSettings::GetColour

   static wxColour GetColour(wxSystemColour index)

   Returns a system colour.

   index can be one of:

=head2 Wx::SystemSettings::GetFont

   static wxFont GetFont(wxSystemFont index)

   Returns a system font.

   index can be one of:

=head2 Wx::SystemSettings::GetMetric

   static int GetMetric(wxSystemMetric index, wxWindow* win = NULL)

   Returns the value of a system metric, or -1 if the metric is not
   supported on the current system. The value of win determines if the
   metric returned is a global value or a wxWindow based value, in which
   case it might determine the widget, the display the window is on, or
   something similar. The window given should be as close to the metric
   as possible (e.g a wxTopLevelWindow in case of the wxSYS_CAPTION_Y
   metric).

   index can be one of:

=head2 Wx::SystemSettings::GetScreenType

   static wxSystemScreenType GetScreenType()

   Returns the screen type. The return value is one of:

=head1 Wx::TarEntry

=head2 Wx::TarEntry::new

   wxTarEntry(const wxString& name = wxEmptyString, const wxDateTime& dt
   = wxDateTime::Now(), wxFileOffset size = wxInvalidOffset)

   Constructor. The tar archive format stores the entry's size ahead of
   the entry's data. Therefore when creating an archive on a non-seekable
   stream it is necessary to supply the correct size when each entry is
   created.

   wxTarEntry(const wxTarEntry& entry)

   Copy constructor.

=head2 Wx::TarEntry::Get/SetAccessTime

   wxDateTime GetAccessTime() const

   void SetAccessTime(const wxDateTime& dt)

   The entry's access time stamp. See also
   wxArchiveEntry::Get/SetDateTime.

=head2 Wx::TarEntry::Get/SetCreateTime

   wxDateTime GetCreateTime() const

   void SetCreateTime(const wxDateTime& dt)

   The entry's creation time stamp. See also
   wxArchiveEntry::Get/SetDateTime.

=head2 Wx::TarEntry::Get/SetDevMajor and Get/SetDevMinor

   int GetDevMajor() const

   int GetDevMinor() const

   void SetDevMajor(int dev)

   void SetDevMinor(int dev)

   OS specific IDs defining a device, these are only meaningful when
   TypeFlag is set to wxTAR_CHRTYPE or wxTAR_BLKTYPE.

=head2 Wx::TarEntry::Get/SetGroupId and Get/SetUserId

   int GetGroupId() const

   int GetUserId() const

   void SetGroupId(int id)

   void SetUserId(int id)

   The user ID and group ID that has permissions over this entry. These
   values aren't usually useful unless the file will only be restored to
   the same system it originated from. Get/SetGroupName and
   Get/SetUserName can be used instead.

=head2 Wx::TarEntry::Get/SetGroupName and Get/SetUserName

   wxString GetGroupName() const

   wxString GetUserName() const

   void SetGroupName(const wxString& group)

   void SetUserName(const wxString& user)

   The names of the user and group that has permissions over this entry.
   These are not present in very old tars.

=head2 Wx::TarEntry::GetInternalName

   wxString GetInternalName() const

   Returns the entry's filename in the internal format used within the
   archive. The name can include directory components, i.e. it can be a
   full path.

   The names of directory entries are returned without any trailing path
   separator. This gives a canonical name that can be used in
   comparisons.

   wxString GetInternalName(const wxString& name, wxPathFormat format =
   wxPATH_NATIVE, bool* pIsDir = NULL)

   A static member that translates a filename into the internal format
   used within the archive. If the third parameter is provided, the bool
   pointed to is set to indicate whether the name looks like a directory
   name (i.e. has a trailing path separator).

=head2 Wx::TarEntry::Get/SetLinkName

   wxString GetLinkName() const

   void SetLinkName(const wxString& link)

   The filename of a previous entry in the tar that this entry is a link
   to. Only meaningful when TypeFlag is set to wxTAR_LNKTYPE or
   wxTAR_SYMTYPE.

=head2 Wx::TarEntry::Get/SetMode

   int GetMode() const

   void SetMode(int mode)

   UNIX permission bits for this entry. Giving read, write and execute
   permissions to the file's User and Group and to others. Symbols are
   defined for them in <wx/file.h>.

   #define wxS_IRUSR 00400
   #define wxS_IWUSR 00200
   #define wxS_IXUSR 00100

=head2 Wx::TarEntry::Get/SetSize

   void SetSize(wxFileOffset size)

   wxFileOffset GetSize() const

   The size of the entry's data in bytes.

   The tar archive format stores the entry's size ahead of the entry's
   data. Therefore when creating an archive on a non-seekable stream it
   is necessary to supply the correct size when each entry is created.
   For seekable streams this is not necessary as wxTarOutputStream will
   attempt to seek back and fix the entry's header when the entry is
   closed, though it is still more efficient if the size is given
   beforehand.

=head2 Wx::TarEntry::Get/SetTypeFlag

   int GetTypeFlag() const

   void SetTypeFlag(int type)

   Returns the type of the entry. It should be one of the following:

   // TypeFlag values
   enum {
       wxTAR_REGTYPE   = '0',      // regular file
       wxTAR_LNKTYPE   = '1',      // hard link
       wxTAR_SYMTYPE   = '2',      // symbolic link
       wxTAR_CHRTYPE   = '3',      // character special
       wxTAR_BLKTYPE   = '4',      // block special
       wxTAR_DIRTYPE   = '5',      // directory
       wxTAR_FIFOTYPE  = '6',      // named pipe
       wxTAR_CONTTYPE  = '7'       // contiguous file
   };

=head1 Wx::TarInputStream

=head2 Wx::TarInputStream::new

   wxTarInputStream(wxInputStream& stream, wxMBConv& conv = wxConvLocal)

   wxTarInputStream(wxInputStream* stream, wxMBConv& conv = wxConvLocal)

   Constructor. In a Unicode build the second parameter conv is used to
   translate fields from the standard tar header into Unicode. It has no
   effect on the stream's data. conv is only used for the standard tar
   headers, any pax extended headers are always UTF-8 encoded.

   If the parent stream is passed as a pointer then the new filter stream
   takes ownership of it. If it is passed by reference then it does not.

=head2 Wx::TarInputStream::CloseEntry

   bool CloseEntry()

   Closes the current entry. On a non-seekable stream reads to the end of
   the current entry first.

=head2 Wx::TarInputStream::GetNextEntry

   wxTarEntry* GetNextEntry()

   Closes the current entry if one is open, then reads the meta-data for
   the next entry and returns it in a wxTarEntry object, giving away
   ownership. The stream is then open and can be read.

=head2 Wx::TarInputStream::OpenEntry

   bool OpenEntry(wxTarEntry& entry)

   Closes the current entry if one is open, then opens the entry
   specified by the entry object.

   entry should be from the same tar file, and the tar should be on a
   seekable stream.

   See also

   Looking up an archive entry by name

=head1 Wx::TarOutputStream

=head2 Wx::TarOutputStream::new

   wxTarOutputStream(wxOutputStream& stream, wxTarFormat format =
   wxTAR_PAX, wxMBConv& conv = wxConvLocal)

   wxTarOutputStream(wxOutputStream* stream, wxTarFormat format =
   wxTAR_PAX, wxMBConv& conv = wxConvLocal)

   If the parent stream is passed as a pointer then the new filter stream
   takes ownership of it. If it is passed by reference then it does not.

   In a Unicode build the third parameter conv is used to translate the
   headers fields into an 8-bit encoding. It has no effect on the
   stream's data.

   When the format is wxTAR_PAX, pax extended headers are generated when
   any header field will not fit the standard tar header block or if it
   uses any non-ascii characters.

   Extended headers are stored as extra 'files' within the tar, and will
   be extracted as such by any other tar program that does not understand
   them. The conv parameter only affect the standard tar headers, the
   extended headers are always UTF-8 encoded.

   When the format is wxTAR_USTAR, no extended headers are generated, and
   instead a warning message is logged if any header field overflows.

=head2 Wx::TarOutputStream::DESTROY

   ~wxTarOutputStream()

   The destructor calls Close() to finish writing the tar if it has not
   been called already.

=head2 Wx::TarOutputStream::Close

   bool Close()

   Finishes writing the tar, returning true if successful. Called by the
   destructor if not called explicitly.

=head2 Wx::TarOutputStream::CloseEntry

   bool CloseEntry()

   Close the current entry. It is called implicitly whenever another new
   entry is created with CopyEntry() or PutNextEntry(), or when the tar
   is closed.

=head2 Wx::TarOutputStream::CopyArchiveMetaData

   bool CopyArchiveMetaData(wxTarInputStream& s)

   See wxArchiveOutputStream::CopyArchiveMetaData. For the tar format
   this function does nothing.

=head2 Wx::TarOutputStream::CopyEntry

   bool CopyEntry(wxTarEntry* entry, wxTarInputStream& inputStream)

   Takes ownership of entry and uses it to create a new entry in the tar.
   entry is then opened in inputStream and its contents copied to this
   stream.

   For some other archive formats CopyEntry() is much more efficient than
   transferring the data using Read() and Write() since it will copy them
   without decompressing and recompressing them. For tar however it makes
   no difference.

   For tars on seekable streams, entry must be from the same tar file as
   stream. For non-seekable streams, entry must also be the last thing
   read from inputStream.

=head2 Wx::TarOutputStream::Get/SetBlockingFactor

   int GetBlockingFactor() const

   void SetBlockingFactor(int factor)

   The tar is zero padded to round its size up to BlockingFactor * 512
   bytes.

   Defaults to 10 for wxTAR_PAX and 20 for wxTAR_USTAR (see the
   constructor), as specified in the POSIX standards.

=head2 Wx::TarOutputStream::PutNextDirEntry

   bool PutNextDirEntry(const wxString& name, const wxDateTime& dt =
   wxDateTime::Now())

   Create a new directory entry (see wxArchiveEntry::IsDir()) with the
   given name and timestamp.

   PutNextEntry() can also be used to create directory entries, by
   supplying a name with a trailing path separator.

=head2 Wx::TarOutputStream::PutNextEntry

   bool PutNextEntry(wxTarEntry* entry)

   Takes ownership of entry and uses it to create a new entry in the tar.

   bool PutNextEntry(const wxString& name, const wxDateTime& dt =
   wxDateTime::Now(), wxFileOffset size = wxInvalidOffset)

   Create a new entry with the given name, timestamp and size.

=head1 Wx::TaskBarIcon

=head2 Wx::TaskBarIcon::new

   wxTaskBarIcon()

   Default constructor.

=head2 Wx::TaskBarIcon::DESTROY

   ~wxTaskBarIcon()

   Destroys the wxTaskBarIcon object, removing the icon if not already
   removed.

=head2 Wx::TaskBarIcon::CreatePopupMenu

   virtual wxMenu* CreatePopupMenu()

   This method is called by the library when the user requests popup menu
   (on Windows and Unix platforms, this is when the user right-clicks the
   icon). Override this function in order to provide popup menu
   associated with the icon.

   If CreatePopupMenu returns NULL (this happens by default), no menu is
   shown, otherwise the menu is displayed and then deleted by the library
   as soon as the user dismisses it. The events can be handled by a class
   derived from wxTaskBarIcon.

=head2 Wx::TaskBarIcon::IsIconInstalled

   bool IsIconInstalled()

   Returns true if SetIcon was called with no subsequent RemoveIcon.

=head2 Wx::TaskBarIcon::IsOk

   bool IsOk()

   Returns true if the object initialized successfully.

=head2 Wx::TaskBarIcon::PopupMenu

   bool PopupMenu(wxMenu* menu)

   Pops up a menu at the current mouse position. The events can be
   handled by a class derived from wxTaskBarIcon.

   Note

   It is recommended to override CreatePopupMenu callback instead of
   calling this method from event handler, because some ports (e.g.
   wxCocoa) may not implement PopupMenu and mouse click events at all.

=head2 Wx::TaskBarIcon::RemoveIcon

   bool RemoveIcon()

   Removes the icon previously set with SetIcon.

=head2 Wx::TaskBarIcon::SetIcon

   bool SetIcon(const wxIcon& icon, const wxString& tooltip)

   Sets the icon, and optional tooltip text.

=head1 Wx::TCPClient

=head2 Wx::TCPClient::new

   wxTCPClient()

   Constructs a client object.

=head2 Wx::TCPClient::MakeConnection

   wxConnectionBase * MakeConnection(const wxString& host, const wxString&
   service, const wxString& topic)

   Tries to make a connection with a server specified by the host (a
   machine name under Unix), service name (must contain an integer port
   number under Unix), and a topic string. If the server allows a
   connection, a wxTCPConnection object will be returned. The type of
   wxTCPConnection returned can be altered by overriding the
   wxTCPClient::OnMakeConnection member to return your own derived
   connection object.

=head2 Wx::TCPClient::OnMakeConnection

   wxConnectionBase * OnMakeConnection()

   The type of wxTCPConnection returned from a
   wxTCPClient::MakeConnection call can be altered by deriving the
   OnMakeConnection member to return your own derived connection object.
   By default, a wxTCPConnection object is returned.

   The advantage of deriving your own connection class is that it will
   enable you to intercept messages initiated by the server, such as
   wxTCPConnection::OnAdvise. You may also want to store
   application-specific data in instances of the new class.

=head2 Wx::TCPClient::ValidHost

   bool ValidHost(const wxString& host)

   Returns true if this is a valid host name, false otherwise.

=head1 Wx::TCPConnection

=head2 Wx::TCPConnection::new

   wxTCPConnection()

   wxTCPConnection(char* buffer, int size)

   Constructs a connection object. If no user-defined connection object
   is to be derived from wxTCPConnection, then the constructor should not
   be called directly, since the default connection object will be
   provided on requesting (or accepting) a connection. However, if the
   user defines his or her own derived connection object, the
   wxTCPServer::OnAcceptConnection and/or wxTCPClient::OnMakeConnection
   members should be replaced by functions which construct the new
   connection object. If the arguments of the wxTCPConnection constructor
   are void, then a default buffer is associated with the connection.
   Otherwise, the programmer must provide a a buffer and size of the
   buffer for the connection object to use in transactions.

=head2 Wx::TCPConnection::Advise

   bool Advise(const wxString& item, char* data, int size = -1,
   wxIPCFormat format = wxCF_TEXT)

   Called by the server application to advise the client of a change in
   the data associated with the given item. Causes the client
   connection's wxTCPConnection::OnAdvise member to be called. Returns
   true if successful.

=head2 Wx::TCPConnection::Execute

   bool Execute(char* data, int size = -1, wxIPCFormat format = wxCF_TEXT)

   Called by the client application to execute a command on the server.
   Can also be used to transfer arbitrary data to the server (similar to
   wxTCPConnection::Poke in that respect). Causes the server connection's
   wxTCPConnection::OnExecute member to be called. Returns true if
   successful.

=head2 Wx::TCPConnection::Disconnect

   bool Disconnect()

   Called by the client or server application to disconnect from the
   other program; it causes the wxTCPConnection::OnDisconnect message to
   be sent to the corresponding connection object in the other program.
   The default behaviour of OnDisconnect is to delete the connection, but
   the calling application must explicitly delete its side of the
   connection having called Disconnect. Returns true if successful.

=head2 Wx::TCPConnection::OnAdvise

   virtual bool OnAdvise(const wxString& topic, const wxString& item,
   char* data, int size, wxIPCFormat format)

   Message sent to the client application when the server notifies it of
   a change in the data associated with the given item.

=head2 Wx::TCPConnection::OnDisconnect

   virtual bool OnDisconnect()

   Message sent to the client or server application when the other
   application notifies it to delete the connection. Default behaviour is
   to delete the connection object.

=head2 Wx::TCPConnection::OnExecute

   virtual bool OnExecute(const wxString& topic, char* data, int size,
   wxIPCFormat format)

   Message sent to the server application when the client notifies it to
   execute the given data. Note that there is no item associated with
   this message.

=head2 Wx::TCPConnection::OnPoke

   virtual bool OnPoke(const wxString& topic, const wxString& item, char*
   data, int size, wxIPCFormat format)

   Message sent to the server application when the client notifies it to
   accept the given data.

=head2 Wx::TCPConnection::OnRequest

   virtual char* OnRequest(const wxString& topic, const wxString& item,
   int *size, wxIPCFormat format)

   Message sent to the server application when the client calls
   wxTCPConnection::Request. The server should respond by returning a
   character string from OnRequest, or NULL to indicate no data.

=head2 Wx::TCPConnection::OnStartAdvise

   virtual bool OnStartAdvise(const wxString& topic, const wxString& item)

   Message sent to the server application by the client, when the client
   wishes to start an 'advise loop' for the given topic and item. The
   server can refuse to participate by returning false.

=head2 Wx::TCPConnection::OnStopAdvise

   virtual bool OnStopAdvise(const wxString& topic, const wxString& item)

   Message sent to the server application by the client, when the client
   wishes to stop an 'advise loop' for the given topic and item. The
   server can refuse to stop the advise loop by returning false, although
   this doesn't have much meaning in practice.

=head2 Wx::TCPConnection::Poke

   bool Poke(const wxString& item, char* data, int size = -1, wxIPCFormat
   format = wxCF_TEXT)

   Called by the client application to poke data into the server. Can be
   used to transfer arbitrary data to the server. Causes the server
   connection's wxTCPConnection::OnPoke member to be called. Returns true
   if successful.

=head2 Wx::TCPConnection::Request

   char* Request(const wxString& item, int *size, wxIPCFormat format =
   wxIPC_TEXT)

   Called by the client application to request data from the server.
   Causes the server connection's wxTCPConnection::OnRequest member to be
   called. Returns a character string (actually a pointer to the
   connection's buffer) if successful, NULL otherwise.

=head2 Wx::TCPConnection::StartAdvise

   bool StartAdvise(const wxString& item)

   Called by the client application to ask if an advise loop can be
   started with the server. Causes the server connection's
   wxTCPConnection::OnStartAdvise member to be called. Returns true if
   the server okays it, false otherwise.

=head2 Wx::TCPConnection::StopAdvise

   bool StopAdvise(const wxString& item)

   Called by the client application to ask if an advise loop can be
   stopped. Causes the server connection's wxTCPConnection::OnStopAdvise
   member to be called. Returns true if the server okays it, false
   otherwise.

=head1 Wx::TCPServer

=head2 Wx::TCPServer::new

   wxTCPServer()

   Constructs a server object.

=head2 Wx::TCPServer::Create

   bool Create(const wxString& service)

   Registers the server using the given service name. Under Unix, the
   string must contain an integer id which is used as an Internet port
   number. false is returned if the call failed (for example, the port
   number is already in use).

=head2 Wx::TCPServer::OnAcceptConnection

   virtual wxConnectionBase * OnAcceptConnection(const wxString& topic)

   When a client calls MakeConnection, the server receives the message
   and this member is called. The application should derive a member to
   intercept this message and return a connection object of either the
   standard wxTCPConnection type, or of a user-derived type. If the topic
   is "STDIO'', the application may wish to refuse the connection. Under
   Unix, when a server is created the OnAcceptConnection message is
   always sent for standard input and output.

=head1 Wx::TempFile

=head2 Wx::TempFile::new

   wxTempFile()

   Default constructor - Open must be used to open the file.

=head2 Wx::TempFile::new

   wxTempFile(const wxString& strName)

   Associates wxTempFile with the file to be replaced and opens it. You
   should use IsOpened to verify if the constructor succeeded.

=head2 Wx::TempFile::Open

   bool Open(const wxString& strName)

   Open the temporary file, returns true on success, false if an error
   occurred.

   strName is the name of file to be replaced. The temporary file is
   always created in the directory where strName is. In particular, if
   strName doesn't include the path, it is created in the current
   directory and the program should have write access to it for the
   function to succeed.

=head2 Wx::TempFile::IsOpened

   bool IsOpened() const

   Returns true if the file was successfully opened.

=head2 Wx::TempFile::Length

   wxFileOffset Length() const

   Returns the length of the file.

=head2 Wx::TempFile::Seek

   wxFileOffset Seek(wxFileOffset ofs, wxSeekMode mode = wxFromStart)

   Seeks to the specified position.

=head2 Wx::TempFile::Tell

   wxFileOffset Tell() const

   Returns the current position or wxInvalidOffset if file is not opened
   or if another error occurred.

=head2 Wx::TempFile::Write

   bool Write(const void *p, size_t n)

   Write to the file, return true on success, false on failure.

=head2 Wx::TempFile::Write

   bool Write(const wxString& str, wxMBConv& conv = wxConvLibc)

   Write to the file, return true on success, false on failure.

   The second argument is only meaningful in Unicode build of wxWidgets
   when conv is used to convert str to multibyte representation.

=head2 Wx::TempFile::Commit

   bool Commit()

   Validate changes: deletes the old file of name m_strName and renames
   the new file to the old name. Returns true if both actions succeeded.
   If false is returned it may unfortunately mean two quite different
   things: either that either the old file couldn't be deleted or that
   the new file couldn't be renamed to the old name.

=head2 Wx::TempFile::Discard

   void Discard()

   Discard changes: the old file contents is not changed, temporary file
   is deleted.

=head2 Wx::TempFile::DESTROY

   ~wxTempFile()

   Destructor calls Discard() if temporary file is still opened.

=head1 Wx::TempFileOutputStream

=head2 Wx::TempFileOutputStream::new

   wxTempFileOutputStream(const wxString& fileName)

   Associates wxTempFileOutputStream with the file to be replaced and
   opens it. You should use IsOk to verify if the constructor succeeded.

   Call Commit() or Close() to replace the old file and close this one.
   Calling Discard() (or allowing the destructor to do it) will discard
   the changes.

=head2 Wx::TempFileOutputStream::Commit

   bool Commit()

   Validate changes: deletes the old file of the given name and renames
   the new file to the old name. Returns true if both actions succeeded.
   If false is returned it may unfortunately mean two quite different
   things: either that either the old file couldn't be deleted or that
   the new file couldn't be renamed to the old name.

=head2 Wx::TempFileOutputStream::Discard

   void Discard()

   Discard changes: the old file contents are not changed, the temporary
   file is deleted.

=head1 Wx::TextAttr

=head2 Wx::TextAttr::new

   wxTextAttr()

   wxTextAttr(const wxColour& colText, const wxColour& colBack =
   wxNullColour, const wxFont& font = wxNullFont, wxTextAttrAlignment
   alignment = wxTEXT_ALIGNMENT_DEFAULT)

   The constructors initialize one or more of the text foreground colour,
   background colour, font, and alignment. The values not initialized in
   the constructor can be set later, otherwise wxTextCtrl::SetStyle will
   use the default values for them.

=head2 Wx::TextAttr::GetAlignment

   wxTextAttrAlignment GetAlignment() const

   Returns the paragraph alignment.

=head2 Wx::TextAttr::GetBackgroundColour

   const wxColour& GetBackgroundColour() const

   Return the background colour specified by this attribute.

=head2 Wx::TextAttr::GetFont

   const wxFont& GetFont() const

   Return the text font specified by this attribute.

=head2 Wx::TextAttr::GetLeftIndent

   int GetLeftIndent() const

   Returns the left indent in tenths of a millimetre.

=head2 Wx::TextAttr::GetLeftSubIndent

   int GetLeftSubIndent() const

   Returns the left sub indent for all lines but the first line in a
   paragraph in tenths of a millimetre.

=head2 Wx::TextAttr::GetRightIndent

   int GetRightIndent() const

   Returns the right indent in tenths of a millimetre.

=head2 Wx::TextAttr::GetTabs

   const wxArrayInt& GetTabs() const

   Returns the array of integers representing the tab stops. Each array
   element specifies the tab stop in tenths of a millimetre.

=head2 Wx::TextAttr::GetTextColour

   const wxColour& GetTextColour() const

   Return the text colour specified by this attribute.

=head2 Wx::TextAttr::HasAlignment

   bool HasAlignment() const

   Returns true if this style specifies the text alignment.

=head2 Wx::TextAttr::HasBackgroundColour

   bool HasBackgroundColour() const

   Returns true if this style specifies the background colour to use.

=head2 Wx::TextAttr::HasFont

   bool HasFont() const

   Returns true if this style specifies the font to use.

=head2 Wx::TextAttr::HasLeftIndent

   bool HasLeftIndent() const

   Returns true if this style specifies the left indent.

=head2 Wx::TextAttr::HasRightIndent

   bool HasRightIndent() const

   Returns true if this style specifies the right indent.

=head2 Wx::TextAttr::HasTabs

   bool HasTabs() const

   Returns true if this style specifies any tabstobs.

=head2 Wx::TextAttr::HasTextColour

   bool HasTextColour() const

   Returns true if this style specifies the foreground colour to use.

=head2 Wx::TextAttr::GetFlags

   long GetFlags()

   Returns a bitlist indicating which attributes will be set.

=head2 Wx::TextAttr::IsDefault

   bool IsDefault() const

   Returns true if this style specifies any non-default attributes.

=head2 Wx::TextAttr::Merge

   void Merge(const wxTextAttr& overlay)

   Copies all defined/valid properties from overlay to current object.

   static wxTextAttr Merge(const wxTextAttr& base, const wxTextAttr&
   overlay)

   Creates a new wxTextAttr which is a merge of base and overlay.
   Properties defined in overlay take precedence over those in base.
   Properties undefined/invalid in both are undefined in the result.

=head2 Wx::TextAttr::SetAlignment

   void SetAlignment(wxTextAttrAlignment alignment)

   Sets the paragraph alignment.

=head2 Wx::TextAttr::SetBackgroundColour

   void SetBackgroundColour(const wxColour& colour)

   Sets the background colour.

=head2 Wx::TextAttr::SetFlags

   void SetFlags(long flags)

   Pass a bitlist indicating which attributes will be set.

=head2 Wx::TextAttr::SetFont

   void SetFont(const wxFont& font)

   Sets the text font.

=head2 Wx::TextAttr::SetLeftIndent

   void SetLeftIndent(int indent, int subIndent = 0)

   Sets the left indent in tenths of a millimetre. subIndent sets the
   indent for all lines but the first line in a paragraph relative to the
   first line.

=head2 Wx::TextAttr::SetRightIndent

   void SetRightIndent(int indent)

   Sets the right indent in tenths of a millimetre.

=head2 Wx::TextAttr::SetTabs

   void SetTabs(const wxArrayInt& tabs)

   Sets the array of integers representing the tab stops. Each array
   element specifies the tab stop in tenths of a millimetre.

=head2 Wx::TextAttr::SetTextColour

   void SetTextColour(const wxColour& colour)

   Sets the text colour.

=head1 Wx::TextAttrEx

=head2 Wx::TextAttrEx::new

   wxTextAttrEx()

=head2 Wx::TextAttrEx::GetBulletFont

   const wxString& GetBulletFont() const

   Returns a string containing the name of the font associated with the
   bullet symbol. Only valid for attributes with
   wxTEXT_ATTR_BULLET_SYMBOL.

=head2 Wx::TextAttrEx::GetBulletName

   const wxString& GetBulletName() const

   Returns the standard bullet name, applicable if the bullet style is
   wxTEXT_ATTR_BULLET_STYLE_STANDARD. Currently the following standard
   bullet names are supported:

=head2 Wx::TextAttrEx::GetBulletNumber

   int GetBulletNumber() const

   Returns the bullet number.

=head2 Wx::TextAttrEx::GetBulletStyle

   int GetBulletStyle() const

   Returns the bullet style. See wxTextAttrEx::SetBulletStyle for a list
   of available styles.

=head2 Wx::TextAttrEx::GetBulletText

   const wxString& GetBulletText() const

   Returns the bullet text, which could be a symbol, or (for example)
   cached outline text.

=head2 Wx::TextAttrEx::GetCharacterStyleName

   const wxString& GetCharacterStyleName() const

   Returns the name of the character style.

=head2 Wx::TextAttrEx::GetLineSpacing

   int GetLineSpacing() const

   Returns the line spacing value, one of
   wxTEXT_ATTR_LINE_SPACING_NORMAL, wxTEXT_ATTR_LINE_SPACING_HALF, and
   wxTEXT_ATTR_LINE_SPACING_TWICE.

=head2 Wx::TextAttrEx::GetListStyleName

   const wxString& GetListStyleName() const

   Returns the name of the list style.

=head2 Wx::TextAttrEx::GetOutlineLevel

   int GetOutlineLevel() const

   Returns the outline level.

=head2 Wx::TextAttrEx::GetParagraphSpacingAfter

   int GetParagraphSpacingAfter() const

   Returns the space in tenths of a millimeter after the paragraph.

=head2 Wx::TextAttrEx::GetParagraphSpacingBefore

   int GetParagraphSpacingBefore() const

   Returns the space in tenths of a millimeter before the paragraph.

=head2 Wx::TextAttrEx::GetParagraphStyleName

   const wxString& GetParagraphStyleName() const

   Returns the name of the paragraph style.

=head2 Wx::TextAttrEx::GetTextEffectFlags

   int GetTextEffectFlags() const

   Returns the text effect bits of interest. See wxTextAttr::SetFlags for
   further information.

=head2 Wx::TextAttrEx::GetTextEffects

   int GetTextEffects() const

   Returns the text effects, a bit list of styles. See
   wxTextAttrEx::SetTextEffects for details.

=head2 Wx::TextAttrEx::GetURL

   const wxString& GetURL() const

   Returns the URL for the content. Content with wxTEXT_ATTR_URL style
   causes wxRichTextCtrl to show a hand cursor over it, and
   wxRichTextCtrl generates a wxTextUrlEvent when the content is clicked.

=head2 Wx::TextAttrEx::HasBulletName

   bool HasBulletName() const

   Returns true if the attribute object specifies a standard bullet name.

=head2 Wx::TextAttrEx::HasBulletNumber

   bool HasBulletNumber() const

   Returns true if the attribute object specifies a bullet number.

=head2 Wx::TextAttrEx::HasBulletStyle

   bool HasBulletStyle() const

   Returns true if the attribute object specifies a bullet style.

=head2 Wx::TextAttrEx::HasBulletText

   bool HasBulletText() const

   Returns true if the attribute object specifies bullet text (usually
   containing a symbol).

=head2 Wx::TextAttrEx::HasCharacterStyleName

   bool HasCharacterStyleName() const

   Returns true if the attribute object specifies a character style name.

=head2 Wx::TextAttrEx::HasLineSpacing

   bool HasLineSpacing() const

   Returns true if the attribute object specifies line spacing.

=head2 Wx::TextAttrEx::HasListStyleName

   bool HasListStyleName() const

   Returns true if the attribute object specifies a list style name.

=head2 Wx::TextAttrEx::HasOutlineLevel

   bool HasOutlineLevel() const

   Returns true if the attribute object specifies an outline level.

=head2 Wx::TextAttrEx::HasPageBreak

   bool HasPageBreak() const

   Returns true if the attribute object specifies a page break before
   this paragraph.

=head2 Wx::TextAttrEx::HasParagraphSpacingAfter

   bool HasParagraphSpacingAfter() const

   Returns true if the attribute object specifies spacing after a
   paragraph.

=head2 Wx::TextAttrEx::HasParagraphSpacingBefore

   bool HasParagraphSpacingBefore() const

   Returns true if the attribute object specifies spacing before a
   paragraph.

=head2 Wx::TextAttrEx::HasParagraphStyleName

   bool HasParagraphStyleName() const

   Returns true if the attribute object specifies a paragraph style name.

=head2 Wx::TextAttrEx::HasTextEffects

   bool HasTextEffects() const

   Returns true if the attribute object specifies text effects.

=head2 Wx::TextAttrEx::HasURL

   bool HasURL() const

   Returns true if the attribute object specifies a URL.

=head2 Wx::TextAttrEx::Init

   void Init()

   Initialises this object.

=head2 Wx::TextAttrEx::IsCharacterStyle

   bool IsCharacterStyle() const

   Returns true if the object represents a character style, that is, the
   flags specify a font or a text background or foreground colour.

=head2 Wx::TextAttrEx::IsDefault

   bool IsDefault() const

   Returns false if we have any attributes set, true otherwise.

=head2 Wx::TextAttrEx::IsParagraphStyle

   bool IsParagraphStyle() const

   Returns true if the object represents a paragraph style, that is, the
   flags specify alignment, indentation, tabs, paragraph spacing, or
   bullet style.

=head2 Wx::TextAttrEx::SetBulletFont

   void SetBulletFont(const wxString& font)

   Sets the name of the font associated with the bullet symbol. Only
   valid for attributes with wxTEXT_ATTR_BULLET_SYMBOL.

=head2 Wx::TextAttrEx::SetBulletNumber

   void SetBulletNumber(int n)

   Sets the bullet number.

=head2 Wx::TextAttrEx::SetBulletName

   void SetBulletName(const wxString& name)

   Sets the standard bullet name, applicable if the bullet style is
   wxTEXT_ATTR_BULLET_STYLE_STANDARD. See wxTextAttrEx::GetBulletName for
   a list of supported names, and how to expand the range of supported
   types.

=head2 Wx::TextAttrEx::SetBulletStyle

   void SetBulletStyle(int style)

   Sets the bullet style. The following styles can be passed:

   #define wxTEXT_ATTR_BULLET_STYLE_NONE               0x00000000
   #define wxTEXT_ATTR_BULLET_STYLE_ARABIC             0x00000001
   #define wxTEXT_ATTR_BULLET_STYLE_LETTERS_UPPER      0x00000002
   #define wxTEXT_ATTR_BULLET_STYLE_LETTERS_LOWER      0x00000004
   #define wxTEXT_ATTR_BULLET_STYLE_ROMAN_UPPER        0x00000008
   #define wxTEXT_ATTR_BULLET_STYLE_ROMAN_LOWER        0x00000010
   #define wxTEXT_ATTR_BULLET_STYLE_SYMBOL             0x00000020
   #define wxTEXT_ATTR_BULLET_STYLE_BITMAP             0x00000040
   #define wxTEXT_ATTR_BULLET_STYLE_PARENTHESES        0x00000080
   #define wxTEXT_ATTR_BULLET_STYLE_PERIOD             0x00000100
   #define wxTEXT_ATTR_BULLET_STYLE_STANDARD           0x00000200
   #define wxTEXT_ATTR_BULLET_STYLE_RIGHT_PARENTHESIS  0x00000400
   #define wxTEXT_ATTR_BULLET_STYLE_OUTLINE            0x00000800
   #define wxTEXT_ATTR_BULLET_STYLE_ALIGN_LEFT         0x00000000
   #define wxTEXT_ATTR_BULLET_STYLE_ALIGN_RIGHT        0x00001000
   #define wxTEXT_ATTR_BULLET_STYLE_ALIGN_CENTRE       0x00002000

   Currently wxTEXT_ATTR_BULLET_STYLE_BITMAP is not supported.

=head2 Wx::TextAttrEx::SetBulletText

   void SetBulletText(const wxString& text)

   Sets the bullet text, which could be a symbol, or (for example) cached
   outline text.

=head2 Wx::TextAttrEx::SetCharacterStyleName

   void SetCharacterStyleName(const wxString& name)

   Sets the character style name.

=head2 Wx::TextAttrEx::SetLineSpacing

   void SetLineSpacing(int spacing)

   Sets the line spacing. spacing is a multiple, where 10 means
   single-spacing, 15 means 1.5 spacing, and 20 means double spacing. The
   following constants are defined for convenience:

   #define wxTEXT_ATTR_LINE_SPACING_NORMAL         10
   #define wxTEXT_ATTR_LINE_SPACING_HALF           15
   #define wxTEXT_ATTR_LINE_SPACING_TWICE          20

=head2 Wx::TextAttrEx::SetListStyleName

   void SetListStyleName(const wxString& name)

   Sets the list style name.

=head2 Wx::TextAttrEx::SetOutlineLevel

   void SetOutlineLevel(int level)

   Specifies the outline level. Zero represents normal text. At present,
   the outline level is not used, but may be used in future for
   determining list levels and for applications that need to store
   document structure information.

=head2 Wx::TextAttrEx::SetPageBreak

   void SetPageBreak(bool pageBreak = true)

   Specifies a page break before this paragraph.

=head2 Wx::TextAttrEx::SetParagraphSpacingAfter

   void SetParagraphSpacingAfter(int spacing)

   Sets the spacing after a paragraph, in tenths of a millimetre.

=head2 Wx::TextAttrEx::SetParagraphSpacingBefore

   void SetParagraphSpacingBefore(int spacing)

   Sets the spacing before a paragraph, in tenths of a millimetre.

=head2 Wx::TextAttrEx::SetParagraphStyleName

   void SetParagraphStyleName(const wxString& name)

   Sets the name of the paragraph style.

=head2 Wx::TextAttrEx::SetTextEffectFlags

   void SetTextEffectFlags(int flags)

   Sets the text effect bits of interest. You should also pass
   wxTEXT_ATTR_EFFECTS to wxTextAttr::SetFlags.

=head2 Wx::TextAttrEx::SetTextEffects

   void SetTextEffects(int effects)

   Sets the text effects, a bit list of styles.

   The following styles can be passed:

   #define wxTEXT_ATTR_EFFECT_NONE                     0x00000000
   #define wxTEXT_ATTR_EFFECT_CAPITALS                 0x00000001
   #define wxTEXT_ATTR_EFFECT_SMALL_CAPITALS           0x00000002
   #define wxTEXT_ATTR_EFFECT_STRIKETHROUGH            0x00000004
   #define wxTEXT_ATTR_EFFECT_DOUBLE_STRIKETHROUGH     0x00000008
   #define wxTEXT_ATTR_EFFECT_SHADOW                   0x00000010
   #define wxTEXT_ATTR_EFFECT_EMBOSS                   0x00000020
   #define wxTEXT_ATTR_EFFECT_OUTLINE                  0x00000040
   #define wxTEXT_ATTR_EFFECT_ENGRAVE                  0x00000080
   #define wxTEXT_ATTR_EFFECT_SUPERSCRIPT              0x00000100
   #define wxTEXT_ATTR_EFFECT_SUBSCRIPT                0x00000200

   Of these, only wxTEXT_ATTR_EFFECT_CAPITALS and
   wxTEXT_ATTR_EFFECT_STRIKETHROUGH are implemented.
   wxTEXT_ATTR_EFFECT_CAPITALS capitalises text when displayed (leaving
   the case of the actual buffer text unchanged), and
   wxTEXT_ATTR_EFFECT_STRIKETHROUGH draws a line through text.

   To set effects, you should also pass wxTEXT_ATTR_EFFECTS to
   wxTextAttr::SetFlags, and call wxTextAttrEx::SetTextEffectFlags with
   the styles (taken from the above set) that you are interested in
   setting.

=head2 Wx::TextAttrEx::SetURL

   void SetURL(const wxString& url)

   Sets the URL for the content. Sets the wxTEXT_ATTR_URL style; content
   with this style causes wxRichTextCtrl to show a hand cursor over it,
   and wxRichTextCtrl generates a wxTextUrlEvent when the content is
   clicked.

=head1 Wx::TextCtrl

=head2 Wx::TextCtrl::new

   wxTextCtrl()

   Default constructor.

   wxTextCtrl(wxWindow* parent, wxWindowID id, const wxString& value = "",
   const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = 0, const wxValidator& validator =
   wxDefaultValidator, const wxString& name = wxTextCtrlNameStr)

   Constructor, creating and showing a text control.

   Parameters

   parent

       Parent window. Should not be NULL.

   id  

       Control identifier. A value of -1 denotes a default value.

   value

       Default text value.

   pos 

       Text control position.

   size

       Text control size.

   style

       Window style. See wxTextCtrl.

   validator

       Window validator.

   name

       Window name.

   Remarks

   The horizontal scrollbar (wxHSCROLL style flag) will only be created
   for multi-line text controls. Without a horizontal scrollbar, text
   lines that don't fit in the control's size will be wrapped (but no
   newline character is inserted). Single line controls don't have a
   horizontal scrollbar, the text is automatically scrolled so that the
   insertion point is always visible.

   See also

   wxTextCtrl::Create, wxValidator

=head2 Wx::TextCtrl::DESTROY

   ~wxTextCtrl()

   Destructor, destroying the text control.

=head2 Wx::TextCtrl::AppendText

   void AppendText(const wxString& text)

   Appends the text to the end of the text control.

   Parameters

   text

       Text to write to the text control.

   Remarks

   After the text is appended, the insertion point will be at the end of
   the text control. If this behaviour is not desired, the programmer
   should use GetInsertionPoint and SetInsertionPoint.

   See also

   wxTextCtrl::WriteText

=head2 Wx::TextCtrl::CanCopy

   virtual bool CanCopy()

   Returns true if the selection can be copied to the clipboard.

=head2 Wx::TextCtrl::CanCut

   virtual bool CanCut()

   Returns true if the selection can be cut to the clipboard.

=head2 Wx::TextCtrl::CanPaste

   virtual bool CanPaste()

   Returns true if the contents of the clipboard can be pasted into the
   text control. On some platforms (Motif, GTK) this is an approximation
   and returns true if the control is editable, false otherwise.

=head2 Wx::TextCtrl::CanRedo

   virtual bool CanRedo()

   Returns true if there is a redo facility available and the last
   operation can be redone.

=head2 Wx::TextCtrl::CanUndo

   virtual bool CanUndo()

   Returns true if there is an undo facility available and the last
   operation can be undone.

=head2 Wx::TextCtrl::Clear

   virtual void Clear()

   Clears the text in the control.

   Note that this function will generate a wxEVT_COMMAND_TEXT_UPDATED
   event.

=head2 Wx::TextCtrl::Copy

   virtual void Copy()

   Copies the selected text to the clipboard under Motif and MS Windows.

=head2 Wx::TextCtrl::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxString& value =
   "", const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = 0, const wxValidator& validator =
   wxDefaultValidator, const wxString& name = wxTextCtrlNameStr)

   Creates the text control for two-step construction. Derived classes
   should call or replace this function. See wxTextCtrl::wxTextCtrl for
   further details.

=head2 Wx::TextCtrl::Cut

   virtual void Cut()

   Copies the selected text to the clipboard and removes the selection.

=head2 Wx::TextCtrl::DiscardEdits

   void DiscardEdits()

   Resets the internal 'modified' flag as if the current edits had been
   saved.

=head2 Wx::TextCtrl::EmulateKeyPress

   bool EmulateKeyPress(const wxKeyEvent& event)

   This functions inserts into the control the character which would have
   been inserted if the given key event had occurred in the text control.
   The event object should be the same as the one passed to EVT_KEY_DOWN
   handler previously by wxWidgets.

   Please note that this function doesn't currently work correctly for
   all keys under any platform but MSW.

   Return value

   true if the event resulted in a change to the control, false
   otherwise.

=head2 Wx::TextCtrl::GetDefaultStyle

   const wxTextAttr& GetDefaultStyle() const

   Returns the style currently used for the new text.

   See also

   SetDefaultStyle

=head2 Wx::TextCtrl::GetInsertionPoint

   virtual long GetInsertionPoint() const

   Returns the insertion point. This is defined as the zero based index
   of the character position to the right of the insertion point. For
   example, if the insertion point is at the end of the text control, it
   is equal to both GetValue().Length() and GetLastPosition().

   The following code snippet safely returns the character at the
   insertion point or the zero character if the point is at the end of
   the control.

     char GetCurrentChar(wxTextCtrl *tc) {
       if (tc->GetInsertionPoint() == tc->GetLastPosition())
         return '\0';
       return tc->GetValue[tc->GetInsertionPoint()];
     }

=head2 Wx::TextCtrl::GetLastPosition

   virtual wxTextPos GetLastPosition() const

   Returns the zero based index of the last position in the text control,
   which is equal to the number of characters in the control.

=head2 Wx::TextCtrl::GetLineLength

   int GetLineLength(long lineNo) const

   Gets the length of the specified line, not including any trailing
   newline character(s).

   Parameters

   lineNo

       Line number (starting from zero).

   Return value

   The length of the line, or -1 if lineNo was invalid.

=head2 Wx::TextCtrl::GetLineText

   wxString GetLineText(long lineNo) const

   Returns the contents of a given line in the text control, not
   including any trailing newline character(s).

   Parameters

   lineNo

       The line number, starting from zero.

   Return value

   The contents of the line.

=head2 Wx::TextCtrl::GetNumberOfLines

   int GetNumberOfLines() const

   Returns the number of lines in the text control buffer.

   Remarks

   Note that even empty text controls have one line (where the insertion
   point is), so GetNumberOfLines() never returns 0.

   For wxGTK using GTK+ 1.2.x and earlier, the number of lines in a
   multi-line text control is calculated by actually counting newline
   characters in the buffer, i.e. this function returns the number of
   logical lines and doesn't depend on whether any of them are wrapped.
   For all the other platforms, the number of physical lines in the
   control is returned.

   Also note that you may wish to avoid using functions that work with
   line numbers if you are working with controls that contain large
   amounts of text as this function has O(N) complexity for N being the
   number of lines.

=head2 Wx::TextCtrl::GetRange

   virtual wxString GetRange(long from, long to) const

   Returns the string containing the text starting in the positions from
   and up to to in the control. The positions must have been returned by
   another wxTextCtrl method.

   Please note that the positions in a multiline wxTextCtrl do not
   correspond to the indices in the string returned by GetValue because
   of the different new line representations (CR or CR LF) and so this
   method should be used to obtain the correct results instead of
   extracting parts of the entire value. It may also be more efficient,
   especially if the control contains a lot of data.

=head2 Wx::TextCtrl::GetSelection

   virtual void GetSelection(long* from, long* to) const

   Gets the current selection span. If the returned values are equal,
   there was no selection.

   Please note that the indices returned may be used with the other
   wxTextctrl methods but don't necessarily represent the correct indices
   into the string returned by GetValue() for multiline controls under
   Windows (at least,) you should use GetStringSelection() to get the
   selected text.

   Parameters

   from

       The returned first position.

   to  

       The returned last position.

   wxPython note: The wxPython version of this method returns a tuple
   consisting of the from and to values.

   wxPerl note: In wxPerl this method takes no parameter and returns a
   2-element list ( from, to ).

=head2 Wx::TextCtrl::GetStringSelection

   virtual wxString GetStringSelection()

   Gets the text currently selected in the control. If there is no
   selection, the returned string is empty.

=head2 Wx::TextCtrl::GetStyle

   bool GetStyle(long position, wxTextAttr& style)

   Returns the style at this position in the text control. Not all
   platforms support this function.

   Return value

   true on success, false if an error occurred - it may also mean that
   the styles are not supported under this platform.

   See also

   wxTextCtrl::SetStyle, wxTextAttr

=head2 Wx::TextCtrl::GetValue

   wxString GetValue() const

   Gets the contents of the control. Notice that for a multiline text
   control, the lines will be separated by (Unix-style) \n characters,
   even under Windows where they are separated by a \r\n sequence in the
   native control.

=head2 Wx::TextCtrl::HitTest

   wxTextCtrlHitTestResult HitTest(const wxPoint& pt, wxTextCoord *col,
   wxTextCoord *row) const

   This function finds the character at the specified position expressed
   in pixels. If the return code is not wxTE_HT_UNKNOWN the row and
   column of the character closest to this position are returned in the
   col and row parameters (unless the pointers are NULL which is
   allowed).

   Please note that this function is currently only implemented in
   wxUniv, wxMSW and wxGTK2 ports.

   See also

   PositionToXY, XYToPosition

   wxPerl note: In wxPerl this function takes only the position argument
   and returns a 3-element list (result, col, row).

=head2 Wx::TextCtrl::IsEditable

   bool IsEditable() const

   Returns true if the controls contents may be edited by user (note that
   it always can be changed by the program), i.e. if the control hasn't
   been put in read-only mode by a previous call to SetEditable.

=head2 Wx::TextCtrl::IsEmpty

   bool IsEmpty() const

   Returns true if the control is currently empty. This is the same as
   GetValue().empty() but can be much more efficient for the multiline
   controls containing big amounts of text.

   This function is new since wxWidgets version 2.7.1

=head2 Wx::TextCtrl::IsModified

   bool IsModified() const

   Returns true if the text has been modified by user. Note that calling
   SetValue doesn't make the control modified.

   See also

   MarkDirty

=head2 Wx::TextCtrl::IsMultiLine

   bool IsMultiLine() const

   Returns true if this is a multi line edit control and false otherwise.

   See also

   IsSingleLine

=head2 Wx::TextCtrl::IsSingleLine

   bool IsSingleLine() const

   Returns true if this is a single line edit control and false
   otherwise.

   See also

   IsMultiLine

=head2 Wx::TextCtrl::LoadFile

   bool LoadFile(const wxString& filename, int fileType = wxTEXT_TYPE_ANY)

   Loads and displays the named file, if it exists.

   Parameters

   filename

       The filename of the file to load.

   fileType

       The type of file to load. This is currently ignored in wxTextCtrl.

   Return value

   true if successful, false otherwise.

=head2 Wx::TextCtrl::MarkDirty

   void MarkDirty()

   Mark text as modified (dirty).

   See also

   IsModified

=head2 Wx::TextCtrl::OnDropFiles

   void OnDropFiles(wxDropFilesEvent& event)

   This event handler function implements default drag and drop
   behaviour, which is to load the first dropped file into the control.

   Parameters

   event

       The drop files event.

   Remarks

   This is not implemented on non-Windows platforms.

   See also

   wxDropFilesEvent

=head2 Wx::TextCtrl::Paste

   virtual void Paste()

   Pastes text from the clipboard to the text item.

=head2 Wx::TextCtrl::PositionToXY

   bool PositionToXY(long pos, long *x, long *y) const

   Converts given position to a zero-based column, line number pair.

   Parameters

   pos 

       Position.

   x   

       Receives zero based column number.

   y   

       Receives zero based line number.

   Return value

   true on success, false on failure (most likely due to a too large
   position parameter).

   See also

   wxTextCtrl::XYToPosition

   wxPython note: In Python, PositionToXY() returns a tuple containing
   the x and y values, so (x,y) = PositionToXY() is equivalent to the
   call described above.

   wxPerl note: In wxPerl this method only takes the pos parameter, and
   returns a 2-element list ( x, y ).

=head2 Wx::TextCtrl::Redo

   virtual void Redo()

   If there is a redo facility and the last operation can be redone,
   redoes the last operation. Does nothing if there is no redo facility.

=head2 Wx::TextCtrl::Remove

   virtual void Remove(long from, long to)

   Removes the text starting at the first given position up to (but not
   including) the character at the last position.

   Parameters

   from

       The first position.

   to  

       The last position.

=head2 Wx::TextCtrl::Replace

   virtual void Replace(long from, long to, const wxString& value)

   Replaces the text starting at the first position up to (but not
   including) the character at the last position with the given text.

   Parameters

   from

       The first position.

   to  

       The last position.

   value

       The value to replace the existing text with.

=head2 Wx::TextCtrl::SaveFile

   bool SaveFile(const wxString& filename, int fileType = wxTEXT_TYPE_ANY)

   Saves the contents of the control in a text file.

   Parameters

   filename

       The name of the file in which to save the text.

   fileType

       The type of file to save. This is currently ignored in wxTextCtrl.

   Return value

   true if the operation was successful, false otherwise.

=head2 Wx::TextCtrl::SetDefaultStyle

   bool SetDefaultStyle(const wxTextAttr& style)

   Changes the default style to use for the new text which is going to be
   added to the control using WriteText or AppendText.

   If either of the font, foreground, or background colour is not set in
   style, the values of the previous default style are used for them. If
   the previous default style didn't set them neither, the global font or
   colours of the text control itself are used as fall back.

   However if the style parameter is the default wxTextAttr, then the
   default style is just reset (instead of being combined with the new
   style which wouldn't change it at all).

   Parameters

   style

       The style for the new text.

   Return value

   true on success, false if an error occurred - may also mean that the
   styles are not supported under this platform.

   See also

   GetDefaultStyle

=head2 Wx::TextCtrl::SetEditable

   virtual void SetEditable(const bool editable)

   Makes the text item editable or read-only, overriding the
   wxTE_READONLY flag.

   Parameters

   editable

       If true, the control is editable. If false, the control is
       read-only.

   See also

   IsEditable

=head2 Wx::TextCtrl::SetInsertionPoint

   virtual void SetInsertionPoint(long pos)

   Sets the insertion point at the given position.

   Parameters

   pos 

       Position to set.

=head2 Wx::TextCtrl::SetInsertionPointEnd

   virtual void SetInsertionPointEnd()

   Sets the insertion point at the end of the text control. This is
   equivalent to SetInsertionPoint(GetLastPosition()).

=head2 Wx::TextCtrl::SetMaxLength

   virtual void SetMaxLength(unsigned long len)

   This function sets the maximum number of characters the user can enter
   into the control. In other words, it allows to limit the text value
   length to len not counting the terminating NUL character.

   If len is 0, the previously set max length limit, if any, is discarded
   and the user may enter as much text as the underlying native text
   control widget supports (typically at least 32Kb).

   If the user tries to enter more characters into the text control when
   it already is filled up to the maximal length, a
   wxEVT_COMMAND_TEXT_MAXLEN event is sent to notify the program about it
   (giving it the possibility to show an explanatory message, for
   example) and the extra input is discarded.

   Note that under GTK+, this function may only be used with single line
   text controls.

   Compatibility

   Only implemented in wxMSW/wxGTK starting with wxWidgets 2.3.2.

=head2 Wx::TextCtrl::SetModified

   void SetModified(bool modified)

   Marks the control as being modified by the user or not.

   See also

   MarkDirty, DiscardEdits

=head2 Wx::TextCtrl::SetSelection

   virtual void SetSelection(long from, long to)

   Selects the text starting at the first position up to (but not
   including) the character at the last position. If both parameters are
   equal to -1 all text in the control is selected.

   Parameters

   from

       The first position.

   to  

       The last position.

=head2 Wx::TextCtrl::SetStyle

   bool SetStyle(long start, long end, const wxTextAttr& style)

   Changes the style of the given range. If any attribute within style is
   not set, the corresponding attribute from GetDefaultStyle() is used.

   Parameters

   start

       The start of the range to change.

   end 

       The end of the range to change.

   style

       The new style for the range.

   Return value

   true on success, false if an error occurred - it may also mean that
   the styles are not supported under this platform.

   See also

   wxTextCtrl::GetStyle, wxTextAttr

=head2 Wx::TextCtrl::SetValue

   virtual void SetValue(const wxString& value)

   Sets the text value and marks the control as not-modified (which means
   that IsModified would return false immediately after the call to
   SetValue).

   Note that this function will generate a wxEVT_COMMAND_TEXT_UPDATED
   event.

   This function is deprecated and should not be used in new code. Please
   use the ChangeValue function instead.

   Parameters

   value

       The new value to set. It may contain newline characters if the
       text control is multi-line.

=head2 Wx::TextCtrl::ChangeValue

   virtual void ChangeValue(const wxString& value)

   Sets the text value and marks the control as not-modified (which means
   that IsModified would return false immediately after the call to
   SetValue).

   Note that this function will not generate the
   wxEVT_COMMAND_TEXT_UPDATED event. This is the only difference with
   SetValue. See this topic for more information.

   This function is new since wxWidgets version 2.7.1

   Parameters

   value

       The new value to set. It may contain newline characters if the
       text control is multi-line.

=head2 Wx::TextCtrl::ShowPosition

   void ShowPosition(long pos)

   Makes the line containing the given position visible.

   Parameters

   pos 

       The position that should be visible.

=head2 Wx::TextCtrl::Undo

   virtual void Undo()

   If there is an undo facility and the last operation can be undone,
   undoes the last operation. Does nothing if there is no undo facility.

=head2 Wx::TextCtrl::WriteText

   void WriteText(const wxString& text)

   Writes the text into the text control at the current insertion
   position.

   Parameters

   text

       Text to write to the text control.

   Remarks

   Newlines in the text string are the only control characters allowed,
   and they will cause appropriate line breaks. See wxTextCtrl::<< and
   wxTextCtrl::AppendText for more convenient ways of writing to the
   window.

   After the write operation, the insertion point will be at the end of
   the inserted text, so subsequent write operations will be appended. To
   append text after the user may have interacted with the control, call
   wxTextCtrl::SetInsertionPointEnd before writing.

=head2 Wx::TextCtrl::XYToPosition

   long XYToPosition(long x, long y)

   Converts the given zero based column and line number to a position.

   Parameters

   x   

       The column number.

   y   

       The line number.

   Return value

   The position value, or -1 if x or y was invalid.

=head1 Wx::TextDataObject

=head2 Wx::TextDataObject::new

   wxTextDataObject(const wxString& text = wxEmptyString)

   Constructor, may be used to initialise the text (otherwise SetText
   should be used later).

=head2 Wx::TextDataObject::GetTextLength

   virtual size_t GetTextLength() const

   Returns the data size. By default, returns the size of the text data
   set in the constructor or using SetText. This can be overridden to
   provide text size data on-demand. It is recommended to return the text
   length plus 1 for a trailing zero, but this is not strictly required.

=head2 Wx::TextDataObject::GetText

   virtual wxString GetText() const

   Returns the text associated with the data object. You may wish to
   override this method when offering data on-demand, but this is not
   required by wxWidgets' internals. Use this method to get data in text
   form from the wxClipboard.

=head2 Wx::TextDataObject::SetText

   virtual void SetText(const wxString& strText)

   Sets the text associated with the data object. This method is called
   when the data object receives the data and, by default, copies the
   text into the member variable. If you want to process the text on the
   fly you may wish to override this function.

=head1 Wx::TextDropTarget

=head2 Wx::TextDropTarget::new

   wxTextDropTarget()

   Constructor.

=head2 Wx::TextDropTarget::OnDrop

   virtual bool OnDrop(long x, long y, const void *data, size_t size)

   See wxDropTarget::OnDrop. This function is implemented appropriately
   for text, and calls wxTextDropTarget::OnDropText.

=head2 Wx::TextDropTarget::OnDropText

   virtual bool OnDropText(wxCoord x, wxCoord y, const wxString& data)

   Override this function to receive dropped text.

   Parameters

   x   

       The x coordinate of the mouse.

   y   

       The y coordinate of the mouse.

   data

       The data being dropped: a wxString.

   Return value

   Return true to accept the data, false to veto the operation.

=head1 Wx::TextEntryDialog

=head2 Wx::TextEntryDialog::new

   wxTextEntryDialog(wxWindow* parent, const wxString& message, const
   wxString& caption = "Please enter text", const wxString& defaultValue
   = "", long style = wxOK | wxCANCEL | wxCENTRE, const wxPoint& pos =
   wxDefaultPosition)

   Constructor. Use wxTextEntryDialog::ShowModal to show the dialog.

   Parameters

   parent

       Parent window.

   message

       Message to show on the dialog.

   defaultValue

       The default value, which may be the empty string.

   style

       A dialog style, specifying the buttons (wxOK, wxCANCEL) and an
       optional wxCENTRE style. Additionally, wxTextCtrl styles (such as
       wxTE_PASSWORD) may be specified here.

   pos 

       Dialog position.

=head2 Wx::TextEntryDialog::DESTROY

   ~wxTextEntryDialog()

   Destructor.

=head2 Wx::TextEntryDialog::GetValue

   wxString GetValue() const

   Returns the text that the user has entered if the user has pressed OK,
   or the original value if the user has pressed Cancel.

=head2 Wx::TextEntryDialog::SetValue

   void SetValue(const wxString& value)

   Sets the default text value.

=head2 Wx::TextEntryDialog::ShowModal

   int ShowModal()

   Shows the dialog, returning wxID_OK if the user pressed OK, and
   wxID_CANCEL otherwise.

=head1 Wx::TextFile

=head2 Wx::TextFile::new

   wxTextFile() const

   Default constructor, use Create or Open with a file name parameter to
   initialize the object.

=head2 Wx::TextFile::new

   wxTextFile(const wxString& strFile) const

   Constructor does not load the file into memory, use Open() to do it.

=head2 Wx::TextFile::DESTROY

   ~wxTextFile() const

   Destructor does nothing.

=head2 Wx::TextFile::AddLine

   void AddLine(const wxString& str, wxTextFileType type = typeDefault)
   const

   Adds a line to the end of file.

=head2 Wx::TextFile::Close

   bool Close() const

   Closes the file and frees memory, losing all changes. Use Write() if
   you want to save them.

=head2 Wx::TextFile::Create

   bool Create() const

   bool Create(const wxString& strFile) const

   Creates the file with the given name or the name which was given in
   the constructor. The array of file lines is initially empty.

   It will fail if the file already exists, Open should be used in this
   case.

=head2 Wx::TextFile::Exists

   bool Exists() const

   Return true if file exists - the name of the file should have been
   specified in the constructor before calling Exists().

=head2 Wx::TextFile::IsOpened

   bool IsOpened() const

   Returns true if the file is currently opened.

=head2 Wx::TextFile::GetLineCount

   size_t GetLineCount() const

   Get the number of lines in the file.

=head2 Wx::TextFile::GetLine

   wxString& GetLine(size_t n) const

   Retrieves the line number n from the file. The returned line may be
   modified but you shouldn't add line terminator at the end - this will
   be done by wxTextFile.

=head2 Wx::TextFile::GetCurrentLine

   size_t GetCurrentLine() const

   Returns the current line: it has meaning only when you're using
   GetFirstLine()/GetNextLine() functions, it doesn't get updated when
   you're using "direct access" functions like GetLine(). GetFirstLine()
   and GetLastLine() also change the value of the current line, as well
   as GoToLine().

=head2 Wx::TextFile::GoToLine

   void GoToLine(size_t n) const

   Changes the value returned by GetCurrentLine and used by
   GetFirstLine()/GetNextLine().

=head2 Wx::TextFile::Eof

   bool Eof() const

   Returns true if the current line is the last one.

=head2 Wx::TextFile::GetEOL

   static const char* GetEOL(wxTextFileType type = typeDefault) const

   Get the line termination string corresponding to given constant.
   typeDefault is the value defined during the compilation and
   corresponds to the native format of the platform, i.e. it will be
   wxTextFileType_Dos under Windows, wxTextFileType_Unix under Unix
   (including Mac OS X when compiling with the Apple Developer Tools) and
   wxTextFileType_Mac under Mac OS (including Mac OS X when compiling
   with CodeWarrior).

=head2 Wx::TextFile::GetFirstLine

   wxString& GetFirstLine() const

   This method together with GetNextLine() allows more "iterator-like"
   traversal of the list of lines, i.e. you may write something like:

   wxTextFile file;
   ...
   for ( str = file.GetFirstLine(); !file.Eof(); str = file.GetNextLine() )
   {
       // do something with the current line in str
   }
   // do something with the last line in str

=head2 Wx::TextFile::GetNextLine

   wxString& GetNextLine()

   Gets the next line (see GetFirstLine for the example).

=head2 Wx::TextFile::GetPrevLine

   wxString& GetPrevLine()

   Gets the previous line in the file.

=head2 Wx::TextFile::GetLastLine

   wxString& GetLastLine()

   Gets the last line of the file. Together with GetPrevLine it allows to
   enumerate the lines in the file from the end to the beginning like
   this:

   wxTextFile file;
   ...
   for ( str = file.GetLastLine();
         file.GetCurrentLine() > 0;
         str = file.GetPrevLine() )
   {
       // do something with the current line in str
   }
   // do something with the first line in str

=head2 Wx::TextFile::GetLineType

   wxTextFileType GetLineType(size_t n) const

   Get the type of the line (see also GetEOL)

=head2 Wx::TextFile::GuessType

   wxTextFileType GuessType() const

   Guess the type of file (which is supposed to be opened). If
   sufficiently many lines of the file are in DOS/Unix/Mac format, the
   corresponding value will be returned. If the detection mechanism fails
   wxTextFileType_None is returned.

=head2 Wx::TextFile::GetName

   const char* GetName() const

   Get the name of the file.

=head2 Wx::TextFile::InsertLine

   void InsertLine(const wxString& str, size_t n, wxTextFileType type =
   typeDefault) const

   Insert a line before the line number n.

=head2 Wx::TextFile::Open

   bool Open(wxMBConv& conv = wxConvUTF8) const

   bool Open(const wxString& strFile, wxMBConv& conv = wxConvUTF8) const

   Open() opens the file with the given name or the name which was given
   in the constructor and also loads file in memory on success. It will
   fail if the file does not exist, Create should be used in this case.

   The conv argument is only meaningful in Unicode build of wxWidgets
   when it is used to convert the file to wide character representation.

=head2 Wx::TextFile::RemoveLine

   void RemoveLine(size_t n) const

   Delete line number n from the file.

=head2 Wx::TextFile::Clear

   void Clear() const

   Delete all lines from the file, set current line number to 0.

=head2 Wx::TextFile::Write

   bool Write(wxTextFileType typeNew = wxTextFileType_None, wxMBConv&
   conv = wxConvUTF8) const

   Change the file on disk. The typeNew parameter allows you to change
   the file format (default argument means "don't change type") and may
   be used to convert, for example, DOS files to Unix.

   The conv argument is only meaningful in Unicode build of wxWidgets
   when it is used to convert all lines to multibyte representation
   before writing them them to physical file.

   Returns true if operation succeeded, false if it failed.

=head1 Wx::TextInputStream

=head2 Wx::TextInputStream::new

   wxTextInputStream(wxInputStream& stream, const wxString& sep=" \t",
   wxMBConv& conv = wxConvUTF8 )

   Constructs a text stream associated to the given input stream.

   Parameters

   stream

       The underlying input stream.

   sep 

       The initial string separator characters.

   conv

       In Unicode build only: The encoding converter used to convert the
       bytes in the underlying input stream to characters.

=head2 Wx::TextInputStream::DESTROY

   ~wxTextInputStream()

   Destroys the wxTextInputStream object.

=head2 Wx::TextInputStream::Read8

   wxUint8 Read8(int base = 10)

   Reads a single unsigned byte from the stream, given in base base.

   The value of base must be comprised between 2 and 36, inclusive, or be
   a special value 0 which means that the usual rules of C numbers are
   applied: if the number starts with 0x it is considered to be in base
   16, if it starts with 0 - in base 8 and in base 10 otherwise. Note
   that you may not want to specify the base 0 if you are parsing the
   numbers which may have leading zeroes as they can yield unexpected (to
   the user not familiar with C) results.

=head2 Wx::TextInputStream::Read8S

   wxInt8 Read8S(int base = 10)

   Reads a single signed byte from the stream.

   See wxTextInputStream::Read8 for the description of the base
   parameter.

=head2 Wx::TextInputStream::Read16

   wxUint16 Read16(int base = 10)

   Reads a unsigned 16 bit integer from the stream.

   See wxTextInputStream::Read8 for the description of the base
   parameter.

=head2 Wx::TextInputStream::Read16S

   wxInt16 Read16S(int base = 10)

   Reads a signed 16 bit integer from the stream.

   See wxTextInputStream::Read8 for the description of the base
   parameter.

=head2 Wx::TextInputStream::Read32

   wxUint32 Read32(int base = 10)

   Reads a 32 bit unsigned integer from the stream.

   See wxTextInputStream::Read8 for the description of the base
   parameter.

=head2 Wx::TextInputStream::Read32S

   wxInt32 Read32S(int base = 10)

   Reads a 32 bit signed integer from the stream.

   See wxTextInputStream::Read8 for the description of the base
   parameter.

=head2 Wx::TextInputStream::GetChar

   wxChar GetChar()

   Reads a character, returns 0 if there are no more characters in the
   stream.

=head2 Wx::TextInputStream::ReadDouble

   double ReadDouble()

   Reads a double (IEEE encoded) from the stream.

=head2 Wx::TextInputStream::ReadLine

   wxString ReadLine()

   Reads a line from the input stream and returns it (without the end of
   line character).

=head2 Wx::TextInputStream::ReadString

   wxString ReadString()

   NB: This method is deprecated, use ReadLine or ReadWord instead.

   Same as ReadLine.

=head2 Wx::TextInputStream::ReadWord

   wxString ReadWord()

   Reads a word (a sequence of characters until the next separator) from
   the input stream.

   See also

   SetStringSeparators

=head2 Wx::TextInputStream::SetStringSeparators

   void SetStringSeparators(const wxString& sep)

   Sets the characters which are used to define the word boundaries in
   ReadWord.

   The default separators are the space and TAB characters.

=head1 Wx::TextOutputStream

=head2 Wx::TextOutputStream::new

   wxTextOutputStream(wxOutputStream& stream, wxEOL mode = wxEOL_NATIVE,
   wxMBConv& conv = wxConvUTF8)

   Constructs a text stream object associated to the given output stream.

   Parameters

   stream

       The output stream.

   mode

       The end-of-line mode. One of wxEOL_NATIVE, wxEOL_DOS, wxEOL_MAC
       and wxEOL_UNIX.

   conv

       In Unicode build only: The object used to convert Unicode text
       into ASCII characters written to the output stream.

=head2 Wx::TextOutputStream::DESTROY

   ~wxTextOutputStream()

   Destroys the wxTextOutputStream object.

=head2 Wx::TextOutputStream::GetMode

   wxEOL GetMode()

   Returns the end-of-line mode. One of wxEOL_DOS, wxEOL_MAC and
   wxEOL_UNIX.

=head2 Wx::TextOutputStream::PutChar

   void PutChar(wxChar c)

   Writes a character to the stream.

=head2 Wx::TextOutputStream::SetMode

   void SetMode(wxEOL mode = wxEOL_NATIVE)

   Set the end-of-line mode. One of wxEOL_NATIVE, wxEOL_DOS, wxEOL_MAC
   and wxEOL_UNIX.

=head2 Wx::TextOutputStream::Write8

   void Write8(wxUint8 i8)

   Writes the single byte i8 to the stream.

=head2 Wx::TextOutputStream::Write16

   void Write16(wxUint16 i16)

   Writes the 16 bit integer i16 to the stream.

=head2 Wx::TextOutputStream::Write32

   void Write32(wxUint32 i32)

   Writes the 32 bit integer i32 to the stream.

=head2 Wx::TextOutputStream::WriteDouble

   virtual void WriteDouble(double f)

   Writes the double f to the stream using the IEEE format.

=head2 Wx::TextOutputStream::WriteString

   virtual void WriteString(const wxString& string)

   Writes string as a line. Depending on the end-of-line mode the end of
   line ('\n') characters in the string are converted to the correct line
   ending terminator.

=head1 Wx::TextValidator

=head2 Wx::TextValidator::new

   wxTextValidator(const wxTextValidator& validator)

   Copy constructor.

   wxTextValidator(long style = wxFILTER_NONE, wxString* valPtr = NULL)

   Constructor, taking a style and optional pointer to a wxString
   variable.

   Parameters

   style

       A bitlist of flags, which can be:

=head2 Wx::TextValidator::Clone

   virtual wxValidator* Clone() const

   Clones the text validator using the copy constructor.

=head2 Wx::TextValidator::GetExcludes

   wxArrayString& GetExcludes() const

   Returns a reference to the exclude list (the list of invalid values).

=head2 Wx::TextValidator::GetIncludes

   wxArrayString& GetIncludes() const

   Returns a reference to the include list (the list of valid values).

=head2 Wx::TextValidator::GetStyle

   long GetStyle() const

   Returns the validator style.

=head2 Wx::TextValidator::OnChar

   void OnChar(wxKeyEvent& event)

   Receives character input from the window and filters it according to
   the current validator style.

=head2 Wx::TextValidator::SetExcludes

   void SetExcludes(const wxArrayString& stringList)

   Sets the exclude list (invalid values for the user input).

=head2 Wx::TextValidator::SetIncludes

   void SetIncludes(const wxArrayString& stringList)

   Sets the include list (valid values for the user input).

=head2 Wx::TextValidator::SetStyle

   void SetStyle(long style)

   Sets the validator style.

=head2 Wx::TextValidator::TransferFromWindow

   virtual bool TransferFromWindow()

   Transfers the value in the text control to the string.

=head2 Wx::TextValidator::TransferToWindow

   virtual bool TransferToWindow()

   Transfers the string value to the text control.

=head2 Wx::TextValidator::Validate

   virtual bool Validate(wxWindow* parent)

   Validates the window contents against the include or exclude lists,
   depending on the validator style.

=head1 Wx::Thread

=head2 Types of Wx::Threads

   There are two types of threads in wxWidgets: detached and joinable,
   modeled after the the POSIX thread API. This is different from the
   Win32 API where all threads are joinable.

   By default wxThreads in wxWidgets use the detached behavior. Detached
   threads delete themselves once they have completed, either by
   themselves when they complete processing or through a call to
   wxThread::Delete, and thus must be created on the heap (through the
   new operator, for example). Conversely, joinable threads do not delete
   themselves when they are done processing and as such are safe to
   create on the stack. Joinable threads also provide the ability for one
   to get value it returned from wxThread::Entry through wxThread::Wait.

   You shouldn't hurry to create all the threads joinable, however,
   because this has a disadvantage as well: you must Wait() for a
   joinable thread or the system resources used by it will never be
   freed, and you also must delete the corresponding wxThread object
   yourself if you did not create it on the stack. In contrast, detached
   threads are of the "fire-and-forget" kind: you only have to start a
   detached thread and it will terminate and destroy itself.

=head2 Wx::Thread deletion

   Regardless of whether it has terminated or not, you should call
   wxThread::Wait on a joinable thread to release its memory, as outlined
   in Types of wxThreads. If you created a joinable thread on the heap,
   remember to delete it manually with the delete operator or similar
   means as only detached threads handle this type of memory management.

   Since detached threads delete themselves when they are finished
   processing, you should take care when calling a routine on one. If you
   are certain the thread is still running and would like to end it, you
   may call wxThread::Delete to gracefully end it (which implies that the
   thread will be deleted after that call to Delete()). It should be
   implied that you should never attempt to delete a detached thread with
   the delete operator or similar means.

   As mentioned, wxThread::Wait or wxThread::Delete attempts to
   gracefully terminate a joinable and detached thread, respectively. It
   does this by waiting until the thread in question calls
   wxThread::TestDestroy or ends processing (returns from wxThread::Entry).

   Obviously, if the thread does call TestDestroy() and does not end the
   calling thread will come to halt. This is why it is important to call
   TestDestroy() in the Entry() routine of your threads as often as
   possible.

   As a last resort you can end the thread immediately through
   wxThread::Kill. It is strongly recommended that you do not do this,
   however, as it does not free the resources associated with the object
   (although the wxThread object of detached threads will still be
   deleted) and could leave the C runtime library in an undefined state.

=head2 Wx::Widgets calls in secondary threads

   All threads other then the "main application thread" (the one
   wxApp::OnInit or your main function runs in, for example) are
   considered "secondary threads". These include all threads created by
   wxThread::Create or the corresponding constructors.

   GUI calls, such as those to a wxWindow or wxBitmap are explicitly not
   safe at all in secondary threads and could end your application
   prematurely. This is due to several reasons, including the underlying
   native API and the fact that wxThread does not run a GUI event loop
   similar to other APIs as MFC.

   A workaround that works on some wxWidgets ports is calling
   wxMutexGUIEnter before any GUI calls and then calling wxMutexGUILeave
   afterwords. However, the recommended way is to simply process the GUI
   calls in the main thread through an event that is posted by either
   wxPostEvent or wxEvtHandler::AddPendingEvent. This does not imply that
   calls to these classes are thread-safe, however, as most wxWidgets
   classes are not thread-safe, including wxString.

=head2 Don't poll a Wx::Thread

   A common problem users experience with wxThread is that in their main
   thread they will check the thread every now and then to see if it has
   ended through wxThread::IsRunning, only to find that their application
   has run into problems because the thread is using the default behavior
   and has already deleted itself. Naturally, they instead attempt to use
   joinable threads in place of the previous behavior.

   However, polling a wxThread for when it has ended is in general a bad
   idea - in fact calling a routine on any running wxThread should be
   avoided if possible. Instead, find a way to notify yourself when the
   thread has ended. Usually you only need to notify the main thread, in
   which case you can post an event to it via wxPostEvent or
   wxEvtHandler::AddPendingEvent. In the case of secondary threads you
   can call a routine of another class when the thread is about to
   complete processing and/or set the value of a variable, possibly using
   mutexes and/or other synchronization means if necessary.

=head2 Wx::Thread::new

   wxThread(wxThreadKind kind = wxTHREAD_DETACHED)

   This constructor creates a new detached (default) or joinable C++
   thread object. It does not create or start execution of the real
   thread -- for this you should use the Create and Run methods.

   The possible values for kind parameters are:

=head2 Wx::Thread::DESTROY

   ~wxThread()

   The destructor frees the resources associated with the thread. Notice
   that you should never delete a detached thread -- you may only call
   Delete on it or wait until it terminates (and auto destructs) itself.
   Because the detached threads delete themselves, they can only be
   allocated on the heap.

   Joinable threads should be deleted explicitly. The Delete and Kill
   functions will not delete the C++ thread object. It is also safe to
   allocate them on stack.

=head2 Wx::Thread::Create

   wxThreadError Create(unsigned int stackSize = 0)

   Creates a new thread. The thread object is created in the suspended
   state, and you should call Run to start running it. You may optionally
   specify the stack size to be allocated to it (Ignored on platforms
   that don't support setting it explicitly, eg. Unix system without
   pthread_attr_setstacksize). If you do not specify the stack size, the
   system's default value is used.

   Warning: It is a good idea to explicitly specify a value as systems'
   default values vary from just a couple of KB on some systems (BSD and
   OS/2 systems) to one or several MB (Windows, Solaris, Linux). So, if
   you have a thread that requires more than just a few KB of memory, you
   will have mysterious problems on some platforms but not on the common
   ones. On the other hand, just indicating a large stack size by default
   will give you performance issues on those systems with small default
   stack since those typically use fully committed memory for the stack.
   On the contrary, if use a lot of threads (say several hundred),
   virtual adress space can get tight unless you explicitly specify a
   smaller amount of thread stack space for each thread.

=head2 Wx::Thread::Delete

   wxThreadError Delete()

   Calling Delete gracefully terminates a detached thread, either when
   the thread calls TestDestroy or finished processing.

   (Note that while this could work on a joinable thread you simply
   should not call this routine on one as afterwards you may not be able
   to call wxThread::Wait to free the memory of that thread).

   See wxThread deletion for a broader explanation of this routine.

=head2 Wx::Thread::Entry

   virtual ExitCode Entry()

   This is the entry point of the thread. This function is pure virtual
   and must be implemented by any derived class. The thread execution
   will start here.

   The returned value is the thread exit code which is only useful for
   joinable threads and is the value returned by Wait.

   This function is called by wxWidgets itself and should never be called
   directly.

=head2 Wx::Thread::Exit

   void Exit(ExitCode exitcode = 0)

   This is a protected function of the wxThread class and thus can only
   be called from a derived class. It also can only be called in the
   context of this thread, i.e. a thread can only exit from itself, not
   from another thread.

   This function will terminate the OS thread (i.e. stop the associated
   path of execution) and also delete the associated C++ object for
   detached threads. wxThread::OnExit will be called just before exiting.

=head2 Wx::Thread::GetCPUCount

   static int GetCPUCount()

   Returns the number of system CPUs or -1 if the value is unknown.

   See also

   SetConcurrency

=head2 Wx::Thread::GetCurrentId

   static unsigned long GetCurrentId()

   Returns the platform specific thread ID of the current thread as a
   long. This can be used to uniquely identify threads, even if they are
   not wxThreads.

=head2 Wx::Thread::GetId

   unsigned long GetId() const

   Gets the thread identifier: this is a platform dependent number that
   uniquely identifies the thread throughout the system during its
   existence (i.e. the thread identifiers may be reused).

=head2 Wx::Thread::GetPriority

   int GetPriority() const

   Gets the priority of the thread, between zero and 100.

   The following priorities are defined:

=head2 Wx::Thread::IsAlive

   bool IsAlive() const

   Returns true if the thread is alive (i.e. started and not
   terminating).

   Note that this function can only safely be used with joinable threads,
   not detached ones as the latter delete themselves and so when the real
   thread is no longer alive, it is not possible to call this function
   because the wxThread object no longer exists.

=head2 Wx::Thread::IsDetached

   bool IsDetached() const

   Returns true if the thread is of the detached kind, false if it is a
   joinable one.

=head2 Wx::Thread::IsMain

   static bool IsMain()

   Returns true if the calling thread is the main application thread.

=head2 Wx::Thread::IsPaused

   bool IsPaused() const

   Returns true if the thread is paused.

=head2 Wx::Thread::IsRunning

   bool IsRunning() const

   Returns true if the thread is running.

   This method may only be safely used for joinable threads, see the
   remark in IsAlive.

=head2 Wx::Thread::Kill

   wxThreadError Kill()

   Immediately terminates the target thread. This function is dangerous
   and should be used with extreme care (and not used at all whenever
   possible)! The resources allocated to the thread will not be freed and
   the state of the C runtime library may become inconsistent. Use
   Delete() for detached threads or Wait() for joinable threads instead.

   For detached threads Kill() will also delete the associated C++
   object. However this will not happen for joinable threads and this
   means that you will still have to delete the wxThread object yourself
   to avoid memory leaks. In neither case OnExit of the dying thread will
   be called, so no thread-specific cleanup will be performed.

   This function can only be called from another thread context, i.e. a
   thread cannot kill itself.

   It is also an error to call this function for a thread which is not
   running or paused (in the latter case, the thread will be resumed
   first) -- if you do it, a wxTHREAD_NOT_RUNNING error will be returned.

=head2 Wx::Thread::OnExit

   void OnExit()

   Called when the thread exits. This function is called in the context
   of the thread associated with the wxThread object, not in the context
   of the main thread. This function will not be called if the thread was
   killed.

   This function should never be called directly.

=head2 Wx::Thread::Pause

   wxThreadError Pause()

   Suspends the thread. Under some implementations (Win32), the thread is
   suspended immediately, under others it will only be suspended when it
   calls TestDestroy for the next time (hence, if the thread doesn't call
   it at all, it won't be suspended).

   This function can only be called from another thread context.

=head2 Wx::Thread::Run

   wxThreadError Run()

   Starts the thread execution. Should be called after Create.

   This function can only be called from another thread context.

=head2 Wx::Thread::SetPriority

   void SetPriority(int priority)

   Sets the priority of the thread, between 0 and 100. It can only be set
   after calling Create() but before calling Run().

   The following priorities are already defined:

=head2 Wx::Thread::Sleep

   static void Sleep(unsigned long milliseconds)

   Pauses the thread execution for the given amount of time.

   This function should be used instead of wxSleep by all worker threads
   (i.e. all except the main one).

=head2 Wx::Thread::Resume

   wxThreadError Resume()

   Resumes a thread suspended by the call to Pause.

   This function can only be called from another thread context.

=head2 Wx::Thread::SetConcurrency

   static bool SetConcurrency(size_t level)

   Sets the thread concurrency level for this process. This is, roughly,
   the number of threads that the system tries to schedule to run in
   parallel. The value of 0 for level may be used to set the default one.

   Returns true on success or false otherwise (for example, if this
   function is not implemented for this platform -- currently everything
   except Solaris).

=head2 Wx::Thread::TestDestroy

   virtual bool TestDestroy()

   This function should be called periodically by the thread to ensure
   that calls to Pause and Delete will work. If it returns true, the
   thread should exit as soon as possible.

   Notice that under some platforms (POSIX), implementation of Pause also
   relies on this function being called, so not calling it would prevent
   both stopping and suspending thread from working.

=head2 Wx::Thread::This

   static wxThread * This()

   Return the thread object for the calling thread. NULL is returned if
   the calling thread is the main (GUI) thread, but IsMain should be used
   to test whether the thread is really the main one because NULL may
   also be returned for the thread not created with wxThread class.
   Generally speaking, the return value for such a thread is undefined.

=head2 Wx::Thread::Yield

   void Yield()

   Give the rest of the thread time slice to the system allowing the
   other threads to run. See also Sleep().

=head2 Wx::Thread::Wait

   ExitCode Wait() const

   Waits for a joinable thread to terminate and returns the value the
   thread returned from wxThread::Entry or (ExitCode)-1 on error. Notice
   that, unlike Delete doesn't cancel the thread in any way so the caller
   waits for as long as it takes to the thread to exit.

   You can only Wait() for joinable (not detached) threads.

   This function can only be called from another thread context.

   See wxThread deletion for a broader explanation of this routine.

=head1 Wx::ThreadHelper

=head2 Wx::ThreadHelper::new

   wxThreadHelper()

   This constructor simply initializes a member variable.

=head2 Wx::ThreadHelper::m_thread

   wxThread * m_thread

   the actual wxThread object.

=head2 Wx::ThreadHelper::DESTROY

   ~wxThreadHelper()

   The destructor frees the resources associated with the thread.

=head2 Wx::ThreadHelper::Create

   wxThreadError Create(unsigned int stackSize = 0)

   Creates a new thread. The thread object is created in the suspended
   state, and you should call GetThread()->Run() to start running it. You
   may optionally specify the stack size to be allocated to it (Ignored
   on platforms that don't support setting it explicitly, eg. Unix).

   Return value

   One of:

=head2 Wx::ThreadHelper::Entry

   virtual ExitCode Entry()

   This is the entry point of the thread. This function is pure virtual
   and must be implemented by any derived class. The thread execution
   will start here.

   The returned value is the thread exit code which is only useful for
   joinable threads and is the value returned by GetThread()->Wait().

   This function is called by wxWidgets itself and should never be called
   directly.

=head2 Wx::ThreadHelper::GetThread

   wxThread * GetThread()

   This is a public function that returns the wxThread object associated
   with the thread.

=head1 Wx::Timer

=head2 Wx::Timer::new

   wxTimer()

   Default constructor. If you use it to construct the object and don't
   call SetOwner later, you must override Notify method to process the
   notifications.

   wxTimer(wxEvtHandler *owner, int id = -1)

   Creates a timer and associates it with owner. Please see SetOwner for
   the description of parameters.

=head2 Wx::Timer::DESTROY

   ~wxTimer()

   Destructor. Stops the timer if it is running.

=head2 Wx::Timer::GetInterval

   int GetInterval() const

   Returns the current interval for the timer (in milliseconds).

=head2 Wx::Timer::IsOneShot

   bool IsOneShot() const

   Returns true if the timer is one shot, i.e. if it will stop after
   firing the first notification automatically.

=head2 Wx::Timer::IsRunning

   bool IsRunning() const

   Returns true if the timer is running, false if it is stopped.

=head2 Wx::Timer::Notify

   void Notify()

   This member should be overridden by the user if the default
   constructor was used and SetOwner wasn't called.

   Perform whatever action which is to be taken periodically here.

=head2 Wx::Timer::SetOwner

   void SetOwner(wxEvtHandler *owner, int id = -1)

   Associates the timer with the given owner object. When the timer is
   running, the owner will receive timer events with id equal to id
   specified here.

=head2 Wx::Timer::Start

   bool Start(int milliseconds = -1, bool oneShot = false)

   (Re)starts the timer. If milliseconds parameter is -1 (value by
   default), the previous value is used. Returns false if the timer could
   not be started, true otherwise (in MS Windows timers are a limited
   resource).

   If oneShot is false (the default), the Notify function will be called
   repeatedly until the timer is stopped. If true, it will be called only
   once and the timer will stop automatically. To make your code more
   readable you may also use the following symbolic constants:

=head2 Wx::Timer::Stop

   void Stop()

   Stops the timer.

=head1 Wx::TimerEvent

=head2 Wx::TimerEvent::GetInterval

   int GetInterval() const

   Returns the interval of the timer which generated this event.

=head1 Wx::TimeSpan

=head2 Static functions

   Milliseconds

=head2 Constructors

   wxTimeSpan

=head2 Accessors

   GetSeconds

=head2 Operations

   Add

=head2 Tests

   IsNull

=head2 Formatting time spans

   Format

=head2 Wx::TimeSpan::Abs

   wxTimeSpan Abs() const

   Returns the absolute value of the timespan: does not modify the
   object.

=head2 Wx::TimeSpan::Add

   wxTimeSpan Add(const wxTimeSpan& diff) const

   wxTimeSpan& Add(const wxTimeSpan& diff)

   wxTimeSpan& operator+=(const wxTimeSpan&diff)

   Returns the sum of two timespans.

=head2 Wx::TimeSpan::Days

   static wxTimespan Days(long days)

   Returns the timespan for the given number of days.

=head2 Wx::TimeSpan::Day

   static wxTimespan Day()

   Returns the timespan for one day.

=head2 Wx::TimeSpan::Format

   wxString Format(const wxChar * format = wxDefaultTimeSpanFormat)

   Returns the string containing the formatted representation of the time
   span. The following format specifiers are allowed after %:

=head2 Wx::TimeSpan::GetDays

   int GetDays() const

   Returns the difference in number of days.

=head2 Wx::TimeSpan::GetHours

   int GetHours() const

   Returns the difference in number of hours.

=head2 Wx::TimeSpan::GetMilliseconds

   wxLongLong GetMilliseconds() const

   Returns the difference in number of milliseconds.

=head2 Wx::TimeSpan::GetMinutes

   int GetMinutes() const

   Returns the difference in number of minutes.

=head2 Wx::TimeSpan::GetSeconds

   wxLongLong GetSeconds() const

   Returns the difference in number of seconds.

=head2 Wx::TimeSpan::GetValue

   wxLongLong GetValue() const

   Returns the internal representation of timespan.

=head2 Wx::TimeSpan::GetWeeks

   int GetWeeks() const

   Returns the difference in number of weeks.

=head2 Wx::TimeSpan::Hours

   static wxTimespan Hours(long hours)

   Returns the timespan for the given number of hours.

=head2 Wx::TimeSpan::Hour

   static wxTimespan Hour()

   Returns the timespan for one hour.

=head2 Wx::TimeSpan::IsEqualTo

   bool IsEqualTo(const wxTimeSpan& ts) const

   Returns true if two timespans are equal.

=head2 Wx::TimeSpan::IsLongerThan

   bool IsLongerThan(const wxTimeSpan& ts) const

   Compares two timespans: works with the absolute values, i.e. -2 hours
   is longer than 1 hour. Also, it will return false if the timespans are
   equal in absolute value.

=head2 Wx::TimeSpan::IsNegative

   bool IsNegative() const

   Returns true if the timespan is negative.

=head2 Wx::TimeSpan::IsNull

   bool IsNull() const

   Returns true if the timespan is empty.

=head2 Wx::TimeSpan::IsPositive

   bool IsPositive() const

   Returns true if the timespan is positive.

=head2 Wx::TimeSpan::IsShorterThan

   bool IsShorterThan(const wxTimeSpan& ts) const

   Compares two timespans: works with the absolute values, i.e. 1 hour is
   shorter than -2 hours. Also, it will return false if the timespans are
   equal in absolute value.

=head2 Wx::TimeSpan::Minutes

   static wxTimespan Minutes(long min)

   Returns the timespan for the given number of minutes.

=head2 Wx::TimeSpan::Minute

   static wxTimespan Minute()

   Returns the timespan for one minute.

=head2 Wx::TimeSpan::Multiply

   wxTimeSpan Multiply(int n) const

   wxTimeSpan& Multiply(int n)

   wxTimeSpan& operator*=(int n)

   Multiplies timespan by a scalar.

=head2 Wx::TimeSpan::Negate

   wxTimeSpan Negate() const

   Returns timespan with inverted sign.

=head2 Wx::TimeSpan::Neg

   wxTimeSpan& Neg()

   wxTimeSpan& operator-()

   Negate the value of the timespan.

=head2 Wx::TimeSpan::Milliseconds

   static wxTimespan Milliseconds(long ms)

   Returns the timespan for the given number of milliseconds.

=head2 Wx::TimeSpan::Millisecond

   static wxTimespan Millisecond()

   Returns the timespan for one millisecond.

=head2 Wx::TimeSpan::Seconds

   static wxTimespan Seconds(long sec)

   Returns the timespan for the given number of seconds.

=head2 Wx::TimeSpan::Second

   static wxTimespan Second()

   Returns the timespan for one second.

=head2 Wx::TimeSpan::Subtract

   wxTimeSpan Subtract(const wxTimeSpan&diff) const

   wxTimeSpan& Subtract(const wxTimeSpan& diff)

   wxTimeSpan& operator-=(const wxTimeSpan&diff)

   Returns the difference of two timespans.

=head2 Wx::TimeSpan::Weeks

   static wxTimespan Weeks(long weeks)

   Returns the timespan for the given number of weeks.

=head2 Wx::TimeSpan::Week

   static wxTimespan Week()

   Returns the timespan for one week.

=head2 Wx::TimeSpan::new

   wxTimeSpan()

   Default constructor, constructs a zero timespan.

   wxTimeSpan(long hours, long min, long sec, long msec)

   Constructs timespan from separate values for each component, with the
   date set to 0. Hours are not restricted to 0..24 range, neither are
   minutes, seconds or milliseconds.

=head1 Wx::TipProvider

=head2 Wx::TipProvider::new

   wxTipProvider(size_t currentTip)

   Constructor.

   currentTip

       The starting tip index.

=head2 Wx::TipProvider::GetTip

   wxString GetTip()

   Return the text of the current tip and pass to the next one. This
   function is pure virtual, it should be implemented in the derived
   classes.

=head2 Wx::TipProvider::PreprocessTip

   virtual wxString PreProcessTip(const wxString&tip)

   Returns a modified tip. This function will be called immediately after
   read, and before being check whether it is a comment, an empty string
   or a string to translate. You can optionally override this in your
   custom user-derived class to optionally to modify the tip as soon as
   it is read. You can return any modification to the string. If you
   return wxEmptyString, then this tip is skipped, and the next one is
   read.

=head2 Wx::CurrentTipProvider::GetCurrentTip

   size_t GetCurrentTip() const

   Returns the index of the current tip (i.e. the one which would be
   returned by GetTip).

   The program usually remembers the value returned by this function
   after calling wxShowTip. Note that it is not the same as the value
   which was passed to wxShowTip + 1 because the user might have pressed
   the "Next" button in the tip dialog.

=head1 Wx::TipWindow

=head2 Wx::TipWindow::new

   wxTipWindow(wxWindow* parent, const wxString& text, wxCoord maxLength
   = 100, wxTipWindow** windowPtr, wxRect *rectBounds = NULL)

   Constructor. The tip is shown immediately after the window is
   constructed.

   Parameters

   parent

       The parent window, must be non-NULL

   text

       The text to show, may contain the new line characters

   maxLength

       The length of each line, in pixels. Set to a very large value to
       avoid wrapping lines

   windowPtr

       Simply passed to SetTipWindowPtr below, please see its
       documentation for the description of this parameter

   rectBounds

       If non-NULL, passed to SetBoundingRect below, please see its
       documentation for the description of this parameter

=head2 Wx::TipWindow::SetTipWindowPtr

   void SetTipWindowPtr(wxTipWindow** windowPtr)

   When the tip window closes itself (which may happen at any moment and
   unexpectedly to the caller) it may NULL out the pointer pointed to by
   it windowPtr. This is helpful to avoid dereferencing the tip window
   which had been already closed and deleted.

=head2 Wx::TipWindow::SetBoundingRect

   void SetBoundingRect(const wxRect& rectBound)

   By default, the tip window disappears when the user clicks the mouse
   or presses a keyboard key or if it loses focus in any other way - for
   example because the user switched to another application window.

   Additionally, if a non-empty rectBound is provided, the tip window
   will also automatically close if the mouse leaves this area. This is
   useful to dismiss the tip mouse when the mouse leaves the object it is
   associated with.

   Parameters

   rectBound

       The bounding rectangle for the mouse in the screen coordinates

=head1 Wx::ToggleButton

=head2 Wx::ToggleButton::new

   wxToggleButton()

   Default constructor.

   wxToggleButton(wxWindow* parent, wxWindowID id, const wxString& label,
   const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = 0, const wxValidator& val, const wxString&
   name = "checkBox")

   Constructor, creating and showing a toggle button.

   Parameters

   parent

       Parent window. Must not be NULL.

   id  

       Toggle button identifier. A value of -1 indicates a default value.

   label

       Text to be displayed next to the toggle button.

   pos 

       Toggle button position. If the position (-1, -1) is specified then
       a default position is chosen.

   size

       Toggle button size. If the default size (-1, -1) is specified then
       a default size is chosen.

   style

       Window style. See wxToggleButton.

   validator

       Window validator.

   name

       Window name.

   See also

   wxToggleButton::Create, wxValidator

=head2 Wx::ToggleButton::DESTROY

   ~wxToggleButton()

   Destructor, destroying the toggle button.

=head2 Wx::ToggleButton::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxString& label,
   const wxPoint& pos = wxDefaultPosition, const wxSize& size =
   wxDefaultSize, long style = 0, const wxValidator& val, const wxString&
   name = "checkBox")

   Creates the toggle button for two-step construction. See
   wxToggleButton::wxToggleButton for details.

=head2 Wx::ToggleButton::GetValue

   bool GetValue() const

   Gets the state of the toggle button.

   Return value

   Returns true if it is pressed, false otherwise.

=head2 Wx::ToggleButton::SetValue

   void SetValue(const bool state)

   Sets the toggle button to the given state. This does not cause a
   EVT_TOGGLEBUTTON event to be emitted.

   Parameters

   state

       If true, the button is pressed.

=head1 Wx::ToolBar

=head2 Wx::ToolBar::new

   wxToolBar()

   Default constructor.

   wxToolBar(wxWindow* parent, wxWindowID id, const wxPoint& pos =
   wxDefaultPosition, const wxSize& size = wxDefaultSize, long style =
   wxTB_HORIZONTAL | wxNO_BORDER, const wxString& name = wxPanelNameStr)

   Constructs a toolbar.

   Parameters

   parent

       Pointer to a parent window.

   id  

       Window identifier. If -1, will automatically create an identifier.

   pos 

       Window position. wxDefaultPosition is (-1, -1) which indicates
       that wxWidgets should generate a default position for the window.
       If using the wxWindow class directly, supply an actual position.

   size

       Window size. wxDefaultSize is (-1, -1) which indicates that
       wxWidgets should generate a default size for the window.

   style

       Window style. See wxToolBar for details.

   name

       Window name.

   Remarks

   After a toolbar is created, you use wxToolBar::AddTool and perhaps
   wxToolBar::AddSeparator, and then you must call wxToolBar::Realize to
   construct and display the toolbar tools.

   You may also create a toolbar that is managed by the frame, by calling
   wxFrame::CreateToolBar.

=head2 Wx::ToolBar::DESTROY

   void ~wxToolBar()

   Toolbar destructor.

=head2 Wx::ToolBar::AddControl

   bool AddControl(wxControl* control)

   Adds any control to the toolbar, typically e.g. a combobox.

   control

       The control to be added.

=head2 Wx::ToolBar::AddSeparator

   void AddSeparator()

   Adds a separator for spacing groups of tools.

   See also

   wxToolBar::AddTool, wxToolBar::SetToolSeparation

=head2 Wx::ToolBar::AddTool

   wxToolBarToolBase* AddTool(int toolId, const wxString& label, const
   wxBitmap& bitmap1, const wxString& shortHelpString = "", wxItemKind
   kind = wxITEM_NORMAL)

   wxToolBarToolBase* AddTool(int toolId, const wxString& label, const
   wxBitmap& bitmap1, const wxBitmap& bitmap2 = wxNullBitmap, wxItemKind
   kind = wxITEM_NORMAL, const wxString& shortHelpString = "", const
   wxString& longHelpString = "", wxObject* clientData = NULL)

   wxToolBarToolBase* AddTool(wxToolBarToolBase* tool)

   Adds a tool to the toolbar. The first (short and most commonly used)
   version has fewer parameters than the full version at the price of not
   being able to specify some of the more rarely used button features.
   The last version allows you to add an existing tool.

   Parameters

   toolId

       An integer by which the tool may be identified in subsequent
       operations.

   kind

       May be wxITEM_NORMAL for a normal button (default), wxITEM_CHECK
       for a checkable tool (such tool stays pressed after it had been
       toggled) or wxITEM_RADIO for a checkable tool which makes part of
       a radio group of tools each of which is automatically unchecked
       whenever another button in the group is checked

   bitmap1

       The primary tool bitmap.

   bitmap2

       The bitmap used when the tool is disabled. If it is equal to
       wxNullBitmap, the disabled bitmap is automatically generated by
       greing the normal one.

   shortHelpString

       This string is used for the tools tooltip

   longHelpString

       This string is shown in the statusbar (if any) of the parent frame
       when the mouse pointer is inside the tool

   clientData

       An optional pointer to client data which can be retrieved later
       using wxToolBar::GetToolClientData.

   tool

       The tool to be added.

   Remarks

   After you have added tools to a toolbar, you must call
   wxToolBar::Realize in order to have the tools appear.

   See also

   wxToolBar::AddSeparator, wxToolBar::AddCheckTool,
   wxToolBar::AddRadioTool, wxToolBar::InsertTool, wxToolBar::DeleteTool,
   wxToolBar::Realize

=head2 Wx::ToolBar::AddCheckTool

   wxToolBarToolBase* AddCheckTool(int toolId, const wxString& label,
   const wxBitmap& bitmap1, const wxBitmap& bitmap2, const wxString&
   shortHelpString = "", const wxString& longHelpString = "", wxObject*
   clientData = NULL)

   Adds a new check (or toggle) tool to the toolbar. The parameters are
   the same as in wxToolBar::AddTool.

   See also

   wxToolBar::AddTool

=head2 Wx::ToolBar::AddRadioTool

   wxToolBarToolBase* AddRadioTool(int toolId, const wxString& label,
   const wxBitmap& bitmap1, const wxBitmap& bitmap2, const wxString&
   shortHelpString = "", const wxString& longHelpString = "", wxObject*
   clientData = NULL)

   Adds a new radio tool to the toolbar. Consecutive radio tools form a
   radio group such that exactly one button in the group is pressed at
   any moment, in other words whenever a button in the group is pressed
   the previously pressed button is automatically released. You should
   avoid having the radio groups of only one element as it would be
   impossible for the user to use such button.

   By default, the first button in the radio group is initially pressed,
   the others are not.

   See also

   wxToolBar::AddTool

=head2 Wx::ToolBar::ClearTools

   void ClearTools()

   Deletes all the tools in the toolbar.

=head2 Wx::ToolBar::DeleteTool

   bool DeleteTool(int toolId)

   Removes the specified tool from the toolbar and deletes it. If you
   don't want to delete the tool, but just to remove it from the toolbar
   (to possibly add it back later), you may use RemoveTool instead.

   Note that it is unnecessary to call Realize for the change to take
   place, it will happen immediately.

   Returns true if the tool was deleted, false otherwise.

   See also

   DeleteToolByPos

=head2 Wx::ToolBar::DeleteToolByPos

   bool DeleteToolByPos(size_t pos)

   This function behaves like DeleteTool but it deletes the tool at the
   specified position and not the one with the given id.

=head2 Wx::ToolBar::EnableTool

   void EnableTool(int toolId, const bool enable)

   Enables or disables the tool.

   Parameters

   toolId

       Tool to enable or disable.

   enable

       If true, enables the tool, otherwise disables it.

   NB: This function should only be called after Realize.

   Remarks

   Some implementations will change the visible state of the tool to
   indicate that it is disabled.

   See also

   wxToolBar::GetToolEnabled, wxToolBar::ToggleTool

=head2 Wx::ToolBar::FindById

   wxToolBarToolBase* FindById(int id)

   Returns a pointer to the tool identified by id or NULL if no
   corresponding tool is found.

=head2 Wx::ToolBar::FindControl

   wxControl* FindControl(int id)

   Returns a pointer to the control identified by id or NULL if no
   corresponding control is found.

=head2 Wx::ToolBar::FindToolForPosition

   wxToolBarToolBase* FindToolForPosition(wxCoord x, wxCoord y) const

   Finds a tool for the given mouse position.

   Parameters

   x   

       X position.

   y   

       Y position.

   Return value

   A pointer to a tool if a tool is found, or NULL otherwise.

   Remarks

   Currently not implemented in wxGTK (always returns NULL there).

=head2 Wx::ToolBar::GetToolsCount

   int GetToolsCount() const

   Returns the number of tools in the toolbar.

=head2 Wx::ToolBar::GetToolSize

   wxSize GetToolSize()

   Returns the size of a whole button, which is usually larger than a
   tool bitmap because of added 3D effects.

   See also

   wxToolBar::SetToolBitmapSize, wxToolBar::GetToolBitmapSize

=head2 Wx::ToolBar::GetToolBitmapSize

   wxSize GetToolBitmapSize()

   Returns the size of bitmap that the toolbar expects to have. The
   default bitmap size is 16 by 15 pixels.

   Remarks

   Note that this is the size of the bitmap you pass to
   wxToolBar::AddTool, and not the eventual size of the tool button.

   See also

   wxToolBar::SetToolBitmapSize, wxToolBar::GetToolSize

=head2 Wx::ToolBar::GetMargins

   wxSize GetMargins() const

   Returns the left/right and top/bottom margins, which are also used for
   inter-toolspacing.

   See also

   wxToolBar::SetMargins

=head2 Wx::ToolBar::GetToolClientData

   wxObject* GetToolClientData(int toolId) const

   Get any client data associated with the tool.

   Parameters

   toolId

       Id of the tool, as passed to wxToolBar::AddTool.

   Return value

   Client data, or NULL if there is none.

=head2 Wx::ToolBar::GetToolEnabled

   bool GetToolEnabled(int toolId) const

   Called to determine whether a tool is enabled (responds to user
   input).

   Parameters

   toolId

       Id of the tool in question.

   Return value

   true if the tool is enabled, false otherwise.

   See also

   wxToolBar::EnableTool

=head2 Wx::ToolBar::GetToolLongHelp

   wxString GetToolLongHelp(int toolId) const

   Returns the long help for the given tool.

   Parameters

   toolId

       The tool in question.

   See also

   wxToolBar::SetToolLongHelp, wxToolBar::SetToolShortHelp

=head2 Wx::ToolBar::GetToolPacking

   int GetToolPacking() const

   Returns the value used for packing tools.

   See also

   wxToolBar::SetToolPacking

=head2 Wx::ToolBar::GetToolPos

   int GetToolPos(int toolId) const

   Returns the tool position in the toolbar, or wxNOT_FOUND if the tool
   is not found.

=head2 Wx::ToolBar::GetToolSeparation

   int GetToolSeparation() const

   Returns the default separator size.

   See also

   wxToolBar::SetToolSeparation

=head2 Wx::ToolBar::GetToolShortHelp

   wxString GetToolShortHelp(int toolId) const

   Returns the short help for the given tool.

   Parameters

   toolId

       The tool in question.

   See also

   wxToolBar::GetToolLongHelp, wxToolBar::SetToolShortHelp

=head2 Wx::ToolBar::GetToolState

   bool GetToolState(int toolId) const

   Gets the on/off state of a toggle tool.

   Parameters

   toolId

       The tool in question.

   Return value

   true if the tool is toggled on, false otherwise.

   See also

   wxToolBar::ToggleTool

=head2 Wx::ToolBar::InsertControl

   wxToolBarToolBase * InsertControl(size_t pos, wxControl *control)

   Inserts the control into the toolbar at the given position.

   You must call Realize for the change to take place.

   See also

   AddControl,

=head2 Wx::ToolBar::InsertSeparator

   wxToolBarToolBase * InsertSeparator(size_t pos)

   Inserts the separator into the toolbar at the given position.

   You must call Realize for the change to take place.

   See also

   AddSeparator,

=head2 Wx::ToolBar::InsertTool

   wxToolBarToolBase * InsertTool(size_t pos, int toolId, const wxBitmap&
   bitmap1, const wxBitmap& bitmap2 = wxNullBitmap, bool isToggle = false,
   wxObject* clientData = NULL, const wxString& shortHelpString = "",
   const wxString& longHelpString = "")

   wxToolBarToolBase * InsertTool(size_t pos, wxToolBarToolBase* tool)

   Inserts the tool with the specified attributes into the toolbar at the
   given position.

   You must call Realize for the change to take place.

   See also

   AddTool,

=head2 Wx::ToolBar::OnLeftClick

   bool OnLeftClick(int toolId, bool toggleDown)

   Called when the user clicks on a tool with the left mouse button.

   This is the old way of detecting tool clicks; although it will still
   work, you should use the EVT_MENU or EVT_TOOL macro instead.

   Parameters

   toolId

       The identifier passed to wxToolBar::AddTool.

   toggleDown

       true if the tool is a toggle and the toggle is down, otherwise is
       false.

   Return value

   If the tool is a toggle and this function returns false, the toggle
   toggle state (internal and visual) will not be changed. This provides
   a way of specifying that toggle operations are not permitted in some
   circumstances.

   See also

   wxToolBar::OnMouseEnter, wxToolBar::OnRightClick

=head2 Wx::ToolBar::OnMouseEnter

   void OnMouseEnter(int toolId)

   This is called when the mouse cursor moves into a tool or out of the
   toolbar.

   This is the old way of detecting mouse enter events; although it will
   still work, you should use the EVT_TOOL_ENTER macro instead.

   Parameters

   toolId

       Greater than -1 if the mouse cursor has moved into the tool, or -1
       if the mouse cursor has moved. The programmer can override this to
       provide extra information about the tool, such as a short
       description on the status line.

   Remarks

   With some derived toolbar classes, if the mouse moves quickly out of
   the toolbar, wxWidgets may not be able to detect it. Therefore this
   function may not always be called when expected.

=head2 Wx::ToolBar::OnRightClick

   void OnRightClick(int toolId, float x, float y)

   Called when the user clicks on a tool with the right mouse button. The
   programmer should override this function to detect right tool clicks.

   This is the old way of detecting tool right clicks; although it will
   still work, you should use the EVT_TOOL_RCLICKED macro instead.

   Parameters

   toolId

       The identifier passed to wxToolBar::AddTool.

   x   

       The x position of the mouse cursor.

   y   

       The y position of the mouse cursor.

   Remarks

   A typical use of this member might be to pop up a menu.

   See also

   wxToolBar::OnMouseEnter, wxToolBar::OnLeftClick

=head2 Wx::ToolBar::Realize

   bool Realize()

   This function should be called after you have added tools.

=head2 Wx::ToolBar::RemoveTool

   wxToolBarToolBase * RemoveTool(int id)

   Removes the given tool from the toolbar but doesn't delete it. This
   allows to insert/add this tool back to this (or another) toolbar
   later.

   Note that it is unnecessary to call Realize for the change to take
   place, it will happen immediately.

   See also

   DeleteTool

=head2 Wx::ToolBar::SetBitmapResource

   void SetBitmapResource(int resourceId)

   Sets the bitmap resource identifier for specifying tool bitmaps as
   indices into a custom bitmap. Windows CE only.

=head2 Wx::ToolBar::SetMargins

   void SetMargins(const wxSize& size)

   void SetMargins(int x, int y)

   Set the values to be used as margins for the toolbar.

   Parameters

   size

       Margin size.

   x   

       Left margin, right margin and inter-tool separation value.

   y   

       Top margin, bottom margin and inter-tool separation value.

   Remarks

   This must be called before the tools are added if absolute positioning
   is to be used, and the default (zero-size) margins are to be
   overridden.

   See also

   wxToolBar::GetMargins, wxSize

=head2 Wx::ToolBar::SetToolBitmapSize

   void SetToolBitmapSize(const wxSize& size)

   Sets the default size of each tool bitmap. The default bitmap size is
   16 by 15 pixels.

   Parameters

   size

       The size of the bitmaps in the toolbar.

   Remarks

   This should be called to tell the toolbar what the tool bitmap size
   is. Call it before you add tools.

   Note that this is the size of the bitmap you pass to
   wxToolBar::AddTool, and not the eventual size of the tool button.

   See also

   wxToolBar::GetToolBitmapSize, wxToolBar::GetToolSize

=head2 Wx::ToolBar::SetToolClientData

   void SetToolClientData(int id, wxObject* clientData)

   Sets the client data associated with the tool.

=head2 Wx::ToolBar::SetToolDisabledBitmap

   void SetToolDisabledBitmap(int id, const wxBitmap& bitmap)

   Sets the bitmap to be used by the tool with the given ID when the tool
   is in a disabled state. This can only be used on Button tools, not
   controls. NOTE: The native toolbar classes on the main platforms all
   synthesize the disabled bitmap from the normal bitmap, so this
   function will have no effect on those platforms.

=head2 Wx::ToolBar::SetToolLongHelp

   void SetToolLongHelp(int toolId, const wxString& helpString)

   Sets the long help for the given tool.

   Parameters

   toolId

       The tool in question.

   helpString

       A string for the long help.

   Remarks

   You might use the long help for displaying the tool purpose on the
   status line.

   See also

   wxToolBar::GetToolLongHelp, wxToolBar::SetToolShortHelp,

=head2 Wx::ToolBar::SetToolPacking

   void SetToolPacking(int packing)

   Sets the value used for spacing tools. The default value is 1.

   Parameters

   packing

       The value for packing.

   Remarks

   The packing is used for spacing in the vertical direction if the
   toolbar is horizontal, and for spacing in the horizontal direction if
   the toolbar is vertical.

   See also

   wxToolBar::GetToolPacking

=head2 Wx::ToolBar::SetToolShortHelp

   void SetToolShortHelp(int toolId, const wxString& helpString)

   Sets the short help for the given tool.

   Parameters

   toolId

       The tool in question.

   helpString

       The string for the short help.

   Remarks

   An application might use short help for identifying the tool purpose
   in a tooltip.

   See also

   wxToolBar::GetToolShortHelp, wxToolBar::SetToolLongHelp

=head2 Wx::ToolBar::SetToolNormalBitmap

   void SetToolNormalBitmap(int id, const wxBitmap& bitmap)

   Sets the bitmap to be used by the tool with the given ID. This can
   only be used on Button tools, not controls.

=head2 Wx::ToolBar::SetToolSeparation

   void SetToolSeparation(int separation)

   Sets the default separator size. The default value is 5.

   Parameters

   separation

       The separator size.

   See also

   wxToolBar::AddSeparator

=head2 Wx::ToolBar::ToggleTool

   void ToggleTool(int toolId, const bool toggle)

   Toggles a tool on or off. This does not cause any event to get
   emitted.

   Parameters

   toolId

       Tool in question.

   toggle

       If true, toggles the tool on, otherwise toggles it off.

   Remarks

   Only applies to a tool that has been specified as a toggle tool.

   See also

   wxToolBar::GetToolState

=head1 Wx::ToolTip

=head2 Wx::ToolTip::Enable

   static void Enable(bool flag)

   Enable or disable tooltips globally.

   May not be supported on all platforms (eg. wxCocoa).

=head2 Wx::ToolTip::SetDelay

   static void SetDelay(long msecs)

   Set the delay after which the tooltip appears.

   May not be supported on all platforms (eg. wxCocoa).

=head2 Wx::ToolTip::new

   wxToolTip(const wxString& tip)

   Constructor.

=head2 Wx::ToolTip::SetTip

   void SetTip(const wxString& tip)

   Set the tooltip text.

=head2 Wx::ToolTip::GetTip

   wxString GetTip() const

   Get the tooltip text.

=head2 Wx::ToolTip::GetWindow

   wxWindow* GetWindow() const

   Get the associated window.

=head1 Wx::TopLevelWindow

=head2 Wx::TopLevelWindow::CanSetTransparent

   virtual bool CanSetTransparent()

   Returns true if the platform supports making the window translucent.

   See also

   wxTopLevelWindow::SetTransparent

=head2 Wx::TopLevelWindow::EnableCloseButton

   bool EnableCloseButton(bool enable = true)

   Enables or disables the Close button (most often in the right upper
   corner of a dialog) and the Close entry of the system menu (most often
   in the left upper corner of the dialog). Currently only implemented
   for wxMSW and wxGTK. Returns true if operation was successful. This
   may be wrong on X11 (including GTK+) where the window manager may not
   support this operation and there is no way to find out.

=head2 Wx::TopLevelWindow::GetDefaultItem

   wxWindow * GetDefaultItem() const

   Returns a pointer to the button which is the default for this window,
   or NULL. The default button is the one activated by pressing the Enter
   key.

=head2 Wx::TopLevelWindow::GetIcon

   const wxIcon& GetIcon() const

   Returns the standard icon of the window. The icon will be invalid if
   it hadn't been previously set by SetIcon.

   See also

   GetIcons

=head2 Wx::TopLevelWindow::GetIcons

   const wxIconBundle& GetIcons() const

   Returns all icons associated with the window, there will be none of
   them if neither SetIcon nor SetIcons had been called before.

   Use GetIcon to get the main icon of the window.

   See also

   wxIconBundle

=head2 Wx::TopLevelWindow::GetTitle

   wxString GetTitle() const

   Gets a string containing the window title.

   See also

   wxTopLevelWindow::SetTitle

=head2 Wx::TopLevelWindow::HandleSettingChange

   virtual bool HandleSettingChange(WXWPARAM wParam, WXLPARAM lParam)

   Unique to the wxWinCE port. Responds to showing/hiding SIP (soft input
   panel) area and resize window accordingly. Override this if you want
   to avoid resizing or do additional operations.

=head2 Wx::TopLevelWindow::IsActive

   bool IsActive() const

   Returns true if this window is currently active, i.e. if the user is
   currently working with it.

=head2 Wx::TopLevelWindow::IsAlwaysMaximized

   virtual bool IsAlwaysMaximized() const

   Returns true if this window is expected to be always maximized, either
   due to platform policy or due to local policy regarding particular
   class.

=head2 Wx::TopLevelWindow::Iconize

   void Iconize(bool iconize)

   Iconizes or restores the window.

   Parameters

   iconize

       If true, iconizes the window; if false, shows and restores it.

   See also

   wxTopLevelWindow::IsIconized, wxTopLevelWindow::Maximize.

=head2 Wx::TopLevelWindow::IsFullScreen

   bool IsFullScreen()

   Returns true if the window is in fullscreen mode.

   See also

   wxTopLevelWindow::ShowFullScreen

=head2 Wx::TopLevelWindow::IsIconized

   bool IsIconized() const

   Returns true if the window is iconized.

=head2 Wx::TopLevelWindow::IsMaximized

   bool IsMaximized() const

   Returns true if the window is maximized.

=head2 Wx::TopLevelWindow::IsUsingNativeDecorations

   bool IsUsingNativeDecorations() const

   This method is specific to wxUniversal port

   Returns true if this window is using native decorations, false if we
   draw them ourselves.

   See also

   UseNativeDecorations,

=head2 Wx::TopLevelWindow::Maximize

   void Maximize(bool maximize)

   Maximizes or restores the window.

   Parameters

   maximize

       If true, maximizes the window, otherwise it restores it.

   See also

   wxTopLevelWindow::Iconize

=head2 Wx::TopLevelWindow::RequestUserAttention

   void RequestUserAttention(int flags = wxUSER_ATTENTION_INFO)

   Use a system-dependent way to attract users attention to the window
   when it is in background.

   flags may have the value of either wxUSER_ATTENTION_INFO (default) or
   wxUSER_ATTENTION_ERROR which results in a more drastic action. When in
   doubt, use the default value.

   Note that this function should normally be only used when the
   application is not already in foreground.

   This function is currently implemented for Win32 where it flashes the
   window icon in the taskbar, and for wxGTK with task bars supporting
   it.

=head2 Wx::TopLevelWindow::SetDefaultItem

   void SetDefaultItem(wxWindow *win)

   Changes the default item for the panel, usually win is a button.

   See also

   GetDefaultItem

=head2 Wx::TopLevelWindow::SetIcon

   void SetIcon(const wxIcon& icon)

   Sets the icon for this window.

   Parameters

   icon

       The icon to associate with this window.

   Remarks

   The window takes a 'copy' of icon, but since it uses reference
   counting, the copy is very quick. It is safe to delete icon after
   calling this function.

   See also wxIcon.

=head2 Wx::TopLevelWindow::SetIcons

   void SetIcons(const wxIconBundle& icons)

   Sets several icons of different sizes for this window: this allows to
   use different icons for different situations (e.g. task switching bar,
   taskbar, window title bar) instead of scaling, with possibly bad
   looking results, the only icon set by SetIcon.

   Parameters

   icons

       The icons to associate with this window.

   See also

   wxIconBundle.

=head2 Wx::TopLevelWindow::SetLeftMenu

   void SetLeftMenu(int id = wxID_ANY, const wxString& label =
   wxEmptyString, wxMenu * subMenu = NULL)

   Sets action or menu activated by pressing left hardware button on the
   smart phones. Unavailable on full keyboard machines.

   Parameters

   id  

       Identifier for this button.

   label

       Text to be displayed on the screen area dedicated to this hardware
       button.

   subMenu

       The menu to be opened after pressing this hardware button.

   See also

   wxTopLevelWindow::SetRightMenu.

=head2 Wx::TopLevelWindow::SetMaxSize

   void SetMaxSize(const wxSize& size)

   A simpler interface for setting the size hints than SetSizeHints.

=head2 Wx::TopLevelWindow::SetMinSize

   void SetMinSize(const wxSize& size)

   A simpler interface for setting the size hints than SetSizeHints.

=head2 Wx::TopLevelWindow::SetSizeHints

   virtual void SetSizeHints(int minW, int minH, int maxW=-1, int maxH=-1,
   int incW=-1, int incH=-1)

   void SetSizeHints(const wxSize& minSize, const wxSize&
   maxSize=wxDefaultSize, const wxSize& incSize=wxDefaultSize)

   Allows specification of minimum and maximum window sizes, and window
   size increments. If a pair of values is not set (or set to -1), the
   default values will be used.

   incW

       Specifies the increment for sizing the width (Motif/Xt only).

   incH

       Specifies the increment for sizing the height (Motif/Xt only).

   incSize

       Increment size (Motif/Xt only).

   Remarks

   If this function is called, the user will not be able to size the
   window outside the given bounds. The resizing increments are only
   significant under Motif or Xt.

=head2 Wx::TopLevelWindow::SetRightMenu

   void SetRightMenu(int id = wxID_ANY, const wxString& label =
   wxEmptyString, wxMenu * subMenu = NULL)

   Sets action or menu activated by pressing right hardware button on the
   smart phones. Unavailable on full keyboard machines.

   Parameters

   id  

       Identifier for this button.

   label

       Text to be displayed on the screen area dedicated to this hardware
       button.

   subMenu

       The menu to be opened after pressing this hardware button.

   See also

   wxTopLevelWindow::SetLeftMenu.

=head2 Wx::TopLevelWindow::SetShape

   bool SetShape(const wxRegion& region)

   If the platform supports it, sets the shape of the window to that
   depicted by region. The system will not display or respond to any
   mouse event for the pixels that lie outside of the region. To reset
   the window to the normal rectangular shape simply call SetShape again
   with an empty region. Returns true if the operation is successful.

=head2 Wx::TopLevelWindow::SetTitle

   virtual void SetTitle(const wxString& title)

   Sets the window title.

   Parameters

   title

       The window title.

   See also

   wxTopLevelWindow::GetTitle

=head2 Wx::TopLevelWindow::SetTransparent

   virtual bool SetTransparent(int alpha)

   If the platform supports it will set the window to be translucent

   Parameters

   alpha

       Determines how opaque or transparent the window will be, if the
       platform supports the opreration. A value of 0 sets the window to
       be fully transparent, and a value of 255 sets the window to be
       fully opaque.

   Returns true if the transparency was successfully changed.

=head2 Wx::TopLevelWindow::ShouldPreventAppExit

   virtual bool ShouldPreventAppExit() const

   This virtual function is not meant to be called directly but can be
   overridden to return false (it returns true by default) to allow the
   application to close even if this, presumably not very important,
   window is still opened. By default, the application stays alive as
   long as there are any open top level windows.

=head2 Wx::TopLevelWindow::ShowFullScreen

   bool ShowFullScreen(bool show, long style = wxFULLSCREEN_ALL)

   Depending on the value of show parameter the window is either shown
   full screen or restored to its normal state. style is a bit list
   containing some or all of the following values, which indicate what
   elements of the window to hide in full-screen mode:

=head2 Wx::TopLevelWindow::UseNativeDecorations

   void UseNativeDecorations(bool native = true)

   This method is specific to wxUniversal port

   Use native or custom-drawn decorations for this window only. Notice
   that to have any effect this method must be called before really
   creating the window, i.e. two step creation must be used:

       MyFrame *frame = new MyFrame;           // use default ctor
       frame->UseNativeDecorations(false);     // change from default "true"
       frame->Create(parent, title, ...);      // really create the frame

   See also

   UseNativeDecorationsByDefault,

=head2 Wx::TopLevelWindow::UseNativeDecorationsByDefault

   void UseNativeDecorationsByDefault(bool native = true)

   This method is specific to wxUniversal port

   Top level windows in wxUniversal port can use either system-provided
   window decorations (i.e. title bar and various icons, buttons and
   menus in it) or draw the decorations themselves. By default the system
   decorations are used if they are available, but this method can be
   called with native set to false to change this for all windows created
   after this point.

   Also note that if WXDECOR environment variable is set, then custom
   decorations are used by default and so it may make sense to call this
   method with default argument if the application can't use custom
   decorations at all for some reason.

   See also

   UseNativeDecorations

=head1 Wx::Treebook

=head2 Wx::Treebook::new

   wxTreebook()

   Default constructor.

=head2 Wx::Treebook::DESTROY

   ~wxTreebook()

   Destroys the wxTreebook object.

   Also deletes all the pages owned by the control (inserted previously
   into it).

=head2 Wx::Treebook::AddPage

   bool AddPage( wxWindow* page, const wxString& text, bool bSelect =
   false, int imageId = wxNOT_FOUND)

   Adds a new page. The page is placed at the topmost level after all
   other pages. NULL could be specified for page to create an empty page.

=head2 Wx::Treebook::AddSubPage

   bool AddSubPage(wxWindow* page, const wxString& text, bool bSelect =
   false, int imageId = wxNOT_FOUND)

   Adds a new child-page to the last top-level page. NULL could be
   specified for page to create an empty page.

=head2 Wx::Treebook::AssignImageList

   void AssignImageList(wxImageList* imageList)

   Sets the image list for the page control and takes ownership of the
   list.

   See also

   wxImageList, SetImageList

=head2 Wx::Treebook::ChangeSelection

   int ChangeSelection(size_t page)

   Changes the selection for the given page, returning the previous
   selection.

   The call to this function does not generate the page changing events.
   This is the only difference with SetSelection. See this topic for more
   info.

=head2 Wx::Treebook::CollapseNode

   bool CollapseNode(size_t pageId)

   Shortcut for ExpandNode(pageId, false).

=head2 Wx::Treebook::Create

   bool Create(wxWindow* parent, wxWindowID id, const wxPoint& pos =
   wxDefaultPosition, const wxSize& size = wxDefaultSize, long style =
   wxBK_DEFAULT, const wxString& name = wxEmptyString)

   Creates a treebook control. See wxTreebook::wxTreebook for the
   description of the parameters.

=head2 Wx::Treebook::DeleteAllPages

   bool DeleteAllPages()

   Deletes all pages inserted into the treebook. No event is generated.

=head2 Wx::Treebook::DeletePage

   bool DeletePage(size_t pagePos)

   Deletes the page at the specified position and all its children. Could
   trigger page selection change in a case when selected page is removed.
   In that case its parent is selected (or the next page if no parent).

=head2 Wx::Treebook::ExpandNode

   bool ExpandNode(size_t pageId, bool expand = true)

   Expands (collapses) the pageId node. Returns the previous state. May
   generate page changing events (if selected page is under the collapsed
   branch, then its parent is autoselected).

=head2 Wx::Treebook::GetPageImage

   int GetPageImage(size_t n) const

   Returns the image index for the given page.

=head2 Wx::Treebook::GetPageParent

   int GetPageParent(size_t page) const

   Returns the parent page of the given one or wxNOT_FOUND if this is a
   top-level page.

=head2 Wx::Treebook::GetPageText

   wxString GetPageText(size_t n) const

   Returns the string for the given page.

=head2 Wx::Treebook::GetSelection

   int GetSelection() const

   Returns the currently selected page, or wxNOT_FOUND if none was
   selected.

   Note that this method may return either the previously or newly
   selected page when called from the EVT_TREEBOOK_PAGE_CHANGED handler
   depending on the platform and so wxTreebookEvent::GetSelection should
   be used instead in this case.

=head2 Wx::Treebook::InsertPage

   bool InsertPage(size_t pagePos, wxWindow* page, const wxString& text,
   bool bSelect = false, int imageId = wxNOT_FOUND)

   Inserts a new page just before the page indicated by pagePos. The new
   page is placed before pagePos page and on the same level. NULL could
   be specified for page to create an empty page.

=head2 Wx::Treebook::InsertSubPage

   bool InsertSubPage(size_t pagePos, wxWindow* page, const wxString&
   text, bool bSelect = false, int imageId = wxNOT_FOUND)

   Inserts a sub page under the specified page.

   NULL could be specified for page to create an empty page.

=head2 Wx::Treebook::IsNodeExpanded

   bool IsNodeExpanded(size_t pageId) const

   Gets the pagePos page state -- whether it is expanded or collapsed

=head2 Wx::Treebook::SetImageList

   void SetImageList(wxImageList* imageList)

   Sets the image list for the page control. It does not take ownership
   of the image list, you must delete it yourself.

   See also

   wxImageList, AssignImageList

=head2 Wx::Treebook::SetPageImage

   bool SetPageImage(size_t page, int imageId)

   Sets the image index for the given page. ImageId is an index into the
   image list which was set with SetImageList.

=head2 Wx::Treebook::SetPageText

   bool SetPageText(size_t page, const wxString& text)

   Sets the text for the given page.

=head2 Wx::Treebook::SetSelection

   int SetSelection(size_t n)

   Sets the selection for the given page, returning the previous
   selection.

   The call to this function generates the page changing events.

   This function is deprecated and should not be used in new code. Please
   use the ChangeSelection function instead.

   See also

   wxTreebook::GetSelection

=head1 Wx::TreebookEvent

=head2 Wx::TreebookEvent::new

   wxTreebookEvent(wxEventType commandType = wxEVT_NULL, int id = 0, int
   nSel = wxNOT_FOUND, int nOldSel = wxNOT_FOUND)

   See also

   wxNotebookEvent

=head2 Wx::TreebookEvent::GetOldSelection

   int GetOldSelection() const

   Returns the page that was selected before the change, wxNOT_FOUND if
   none was selected.

=head2 Wx::TreebookEvent::GetSelection

   int GetSelection() const

   Returns the currently selected page, or wxNOT_FOUND if none was
   selected.

   See also

   wxNotebookEvent::GetSelection

=head1 Wx::TreeCtrl

=head2 Wx::TreeCtrl::new

   wxTreeCtrl()

   Default constructor.

   wxTreeCtrl(wxWindow* parent, wxWindowID id, const wxPoint& pos =
   wxDefaultPosition, const wxSize& size = wxDefaultSize, long style =
   wxTR_HAS_BUTTONS, const wxValidator& validator = wxDefaultValidator,
   const wxString& name = "treeCtrl")

   Constructor, creating and showing a tree control.

   Parameters

   parent

       Parent window. Must not be NULL.

   id  

       Window identifier. A value of -1 indicates a default value.

   pos 

       Window position.

   size

       Window size. If the default size (-1, -1) is specified then the
       window is sized appropriately.

   style

       Window style. See wxTreeCtrl.

   validator

       Window validator.

   name

       Window name.

   See also

   wxTreeCtrl::Create, wxValidator

=head2 Wx::TreeCtrl::DESTROY

   void ~wxTreeCtrl()

   Destructor, destroying the tree control.

=head2 Wx::TreeCtrl::AddRoot

   wxTreeItemId AddRoot(const wxString& text, int image = -1, int
   selImage = -1, wxTreeItemData* data = NULL)

   Adds the root node to the tree, returning the new item.

   The image and selImage parameters are an index within the normal image
   list specifying the image to use for unselected and selected items,
   respectively. If image > -1 and selImage is -1, the same image is used
   for both selected and unselected items.

=head2 Wx::TreeCtrl::AppendItem

   wxTreeItemId AppendItem(const wxTreeItemId& parent, const wxString&
   text, int image = -1, int selImage = -1, wxTreeItemData* data = NULL)

   Appends an item to the end of the branch identified by parent, return
   a new item id.

   The image and selImage parameters are an index within the normal image
   list specifying the image to use for unselected and selected items,
   respectively. If image > -1 and selImage is -1, the same image is used
   for both selected and unselected items.

=head2 Wx::TreeCtrl::AssignButtonsImageList

   void AssignButtonsImageList(wxImageList* imageList)

   Sets the buttons image list. The button images assigned with this
   method will be automatically deleted by wxTreeCtrl as appropriate
   (i.e. it takes ownership of the list).

   Setting or assigning the button image list enables the display of
   image buttons. Once enabled, the only way to disable the display of
   button images is to set the button image list to NULL.

   This function is only available in the generic version.

   See also SetButtonsImageList.

=head2 Wx::TreeCtrl::AssignImageList

   void AssignImageList(wxImageList* imageList)

   Sets the normal image list. Image list assigned with this method will
   be automatically deleted by wxTreeCtrl as appropriate (i.e. it takes
   ownership of the list).

   See also SetImageList.

=head2 Wx::TreeCtrl::AssignStateImageList

   void AssignStateImageList(wxImageList* imageList)

   Sets the state image list. Image list assigned with this method will
   be automatically deleted by wxTreeCtrl as appropriate (i.e. it takes
   ownership of the list).

   See also SetStateImageList.

=head2 Wx::TreeCtrl::Collapse

   void Collapse(const wxTreeItemId& item)

   Collapses the given item.

=head2 Wx::TreeCtrl::CollapseAll

   void CollapseAll()

   Collapses the root item.

   See also

   ExpandAll

=head2 Wx::TreeCtrl::CollapseAllChildren

   void CollapseAllChildren(const wxTreeItemId& item)

   Collapses this item and all of its children, recursively.

   See also

   ExpandAllChildren

=head2 Wx::TreeCtrl::CollapseAndReset

   void CollapseAndReset(const wxTreeItemId& item)

   Collapses the given item and removes all children.

=head2 Wx::TreeCtrl::Create

   bool wxTreeCtrl(wxWindow* parent, wxWindowID id, const wxPoint& pos =
   wxDefaultPosition, const wxSize& size = wxDefaultSize, long style =
   wxTR_HAS_BUTTONS, const wxValidator& validator = wxDefaultValidator,
   const wxString& name = "treeCtrl")

   Creates the tree control. See wxTreeCtrl::wxTreeCtrl for further
   details.

=head2 Wx::TreeCtrl::Delete

   void Delete(const wxTreeItemId& item)

   Deletes the specified item. A EVT_TREE_DELETE_ITEM event will be
   generated.

   This function may cause a subsequent call to GetNextChild to fail.

=head2 Wx::TreeCtrl::DeleteAllItems

   void DeleteAllItems()

   Deletes all items in the control. Note that this may not generate
   EVT_TREE_DELETE_ITEM events under some Windows versions although
   normally such event is generated for each removed item.

=head2 Wx::TreeCtrl::DeleteChildren

   void DeleteChildren(const wxTreeItemId& item)

   Deletes all children of the given item (but not the item itself). Note
   that this will not generate any events unlike Delete method.

   If you have called wxTreeCtrl::SetItemHasChildren, you may need to
   call it again since DeleteChildren does not automatically clear the
   setting.

=head2 Wx::TreeCtrl::EditLabel

   void EditLabel(const wxTreeItemId& item)

   Starts editing the label of the given item. This function generates a
   EVT_TREE_BEGIN_LABEL_EDIT event which can be vetoed so that no text
   control will appear for in-place editing.

   If the user changed the label (i.e. s/he does not press ESC or leave
   the text control without changes, a EVT_TREE_END_LABEL_EDIT event will
   be sent which can be vetoed as well.

   See also

   wxTreeCtrl::EndEditLabel, wxTreeEvent

=head2 Wx::TreeCtrl::EndEditLabel

   void EndEditLabel(bool cancelEdit)

   Ends label editing. If cancelEdit is true, the edit will be cancelled.

   This function is currently supported under Windows only.

   See also

   wxTreeCtrl::EditLabel

=head2 Wx::TreeCtrl::EnsureVisible

   void EnsureVisible(const wxTreeItemId& item)

   Scrolls and/or expands items to ensure that the given item is visible.

=head2 Wx::TreeCtrl::Expand

   void Expand(const wxTreeItemId& item)

   Expands the given item.

=head2 Wx::TreeCtrl::ExpandAll

   void ExpandAll()

   Expands all items in the tree.

=head2 Wx::TreeCtrl::ExpandAllChildren

   void ExpandAllChildren(const wxTreeItemId& item)

   Expands the given item and all its children recursively.

=head2 Wx::TreeCtrl::GetBoundingRect

   bool GetBoundingRect(const wxTreeItemId& item, wxRect& rect, bool
   textOnly = false) const

   Retrieves the rectangle bounding the item. If textOnly is true, only
   the rectangle around the item's label will be returned, otherwise the
   item's image is also taken into account.

   The return value is true if the rectangle was successfully retrieved
   or false if it was not (in this case rect is not changed) -- for
   example, if the item is currently invisible.

   Notice that the rectangle coordinates are logical, not physical ones.
   So, for example, the x coordinate may be negative if the tree has a
   horizontal scrollbar and its position is not 0.

   wxPython note: The wxPython version of this method requires only the
   item and textOnly parameters. The return value is either a wxRect
   object or None.

   wxPerl note: In wxPerl this method only takes the parameters item and
   textOnly, and returns a Wx::Rect ( or undef ).

=head2 Wx::TreeCtrl::GetButtonsImageList

   wxImageList* GetButtonsImageList() const

   Returns the buttons image list (from which application-defined button
   images are taken).

   This function is only available in the generic version.

=head2 Wx::TreeCtrl::GetChildrenCount

   unsigned int GetChildrenCount(const wxTreeItemId& item, bool
   recursively = true) const

   Returns the number of items in the branch. If recursively is true,
   returns the total number of descendants, otherwise only one level of
   children is counted.

=head2 Wx::TreeCtrl::GetCount

   unsigned int GetCount() const

   Returns the number of items in the control.

=head2 Wx::TreeCtrl::GetEditControl

   wxTextCtrl * GetEditControl() const

   Returns the edit control being currently used to edit a label. Returns
   NULL if no label is being edited.

   NB: It is currently only implemented for wxMSW.

=head2 Wx::TreeCtrl::GetFirstChild

   wxTreeItemId GetFirstChild(const wxTreeItemId& item, wxTreeItemIdValue
   & cookie) const

   Returns the first child; call wxTreeCtrl::GetNextChild for the next
   child.

   For this enumeration function you must pass in a 'cookie' parameter
   which is opaque for the application but is necessary for the library
   to make these functions reentrant (i.e. allow more than one
   enumeration on one and the same object simultaneously). The cookie
   passed to GetFirstChild and GetNextChild should be the same variable.

   Returns an invalid tree item (i.e. IsOk() returns false) if there are
   no further children.

   See also

   wxTreeCtrl::GetNextChild, wxTreeCtrl::GetNextSibling

   wxPython note: In wxPython the returned wxTreeItemId and the new
   cookie value are both returned as a tuple containing the two values.

   wxPerl note: In wxPerl this method only takes the item parameter, and
   returns a 2-element list ( item, cookie ).

=head2 Wx::TreeCtrl::GetFirstVisibleItem

   wxTreeItemId GetFirstVisibleItem() const

   Returns the first visible item.

=head2 Wx::TreeCtrl::GetImageList

   wxImageList* GetImageList() const

   Returns the normal image list.

=head2 Wx::TreeCtrl::GetIndent

   int GetIndent() const

   Returns the current tree control indentation.

=head2 Wx::TreeCtrl::GetItemBackgroundColour

   wxColour GetItemBackgroundColour(const wxTreeItemId& item) const

   Returns the background colour of the item.

=head2 Wx::TreeCtrl::GetItemData

   wxTreeItemData* GetItemData(const wxTreeItemId& item) const

   Returns the tree item data associated with the item.

   See also

   wxTreeItemData

   wxPython note: wxPython provides the following shortcut method:

=head2 Wx::TreeCtrl::GetItemFont

   wxFont GetItemFont(const wxTreeItemId& item) const

   Returns the font of the item label.

=head2 Wx::TreeCtrl::GetItemImage

   int GetItemImage(const wxTreeItemId& item, wxTreeItemIcon which =
   wxTreeItemIcon_Normal) const

   Gets the specified item image. The value of which may be:

=head2 Wx::TreeCtrl::GetItemText

   wxString GetItemText(const wxTreeItemId& item) const

   Returns the item label.

=head2 Wx::TreeCtrl::GetItemTextColour

   wxColour GetItemTextColour(const wxTreeItemId& item) const

   Returns the colour of the item label.

=head2 Wx::TreeCtrl::GetLastChild

   wxTreeItemId GetLastChild(const wxTreeItemId& item) const

   Returns the last child of the item (or an invalid tree item if this
   item has no children).

   See also

   GetFirstChild, wxTreeCtrl::GetNextSibling, GetLastChild

=head2 Wx::TreeCtrl::GetNextChild

   wxTreeItemId GetNextChild(const wxTreeItemId& item, wxTreeItemIdValue
   & cookie) const

   Returns the next child; call wxTreeCtrl::GetFirstChild for the first
   child.

   For this enumeration function you must pass in a 'cookie' parameter
   which is opaque for the application but is necessary for the library
   to make these functions reentrant (i.e. allow more than one
   enumeration on one and the same object simultaneously). The cookie
   passed to GetFirstChild and GetNextChild should be the same.

   Returns an invalid tree item if there are no further children.

   See also

   wxTreeCtrl::GetFirstChild

   wxPython note: In wxPython the returned wxTreeItemId and the new
   cookie value are both returned as a tuple containing the two values.

   wxPerl note: In wxPerl this method returns a 2-element list ( item,
   cookie ), instead of modifying its parameters.

=head2 Wx::TreeCtrl::GetNextSibling

   wxTreeItemId GetNextSibling(const wxTreeItemId& item) const

   Returns the next sibling of the specified item; call
   wxTreeCtrl::GetPrevSibling for the previous sibling.

   Returns an invalid tree item if there are no further siblings.

   See also

   wxTreeCtrl::GetPrevSibling

=head2 Wx::TreeCtrl::GetNextVisible

   wxTreeItemId GetNextVisible(const wxTreeItemId& item) const

   Returns the next visible item.

=head2 Wx::TreeCtrl::GetItemParent

   wxTreeItemId GetItemParent(const wxTreeItemId& item) const

   Returns the item's parent.

=head2 Wx::TreeCtrl::GetPrevSibling

   wxTreeItemId GetPrevSibling(const wxTreeItemId& item) const

   Returns the previous sibling of the specified item; call
   wxTreeCtrl::GetNextSibling for the next sibling.

   Returns an invalid tree item if there are no further children.

   See also

   wxTreeCtrl::GetNextSibling

=head2 Wx::TreeCtrl::GetPrevVisible

   wxTreeItemId GetPrevVisible(const wxTreeItemId& item) const

   Returns the previous visible item.

=head2 Wx::TreeCtrl::GetQuickBestSize

   bool GetQuickBestSize() const

   Returns true if the control will use a quick calculation for the best
   size, looking only at the first and last items. The default is false.

   See also

   wxTreeCtrl::SetQuickBestSize

=head2 Wx::TreeCtrl::GetRootItem

   wxTreeItemId GetRootItem() const

   Returns the root item for the tree control.

=head2 Wx::TreeCtrl::GetItemSelectedImage

   int GetItemSelectedImage(const wxTreeItemId& item) const

   Gets the selected item image (this function is obsolete, use
   GetItemImage(item, wxTreeItemIcon_Selected) instead).

=head2 Wx::TreeCtrl::GetSelection

   wxTreeItemId GetSelection() const

   Returns the selection, or an invalid item if there is no selection.
   This function only works with the controls without wxTR_MULTIPLE
   style, use GetSelections for the controls which do have this style.

=head2 Wx::TreeCtrl::GetSelections

   unsigned int GetSelections(wxArrayTreeItemIds& selection) const

   Fills the array of tree items passed in with the currently selected
   items. This function can be called only if the control has the
   wxTR_MULTIPLE style.

   Returns the number of selected items.

   wxPython note: The wxPython version of this method accepts no
   parameters and returns a Python list of wxTreeItemIds.

   wxPerl note: In wxPerl this method takes no parameters and returns a
   list of Wx::TreeItemIds.

=head2 Wx::TreeCtrl::GetStateImageList

   wxImageList* GetStateImageList() const

   Returns the state image list (from which application-defined state
   images are taken).

=head2 Wx::TreeCtrl::HitTest

   wxTreeItemId HitTest(const wxPoint& point, int& flags) const

   Calculates which (if any) item is under the given point, returning the
   tree item id at this point plus extra information flags. flags is a
   bitlist of the following:

=head2 Wx::TreeCtrl::InsertItem

   wxTreeItemId InsertItem(const wxTreeItemId& parent, const wxTreeItemId&
   previous, const wxString& text, int image = -1, int selImage = -1,
   wxTreeItemData* data = NULL)

   wxTreeItemId InsertItem(const wxTreeItemId& parent, size_t before,
   const wxString& text, int image = -1, int selImage = -1,
   wxTreeItemData* data = NULL)

   Inserts an item after a given one (previous) or before one identified
   by its position (before). before must be less than the number of
   children.

   The image and selImage parameters are an index within the normal image
   list specifying the image to use for unselected and selected items,
   respectively. If image > -1 and selImage is -1, the same image is used
   for both selected and unselected items.

   wxPython note: The second form of this method is called
   InsertItemBefore in wxPython.

=head2 Wx::TreeCtrl::IsBold

   bool IsBold(const wxTreeItemId& item) const

   Returns true if the given item is in bold state.

   See also: SetItemBold

=head2 Wx::TreeCtrl::IsEmpty

   bool IsEmpty() const

   Returns true if the control is empty (i.e. has no items, even no root
   one).

=head2 Wx::TreeCtrl::IsExpanded

   bool IsExpanded(const wxTreeItemId& item) const

   Returns true if the item is expanded (only makes sense if it has
   children).

=head2 Wx::TreeCtrl::IsSelected

   bool IsSelected(const wxTreeItemId& item) const

   Returns true if the item is selected.

=head2 Wx::TreeCtrl::IsVisible

   bool IsVisible(const wxTreeItemId& item) const

   Returns true if the item is visible (it might be outside the view, or
   not expanded).

=head2 Wx::TreeCtrl::ItemHasChildren

   bool ItemHasChildren(const wxTreeItemId& item) const

   Returns true if the item has children.

=head2 Wx::TreeCtrl::OnCompareItems

   int OnCompareItems(const wxTreeItemId& item1, const wxTreeItemId&
   item2)

   Override this function in the derived class to change the sort order
   of the items in the tree control. The function should return a
   negative, zero or positive value if the first item is less than, equal
   to or greater than the second one.

   Please note that you must use wxRTTI macros DECLARE_DYNAMIC_CLASS and
   IMPLEMENT_DYNAMIC_CLASS if you override this function because
   otherwise the base class considers that it is not overridden and uses
   the default comparison, i.e. sorts the items alphabetically, which
   allows it optimize away the calls to the virtual function completely.

   See also: SortChildren

=head2 Wx::TreeCtrl::PrependItem

   wxTreeItemId PrependItem(const wxTreeItemId& parent, const wxString&
   text, int image = -1, int selImage = -1, wxTreeItemData* data = NULL)

   Appends an item as the first child of parent, return a new item id.

   The image and selImage parameters are an index within the normal image
   list specifying the image to use for unselected and selected items,
   respectively. If image > -1 and selImage is -1, the same image is used
   for both selected and unselected items.

=head2 Wx::TreeCtrl::ScrollTo

   void ScrollTo(const wxTreeItemId& item)

   Scrolls the specified item into view.

=head2 Wx::TreeCtrl::SelectItem

   void SelectItem(const wxTreeItemId& item, bool select = true)

   Selects the given item. In multiple selection controls, can be also
   used to deselect a currently selected item if the value of select is
   false.

=head2 Wx::TreeCtrl::SetButtonsImageList

   void SetButtonsImageList(wxImageList* imageList)

   Sets the buttons image list (from which application-defined button
   images are taken). The button images assigned with this method will
   not be deleted by wxTreeCtrl's destructor, you must delete it
   yourself.

   Setting or assigning the button image list enables the display of
   image buttons. Once enabled, the only way to disable the display of
   button images is to set the button image list to NULL.

   This function is only available in the generic version.

   See also AssignButtonsImageList.

=head2 Wx::TreeCtrl::SetIndent

   void SetIndent(int indent)

   Sets the indentation for the tree control.

=head2 Wx::TreeCtrl::SetImageList

   void SetImageList(wxImageList* imageList)

   Sets the normal image list. Image list assigned with this method will
   not be deleted by wxTreeCtrl's destructor, you must delete it
   yourself.

   See also AssignImageList.

=head2 Wx::TreeCtrl::SetItemBackgroundColour

   void SetItemBackgroundColour(const wxTreeItemId& item, const wxColour&
   col)

   Sets the colour of the item's background.

=head2 Wx::TreeCtrl::SetItemBold

   void SetItemBold(const wxTreeItemId& item, bool bold = true)

   Makes item appear in bold font if bold parameter is true or resets it
   to the normal state.

   See also: IsBold

=head2 Wx::TreeCtrl::SetItemData

   void SetItemData(const wxTreeItemId& item, wxTreeItemData* data)

   Sets the item client data.

   wxPython note: wxPython provides the following shortcut method:

=head2 Wx::TreeCtrl::SetItemDropHighlight

   void SetItemDropHighlight(const wxTreeItemId& item, boolhighlight =
   true)

   Gives the item the visual feedback for Drag'n'Drop actions, which is
   useful if something is dragged from the outside onto the tree control
   (as opposed to a DnD operation within the tree control, which already
   is implemented internally).

=head2 Wx::TreeCtrl::SetItemFont

   void SetItemFont(const wxTreeItemId& item, const wxFont& font)

   Sets the item's font. All items in the tree should have the same
   height to avoid text clipping, so the fonts height should be the same
   for all of them, although font attributes may vary.

   See also

   SetItemBold

=head2 Wx::TreeCtrl::SetItemHasChildren

   void SetItemHasChildren(const wxTreeItemId& item, bool hasChildren =
   true)

   Force appearance of the button next to the item. This is useful to
   allow the user to expand the items which don't have any children now,
   but instead adding them only when needed, thus minimizing memory usage
   and loading time.

=head2 Wx::TreeCtrl::SetItemImage

   void SetItemImage(const wxTreeItemId& item, int image, wxTreeItemIcon
   which = wxTreeItemIcon_Normal)

   Sets the specified item image. See GetItemImage for the description of
   the which parameter.

=head2 Wx::TreeCtrl::SetItemSelectedImage

   void SetItemSelectedImage(const wxTreeItemId& item, int selImage)

   Sets the selected item image (this function is obsolete, use
   SetItemImage(item, wxTreeItemIcon_Selected) instead).

=head2 Wx::TreeCtrl::SetItemText

   void SetItemText(const wxTreeItemId& item, const wxString& text)

   Sets the item label.

=head2 Wx::TreeCtrl::SetItemTextColour

   void SetItemTextColour(const wxTreeItemId& item, const wxColour& col)

   Sets the colour of the item's text.

=head2 Wx::TreeCtrl::SetQuickBestSize

   void SetQuickBestSize(bool quickBestSize)

   If true is passed, specifies that the control will use a quick
   calculation for the best size, looking only at the first and last
   items. Otherwise, it will look at all items. The default is false.

   See also

   wxTreeCtrl::GetQuickBestSize

=head2 Wx::TreeCtrl::SetStateImageList

   void SetStateImageList(wxImageList* imageList)

   Sets the state image list (from which application-defined state images
   are taken). Image list assigned with this method will not be deleted
   by wxTreeCtrl's destructor, you must delete it yourself.

   See also AssignStateImageList.

=head2 Wx::TreeCtrl::SetWindowStyle

   void SetWindowStyle(longstyles)

   Sets the mode flags associated with the display of the tree control.
   The new mode takes effect immediately. (Generic only; MSW ignores
   changes.)

=head2 Wx::TreeCtrl::SortChildren

   void SortChildren(const wxTreeItemId& item)

   Sorts the children of the given item using OnCompareItems method of
   wxTreeCtrl. You should override that method to change the sort order
   (the default is ascending case-sensitive alphabetical order).

   See also

   wxTreeItemData, OnCompareItems

=head2 Wx::TreeCtrl::Toggle

   void Toggle(const wxTreeItemId& item)

   Toggles the given item between collapsed and expanded states.

=head2 Wx::TreeCtrl::ToggleItemSelection

   void ToggleItemSelection(const wxTreeItemId& item)

   Toggles the given item between selected and unselected states. For
   multiselection controls only.

=head2 Wx::TreeCtrl::Unselect

   void Unselect()

   Removes the selection from the currently selected item (if any).

=head2 Wx::TreeCtrl::UnselectAll

   void UnselectAll()

   This function either behaves the same as Unselect if the control
   doesn't have wxTR_MULTIPLE style, or removes the selection from all
   items if it does have this style.

=head2 Wx::TreeCtrl::UnselectItem

   void UnselectItem(const wxTreeItemId& item)

   Unselects the given item. This works in multiselection controls only.

=head1 Wx::TreeItemId

=head2 Wx::TreeItemId::new

   wxTreeItemId()

   Default constructor. wxTreemItemIds are not meant to be constructed
   explicitly by the user; they are returned by the wxTreeCtrl functions
   instead.

=head2 Wx::TreeItemId::IsOk

   bool IsOk() const

   Returns true if this instance is referencing a valid tree item.

=head2 Operators

   void operator !() const

   Synonim for IsOk

=head1 Wx::TreeEvent

=head2 Wx::TreeEvent::new

   wxTreeEvent(wxEventType commandType, wxTreeCtrl *tree, const
   wxTreeItemId&item = wxTreeItemId())

   Constructor, used by wxWidgets itself only.

=head2 Wx::TreeEvent::GetKeyCode

   int GetKeyCode() const

   Returns the key code if the event is a key event. Use GetKeyEvent to
   get the values of the modifier keys for this event (i.e. Shift or
   Ctrl).

=head2 Wx::TreeEvent::GetItem

   wxTreeItemId GetItem() const

   Returns the item (valid for all events).

=head2 Wx::TreeEvent::GetKeyEvent

   const wxKeyEvent& GetKeyEvent() const

   Returns the key event for EVT_TREE_KEY_DOWN events.

=head2 Wx::TreeEvent::GetLabel

   const wxString& GetLabel() const

   Returns the label if the event is a begin or end edit label event.

=head2 Wx::TreeEvent::GetOldItem

   wxTreeItemId GetOldItem() const

   Returns the old item index (valid for EVT_TREE_ITEM_CHANGING and
   CHANGED events)

=head2 Wx::TreeEvent::GetPoint

   wxPoint GetPoint() const

   Returns the position of the mouse pointer if the event is a drag or
   menu-context event. In both cases the position is in client
   coordinates - i.e. relative to the wxTreeCtrl window (so that you can
   pass it directly to e.g. wxWindow::PopupMenu).

=head2 Wx::TreeEvent::IsEditCancelled

   bool IsEditCancelled() const

   Returns true if the label edit was cancelled. This should be called
   from within an EVT_TREE_END_LABEL_EDIT handler.

=head2 Wx::TreeEvent::SetToolTip

   void SetToolTip(const wxString& tooltip)

   Set the tooltip for the item (valid for EVT_TREE_ITEM_GETTOOLTIP
   events). Windows only.

=head1 Wx::TreeItemData

=head2 Wx::TreeItemData::new

   wxTreeItemData()

   Default constructor.

   wxPython note: The wxPython version of this constructor optionally
   accepts any Python object as a parameter. This object is then
   associated with the tree item using the wxTreeItemData as a container.

   In addition, the following methods are added in wxPython for accessing
   the object:

=head2 Wx::TreeItemData::DESTROY

   void ~wxTreeItemData()

   Virtual destructor.

=head2 Wx::TreeItemData::GetId

   const wxTreeItemId& GetId()

   Returns the item associated with this node.

=head2 Wx::TreeItemData::SetId

   void SetId(const wxTreeItemId& id)

   Sets the item associated with this node.

=head1 Wx::UpdateUIEvent

=head2 Wx::UpdateUIEvent::new

   wxUpdateUIEvent(wxWindowID commandId = 0)

   Constructor.

=head2 Wx::UpdateUIEvent::CanUpdate

   static bool CanUpdate(wxWindow* window)

   Returns true if it is appropriate to update (send UI update events to)
   this window.

   This function looks at the mode used (see wxUpdateUIEvent::SetMode),
   the wxWS_EX_PROCESS_UPDATE_EVENTS flag in window, the time update
   events were last sent in idle time, and the update interval, to
   determine whether events should be sent to this window now. By default
   this will always return true because the update mode is initially
   wxUPDATE_UI_PROCESS_ALL and the interval is set to 0; so update events
   will be sent as often as possible. You can reduce the frequency that
   events are sent by changing the mode and/or setting an update
   interval.

   See also

   wxUpdateUIEvent::ResetUpdateTime, wxUpdateUIEvent::SetUpdateInterval,
   wxUpdateUIEvent::SetMode

=head2 Wx::UpdateUIEvent::Check

   void Check(bool check)

   Check or uncheck the UI element.

=head2 Wx::UpdateUIEvent::Enable

   void Enable(bool enable)

   Enable or disable the UI element.

=head2 Wx::UpdateUIEvent::Show

   void Show(bool show)

   Show or hide the UI element.

=head2 Wx::UpdateUIEvent::GetChecked

   bool GetChecked() const

   Returns true if the UI element should be checked.

=head2 Wx::UpdateUIEvent::GetEnabled

   bool GetEnabled() const

   Returns true if the UI element should be enabled.

=head2 Wx::UpdateUIEvent::GetShown

   bool GetShown() const

   Returns true if the UI element should be shown.

=head2 Wx::UpdateUIEvent::GetSetChecked

   bool GetSetChecked() const

   Returns true if the application has called wxUpdateUIEvent::Check. For
   wxWidgets internal use only.

=head2 Wx::UpdateUIEvent::GetSetEnabled

   bool GetSetEnabled() const

   Returns true if the application has called wxUpdateUIEvent::Enable.
   For wxWidgets internal use only.

=head2 Wx::UpdateUIEvent::GetSetShown

   bool GetSetShown() const

   Returns true if the application has called wxUpdateUIEvent::Show. For
   wxWidgets internal use only.

=head2 Wx::UpdateUIEvent::GetSetText

   bool GetSetText() const

   Returns true if the application has called wxUpdateUIEvent::SetText.
   For wxWidgets internal use only.

=head2 Wx::UpdateUIEvent::GetText

   wxString GetText() const

   Returns the text that should be set for the UI element.

=head2 Wx::UpdateUIEvent::GetMode

   static wxUpdateUIMode GetMode()

   Static function returning a value specifying how wxWidgets will send
   update events: to all windows, or only to those which specify that
   they will process the events.

   See wxUpdateUIEvent::SetMode.

=head2 Wx::UpdateUIEvent::GetUpdateInterval

   static long GetUpdateInterval()

   Returns the current interval between updates in milliseconds. -1
   disables updates, 0 updates as frequently as possible.

   See wxUpdateUIEvent::SetUpdateInterval.

=head2 Wx::UpdateUIEvent::ResetUpdateTime

   static void ResetUpdateTime()

   Used internally to reset the last-updated time to the current time. It
   is assumed that update events are normally sent in idle time, so this
   is called at the end of idle processing.

   See also

   wxUpdateUIEvent::CanUpdate, wxUpdateUIEvent::SetUpdateInterval,
   wxUpdateUIEvent::SetMode

=head2 Wx::UpdateUIEvent::SetMode

   static void SetMode(wxUpdateUIMode mode)

   Specify how wxWidgets will send update events: to all windows, or only
   to those which specify that they will process the events.

   mode may be one of the following values. The default is
   wxUPDATE_UI_PROCESS_ALL.

   enum wxUpdateUIMode
   {
           // Send UI update events to all windows
       wxUPDATE_UI_PROCESS_ALL,

=head2 Wx::UpdateUIEvent::SetText

   void SetText(const wxString& text)

   Sets the text for this UI element.

=head2 Wx::UpdateUIEvent::SetUpdateInterval

   static void SetUpdateInterval(long updateInterval)

   Sets the interval between updates in milliseconds. Set to -1 to
   disable updates, or to 0 to update as frequently as possible. The
   default is 0.

   Use this to reduce the overhead of UI update events if your
   application has a lot of windows. If you set the value to -1 or
   greater than 0, you may also need to call wxWindow::UpdateWindowUI at
   appropriate points in your application, such as when a dialog is about
   to be shown.

=head1 Wx::URI

=head2 Obtaining individual components

   To obtain individual components you can use one of the following
   methods

   GetScheme

=head2 Deviations from the RFC

   Note that on URIs with a "file" scheme wxURI does not parse the
   userinfo, server, or port portion. This is to keep compatability with
   wxFileSystem, the old wxURL, and older url specifications.

=head2 Wx::URI::new

   wxURI()

   Creates an empty URI.

   wxURI(const wxChar* uri)

   Constructor for quick creation.

   uri 

       string to initialize with

   wxURI(const wxURI& uri)

   Copies this URI from another URI.

   uri 

       URI (Uniform Resource Identifier) to initialize with

=head2 Wx::URI::BuildURI

   wxString BuildURI() const

   Builds the URI from its individual components and adds proper
   separators.

   If the URI is not a reference or is not resolved, the URI that is
   returned from Get is the same one passed to Create.

=head2 Wx::URI::BuildUnescapedURI

   wxString BuildUnescapedURI() const

   Builds the URI from its individual components, adds proper separators,
   and returns escape sequences to normal characters.

   Note that it is preferred to call this over Unescape(BuildURI()) since
   BuildUnescapedURI performs some optimizations over the plain method.

=head2 Wx::URI::Create

   const wxChar* Create(const wxStringuri)

   Creates this URI from the string uri.

   Returns the position at which parsing stopped (there is no such thing
   as an "invalid" wxURI).

   uri 

       string to initialize from

=head2 Wx::URI::GetFragment

   const wxString GetFragment() const

   Obtains the fragment of this URI.

   The fragment of a URI is the last value of the URI, and is the value
   after a '' character after the path of the URI.

   http://mysite.com/mypath#<fragment>

=head2 Wx::URI::GetHostType

   const HostType& GetHostType() const

   Obtains the host type of this URI, which is of type wxURI::HostType:

=head2 Wx::URI::GetPassword

   const wxString GetPassword() const

   Returns the password part of the userinfo component of this URI. Note
   that this is explicitly depreciated by RFC 1396 and should generally
   be avoided if possible.

   http://<user>:<password>@mysite.com/mypath

=head2 Wx::URI::GetPath

   const wxString GetPath() const

   Returns the (normalized) path of the URI.

   The path component of a URI comes directly after the scheme component
   if followed by zero or one slashes ('/'), or after the server/port
   component.

   Absolute paths include the leading '/' character.

   http://mysite.com<path>

=head2 Wx::URI::GetPort

   const wxString GetPort() const

   Returns a string representation of the URI's port.

   The Port of a URI is a value after the server, and must come after a
   colon (:).

   http://mysite.com:<port>

   Note that you can easily get the numeric value of the port by using
   wxAtoi or wxString::Format.

=head2 Wx::URI::GetQuery

   const wxString GetQuery() const

   Returns the Query component of the URI.

   The query component is what is commonly passed to a cgi application,
   and must come after the path component, and after a '?' character.

   http://mysite.com/mypath?<query>

=head2 Wx::URI::GetScheme

   const wxString GetScheme() const

   Returns the Scheme component of the URI.

   The first part of the uri.

   <scheme>://mysite.com

=head2 Wx::URI::GetServer

   const wxString GetServer() const

   Returns the Server component of the URI.

   The server of the uri can be a server name or a type of ip address.
   See GetHostType for the possible values for the host type of the
   server component.

   http://<server>/mypath

=head2 Wx::URI::GetUser

   const wxString GetUser() const

   Returns the username part of the userinfo component of this URI. Note
   that this is explicitly depreciated by RFC 1396 and should generally
   be avoided if possible.

   http://<user>:<password>@mysite.com/mypath

=head2 Wx::URI::GetUserInfo

   const wxString GetUserInfo() const

   Returns the UserInfo component of the URI.

   The component of a URI before the server component that is postfixed
   by a '@' character.

   http://<userinfo>@mysite.com/mypath

=head2 Wx::URI::HasFragment

   bool HasFragment() const

   Returns true if the Fragment component of the URI exists.

=head2 Wx::URI::HasPath

   bool HasPath() const

   Returns true if the Path component of the URI exists.

=head2 Wx::URI::HasPort

   bool HasPort() const

   Returns true if the Port component of the URI exists.

=head2 Wx::URI::HasQuery

   bool HasQuery() const

   Returns true if the Query component of the URI exists.

=head2 Wx::URI::HasScheme

   bool HasScheme() const

   Returns true if the Scheme component of the URI exists.

=head2 Wx::URI::HasServer

   bool HasServer() const

   Returns true if the Server component of the URI exists.

=head2 Wx::URI::HasUser

   bool HasUser() const

   Returns true if the User component of the URI exists.

=head2 Wx::URI::IsReference

   bool IsReference() const

   Returns true if a valid [absolute] URI, otherwise this URI is a URI
   reference and not a full URI, and IsReference returns false.

=head2 Wx::URI::Resolve

   void Resolve(const wxURI& base, int flags = wxURI_STRICT)

   Inherits this URI from a base URI - components that do not exist in
   this URI are copied from the base, and if this URI's path is not an
   absolute path (prefixed by a '/'), then this URI's path is merged with
   the base's path.

   For instance, resolving "../mydir" from "http://mysite.com/john/doe"
   results in the scheme (http) and server (mysite.com) being copied into
   this URI, since they do not exist. In addition, since the path of this
   URI is not absolute (does not begin with '/'), the path of the base's
   is merged with this URI's path, resulting in the URI
   "http://mysite.com/john/mydir".

   base

       Base URI to inherit from. Must be a full URI and not a reference

=head2 Wx::URI::Unescape

   wxString Unescape(const wxString& uri)

   Translates all escape sequences (normal characters and returns the
   result.

   This is the preferred over deprecated wxURL::ConvertFromURI.

   If you want to unescape an entire wxURI, use BuildUnescapedURI
   instead, as it performs some optimizations over this method.

   uri 

       string with escaped characters to convert

=head1 Wx::URL

=head2 Wx::URL::new

   wxURL(const wxString& url = wxEmptyString)

   Constructs a URL object from the string. The URL must be valid
   according to RFC 1738. In particular, file URLs must be of the format
   file://hostname/path/to/file otherwise GetError will return a value
   different from wxURL_NOERR.

   It is valid to leave out the hostname but slashes must remain in place
   - i.e. a file URL without a hostname must contain three consecutive
   slashes (e.g. file:///somepath/myfile).

   Parameters

   url 

       Url string to parse.

=head2 Wx::URL::DESTROY

   ~wxURL()

   Destroys the URL object.

=head2 Wx::URL::GetProtocol

   wxProtocol& GetProtocol()

   Returns a reference to the protocol which will be used to get the URL.

=head2 Wx::URL::GetError

   wxURLError GetError() const

   Returns the last error. This error refers to the URL parsing or to the
   protocol. It can be one of these errors:

=head2 Wx::URL::GetInputStream

   wxInputStream * GetInputStream()

   Creates a new input stream on the specified URL. You can use all but
   seek functionality of wxStream. Seek isn't available on all streams.
   For example, HTTP or FTP streams don't deal with it.

   Note that this method is somewhat deprecated, all future wxWidgets
   applications should really use wxFileSystem instead.

   Example:

     wxURL url("http://a.host/a.dir/a.file");
     if (url.GetError() == wxURL_NOERR)
     {
         wxInputStream *in_stream;

=head2 Wx::URL::IsOk

   bool IsOk() const

   Returns true if this object is correctly initialized, i.e. if GetError
   returns wxURL_NOERR.

=head2 Wx::URL::SetDefaultProxy

   static void SetDefaultProxy(const wxString& url_proxy)

   Sets the default proxy server to use to get the URL. The string
   specifies the proxy like this: <hostname>:<port number>.

   Parameters

   url_proxy

       Specifies the proxy to use

   See also

   wxURL::SetProxy

=head2 Wx::URL::SetProxy

   void SetProxy(const wxString& url_proxy)

   Sets the proxy to use for this URL.

   See also

   wxURL::SetDefaultProxy

=head2 Wx::URL::SetURL

   wxURLError SetURL(const wxString& url)

   Initializes this object with the given URL and returns wxURL_NOERR if
   it's valid (see GetError for more info).

=head1 Wx::URLDataObject

=head2 Wx::URLDataObject::new

   wxURLDataObject(const wxString& url = wxEmptyString)

   Constructor, may be used to initialize the URL. If url is empty,
   SetURL can be used later.

=head2 Wx::URLDataObject::GetURL

   wxString GetURL() const

   Returns the URL stored by this object, as a string.

=head2 Wx::URLDataObject::SetURL

   void SetURL(const wxString& url)

   Sets the URL stored by this object.

=head1 Wx::Validator

=head2 Wx::Validator::new

   wxValidator()

   Constructor.

=head2 Wx::Validator::DESTROY

   ~wxValidator()

   Destructor.

=head2 Wx::Validator::Clone

   virtual wxObject* Clone() const

   All validator classes must implement the Clone function, which returns
   an identical copy of itself. This is because validators are passed to
   control constructors as references which must be copied. Unlike
   objects such as pens and brushes, it does not make sense to have a
   reference counting scheme to do this cloning, because all validators
   should have separate data.

   This base function returns NULL.

=head2 Wx::Validator::GetWindow

   wxWindow* GetWindow() const

   Returns the window associated with the validator.

=head2 Wx::Validator::SetBellOnError

   void SetBellOnError(bool doIt = true)

   This functions switches on or turns off the error sound produced by
   the validators if an invalid key is pressed.

=head2 Wx::Validator::SetWindow

   void SetWindow(wxWindow* window)

   Associates a window with the validator.

=head2 Wx::Validator::TransferFromWindow

   virtual bool TransferToWindow()

   This overridable function is called when the value in the window must
   be transferred to the validator. Return false if there is a problem.

=head2 Wx::Validator::TransferToWindow

   virtual bool TransferToWindow()

   This overridable function is called when the value associated with the
   validator must be transferred to the window. Return false if there is
   a problem.

=head2 Wx::Validator::Validate

   virtual bool Validate(wxWindow* parent)

   This overridable function is called when the value in the associated
   window must be validated. Return false if the value in the window is
   not valid; you may pop up an error dialog.

=head1 Wx::Variant

=head2 Wx::Variant::new

   wxVariant()

   Default constructor.

   wxVariant(const wxVariant& variant)

   Copy constructor, uses reference counting.

   wxVariant(const wxChar* value, const wxString& name = "")

   wxVariant(const wxString& value, const wxString& name = "")

   Construction from a string value.

   wxVariant(wxChar value, const wxString& name = "")

   Construction from a character value.

   wxVariant(long value, const wxString& name = "")

   Construction from an integer value. You may need to cast to (long) to
   avoid confusion with other constructors (such as the bool
   constructor).

   wxVariant(bool value, const wxString& name = "")

   Construction from a boolean value.

   wxVariant(double value, const wxString& name = "")

   Construction from a double-precision floating point value.

   wxVariant(const wxList& value, const wxString& name = "")

   Construction from a list of wxVariant objects. This constructor copies
   value, the application is still responsible for deleting value and its
   contents.

   wxVariant(void* value, const wxString& name = "")

   Construction from a void pointer.

   wxVariant(wxObject* value, const wxString& name = "")

   Construction from a wxObject pointer.

   wxVariant(wxVariantData* data, const wxString& name = "")

   Construction from user-defined data. The variant holds onto the data
   pointer.

   wxVariant(wxDateTime& val, const wxString& name = "")

   Construction from a wxDateTime.

   wxVariant(wxArrayString& val, const wxString& name = "")

   Construction from an array of strings. This constructor copies value
   and its contents.

   wxVariant(DATE_STRUCT* val, const wxString& name = "")

   Construction from a odbc date value. Represented internally by a
   wxDateTime value.

   wxVariant(TIME_STRUCT* val, const wxString& name = "")

   Construction from a odbc time value. Represented internally by a
   wxDateTime value.

   wxVariant(TIMESTAMP_STRUCT* val, const wxString& name = "")

   Construction from a odbc timestamp value. Represented internally by a
   wxDateTime value.

=head2 Wx::Variant::DESTROY

   ~wxVariant()

   Destructor.

   Note that destructor is protected, so wxVariantData cannot usually be
   deleted. Instead, DecRef should be called. See reference-counted
   object destruction for more info.

=head2 Wx::Variant::Append

   void Append(const wxVariant& value)

   Appends a value to the list.

=head2 Wx::Variant::Clear

   void Clear()

   Makes the variant null by deleting the internal data and set the name
   to wxEmptyString.

=head2 Wx::Variant::ClearList

   void ClearList()

   Deletes the contents of the list.

=head2 Wx::Variant::Convert

   bool Convert(long* value) const

   bool Convert(bool* value) const

   bool Convert(double* value) const

   bool Convert(wxString* value) const

   bool Convert(wxChar* value) const

   bool Convert(wxDateTime* value) const

   Retrieves and converts the value of this variant to the type that
   value is.

=head2 Wx::Variant::GetCount

   size_t GetCount() const

   Returns the number of elements in the list.

=head2 Wx::Variant::Delete

   bool Delete(size_t item)

   Deletes the zero-based item from the list.

=head2 Wx::Variant::GetArrayString

   wxArrayString GetArrayString() const

   Returns the string array value.

=head2 Wx::Variant::GetBool

   bool GetBool() const

   Returns the boolean value.

=head2 Wx::Variant::GetChar

   wxChar GetChar() const

   Returns the character value.

=head2 Wx::Variant::GetData

   wxVariantData* GetData() const

   Returns a pointer to the internal variant data. To take ownership of
   this data, you must call its IncRef method. When you stop using it,
   DecRef must be likewise called.

=head2 Wx::Variant::GetDateTime

   wxDateTime GetDateTime() const

   Returns the date value.

=head2 Wx::Variant::GetDouble

   double GetDouble() const

   Returns the floating point value.

=head2 Wx::Variant::GetLong

   long GetLong() const

   Returns the integer value.

=head2 Wx::Variant::GetName

   const wxString& GetName() const

   Returns a constant reference to the variant name.

=head2 Wx::Variant::GetString

   wxString GetString() const

   Gets the string value.

=head2 Wx::Variant::GetType

   wxString GetType() const

   Returns the value type as a string. The built-in types are: bool,
   char, date, double, list, long, string, stringlist, time, void*.

   If the variant is null, the value type returned is the string "null"
   (not the empty string).

=head2 Wx::Variant::GetVoidPtr

   void* GetVoidPtr() const

   Gets the void pointer value.

=head2 Wx::Variant::GetWxObjectPtr

   wxObject* GetWxObjectPtr() const

   Gets the wxObject pointer value.

=head2 Wx::Variant::Insert

   void Insert(const wxVariant& value)

   Inserts a value at the front of the list.

=head2 Wx::Variant::IsNull

   bool IsNull() const

   Returns true if there is no data associated with this variant, false
   if there is data.

=head2 Wx::Variant::IsType

   bool IsType(const wxString& type) const

   Returns true if type matches the type of the variant, false otherwise.

=head2 Wx::Variant::IsValueKindOf

   bool IsValueKindOf(const wxClassInfo* type type) const

   Returns true if the data is derived from the class described by type,
   false otherwise.

=head2 Wx::Variant::MakeNull

   void MakeNull()

   Makes the variant null by deleting the internal data.

=head2 Wx::Variant::MakeString

   wxString MakeString() const

   Makes a string representation of the variant value (for any type).

=head2 Wx::Variant::Member

   bool Member(const wxVariant& value) const

   Returns true if value matches an element in the list.

=head2 Wx::Variant::NullList

   void NullList()

   Makes an empty list. This differs from a null variant which has no
   data; a null list is of type list, but the number of elements in the
   list is zero.

=head2 Wx::Variant::SetData

   void SetData(wxVariantData* data)

   Sets the internal variant data, deleting the existing data if there is
   any.

=head1 Wx::VariantData

=head2 Wx::VariantData::new

   wxVariantData()

   Default constructor.

=head2 Wx::VariantData::DecRef

   void DecRef()

   Decreases reference count. If the count reaches zero, the object is
   automatically deleted.

   Note that destructor of wxVariantData is protected, so delete cannot
   be used as normal. Instead, DecRef should be called.

=head2 Wx::VariantData::Eq

   bool Eq(wxVariantData& data) const

   Returns true if this object is equal to data.

=head2 Wx::VariantData::GetType

   wxString GetType() const

   Returns the string type of the data.

=head2 Wx::VariantData::GetValueClassInfo

   wxClassInfo* GetValueClassInfo() const

   If the data is a wxObject returns a pointer to the objects wxClassInfo
   structure, if the data isn't a wxObject the method returns NULL.

=head2 Wx::VariantData::IncRef

   void IncRef()

   Increases reference count. Note that initially wxVariantData has
   reference count of 1.

=head2 Wx::VariantData::Read

   bool Read(ostream& stream)

   bool Read(wxString& string)

   Reads the data from stream or string.

=head2 Wx::VariantData::Write

   bool Write(ostream& stream) const

   bool Write(wxString& string) const

   Writes the data to stream or string.

=head2 Wx::GetVariantCast

   classname * wxGetVariantCast(wxVariant&, classname)

   This macro returns the data stored in variant cast to the type
   classname * if the data is of this type (the check is done during the
   run-time) or NULL otherwise.

=head1 Wx::View

=head2 Wx::View::m_viewDocument

   wxDocument* m_viewDocument

   The document associated with this view. There may be more than one
   view per document, but there can never be more than one document for
   one view.

=head2 Wx::View::m_viewFrame

   wxFrame* m_viewFrame

   Frame associated with the view, if any.

=head2 Wx::View::m_viewTypeName

   wxString m_viewTypeName

   The view type name given to the wxDocTemplate constructor, copied to
   this variable when the view is created. Not currently used by the
   framework.

=head2 Wx::View::new

   wxView()

   Constructor. Define your own default constructor to initialize
   application-specific data.

=head2 Wx::View::DESTROY

   ~wxView()

   Destructor. Removes itself from the document's list of views.

=head2 Wx::View::Activate

   virtual void Activate(bool activate)

   Call this from your view frame's OnActivate member to tell the
   framework which view is currently active. If your windowing system
   doesn't call OnActivate, you may need to call this function from any
   place where you know the view must be active, and the framework will
   need to get the current view.

   The prepackaged view frame wxDocChildFrame calls wxView::Activate from
   its OnActivate member.

   This function calls wxView::OnActivateView.

=head2 Wx::View::Close

   virtual bool Close(bool deleteWindow = true)

   Closes the view by calling OnClose. If deleteWindow is true, this
   function should delete the window associated with the view.

=head2 Wx::View::GetDocument

   wxDocument* GetDocument() const

   Gets a pointer to the document associated with the view.

=head2 Wx::View::GetDocumentManager

   wxDocManager* GetDocumentManager() const

   Returns a pointer to the document manager instance associated with
   this view.

=head2 Wx::View::GetFrame

   wxWindow * GetFrame()

   Gets the frame associated with the view (if any). Note that this
   "frame'' is not a wxFrame at all in the generic MDI implementation
   which uses the notebook pages instead of the frames and this is why
   this method returns a wxWindow and not a wxFrame.

=head2 Wx::View::GetViewName

   wxString GetViewName() const

   Gets the name associated with the view (passed to the wxDocTemplate
   constructor). Not currently used by the framework.

=head2 Wx::View::OnActivateView

   virtual void OnActivateView(bool activate, wxView *activeView, wxView
   *deactiveView)

   Called when a view is activated by means of wxView::Activate. The
   default implementation does nothing.

=head2 Wx::View::OnChangeFilename

   virtual void OnChangeFilename()

   Called when the filename has changed. The default implementation
   constructs a suitable title and sets the title of the view frame (if
   any).

=head2 Wx::View::OnClose

   virtual bool OnClose(bool deleteWindow)

   Implements closing behaviour. The default implementation calls
   wxDocument::Close to close the associated document. Does not delete
   the view. The application may wish to do some cleaning up operations
   in this function, if a call to wxDocument::Close succeeded. For
   example, if your views all share the same window, you need to
   disassociate the window from the view and perhaps clear the window. If
   deleteWindow is true, delete the frame associated with the view.

=head2 Wx::View::OnClosingDocument

   virtual void OnClosingDoocument()

   Override this to clean up the view when the document is being closed.

=head2 Wx::View::OnCreate

   virtual bool OnCreate(wxDocument* doc, long flags)

   wxDocManager or wxDocument creates a wxView via a wxDocTemplate. Just
   after the wxDocTemplate creates the wxView, it calls wxView::OnCreate.
   In its OnCreate member function, the wxView can create a
   wxDocChildFrame or a derived class. This wxDocChildFrame provides user
   interface elements to view and/or edit the contents of the wxDocument.

   By default, simply returns true. If the function returns false, the
   view will be deleted.

=head2 Wx::View::OnCreatePrintout

   virtual wxPrintout* OnCreatePrintout()

   If the printing framework is enabled in the library, this function
   returns a wxPrintout object for the purposes of printing. It should
   create a new object every time it is called; the framework will delete
   objects it creates.

   By default, this function returns an instance of wxDocPrintout, which
   prints and previews one page by calling wxView::OnDraw.

   Override to return an instance of a class other than wxDocPrintout.

=head2 Wx::View::OnDraw

   virtual void OnDraw(wxDC* dc)

   Override this function to render the view on the given device context.

=head2 Wx::View::OnUpdate

   virtual void OnUpdate(wxView* sender, wxObject* hint)

   Called when the view should be updated. sender is a pointer to the
   view that sent the update request, or NULL if no single view requested
   the update (for instance, when the document is opened). hint is as yet
   unused but may in future contain application-specific information for
   making updating more efficient.

=head2 Wx::View::SetDocument

   void SetDocument(wxDocument* doc)

   Associates the given document with the view. Normally called by the
   framework.

=head2 Wx::View::SetFrame

   void SetFrame(wxWindow* frame)

   Sets the frame associated with this view. The application should call
   this if possible, to tell the view about the frame.

   See GetFrame for the explanation about the mismatch between the
   "Frame'' in the method name and the type of its parameter.

=head2 Wx::View::SetViewName

   void SetViewName(const wxString& name)

   Sets the view type name. Should only be called by the framework.

=head1 Wx::VListBox

=head2 Wx::VListBox::new

   wxVListBox(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint&
   pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long
   style = 0, const wxString& name = wxVListBoxNameStr)

   Normal constructor which calls Create() internally.

   wxVListBox()

   Default constructor, you must call Create() later.

=head2 Wx::VListBox::Clear

   void Clear()

   Deletes all items from the control.

=head2 Wx::VListBox::Create

   bool Create(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint&
   pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long
   style = 0, const wxString& name = wxVListBoxNameStr)

   Creates the control. To finish creating it you also should call
   SetItemCount() to let it know about the number of items it contains.

   The only special style which may be used with wxVListBox is
   wxLB_MULTIPLE which indicates that the listbox should support multiple
   selection.

   Returns true on success or false if the control couldn't be created

=head2 Wx::VListBox::DeselectAll

   bool DeselectAll()

   Deselects all the items in the listbox.

   Returns true if any items were changed, i.e. if there had been any
   selected items before, or false if all the items were already
   deselected.

   This method is only valid for multi selection listboxes.

   See also

   SelectAll, Select

=head2 Wx::VListBox::GetFirstSelected

   int GetFirstSelected(unsigned long& cookie) const

   Returns the index of the first selected item in the listbox or
   wxNOT_FOUND if no items are currently selected.

   cookie is an opaque parameter which should be passed to the subsequent
   calls to GetNextSelected. It is needed in order to allow parallel
   iterations over the selected items.

   Here is a typical example of using these functions:

   unsigned long cookie;
   int item = hlbox->GetFirstSelected(cookie);
   while ( item != wxNOT_FOUND )
   {
       ... process item ...
       item = hlbox->GetNextSelected(cookie);
   }

   This method is only valid for multi selection listboxes.

=head2 Wx::VListBox::GetItemCount

   size_t GetItemCount() const

   Get the number of items in the control.

   See also

   SetItemCount()

=head2 Wx::VListBox::GetMargins

   wxPoint GetMargins() const

   Returns the margins used by the control. The x field of the returned
   point is the horizontal margin and the y field is the vertical one.

   See also

   SetMargins

=head2 Wx::VListBox::GetNextSelected

   int GetNextSelected(unsigned long& cookie) const

   Returns the index of the next selected item or wxNOT_FOUND if there
   are no more.

   This method is only valid for multi selection listboxes.

   See also

   GetFirstSelected

=head2 Wx::VListBox::GetSelectedCount

   size_t GetSelectedCount() const

   Returns the number of the items currently selected.

   It is valid for both single and multi selection controls. In the
   former case it may only return 0 or 1 however.

   See also

   IsSelected,

=head2 Wx::VListBox::GetSelection

   int GetSelection() const

   Get the currently selected item or wxNOT_FOUND if there is no
   selection.

=head2 Wx::VListBox::GetSelectionBackground

   const wxColour& GetSelectionBackground() const

   Returns the background colour used for the selected cells. By default
   the standard system colour is used.

   See also

   wxSystemSettings::GetColour,

=head2 Wx::VListBox::HasMultipleSelection

   bool HasMultipleSelection() const

   Returns true if the listbox was created with wxLB_MULTIPLE style and
   so supports multiple selection or false if it is a single selection
   listbox.

=head2 Wx::VListBox::IsCurrent

   bool IsCurrent(size_t item) const

   Returns true if this item is the current one, false otherwise.

   Current item is always the same as selected one for the single
   selection listbox and in this case this method is equivalent to
   IsSelected but they are different for multi selection listboxes where
   many items may be selected but only one (at most) is current.

=head2 Wx::VListBox::IsSelected

   bool IsSelected(size_t item) const

   Returns true if this item is selected, false otherwise.

=head2 Wx::VListBox::OnDrawBackground

   void OnDrawBackground(wxDC& dc, const wxRect& rect, size_t n) const

   This method is used to draw the items background and, maybe, a border
   around it.

   The base class version implements a reasonable default behaviour which
   consists in drawing the selected item with the standard background
   colour and drawing a border around the item if it is either selected
   or current.

=head2 Wx::VListBox::OnDrawItem

   void OnDrawItem(wxDC& dc, const wxRect& rect, size_t n) const

   The derived class must implement this function to actually draw the
   item with the given index on the provided DC.

   Parameters

   dc  

       The device context to use for drawing

   rect

       The bounding rectangle for the item being drawn (DC clipping
       region is set to this rectangle before calling this function)

   n   

       The index of the item to be drawn

=head2 Wx::VListBox::OnDrawSeparator

   void OnDrawSeparator(wxDC& dc, wxRect& rect, size_t n) const

   This method may be used to draw separators between the lines. The
   rectangle passed to it may be modified, typically to deflate it a bit
   before passing to OnDrawItem().

   The base class version of this method doesn't do anything.

   Parameters

   dc  

       The device context to use for drawing

   rect

       The bounding rectangle for the item

   n   

       The index of the item

=head2 Wx::VListBox::OnMeasureItem

   wxCoord OnMeasureItem(size_t n) const

   The derived class must implement this method to return the height of
   the specified item (in pixels).

=head2 Wx::VListBox::Select

   bool Select(size_t item, bool select = true)

   Selects or deselects the specified item which must be valid (i.e. not
   equal to wxNOT_FOUND).

   Return true if the items selection status has changed or false
   otherwise.

   This function is only valid for the multiple selection listboxes, use
   SetSelection for the single selection ones.

=head2 Wx::VListBox::SelectAll

   bool SelectAll()

   Selects all the items in the listbox.

   Returns true if any items were changed, i.e. if there had been any
   unselected items before, or false if all the items were already
   selected.

   This method is only valid for multi selection listboxes.

   See also

   DeselectAll, Select

=head2 Wx::VListBox::SelectRange

   bool SelectRange(size_t from, size_t to)

   Selects all items in the specified range which may be given in any
   order.

   Return true if the items selection status has changed or false
   otherwise.

   This method is only valid for multi selection listboxes.

   See also

   SelectAll, Select

=head2 Wx::VListBox::SetItemCount

   void SetItemCount(size_t count)

   Set the number of items to be shown in the control.

   This is just a synonym for wxVScrolledWindow::SetLineCount().

=head2 Wx::VListBox::SetMargins

   void SetMargins(const wxPoint& pt)

   void SetMargins(wxCoord x, wxCoord y)

   Set the margins: horizontal margin is the distance between the window
   border and the item contents while vertical margin is half of the
   distance between items.

   By default both margins are 0.

=head2 Wx::VListBox::SetSelection

   void SetSelection(int selection)

   Set the selection to the specified item, if it is -1 the selection is
   unset. The selected item will be automatically scrolled into view if
   it isn't currently visible.

   This method may be used both with single and multiple selection
   listboxes.

=head2 Wx::VListBox::SetSelectionBackground

   void SetSelectionBackground(const wxColour& col)

   Sets the colour to be used for the selected cells background. The
   background of the standard cells may be changed by simply calling
   SetBackgroundColour.

   See also

   GetSelectionBackground

=head2 Wx::VListBox::Toggle

   void Toggle(size_t item)

   Toggles the state of the specified item, i.e. selects it if it was
   unselected and deselects it if it was selected.

   This method is only valid for multi selection listboxes.

   See also

   Select

=head1 Wx::VScrolledWindow

=head2 Wx::VScrolledWindow::new

   wxVScrolledWindow(wxWindow* parent, wxWindowID id = wxID_ANY, const
   wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
   long style = 0, const wxString& name = wxPanelNameStr)

   This is the normal constructor, no need to call Create() after using
   this one.

   Note that wxVSCROLL is always automatically added to our style, there
   is no need to specify it explicitly.

   wxVScrolledWindow()

   Default constructor, you must call Create() later.

   Parameters

   parent

       The parent window, must not be NULL

   id  

       The identifier of this window, wxID_ANY by default

   pos 

       The initial window position

   size

       The initial window size

   style

       The window style. There are no special style bits defined for this
       class.

   name

       The name for this window; usually not used

=head2 Wx::VScrolledWindow::Create

   bool Create(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint&
   pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long
   style = 0, const wxString& name = wxPanelNameStr)

   Same as the non default ctor but returns status code: true if ok,
   false if the window couldn't have been created.

   Just as with the ctor above, wxVSCROLL style is always used, there is
   no need to specify it explicitly.

=head2 Wx::VScrolledWindow::EstimateTotalHeight

   virtual wxCoord EstimateTotalHeight() const

   This protected function is used internally by wxVScrolledWindow to
   estimate the total height of the window when SetLineCount is called.
   The default implementation uses the brute force approach if the number
   of the items in the control is small enough. Otherwise, it tries to
   find the average line height using some lines in the beginning, middle
   and the end.

   If it is undesirable to access all these lines (some of which might be
   never shown) just for the total height calculation, you may override
   the function and provide your own guess better and/or faster.

   Note that although returning a totally wrong value would still work,
   it risks to result in very strange scrollbar behaviour so this
   function should really try to make the best guess possible.

=head2 Wx::VScrolledWindow::GetFirstVisibleLine

   size_t GetFirstVisibleLine() const

   Returns the index of the first currently visible line.

   This is same as GetVisibleBegin and exists only for symmetry with
   GetLastVisibleLine.

=head2 Wx::VScrolledWindow::GetLastVisibleLine

   size_t GetLastVisibleLine() const

   Returns the index of the last currently visible line. Note that this
   method returns (size_t)-1 (i.e. a huge positive number) if the control
   is empty so if this is possible you should use GetVisibleEnd instead.

   See also

   GetFirstVisibleLine

=head2 Wx::VScrolledWindow::GetLineCount

   size_t GetLineCount() const

   Get the number of lines this window contains (previously set by
   SetLineCount())

=head2 Wx::VScrolledWindow::GetVisibleBegin

   size_t GetVisibleBegin() const

   Returns the index of the first currently visible line.

   See also

   GetVisibleEnd

=head2 Wx::VScrolledWindow::GetVisibleEnd

   size_t GetVisibleEnd() const

   Returns the index of the first line after the currently visible one.
   If the return value is 0 it means that no lines are currently shown
   (which only happens if the control is empty). Note that the index
   returned by this method is not always a valid index as it may be equal
   to GetLineCount.

   See also

   GetVisibleBegin

=head2 Wx::VScrolledWindow::HitTest

   int HitTest(wxCoord x, wxCoord y) const

   int HitTest(const wxPoint& pt) const

   Return the item at the specified (in physical coordinates) position or
   wxNOT_FOUND if none, i.e. if it is below the last item.

=head2 Wx::VScrolledWindow::IsVisible

   bool IsVisible(size_t line) const

   Returns true if the given line is (at least partially) visible or
   false otherwise.

=head2 Wx::VScrolledWindow::OnGetLineHeight

   virtual wxCoord OnGetLineHeight(size_t n) const

   This protected virtual function must be overridden in the derived
   class and it should return the height of the given line in pixels.

   See also

   OnGetLinesHint

=head2 Wx::VScrolledWindow::OnGetLinesHint

   virtual void OnGetLinesHint(size_t lineMin, size_t lineMax) const

   This function doesn't have to be overridden but it may be useful to do
   it if calculating the lines heights is a relatively expensive
   operation as it gives the user code a possibility to calculate several
   of them at once.

   OnGetLinesHint() is normally called just before OnGetLineHeight() but
   you shouldn't rely on the latter being called for all lines in the
   interval specified here. It is also possible that OnGetLineHeight()
   will be called for the lines outside of this interval, so this is
   really just a hint, not a promise.

   Finally note that lineMin is inclusive, while lineMax is exclusive, as
   usual.

=head2 Wx::VScrolledWindow::RefreshLine

   void RefreshLine(size_t line)

   Refreshes the specified line -- it will be redrawn during the next
   main loop iteration.

   See also

   RefreshLines

=head2 Wx::VScrolledWindow::RefreshLines

   void RefreshLines(size_t from, size_t to)

   Refreshes all lines between from and to, inclusive. from should be
   less than or equal to to.

   See also

   RefreshLine

=head2 Wx::VScrolledWindow::RefreshAll

   void RefreshAll()

   This function completely refreshes the control, recalculating the
   number of items shown on screen and repainting them. It should be
   called when the values returned by OnGetLineHeight change for some
   reason and the window must be updated to reflect this.

=head2 Wx::VScrolledWindow::ScrollLines

   bool ScrollLines(int lines)

   Scroll by the specified number of lines which may be positive (to
   scroll down) or negative (to scroll up).

   Returns true if the window was scrolled, false otherwise (for example
   if we're trying to scroll down but we are already showing the last
   line).

   See also

   LineUp, LineDown

=head2 Wx::VScrolledWindow::ScrollPages

   bool ScrollPages(int pages)

   Scroll by the specified number of pages which may be positive (to
   scroll down) or negative (to scroll up).

   See also

   ScrollLines,

=head2 Wx::VScrolledWindow::ScrollToLine

   bool ScrollToLine(size_t line)

   Scroll to the specified line: it will become the first visible line in
   the window.

   Return true if we scrolled the window, false if nothing was done.

=head2 Wx::VScrolledWindow::SetLineCount

   void SetLineCount(size_t count)

   Set the number of lines the window contains: the derived class must
   provide the heights for all lines with indices up to the one given
   here in its OnGetLineHeight().

=head1 Wx::Window

=head2 Wx::Window::new

   wxWindow()

   Default constructor.

   wxWindow(wxWindow* parent, wxWindowID id, const wxPoint& pos =
   wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0,
   const wxString& name = wxPanelNameStr)

   Constructs a window, which can be a child of a frame, dialog or any
   other non-control window.

   Parameters

   parent

       Pointer to a parent window.

   id  

       Window identifier. If wxID_ANY, will automatically create an
       identifier.

   pos 

       Window position. wxDefaultPosition indicates that wxWidgets should
       generate a default position for the window. If using the wxWindow
       class directly, supply an actual position.

   size

       Window size. wxDefaultSize indicates that wxWidgets should
       generate a default size for the window. If no suitable size can be
       found, the window will be sized to 20x20 pixels so that the window
       is visible but obviously not correctly sized.

   style

       Window style. For generic window styles, please see wxWindow.

   name

       Window name.

=head2 Wx::Window::DESTROY

   ~wxWindow()

   Destructor. Deletes all subwindows, then deletes itself. Instead of
   using the delete operator explicitly, you should normally use
   wxWindow::Destroy so that wxWidgets can delete a window only when it
   is safe to do so, in idle time.

   See also

   Window deletion overview, wxWindow::Destroy, wxCloseEvent

=head2 Wx::Window::AddChild

   virtual void AddChild(wxWindow* child)

   Adds a child window. This is called automatically by window creation
   functions so should not be required by the application programmer.

   Notice that this function is mostly internal to wxWidgets and
   shouldn't be called by the user code.

   Parameters

   child

       Child window to add.

=head2 Wx::Window::CacheBestSize

   void CacheBestSize(const wxSize& size) const

   Sets the cached best size value.

=head2 Wx::Window::CaptureMouse

   virtual void CaptureMouse()

   Directs all mouse input to this window. Call wxWindow::ReleaseMouse to
   release the capture.

   Note that wxWidgets maintains the stack of windows having captured the
   mouse and when the mouse is released the capture returns to the window
   which had had captured it previously and it is only really released if
   there were no previous window. In particular, this means that you must
   release the mouse as many times as you capture it, unless the window
   receives the wxMouseCaptureLostEvent event.

   Any application which captures the mouse in the beginning of some
   operation must handle wxMouseCaptureLostEvent and cancel this
   operation when it receives the event. The event handler must not
   recapture mouse.

   See also

   wxWindow::ReleaseMouse wxMouseCaptureLostEvent

=head2 Wx::Window::Center

   void Center(int direction)

   A synonym for Centre.

=head2 Wx::Window::CenterOnParent

   void CenterOnParent(int direction)

   A synonym for CentreOnParent.

=head2 Wx::Window::CenterOnScreen

   void CenterOnScreen(int direction)

   A synonym for CentreOnScreen.

=head2 Wx::Window::Centre

   void Centre(int direction = wxBOTH)

   Centres the window.

   Parameters

   direction

       Specifies the direction for the centering. May be wxHORIZONTAL,
       wxVERTICAL or wxBOTH. It may also include wxCENTRE_ON_SCREEN flag
       if you want to center the window on the entire screen and not on
       its parent window.

   The flag wxCENTRE_FRAME is obsolete and should not be used any longer
   (it has no effect).

   Remarks

   If the window is a top level one (i.e. doesn't have a parent), it will
   be centered relative to the screen anyhow.

   See also

   wxWindow::Center

=head2 Wx::Window::CentreOnParent

   void CentreOnParent(int direction = wxBOTH)

   Centres the window on its parent. This is a more readable synonym for
   Centre.

   Parameters

   direction

       Specifies the direction for the centering. May be wxHORIZONTAL,
       wxVERTICAL or wxBOTH.

   Remarks

   This methods provides for a way to center top level windows over their
   parents instead of the entire screen. If there is no parent or if the
   window is not a top level window, then behaviour is the same as
   wxWindow::Centre.

   See also

   wxWindow::CentreOnScreen

=head2 Wx::Window::CentreOnScreen

   void CentreOnScreen(int direction = wxBOTH)

   Centres the window on screen. This only works for top level windows -
   otherwise, the window will still be centered on its parent.

   Parameters

   direction

       Specifies the direction for the centering. May be wxHORIZONTAL,
       wxVERTICAL or wxBOTH.

   See also

   wxWindow::CentreOnParent

=head2 Wx::Window::ClearBackground

   void ClearBackground()

   Clears the window by filling it with the current background colour.
   Does not cause an erase background event to be generated.

=head2 Wx::Window::ClientToScreen

   virtual void ClientToScreen(int* x, int* y) const

   wxPerl note: In wxPerl this method returns a 2-element list instead of
   modifying its parameters.

   virtual wxPoint ClientToScreen(const wxPoint& pt) const

   Converts to screen coordinates from coordinates relative to this
   window.

   x   

       A pointer to a integer value for the x coordinate. Pass the client
       coordinate in, and a screen coordinate will be passed out.

   y   

       A pointer to a integer value for the y coordinate. Pass the client
       coordinate in, and a screen coordinate will be passed out.

   pt  

       The client position for the second form of the function.

   wxPython note: In place of a single overloaded method name, wxPython
   implements the following methods:

=head2 Wx::Window::ClientToWindowSize

   wxSize ClientToWindowSize(const wxSize& size)

   Converts client area size size to corresponding window size. In other
   words, the returned value is what would GetSize return if this window
   had client area of given size. Components with wxDefaultCoord value
   are left unchanged.

   Note that the conversion is not always exact, it assumes that
   non-client area doesn't change and so doesn't take into account things
   like menu bar (un)wrapping or (dis)appearance of the scrollbars.

   This function is new since wxWidgets version 2.8.8

   See also

   wxWindow::WindowToClientSize

=head2 Wx::Window::Close

   bool Close(bool force = false)

   This function simply generates a wxCloseEvent whose handler usually
   tries to close the window. It doesn't close the window itself,
   however.

   Parameters

   force

       false if the window's close handler should be able to veto the
       destruction of this window, true if it cannot.

   Remarks

   Close calls the close handler for the window, providing an opportunity
   for the window to choose whether to destroy the window. Usually it is
   only used with the top level windows (wxFrame and wxDialog classes) as
   the others are not supposed to have any special OnClose() logic.

   The close handler should check whether the window is being deleted
   forcibly, using wxCloseEvent::CanVeto, in which case it should destroy
   the window using wxWindow::Destroy.

   Note that calling Close does not guarantee that the window will be
   destroyed; but it provides a way to simulate a manual close of a
   window, which may or may not be implemented by destroying the window.
   The default implementation of wxDialog::OnCloseWindow does not
   necessarily delete the dialog, since it will simply simulate an
   wxID_CANCEL event which is handled by the appropriate button event
   handler and may do anything at all.

   To guarantee that the window will be destroyed, call wxWindow::Destroy
   instead

   See also

   Window deletion overview, wxWindow::Destroy, wxCloseEvent

=head2 Wx::Window::ConvertDialogToPixels

   wxPoint ConvertDialogToPixels(const wxPoint& pt)

   wxSize ConvertDialogToPixels(const wxSize& sz)

   Converts a point or size from dialog units to pixels.

   For the x dimension, the dialog units are multiplied by the average
   character width and then divided by 4.

   For the y dimension, the dialog units are multiplied by the average
   character height and then divided by 8.

   Remarks

   Dialog units are used for maintaining a dialog's proportions even if
   the font changes.

   You can also use these functions programmatically. A convenience macro
   is defined:

   #define wxDLG_UNIT(parent, pt) parent->ConvertDialogToPixels(pt)

   See also

   wxWindow::ConvertPixelsToDialog

   wxPython note: In place of a single overloaded method name, wxPython
   implements the following methods:

=head2 Wx::Window::ConvertPixelsToDialog

   wxPoint ConvertPixelsToDialog(const wxPoint& pt)

   wxSize ConvertPixelsToDialog(const wxSize& sz)

   Converts a point or size from pixels to dialog units.

   For the x dimension, the pixels are multiplied by 4 and then divided
   by the average character width.

   For the y dimension, the pixels are multiplied by 8 and then divided
   by the average character height.

   Remarks

   Dialog units are used for maintaining a dialog's proportions even if
   the font changes.

   See also

   wxWindow::ConvertDialogToPixels

   wxPython note: In place of a single overloaded method name, wxPython
   implements the following methods:

=head2 Wx::Window::Destroy

   virtual bool Destroy()

   Destroys the window safely. Use this function instead of the delete
   operator, since different window classes can be destroyed differently.
   Frames and dialogs are not destroyed immediately when this function is
   called -- they are added to a list of windows to be deleted on idle
   time, when all the window's events have been processed. This prevents
   problems with events being sent to non-existent windows.

   Return value

   true if the window has either been successfully deleted, or it has
   been added to the list of windows pending real deletion.

=head2 Wx::Window::DestroyChildren

   virtual void DestroyChildren()

   Destroys all children of a window. Called automatically by the
   destructor.

=head2 Wx::Window::Disable

   bool Disable()

   Disables the window, same as Enable(false).

   Return value

   Returns true if the window has been disabled, false if it had been
   already disabled before the call to this function.

=head2 Wx::Window::DoGetBestSize

   virtual wxSize DoGetBestSize() const

   Gets the size which best suits the window: for a control, it would be
   the minimal size which doesn't truncate the control, for a panel - the
   same size as it would have after a call to Fit().

=head2 Wx::Window::DoUpdateWindowUI

   virtual void DoUpdateWindowUI(wxUpdateUIEvent& event)

   Does the window-specific updating after processing the update event.
   This function is called by wxWindow::UpdateWindowUI in order to check
   return values in the wxUpdateUIEvent and act appropriately. For
   example, to allow frame and dialog title updating, wxWidgets
   implements this function as follows:

   // do the window-specific processing after processing the update event
   void wxTopLevelWindowBase::DoUpdateWindowUI(wxUpdateUIEvent& event)
   {
       if ( event.GetSetEnabled() )
           Enable(event.GetEnabled());

=head2 Wx::Window::DragAcceptFiles

   virtual void DragAcceptFiles(bool accept)

   Enables or disables eligibility for drop file events (OnDropFiles).

   Parameters

   accept

       If true, the window is eligible for drop file events. If false,
       the window will not accept drop file events.

   Remarks

   Windows only until version 2.8.9, available on all platforms since
   2.8.10. Cannot be used together with SetDropTarget on non-Windows
   platforms.

=head2 Wx::Window::Enable

   virtual bool Enable(bool enable = true)

   Enable or disable the window for user input. Note that when a parent
   window is disabled, all of its children are disabled as well and they
   are reenabled again when the parent is.

   Parameters

   enable

       If true, enables the window for input. If false, disables the
       window.

   Return value

   Returns true if the window has been enabled or disabled, false if
   nothing was done, i.e. if the window had already been in the specified
   state.

   See also

   wxWindow::IsEnabled, wxWindow::Disable, wxRadioBox::Enable

=head2 Wx::Window::FindFocus

   static wxWindow* FindFocus()

   Finds the window or control which currently has the keyboard focus.

   Remarks

   Note that this is a static function, so it can be called without
   needing a wxWindow pointer.

   See also

   wxWindow::SetFocus

=head2 Wx::Window::FindWindow

   wxWindow* FindWindow(long id) const

   Find a child of this window, by identifier.

   wxWindow* FindWindow(const wxString& name) const

   Find a child of this window, by name.

   wxPython note: In place of a single overloaded method name, wxPython
   implements the following methods:

=head2 Wx::Window::FindWindowById

   static wxWindow* FindWindowById(long id, wxWindow* parent = NULL)

   Find the first window with the given id.

   If parent is NULL, the search will start from all top-level frames and
   dialog boxes; if non-NULL, the search will be limited to the given
   window hierarchy. The search is recursive in both cases.

   See also

   FindWindow

=head2 Wx::Window::FindWindowByLabel

   static wxWindow* FindWindowByLabel(const wxString& label, wxWindow*
   parent = NULL)

   Find a window by its label. Depending on the type of window, the label
   may be a window title or panel item label. If parent is NULL, the
   search will start from all top-level frames and dialog boxes; if
   non-NULL, the search will be limited to the given window hierarchy.
   The search is recursive in both cases.

   See also

   FindWindow

=head2 Wx::Window::FindWindowByName

   static wxWindow* FindWindowByName(const wxString& name, wxWindow*
   parent = NULL)

   Find a window by its name (as given in a window constructor or Create
   function call). If parent is NULL, the search will start from all
   top-level frames and dialog boxes; if non-NULL, the search will be
   limited to the given window hierarchy. The search is recursive in both
   cases.

   If no window with such name is found, FindWindowByLabel is called.

   See also

   FindWindow

=head2 Wx::Window::Fit

   virtual void Fit()

   Sizes the window so that it fits around its subwindows. This function
   won't do anything if there are no subwindows and will only really work
   correctly if the sizers are used for the subwindows layout. Also, if
   the window has exactly one subwindow it is better (faster and the
   result is more precise as Fit adds some margin to account for
   fuzziness of its calculations) to call

       window->SetClientSize(child->GetSize());

   instead of calling Fit.

=head2 Wx::Window::FitInside

   virtual void FitInside()

   Similar to Fit, but sizes the interior (virtual) size of a window.
   Mainly useful with scrolled windows to reset scrollbars after sizing
   changes that do not trigger a size event, and/or scrolled windows
   without an interior sizer. This function similarly won't do anything
   if there are no subwindows.

=head2 Wx::Window::Freeze

   virtual void Freeze()

   Freezes the window or, in other words, prevents any updates from
   taking place on screen, the window is not redrawn at all. Thaw must be
   called to reenable window redrawing. Calls to these two functions may
   be nested.

   This method is useful for visual appearance optimization (for example,
   it is a good idea to use it before doing many large text insertions in
   a row into a wxTextCtrl under wxGTK) but is not implemented on all
   platforms nor for all controls so it is mostly just a hint to
   wxWidgets and not a mandatory directive.

   See also

   wxWindowUpdateLocker

=head2 Wx::Window::GetAcceleratorTable

   wxAcceleratorTable* GetAcceleratorTable() const

   Gets the accelerator table for this window. See wxAcceleratorTable.

=head2 Wx::Window::GetAccessible

   wxAccessible* GetAccessible()

   Returns the accessible object for this window, if any.

   See also wxAccessible.

=head2 Wx::Window::GetAdjustedBestSize

   wxSize GetAdjustedBestSize() const

   This method is deprecated, use GetEffectiveMinSize instead.

=head2 Wx::Window::GetBackgroundColour

   virtual wxColour GetBackgroundColour() const

   Returns the background colour of the window.

   See also

   wxWindow::SetBackgroundColour, wxWindow::SetForegroundColour,
   wxWindow::GetForegroundColour

=head2 Wx::Window::GetBackgroundStyle

   virtual wxBackgroundStyle GetBackgroundStyle() const

   Returns the background style of the window. The background style
   indicates whether background colour should be determined by the system
   (wxBG_STYLE_SYSTEM), be set to a specific colour (wxBG_STYLE_COLOUR),
   or should be left to the application to implement (wxBG_STYLE_CUSTOM).

   On GTK+, use of wxBG_STYLE_CUSTOM allows the flicker-free drawing of a
   custom background, such as a tiled bitmap. Currently the style has no
   effect on other platforms.

   See also

   wxWindow::SetBackgroundColour, wxWindow::GetForegroundColour,
   wxWindow::SetBackgroundStyle

=head2 Wx::Window::GetEffectiveMinSize

   wxSize GetEffectiveMinSize() const

   Merges the window's best size into the min size and returns the
   result. This is the value used by sizers to determine the appropriate
   ammount of sapce to allocate for the widget.

   See also

   wxWindow::GetBestSize, wxWindow::SetInitialSize

=head2 Wx::Window::GetBestSize

   wxSize GetBestSize() const

   This functions returns the best acceptable minimal size for the
   window. For example, for a static control, it will be the minimal size
   such that the control label is not truncated. For windows containing
   subwindows (typically wxPanel), the size returned by this function
   will be the same as the size the window would have had after calling
   Fit.

=head2 Wx::Window::GetCapture

   static wxWindow * GetCapture()

   Returns the currently captured window.

   See also

   wxWindow::HasCapture, wxWindow::CaptureMouse, wxWindow::ReleaseMouse,
   wxMouseCaptureLostEvent wxMouseCaptureChangedEvent

=head2 Wx::Window::GetCaret

   wxCaret * GetCaret() const

   Returns the caret associated with the window.

=head2 Wx::Window::GetCharHeight

   virtual int GetCharHeight() const

   Returns the character height for this window.

=head2 Wx::Window::GetCharWidth

   virtual int GetCharWidth() const

   Returns the average character width for this window.

=head2 Wx::Window::GetChildren

   wxWindowList& GetChildren()

   const wxWindowList& GetChildren() const

   Returns a reference to the list of the window's children. wxWindowList
   is a type-safe wxList-like class whose elements are of type wxWindow *.

=head2 Wx::Window::GetClassDefaultAttributes

   static wxVisualAttributes GetClassDefaultAttributes(wxWindowVariant
   variant = wxWINDOW_VARIANT_NORMAL)

   Returns the default font and colours which are used by the control.
   This is useful if you want to use the same font or colour in your own
   control as in a standard control -- which is a much better idea than
   hard coding specific colours or fonts which might look completely out
   of place on the users system, especially if it uses themes.

   The variant parameter is only relevant under Mac currently and is
   ignore under other platforms. Under Mac, it will change the size of
   the returned font. See wxWindow::SetWindowVariant for more about this.

   This static method is "overridden'' in many derived classes and so
   calling, for example, wxButton::GetClassDefaultAttributes() will
   typically return the values appropriate for a button which will be
   normally different from those returned by, say, wxListCtrl::GetClassDefaultAttributes().

   The wxVisualAttributes structure has at least the fields font, colFg
   and colBg. All of them may be invalid if it was not possible to
   determine the default control appearance or, especially for the
   background colour, if the field doesn't make sense as is the case for
   colBg for the controls with themed background.

   See also

   InheritAttributes

=head2 Wx::Window::GetClientSize

   void GetClientSize(int* width, int* height) const

   wxPerl note: In wxPerl this method takes no parameter and returns a
   2-element list (width, height).

   wxSize GetClientSize() const

   This gets the size of the window 'client area' in pixels. The client
   area is the area which may be drawn on by the programmer, excluding
   title bar, border, scrollbars, etc.

   Parameters

   width

       Receives the client width in pixels.

   height

       Receives the client height in pixels.

   wxPython note: In place of a single overloaded method name, wxPython
   implements the following methods:

=head2 Wx::Window::GetConstraints

   wxLayoutConstraints* GetConstraints() const

   Returns a pointer to the window's layout constraints, or NULL if there
   are none.

=head2 Wx::Window::GetContainingSizer

   const wxSizer * GetContainingSizer() const

   Return the sizer that this window is a member of, if any, otherwise
   NULL.

=head2 Wx::Window::GetCursor

   const wxCursor& GetCursor() const

   Return the cursor associated with this window.

   See also

   wxWindow::SetCursor

=head2 Wx::Window::GetDefaultAttributes

   virtual wxVisualAttributes GetDefaultAttributes() const

   Currently this is the same as calling GetClassDefaultAttributes(GetWindowVariant()).

   One advantage of using this function compared to the static version is
   that the call is automatically dispatched to the correct class (as
   usual with virtual functions) and you don't have to specify the class
   name explicitly.

   The other one is that in the future this function could return
   different results, for example it might return a different font for an
   "Ok'' button than for a generic button if the users GUI is configured
   to show such buttons in bold font. Of course, the down side is that it
   is impossible to call this function without actually having an object
   to apply it to whereas the static version can be used without having
   to create an object first.

=head2 Wx::Window::GetDropTarget

   wxDropTarget* GetDropTarget() const

   Returns the associated drop target, which may be NULL.

   See also

   wxWindow::SetDropTarget, Drag and drop overview

=head2 Wx::Window::GetEventHandler

   wxEvtHandler* GetEventHandler() const

   Returns the event handler for this window. By default, the window is
   its own event handler.

   See also

   wxWindow::SetEventHandler, wxWindow::PushEventHandler,
   wxWindow::PopEventHandler, wxEvtHandler::ProcessEvent, wxEvtHandler

=head2 Wx::Window::GetExtraStyle

   long GetExtraStyle() const

   Returns the extra style bits for the window.

=head2 Wx::Window::GetFont

   wxFont GetFont() const

   Returns the font for this window.

   See also

   wxWindow::SetFont

=head2 Wx::Window::GetForegroundColour

   virtual wxColour GetForegroundColour()

   Returns the foreground colour of the window.

   Remarks

   The interpretation of foreground colour is open to interpretation
   according to the window class; it may be the text colour or other
   colour, or it may not be used at all.

   See also

   wxWindow::SetForegroundColour, wxWindow::SetBackgroundColour,
   wxWindow::GetBackgroundColour

=head2 Wx::Window::GetGrandParent

   wxWindow* GetGrandParent() const

   Returns the grandparent of a window, or NULL if there isn't one.

=head2 Wx::Window::GetHandle

   void* GetHandle() const

   Returns the platform-specific handle of the physical window. Cast it
   to an appropriate handle, such as HWND for Windows, Widget for Motif,
   GtkWidget for GTK or WinHandle for PalmOS.

   wxPython note: This method will return an integer in wxPython.

   wxPerl note: This method will return an integer in wxPerl.

=head2 Wx::Window::GetHelpTextAtPoint

   virtual wxString GetHelpTextAtPoint(const wxPointpoint,
   wxHelpEvent::Origin origin) const

   Gets the help text to be used as context-sensitive help for this
   window. This method should be overridden if the help message depends
   on the position inside the window, otherwise GetHelpText can be used.

   Parameters

   point

       Coordinates of the mouse at the moment of help event emission.

   origin

       Help event origin, see also wxHelpEvent::GetOrigin.

   This function is new since wxWidgets version 2.7.0

=head2 Wx::Window::GetHelpText

   virtual wxString GetHelpText() const

   Gets the help text to be used as context-sensitive help for this
   window.

   Note that the text is actually stored by the current wxHelpProvider
   implementation, and not in the window object itself.

   See also

   SetHelpText, GetHelpTextAtPoint, wxHelpProvider

=head2 Wx::Window::GetId

   int GetId() const

   Returns the identifier of the window.

   Remarks

   Each window has an integer identifier. If the application has not
   provided one (or the default wxID_ANY) an unique identifier with a
   negative value will be generated.

   See also

   wxWindow::SetId, Window identifiers

=head2 Wx::Window::GetLabel

   virtual wxString GetLabel() const

   Generic way of getting a label from any window, for identification
   purposes.

   Remarks

   The interpretation of this function differs from class to class. For
   frames and dialogs, the value returned is the title. For buttons or
   static text controls, it is the button text. This function can be
   useful for meta-programs (such as testing tools or special-needs
   access programs) which need to identify windows by name.

=head2 Wx::Window::GetMaxSize

   wxSize GetMaxSize() const

   Returns the maximum size of the window, an indication to the sizer
   layout mechanism that this is the maximum possible size.

=head2 Wx::Window::GetMinSize

   virtual wxSize GetMinSize() const

   Returns the minimum size of the window, an indication to the sizer
   layout mechanism that this is the minimum required size. It normally
   just returns the value set by SetMinSize, but it can be overridden to
   do the calculation on demand.

=head2 Wx::Window::GetName

   virtual wxString GetName() const

   Returns the window's name.

   Remarks

   This name is not guaranteed to be unique; it is up to the programmer
   to supply an appropriate name in the window constructor or via
   wxWindow::SetName.

   See also

   wxWindow::SetName

=head2 Wx::Window::GetNextSibling

   wxWindow * GetNextSibling() const

   Returns the next window after this one among the parent children or
   NULL if this window is the last child.

   This function is new since wxWidgets version 2.8.8

   See also

   GetPrevSibling

=head2 Wx::Window::GetParent

   virtual wxWindow* GetParent() const

   Returns the parent of the window, or NULL if there is no parent.

=head2 Wx::Window::GetPosition

   virtual void GetPosition(int* x, int* y) const

   wxPoint GetPosition() const

   This gets the position of the window in pixels, relative to the parent
   window for the child windows or relative to the display origin for the
   top level windows.

   Parameters

   x   

       Receives the x position of the window if non-NULL.

   y   

       Receives the y position of the window if non-NULL.

   wxPython note: In place of a single overloaded method name, wxPython
   implements the following methods:

=head2 Wx::Window::GetPrevSibling

   wxWindow * GetPrevSibling() const

   Returns the previous window before this one among the parent children
   or NULL if this window is the first child.

   This function is new since wxWidgets version 2.8.8

   See also

   GetNextSibling

=head2 Wx::Window::GetRect

   virtual wxRect GetRect() const

   Returns the size and position of the window as a wxRect object.

   See also

   GetScreenRect

=head2 Wx::Window::GetScreenPosition

   virtual void GetScreenPosition(int* x, int* y) const

   wxPoint GetScreenPosition() const

   Returns the window position in screen coordinates, whether the window
   is a child window or a top level one.

   Parameters

   x   

       Receives the x position of the window on the screen if non-NULL.

   y   

       Receives the y position of the window on the screen if non-NULL.

   See also

   GetPosition

=head2 Wx::Window::GetScreenRect

   virtual wxRect GetScreenRect() const

   Returns the size and position of the window on the screen as a wxRect
   object.

   See also

   GetRect

=head2 Wx::Window::GetScrollPos

   virtual int GetScrollPos(int orientation)

   Returns the built-in scrollbar position.

   See also

   See wxWindow::SetScrollbar

=head2 Wx::Window::GetScrollRange

   virtual int GetScrollRange(int orientation)

   Returns the built-in scrollbar range.

   See also

   wxWindow::SetScrollbar

=head2 Wx::Window::GetScrollThumb

   virtual int GetScrollThumb(int orientation)

   Returns the built-in scrollbar thumb size.

   See also

   wxWindow::SetScrollbar

=head2 Wx::Window::GetSize

   void GetSize(int* width, int* height) const

   wxSize GetSize() const

   This gets the size of the entire window in pixels, including title
   bar, border, scrollbars, etc.

   Parameters

   width

       Receives the window width.

   height

       Receives the window height.

   wxPython note: In place of a single overloaded method name, wxPython
   implements the following methods:

=head2 Wx::Window::GetSizer

   wxSizer * GetSizer() const

   Return the sizer associated with the window by a previous call to
   SetSizer() or NULL.

=head2 Wx::Window::GetTextExtent

   virtual void GetTextExtent(const wxString& string, int* x, int* y,
   int* descent = NULL, int* externalLeading = NULL, const wxFont* font =
   NULL, bool use16 = false) const

   Gets the dimensions of the string as it would be drawn on the window
   with the currently selected font.

   Parameters

   string

       String whose extent is to be measured.

   x   

       Return value for width.

   y   

       Return value for height.

   descent

       Return value for descent (optional).

   externalLeading

       Return value for external leading (optional).

   font

       Font to use instead of the current window font (optional).

   use16

       If true, string contains 16-bit characters. The default is false.

   wxPython note: In place of a single overloaded method name, wxPython
   implements the following methods:

=head2 Wx::Window::GetToolTip

   wxToolTip* GetToolTip() const

   Get the associated tooltip or NULL if none.

=head2 Wx::Window::GetUpdateRegion

   virtual wxRegion GetUpdateRegion() const

   Returns the region specifying which parts of the window have been
   damaged. Should only be called within an wxPaintEvent handler.

   See also

   wxRegion, wxRegionIterator

=head2 Wx::Window::GetValidator

   wxValidator* GetValidator() const

   Returns a pointer to the current validator for the window, or NULL if
   there is none.

=head2 Wx::Window::GetVirtualSize

   void GetVirtualSize(int* width, int* height) const

   wxSize GetVirtualSize() const

   This gets the virtual size of the window in pixels. By default it
   returns the client size of the window, but after a call to
   SetVirtualSize it will return that size.

   Parameters

   width

       Receives the window virtual width.

   height

       Receives the window virtual height.

   GetSize, GetClientSize

=head2 Wx::Window::GetWindowBorderSize

   wxSize GetWindowBorderSize() const

   Returns the size of the left/right and top/bottom borders of this
   window in x and y components of the result respectively.

=head2 Wx::Window::GetWindowStyleFlag

   long GetWindowStyleFlag() const

   Gets the window style that was passed to the constructor or Create
   method. GetWindowStyle() is another name for the same function.

=head2 Wx::Window::GetWindowVariant

   wxWindowVariant GetWindowVariant() const

   Returns the value previously passed to wxWindow::SetWindowVariant.

=head2 Wx::Window::HasCapture

   virtual bool HasCapture() const

   Returns true if this window has the current mouse capture.

   See also

   wxWindow::CaptureMouse, wxWindow::ReleaseMouse,
   wxMouseCaptureLostEvent wxMouseCaptureChangedEvent

=head2 Wx::Window::HasFlag

   bool HasFlag(int flag) const

   Returns true if the window has the given flag bit set.

=head2 Wx::Window::HasMultiplePages

   virtual bool HasMultiplePages() const

   This method should be overridden to return true if this window has
   multiple pages. All standard class with multiple pages such as
   wxNotebook, wxListbook and wxTreebook already override it to return
   true and user-defined classes with similar behaviour should do it as
   well to allow the library to handle such windows appropriately.

=head2 Wx::Window::HasScrollbar

   virtual bool HasScrollbar(int orient) const

   Returns true if this window has a scroll bar for this orientation.

   Parameters

   orient

       Orientation to check, either wxHORIZONTAL or wxVERTICAL.

=head2 Wx::Window::HasTransparentBackground

   virtual bool HasTransparentBackground() const

   Returns true if this window background is transparent (as, for
   example, for wxStaticText) and should show the parent window
   background.

   This method is mostly used internally by the library itself and you
   normally shouldn't have to call it. You may, however, have to override
   it in your wxWindow-derived class to ensure that background is painted
   correctly.

=head2 Wx::Window::Hide

   bool Hide()

   Equivalent to calling Show(false).

=head2 Wx::Window::InheritAttributes

   void InheritAttributes()

   This function is (or should be, in case of custom controls) called
   during window creation to intelligently set up the window visual
   attributes, that is the font and the foreground and background
   colours.

   By "intelligently'' the following is meant: by default, all windows
   use their own default attributes. However if some of the parents
   attributes are explicitly (that is, using SetFont and not SetOwnFont)
   changed and if the corresponding attribute hadn't been explicitly set
   for this window itself, then this window takes the same value as used
   by the parent. In addition, if the window overrides
   ShouldInheritColours to return false, the colours will not be changed
   no matter what and only the font might.

   This rather complicated logic is necessary in order to accommodate the
   different usage scenarios. The most common one is when all default
   attributes are used and in this case, nothing should be inherited as
   in modern GUIs different controls use different fonts (and colours)
   than their siblings so they can't inherit the same value from the
   parent. However it was also deemed desirable to allow to simply change
   the attributes of all children at once by just changing the font or
   colour of their common parent, hence in this case we do inherit the
   parents attributes.

=head2 Wx::Window::InitDialog

   void InitDialog()

   Sends an wxEVT_INIT_DIALOG event, whose handler usually transfers data
   to the dialog via validators.

=head2 Wx::Window::InvalidateBestSize

   void InvalidateBestSize()

   Resets the cached best size value so it will be recalculated the next
   time it is needed.

=head2 Wx::Window::IsDoubleBuffered

   virtual bool IsDoubleBuffered() const

   Returns true if the window contents is double-buffered by the system,
   i.e. if any drawing done on the window is really done on a temporary
   backing surface and transferred to the screen all at once later.

   See also

   wxBufferedDC

=head2 Wx::Window::IsEnabled

   virtual bool IsEnabled() const

   Returns true if the window is enabled for input, false otherwise.

   See also

   wxWindow::Enable

=head2 Wx::Window::IsExposed

   bool IsExposed(int x, int y) const

   bool IsExposed(wxPoint &pt) const

   bool IsExposed(int x, int y, int w, int h) const

   bool IsExposed(wxRect &rect) const

   Returns true if the given point or rectangle area has been exposed
   since the last repaint. Call this in an paint event handler to
   optimize redrawing by only redrawing those areas, which have been
   exposed.

   wxPython note: In place of a single overloaded method name, wxPython
   implements the following methods:

=head2 Wx::Window::IsFrozen

   virtual bool IsFrozen() const

   Returns true if the window is currently frozen by a call to Freeze().

   See also

   Thaw()

=head2 Wx::Window::IsRetained

   virtual bool IsRetained() const

   Returns true if the window is retained, false otherwise.

   Remarks

   Retained windows are only available on X platforms.

=head2 Wx::Window::IsShown

   virtual bool IsShown() const

   Returns true if the window is shown, false if it has been hidden.

   See also

   wxWindow::IsShownOnScreen

=head2 Wx::Window::IsShownOnScreen

   virtual bool IsShownOnScreen() const

   Returns true if the window is physically visible on the screen, i.e.
   it is shown and all its parents up to the toplevel window are shown as
   well.

   See also

   wxWindow::IsShown

=head2 Wx::Window::IsTopLevel

   bool IsTopLevel() const

   Returns true if the given window is a top-level one. Currently all
   frames and dialogs are considered to be top-level windows (even if
   they have a parent window).

=head2 Wx::Window::Layout

   void Layout()

   Invokes the constraint-based layout algorithm or the sizer-based
   algorithm for this window.

   See wxWindow::SetAutoLayout: when auto layout is on, this function
   gets called automatically when the window is resized.

=head2 Wx::Window::LineDown

   This is just a wrapper for ScrollLines(1).

=head2 Wx::Window::LineUp

   This is just a wrapper for ScrollLines(-1).

=head2 Wx::Window::Lower

   void Lower()

   Lowers the window to the bottom of the window hierarchy (z-order).

   See also

   Raise

=head2 Wx::Window::MakeModal

   virtual void MakeModal(bool flag)

   Disables all other windows in the application so that the user can
   only interact with this window.

   Parameters

   flag

       If true, this call disables all other windows in the application
       so that the user can only interact with this window. If false, the
       effect is reversed.

=head2 Wx::Window::Move

   void Move(int x, int y)

   void Move(const wxPoint& pt)

   Moves the window to the given position.

   Parameters

   x   

       Required x position.

   y   

       Required y position.

   pt  

       wxPoint object representing the position.

   Remarks

   Implementations of SetSize can also implicitly implement the
   wxWindow::Move function, which is defined in the base wxWindow class
   as the call:

     SetSize(x, y, wxDefaultCoord, wxDefaultCoord, wxSIZE_USE_EXISTING);

   See also

   wxWindow::SetSize

   wxPython note: In place of a single overloaded method name, wxPython
   implements the following methods:

=head2 Wx::Window::MoveAfterInTabOrder

   void MoveAfterInTabOrder(wxWindow *win)

   Moves this window in the tab navigation order after the specified win.
   This means that when the user presses TAB key on that other window,
   the focus switches to this window.

   Default tab order is the same as creation order, this function and
   MoveBeforeInTabOrder() allow to change it after creating all the
   windows.

   Parameters

   win 

       A sibling of this window which should precede it in tab order,
       must not be NULL

=head2 Wx::Window::MoveBeforeInTabOrder

   void MoveBeforeInTabOrder(wxWindow *win)

   Same as MoveAfterInTabOrder except that it inserts this window just
   before win instead of putting it right after it.

=head2 Wx::Window::Navigate

   bool Navigate(int flags = wxNavigationKeyEvent::IsForward)

   Does keyboard navigation from this window to another, by sending a
   wxNavigationKeyEvent.

   Parameters

   flags

       A combination of wxNavigationKeyEvent::IsForward and
       wxNavigationKeyEvent::WinChange.

   Remarks

   You may wish to call this from a text control custom keypress handler
   to do the default navigation behaviour for the tab key, since the
   standard default behaviour for a multiline text control with the
   wxTE_PROCESS_TAB style is to insert a tab and not navigate to the next
   control.

=head2 Wx::Window::OnInternalIdle

   virtual void OnInternalIdle()

   This virtual function is normally only used internally, but sometimes
   an application may need it to implement functionality that should not
   be disabled by an application defining an OnIdle handler in a derived
   class.

   This function may be used to do delayed painting, for example, and
   most implementations call wxWindow::UpdateWindowUI in order to send
   update events to the window in idle time.

=head2 Wx::Window::PageDown

   This is just a wrapper for ScrollPages()(1).

=head2 Wx::Window::PageUp

   This is just a wrapper for ScrollPages()(-1).

=head2 Wx::Window::PopEventHandler

   wxEvtHandler* PopEventHandler(bool deleteHandler = false) const

   Removes and returns the top-most event handler on the event handler
   stack.

   Parameters

   deleteHandler

       If this is true, the handler will be deleted after it is removed.
       The default value is false.

   See also

   wxWindow::SetEventHandler, wxWindow::GetEventHandler,
   wxWindow::PushEventHandler, wxEvtHandler::ProcessEvent, wxEvtHandler

=head2 Wx::Window::PopupMenu

   bool PopupMenu(wxMenu* menu, const wxPoint& pos = wxDefaultPosition)

   bool PopupMenu(wxMenu* menu, int x, int y)

   Pops up the given menu at the specified coordinates, relative to this
   window, and returns control when the user has dismissed the menu. If a
   menu item is selected, the corresponding menu event is generated and
   will be processed as usually. If the coordinates are not specified,
   the current mouse cursor position is used.

   Parameters

   menu

       Menu to pop up.

   pos 

       The position where the menu will appear.

   x   

       Required x position for the menu to appear.

   y   

       Required y position for the menu to appear.

   See also

   wxMenu

   Remarks

   Just before the menu is popped up, wxMenu::UpdateUI is called to
   ensure that the menu items are in the correct state. The menu does not
   get deleted by the window.

   It is recommended to not explicitly specify coordinates when calling
   PopupMenu in response to mouse click, because some of the ports
   (namely, wxGTK) can do a better job of positioning the menu in that
   case.

   wxPython note: In place of a single overloaded method name, wxPython
   implements the following methods:

=head2 Wx::Window::PushEventHandler

   void PushEventHandler(wxEvtHandler* handler)

   Pushes this event handler onto the event stack for the window.

   Parameters

   handler

       Specifies the handler to be pushed.

   Remarks

   An event handler is an object that is capable of processing the events
   sent to a window. By default, the window is its own event handler, but
   an application may wish to substitute another, for example to allow
   central implementation of event-handling for a variety of different
   window classes.

   wxWindow::PushEventHandler allows an application to set up a chain of
   event handlers, where an event not handled by one event handler is
   handed to the next one in the chain. Use wxWindow::PopEventHandler to
   remove the event handler.

   See also

   wxWindow::SetEventHandler, wxWindow::GetEventHandler,
   wxWindow::PopEventHandler, wxEvtHandler::ProcessEvent, wxEvtHandler

=head2 Wx::Window::Raise

   void Raise()

   Raises the window to the top of the window hierarchy (z-order).

   In current version of wxWidgets this works both for managed and child
   windows.

   See also

   Lower

=head2 Wx::Window::Refresh

   virtual void Refresh(bool eraseBackground = true, const wxRect* rect =
   NULL)

   Causes this window, and all of its children recursively (except under
   wxGTK1 where this is not implemented), to be repainted. Note that
   repainting doesn't happen immediately but only during the next event
   loop iteration, if you need to update the window immediately you
   should use Update instead.

   Parameters

   eraseBackground

       If true, the background will be erased.

   rect

       If non-NULL, only the given rectangle will be treated as damaged.

   See also

   wxWindow::RefreshRect

=head2 Wx::Window::RefreshRect

   void RefreshRect(const wxRect& rect, bool eraseBackground = true)

   Redraws the contents of the given rectangle: only the area inside it
   will be repainted.

   This is the same as Refresh but has a nicer syntax as it can be called
   with a temporary wxRect object as argument like this
   RefreshRect(wxRect(x, y, w, h)).

=head2 Wx::Window::RegisterHotKey

   bool RegisterHotKey(int hotkeyId, int modifiers, int virtualKeyCode)

   Registers a system wide hotkey. Every time the user presses the hotkey
   registered here, this window will receive a hotkey event. It will
   receive the event even if the application is in the background and
   does not have the input focus because the user is working with some
   other application.

   Parameters

   hotkeyId

       Numeric identifier of the hotkey. For applications this must be
       between 0 and 0xBFFF. If this function is called from a shared
       DLL, it must be a system wide unique identifier between 0xC000 and
       0xFFFF. This is a MSW specific detail.

   modifiers

       A bitwise combination of wxMOD_SHIFT, wxMOD_CONTROL, wxMOD_ALT or
       wxMOD_WIN specifying the modifier keys that have to be pressed
       along with the key.

   virtualKeyCode

       The virtual key code of the hotkey.

   Return value

   true if the hotkey was registered successfully. false if some other
   application already registered a hotkey with this
   modifier/virtualKeyCode combination.

   Remarks

   Use EVT_HOTKEY(hotkeyId, fnc) in the event table to capture the event.
   This function is currently only implemented under Windows. It is used
   in the Windows CE port for detecting hardware button presses.

   See also

   wxWindow::UnregisterHotKey

=head2 Wx::Window::ReleaseMouse

   virtual void ReleaseMouse()

   Releases mouse input captured with wxWindow::CaptureMouse.

   See also

   wxWindow::CaptureMouse, wxWindow::HasCapture, wxWindow::ReleaseMouse,
   wxMouseCaptureLostEvent wxMouseCaptureChangedEvent

=head2 Wx::Window::RemoveChild

   virtual void RemoveChild(wxWindow* child)

   Removes a child window. This is called automatically by window
   deletion functions so should not be required by the application
   programmer.

   Notice that this function is mostly internal to wxWidgets and
   shouldn't be called by the user code.

   Parameters

   child

       Child window to remove.

=head2 Wx::Window::RemoveEventHandler

   bool RemoveEventHandler(wxEvtHandler *handler)

   Find the given handler in the windows event handler chain and remove
   (but not delete) it from it.

   Parameters

   handler

       The event handler to remove, must be non-NULL and must be present
       in this windows event handlers chain

   Return value

   Returns true if it was found and false otherwise (this also results in
   an assert failure so this function should only be called when the
   handler is supposed to be there).

   See also

   PushEventHandler, PopEventHandler

=head2 Wx::Window::Reparent

   virtual bool Reparent(wxWindow* newParent)

   Reparents the window, i.e the window will be removed from its current
   parent window (e.g. a non-standard toolbar in a wxFrame) and then
   re-inserted into another.

   Parameters

   newParent

       New parent.

=head2 Wx::Window::ScreenToClient

   virtual void ScreenToClient(int* x, int* y) const

   virtual wxPoint ScreenToClient(const wxPoint& pt) const

   Converts from screen to client window coordinates.

   Parameters

   x   

       Stores the screen x coordinate and receives the client x
       coordinate.

   y   

       Stores the screen x coordinate and receives the client x
       coordinate.

   pt  

       The screen position for the second form of the function.

   wxPython note: In place of a single overloaded method name, wxPython
   implements the following methods:

=head2 Wx::Window::ScrollLines

   virtual bool ScrollLines(int lines)

   Scrolls the window by the given number of lines down (if lines is
   positive) or up.

   Return value

   Returns true if the window was scrolled, false if it was already on
   top/bottom and nothing was done.

   Remarks

   This function is currently only implemented under MSW and wxTextCtrl
   under wxGTK (it also works for wxScrolledWindow derived classes under
   all platforms).

   See also

   ScrollPages

=head2 Wx::Window::ScrollPages

   virtual bool ScrollPages(int pages)

   Scrolls the window by the given number of pages down (if pages is
   positive) or up.

   Return value

   Returns true if the window was scrolled, false if it was already on
   top/bottom and nothing was done.

   Remarks

   This function is currently only implemented under MSW and wxGTK.

   See also

   ScrollLines

=head2 Wx::Window::ScrollWindow

   virtual void ScrollWindow(int dx, int dy, const wxRect* rect = NULL)

   Physically scrolls the pixels in the window and move child windows
   accordingly.

   Parameters

   dx  

       Amount to scroll horizontally.

   dy  

       Amount to scroll vertically.

   rect

       Rectangle to scroll, if it is NULL, the whole window is scrolled
       (this is always the case under wxGTK which doesn't support this
       parameter)

   Remarks

   Note that you can often use wxScrolledWindow instead of using this
   function directly.

=head2 Wx::Window::SetAcceleratorTable

   virtual void SetAcceleratorTable(const wxAcceleratorTable& accel)

   Sets the accelerator table for this window. See wxAcceleratorTable.

=head2 Wx::Window::SetAccessible

   void SetAccessible(wxAccessible* accessible)

   Sets the accessible for this window. Any existing accessible for this
   window will be deleted first, if not identical to accessible.

   See also wxAccessible.

=head2 Wx::Window::SetAutoLayout

   void SetAutoLayout(bool autoLayout)

   Determines whether the wxWindow::Layout function will be called
   automatically when the window is resized. Please note that this only
   happens for the windows usually used to contain children, namely
   wxPanel and wxTopLevelWindow (and the classes deriving from them).

   This method is called implicitly by wxWindow::SetSizer but if you use
   wxWindow::SetConstraints you should call it manually or otherwise the
   window layout won't be correctly updated when its size changes.

   Parameters

   autoLayout

       Set this to true if you wish the Layout function to be called
       automatically when the window is resized.

   See also

   wxWindow::SetConstraints

=head2 Wx::Window::SetBackgroundColour

   virtual bool SetBackgroundColour(const wxColour& colour)

   Sets the background colour of the window.

   Please see InheritAttributes for explanation of the difference between
   this method and SetOwnBackgroundColour.

   Parameters

   colour

       The colour to be used as the background colour, pass wxNullColour
       to reset to the default colour.

   Remarks

   The background colour is usually painted by the default wxEraseEvent
   event handler function under Windows and automatically under GTK.

   Note that setting the background colour does not cause an immediate
   refresh, so you may wish to call wxWindow::ClearBackground or
   wxWindow::Refresh after calling this function.

   Using this function will disable attempts to use themes for this
   window, if the system supports them. Use with care since usually the
   themes represent the appearance chosen by the user to be used for all
   applications on the system.

=head2 Wx::Window::SetBackgroundStyle

   virtual void SetBackgroundStyle(wxBackgroundStyle style)

   Sets the background style of the window. The background style
   indicates whether background colour should be determined by the system
   (wxBG_STYLE_SYSTEM), be set to a specific colour (wxBG_STYLE_COLOUR),
   or should be left to the application to implement (wxBG_STYLE_CUSTOM).

   On GTK+, use of wxBG_STYLE_CUSTOM allows the flicker-free drawing of a
   custom background, such as a tiled bitmap. Currently the style has no
   effect on other platforms.

   See also

   wxWindow::SetBackgroundColour, wxWindow::GetForegroundColour,
   wxWindow::GetBackgroundStyle

=head2 Wx::Window::SetInitialSize

   void SetInitialSize(const wxSize& size = wxDefaultSize)

   A smart SetSize that will fill in default size components with the
   window's best size values. Also sets the window's minsize to the value
   passed in for use with sizers. This means that if a full or partial
   size is passed to this function then the sizers will use that size
   instead of the results of GetBestSize to determine the minimum needs
   of the window for layout.

   Most controls will use this to set their initial size, and their min
   size to the passed in value (if any.)

=head2 Wx::Window::SetCaret

   void SetCaret(wxCaret *caret) const

   Sets the caret associated with the window.

=head2 Wx::Window::SetClientSize

   virtual void SetClientSize(int width, int height)

   virtual void SetClientSize(const wxSize& size)

   This sets the size of the window client area in pixels. Using this
   function to size a window tends to be more device-independent than
   wxWindow::SetSize, since the application need not worry about what
   dimensions the border or title bar have when trying to fit the window
   around panel items, for example.

   Parameters

   width

       The required client area width.

   height

       The required client area height.

   size

       The required client size.

   wxPython note: In place of a single overloaded method name, wxPython
   implements the following methods:

=head2 Wx::Window::SetConstraints

   void SetConstraints(wxLayoutConstraints* constraints)

   Sets the window to have the given layout constraints. The window will
   then own the object, and will take care of its deletion. If an
   existing layout constraints object is already owned by the window, it
   will be deleted.

   Parameters

   constraints

       The constraints to set. Pass NULL to disassociate and delete the
       window's constraints.

   Remarks

   You must call wxWindow::SetAutoLayout to tell a window to use the
   constraints automatically in OnSize; otherwise, you must override
   OnSize and call Layout() explicitly. When setting both a
   wxLayoutConstraints and a wxSizer, only the sizer will have effect.

=head2 Wx::Window::SetContainingSizer

   void SetContainingSizer(wxSizer* sizer)

   This normally does not need to be called by user code. It is called
   when a window is added to a sizer, and is used so the window can
   remove itself from the sizer when it is destroyed.

=head2 Wx::Window::SetCursor

   virtual void SetCursor(const wxCursor&cursor)

   Sets the window's cursor. Notice that the window cursor also sets it
   for the children of the window implicitly.

   The cursor may be wxNullCursor in which case the window cursor will be
   reset back to default.

   Parameters

   cursor

       Specifies the cursor that the window should normally display.

   See also

   ::wxSetCursor, wxCursor

=head2 Wx::Window::SetDropTarget

   void SetDropTarget(wxDropTarget* target)

   Associates a drop target with this window.

   If the window already has a drop target, it is deleted.

   See also

   wxWindow::GetDropTarget, Drag and drop overview

=head2 Wx::Window::SetInitialBestSize

   virtual void SetInitialBestSize(const wxSize& size)

   Sets the initial window size if none is given (i.e. at least one of
   the components of the size passed to ctor/Create() is wxDefaultCoord).

=head2 Wx::Window::SetEventHandler

   void SetEventHandler(wxEvtHandler* handler)

   Sets the event handler for this window.

   Parameters

   handler

       Specifies the handler to be set.

   Remarks

   An event handler is an object that is capable of processing the events
   sent to a window. By default, the window is its own event handler, but
   an application may wish to substitute another, for example to allow
   central implementation of event-handling for a variety of different
   window classes.

   It is usually better to use wxWindow::PushEventHandler since this sets
   up a chain of event handlers, where an event not handled by one event
   handler is handed to the next one in the chain.

   See also

   wxWindow::GetEventHandler, wxWindow::PushEventHandler,
   wxWindow::PopEventHandler, wxEvtHandler::ProcessEvent, wxEvtHandler

=head2 Wx::Window::SetExtraStyle

   void SetExtraStyle(long exStyle)

   Sets the extra style bits for the window. The currently defined extra
   style bits are:

=head2 Wx::Window::SetFocus

   virtual void SetFocus()

   This sets the window to receive keyboard input.

   See also

   wxFocusEvent wxPanel::SetFocus wxPanel::SetFocusIgnoringChildren

=head2 Wx::Window::SetFocusFromKbd

   virtual void SetFocusFromKbd()

   This function is called by wxWidgets keyboard navigation code when the
   user gives the focus to this window from keyboard (e.g. using TAB
   key). By default this method simply calls SetFocus but can be
   overridden to do something in addition to this in the derived classes.

=head2 Wx::Window::SetFont

   void SetFont(const wxFont& font)

   Sets the font for this window. This function should not be called for
   the parent window if you don't want its font to be inherited by its
   children, use SetOwnFont instead in this case and see
   InheritAttributes for more explanations.

   Please notice that the given font is not automatically used for
   wxPaintDC objects associated with this window, you need to call
   wxDC::SetFont() too. However this font is used by any standard
   controls for drawing their text as well as by
   wxWindow::GetTextExtent().

   Parameters

   font

       Font to associate with this window, pass wxNullFont to reset to
       the default font.

   See also

   wxWindow::GetFont,

=head2 Wx::Window::SetForegroundColour

   virtual void SetForegroundColour(const wxColour& colour)

   Sets the foreground colour of the window.

   Please see InheritAttributes for explanation of the difference between
   this method and SetOwnForegroundColour.

   Parameters

   colour

       The colour to be used as the foreground colour, pass wxNullColour
       to reset to the default colour.

   Remarks

   The interpretation of foreground colour is open to interpretation
   according to the window class; it may be the text colour or other
   colour, or it may not be used at all.

   Using this function will disable attempts to use themes for this
   window, if the system supports them. Use with care since usually the
   themes represent the appearance chosen by the user to be used for all
   applications on the system.

   See also

   wxWindow::GetForegroundColour, wxWindow::SetBackgroundColour,
   wxWindow::GetBackgroundColour, wxWindow::ShouldInheritColours

=head2 Wx::Window::SetHelpText

   virtual void SetHelpText(const wxString& helpText)

   Sets the help text to be used as context-sensitive help for this
   window.

   Note that the text is actually stored by the current wxHelpProvider
   implementation, and not in the window object itself.

   See also

   GetHelpText, wxHelpProvider

=head2 Wx::Window::SetId

   void SetId(int id)

   Sets the identifier of the window.

   Remarks

   Each window has an integer identifier. If the application has not
   provided one, an identifier will be generated. Normally, the
   identifier should be provided on creation and should not be modified
   subsequently.

   See also

   wxWindow::GetId, Window identifiers

=head2 Wx::Window::SetLabel

   virtual void SetLabel(const wxString& label)

   Sets the window's label.

   Parameters

   label

       The window label.

   See also

   wxWindow::GetLabel

=head2 Wx::Window::SetMaxSize

   void SetMaxSize(const wxSize& size)

   Sets the maximum size of the window, to indicate to the sizer layout
   mechanism that this is the maximum possible size.

=head2 Wx::Window::SetMinSize

   void SetMinSize(const wxSize& size)

   Sets the minimum size of the window, to indicate to the sizer layout
   mechanism that this is the minimum required size. You may need to call
   this if you change the window size after construction and before
   adding to its parent sizer.

=head2 Wx::Window::SetName

   virtual void SetName(const wxString& name)

   Sets the window's name.

   Parameters

   name

       A name to set for the window.

   See also

   wxWindow::GetName

=head2 Wx::Window::SetOwnBackgroundColour

   void SetOwnBackgroundColour(const wxColour& colour)

   Sets the background colour of the window but prevents it from being
   inherited by the children of this window.

   See also

   SetBackgroundColour, InheritAttributes

=head2 Wx::Window::SetOwnFont

   void SetOwnFont(const wxFont& font)

   Sets the font of the window but prevents it from being inherited by
   the children of this window.

   See also

   SetFont, InheritAttributes

=head2 Wx::Window::SetOwnForegroundColour

   void SetOwnForegroundColour(const wxColour& colour)

   Sets the foreground colour of the window but prevents it from being
   inherited by the children of this window.

   See also

   SetForegroundColour, InheritAttributes

=head2 Wx::Window::SetPalette

   virtual void SetPalette(wxPalette* palette)

   Obsolete - use wxDC::SetPalette instead.

=head2 Wx::Window::SetScrollbar

   virtual void SetScrollbar(int orientation, int position, int thumbSize,
   int range, bool refresh = true)

   Sets the scrollbar properties of a built-in scrollbar.

   Parameters

   orientation

       Determines the scrollbar whose page size is to be set. May be
       wxHORIZONTAL or wxVERTICAL.

   position

       The position of the scrollbar in scroll units.

   thumbSize

       The size of the thumb, or visible portion of the scrollbar, in
       scroll units.

   range

       The maximum position of the scrollbar.

   refresh

       true to redraw the scrollbar, false otherwise.

   Remarks

   Let's say you wish to display 50 lines of text, using the same font.
   The window is sized so that you can only see 16 lines at a time.

   You would use:

     SetScrollbar(wxVERTICAL, 0, 16, 50);

   Note that with the window at this size, the thumb position can never
   go above 50 minus 16, or 34.

   You can determine how many lines are currently visible by dividing the
   current view size by the character height in pixels.

   When defining your own scrollbar behaviour, you will always need to
   recalculate the scrollbar settings when the window size changes. You
   could therefore put your scrollbar calculations and SetScrollbar call
   into a function named AdjustScrollbars, which can be called initially
   and also from your wxSizeEvent handler function.

   See also

   Scrolling overview, wxScrollBar, wxScrolledWindow, wxScrollWinEvent

=head2 Wx::Window::SetScrollPos

   virtual void SetScrollPos(int orientation, int pos, bool refresh =
   true)

   Sets the position of one of the built-in scrollbars.

   Parameters

   orientation

       Determines the scrollbar whose position is to be set. May be
       wxHORIZONTAL or wxVERTICAL.

   pos 

       Position in scroll units.

   refresh

       true to redraw the scrollbar, false otherwise.

   Remarks

   This function does not directly affect the contents of the window: it
   is up to the application to take note of scrollbar attributes and
   redraw contents accordingly.

   See also

   wxWindow::SetScrollbar, wxWindow::GetScrollPos,
   wxWindow::GetScrollThumb, wxScrollBar, wxScrolledWindow

=head2 Wx::Window::SetSize

   virtual void SetSize(int x, int y, int width, int height, int
   sizeFlags = wxSIZE_AUTO)

   virtual void SetSize(const wxRect& rect)

   Sets the size and position of the window in pixels.

   virtual void SetSize(int width, int height)

   virtual void SetSize(const wxSize& size)

   Sets the size of the window in pixels.

   Parameters

   x   

       Required x position in pixels, or wxDefaultCoord to indicate that
       the existing value should be used.

   y   

       Required y position in pixels, or wxDefaultCoord to indicate that
       the existing value should be used.

   width

       Required width in pixels, or wxDefaultCoord to indicate that the
       existing value should be used.

   height

       Required height position in pixels, or wxDefaultCoord to indicate
       that the existing value should be used.

   size

       wxSize object for setting the size.

   rect

       wxRect object for setting the position and size.

   sizeFlags

       Indicates the interpretation of other parameters. It is a bit list
       of the following:

       wxSIZE_AUTO_WIDTH: a wxDefaultCoord width value is taken to
       indicate a wxWidgets-supplied default width.

=head2 Wx::Window::SetSizeHints

   Use of this function for windows which are not toplevel windows (such
   as wxDialog or wxFrame) is discouraged. Please use SetMinSize and
   SetMaxSize instead.

   See also

   wxTopLevelWindow::SetSizeHints.

=head2 Wx::Window::SetSizer

   void SetSizer(wxSizer* sizer, bool deleteOld=true)

   Sets the window to have the given layout sizer. The window will then
   own the object, and will take care of its deletion. If an existing
   layout constraints object is already owned by the window, it will be
   deleted if the deleteOld parameter is true.

   Note that this function will also call SetAutoLayout implicitly with
   true parameter if the sizer is non-NULL and false otherwise.

   Parameters

   sizer

       The sizer to set. Pass NULL to disassociate and conditionally
       delete the window's sizer. See below.

   deleteOld

       If true (the default), this will delete any prexisting sizer. Pass
       false if you wish to handle deleting the old sizer yourself.

   Remarks

   SetSizer now enables and disables Layout automatically, but prior to
   wxWidgets 2.3.3 the following applied:

   You must call wxWindow::SetAutoLayout to tell a window to use the
   sizer automatically in OnSize; otherwise, you must override OnSize and
   call Layout() explicitly. When setting both a wxSizer and a
   wxLayoutConstraints, only the sizer will have effect.

=head2 Wx::Window::SetSizerAndFit

   void SetSizerAndFit(wxSizer* sizer, bool deleteOld=true)

   The same as SetSizer, except it also sets the size hints for the
   window based on the sizer's minimum size.

=head2 Wx::Window::SetThemeEnabled

   virtual void SetThemeEnabled(bool enable)

   This function tells a window if it should use the system's "theme"
   code to draw the windows' background instead if its own background
   drawing code. This does not always have any effect since the
   underlying platform obviously needs to support the notion of themes in
   user defined windows. One such platform is GTK+ where windows can have
   (very colourful) backgrounds defined by a user's selected theme.

   Dialogs, notebook pages and the status bar have this flag set to true
   by default so that the default look and feel is simulated best.

=head2 Wx::Window::SetToolTip

   void SetToolTip(const wxString& tip)

   void SetToolTip(wxToolTip* tip)

   Attach a tooltip to the window.

   See also: GetToolTip, wxToolTip

=head2 Wx::Window::SetValidator

   virtual void SetValidator(const wxValidator& validator)

   Deletes the current validator (if any) and sets the window validator,
   having called wxValidator::Clone to create a new validator of this
   type.

=head2 Wx::Window::SetVirtualSize

   void SetVirtualSize(int width, int height)

   void SetVirtualSize(const wxSize& size)

   Sets the virtual size of the window in pixels.

=head2 Wx::Window::SetVirtualSizeHints

   virtual void SetVirtualSizeHints(int minW,int minH, int maxW=-1, int
   maxH=-1)

   void SetVirtualSizeHints(const wxSize& minSize=wxDefaultSize, const
   wxSize& maxSize=wxDefaultSize)

=head2 Wx::Window::SetWindowStyle

   void SetWindowStyle(long style)

   Identical to SetWindowStyleFlag.

=head2 Wx::Window::SetWindowStyleFlag

   virtual void SetWindowStyleFlag(long style)

   Sets the style of the window. Please note that some styles cannot be
   changed after the window creation and that Refresh() might need to be
   be called after changing the others for the change to take place
   immediately.

   See Window styles for more information about flags.

   See also

   GetWindowStyleFlag

=head2 Wx::Window::SetWindowVariant

   void SetWindowVariant(wxWindowVariantvariant)

   This function can be called under all platforms but only does anything
   under Mac OS X 10.3+ currently. Under this system, each of the
   standard control can exist in several sizes which correspond to the
   elements of wxWindowVariant enum:

   enum wxWindowVariant
   {
       wxWINDOW_VARIANT_NORMAL,        // Normal size
       wxWINDOW_VARIANT_SMALL,         // Smaller size (about 25 % smaller than normal )
       wxWINDOW_VARIANT_MINI,          // Mini size (about 33 % smaller than normal )
       wxWINDOW_VARIANT_LARGE,         // Large size (about 25 % larger than normal )
   };

   By default the controls use the normal size, of course, but this
   function can be used to change this.

=head2 Wx::Window::ShouldInheritColours

   virtual bool ShouldInheritColours()

   Return true from here to allow the colours of this window to be
   changed by InheritAttributes, returning false forbids inheriting them
   from the parent window.

   The base class version returns false, but this method is overridden in
   wxControl where it returns true.

=head2 Wx::Window::Show

   virtual bool Show(bool show = true)

   Shows or hides the window. You may need to call Raise for a top level
   window if you want to bring it to top, although this is not needed if
   Show() is called immediately after the frame creation.

   Parameters

   show

       If true displays the window. Otherwise, hides it.

   Return value

   true if the window has been shown or hidden or false if nothing was
   done because it already was in the requested state.

   See also

   wxWindow::IsShown, wxWindow::Hide, wxRadioBox::Show

=head2 Wx::Window::Thaw

   virtual void Thaw()

   Reenables window updating after a previous call to Freeze. To really
   thaw the control, it must be called exactly the same number of times
   as Freeze.

   See also

   wxWindowUpdateLocker

=head2 Wx::Window::ToggleWindowStyle

   bool ToggleWindowStyle(int flag)

   Turns the given flag on if it's currently turned off and vice versa.
   This function cannot be used if the value of the flag is 0 (which is
   often the case for default flags).

   Also, please notice that not all styles can be changed after the
   control creation.

   Return value

   Returns true if the style was turned on by this function, false if it
   was switched off.

   See also

   wxWindow::SetWindowStyleFlag, wxWindow::HasFlag

=head2 Wx::Window::TransferDataFromWindow

   virtual bool TransferDataFromWindow()

   Transfers values from child controls to data areas specified by their
   validators. Returns false if a transfer failed.

   If the window has wxWS_EX_VALIDATE_RECURSIVELY extra style flag set,
   the method will also call TransferDataFromWindow() of all child
   windows.

   See also

   wxWindow::TransferDataToWindow, wxValidator, wxWindow::Validate

=head2 Wx::Window::TransferDataToWindow

   virtual bool TransferDataToWindow()

   Transfers values to child controls from data areas specified by their
   validators.

   If the window has wxWS_EX_VALIDATE_RECURSIVELY extra style flag set,
   the method will also call TransferDataToWindow() of all child windows.

   Return value

   Returns false if a transfer failed.

   See also

   wxWindow::TransferDataFromWindow, wxValidator, wxWindow::Validate

=head2 Wx::Window::UnregisterHotKey

   bool UnregisterHotKey(int hotkeyId)

   Unregisters a system wide hotkey.

   Parameters

   hotkeyId

       Numeric identifier of the hotkey. Must be the same id that was
       passed to RegisterHotKey.

   Return value

   true if the hotkey was unregistered successfully, false if the id was
   invalid.

   Remarks

   This function is currently only implemented under MSW.

   See also

   wxWindow::RegisterHotKey

=head2 Wx::Window::Update

   virtual void Update()

   Calling this method immediately repaints the invalidated area of the
   window and all of its children recursively while this would usually
   only happen when the flow of control returns to the event loop. Notice
   that this function doesn't invalidate any area of the window so
   nothing happens if nothing has been invalidated (i.e. marked as
   requiring a redraw). Use Refresh first if you want to immediately
   redraw the window unconditionally.

=head2 Wx::Window::UpdateWindowUI

   virtual void UpdateWindowUI(long flags = wxUPDATE_UI_NONE)

   This function sends wxUpdateUIEvents to the window. The particular
   implementation depends on the window; for example a wxToolBar will
   send an update UI event for each toolbar button, and a wxFrame will
   send an update UI event for each menubar menu item. You can call this
   function from your application to ensure that your UI is up-to-date at
   this point (as far as your wxUpdateUIEvent handlers are concerned).
   This may be necessary if you have called wxUpdateUIEvent::SetMode or
   wxUpdateUIEvent::SetUpdateInterval to limit the overhead that
   wxWidgets incurs by sending update UI events in idle time.

   flags should be a bitlist of one or more of the following values.

   enum wxUpdateUI
   {
       wxUPDATE_UI_NONE          = 0x0000, // No particular value
       wxUPDATE_UI_RECURSE       = 0x0001, // Call the function for descendants
       wxUPDATE_UI_FROMIDLE      = 0x0002  // Invoked from On(Internal)Idle
   };

   If you are calling this function from an OnInternalIdle or OnIdle
   function, make sure you pass the wxUPDATE_UI_FROMIDLE flag, since this
   tells the window to only update the UI elements that need to be
   updated in idle time. Some windows update their elements only when
   necessary, for example when a menu is about to be shown. The following
   is an example of how to call UpdateWindowUI from an idle function.

   void MyWindow::OnInternalIdle()
   {
       if (wxUpdateUIEvent::CanUpdate(this))
           UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
   }

   See also

   wxUpdateUIEvent, wxWindow::DoUpdateWindowUI, wxWindow::OnInternalIdle

=head2 Wx::Window::Validate

   virtual bool Validate()

   Validates the current values of the child controls using their
   validators.

   If the window has wxWS_EX_VALIDATE_RECURSIVELY extra style flag set,
   the method will also call Validate() of all child windows.

   Return value

   Returns false if any of the validations failed.

   See also

   wxWindow::TransferDataFromWindow, wxWindow::TransferDataToWindow,
   wxValidator

=head2 Wx::Window::WarpPointer

   void WarpPointer(int x, int y)

   Moves the pointer to the given position on the window.

   NB: This function is not supported under Mac because Apple Human
   Interface Guidelines forbid moving the mouse cursor programmatically.

   Parameters

   x   

       The new x position for the cursor.

   y   

       The new y position for the cursor.

=head2 Wx::Window::WindowToClientSize

   virtual wxSize WindowToClientSize(const wxSize& size)

   Converts window size size to corresponding client area size. In other
   words, the returned value is what would GetClientSize return if this
   window had given window size. Components with wxDefaultCoord value are
   left unchanged.

   Note that the conversion is not always exact, it assumes that
   non-client area doesn't change and so doesn't take into account things
   like menu bar (un)wrapping or (dis)appearance of the scrollbars.

   This function is new since wxWidgets version 2.8.8

   See also

   wxWindow::ClientToWindowSize

=head1 Wx::WindowUpdateLocker

=head2 Wx::WindowUpdateLocker::new

   wxWindowUpdateLocker(wxWindow *win)

   Creates an object preventing the updates of the specified win. The
   parameter must be non-NULL and the window must exist for longer than
   wxWindowUpdateLocker object itself.

=head2 Wx::WindowUpdateLocker::DESTROY

   ~wxWindowUpdateLocker()

   Destructor reenables updates for the window this object is associated
   with.

=head1 Wx::WindowCreateEvent

=head2 Wx::WindowCreateEvent::new

   wxWindowCreateEvent(wxWindow* win = NULL)

   Constructor.

=head1 Wx::WindowDC

=head2 Wx::WindowDC::new

   wxWindowDC(wxWindow* window)

   Constructor. Pass a pointer to the window on which you wish to paint.

=head1 Wx::WindowDestroyEvent

=head2 Wx::WindowDestroyEvent::new

   wxWindowDestroyEvent(wxWindow* win = NULL)

   Constructor.

=head1 Wx::WindowDisabler

=head2 Wx::WindowDisabler::new

   wxWindowDisabler(wxWindow *winToSkip = NULL)

   Disables all top level windows of the applications with the exception
   of winToSkip if it is not NULL.

=head2 Wx::WindowDisabler::DESTROY

   ~wxWindowDisabler()

   Reenables back the windows disabled by the constructor.

=head1 Wx::Wizard

=head2 Wx::Wizard::new

   wxWizard()

   Default constructor. Use this if you wish to derive from wxWizard and
   then call Create, for example if you wish to set an extra style with
   wxWindow::SetExtraStyle between the two calls.

   wxWizard(wxWindow* parent, int id = -1, const wxString& title =
   wxEmptyString, const wxBitmap& bitmap = wxNullBitmap, const wxPoint&
   pos = wxDefaultPosition, long style = wxDEFAULT_DIALOG_STYLE)

   Constructor which really creates the wizard -- if you use this
   constructor, you shouldn't call Create.

   Notice that unlike almost all other wxWidgets classes, there is no
   size parameter in the wxWizard constructor because the wizard will
   have a predefined default size by default. If you want to change this,
   you should use the GetPageAreaSizer function.

   Parameters

   parent

       The parent window, may be NULL.

   id  

       The id of the dialog, will usually be just -1.

   title

       The title of the dialog.

   bitmap

       The default bitmap used in the left side of the wizard. See also
       GetBitmap.

   pos 

       The position of the dialog, it will be centered on the screen by
       default.

   style

       Window style is passed to wxDialog.

=head2 Wx::Wizard::Create

   bool Create(wxWindow* parent, int id = -1, const wxString& title =
   wxEmptyString, const wxBitmap& bitmap = wxNullBitmap, const wxPoint&
   pos = wxDefaultPosition, long style = wxDEFAULT_DIALOG_STYLE)

   Creates the wizard dialog. Must be called if the default constructor
   had been used to create the object.

   Notice that unlike almost all other wxWidgets classes, there is no
   size parameter in the wxWizard constructor because the wizard will
   have a predefined default size by default. If you want to change this,
   you should use the GetPageAreaSizer function.

   Parameters

   parent

       The parent window, may be NULL.

   id  

       The id of the dialog, will usually be just -1.

   title

       The title of the dialog.

   bitmap

       The default bitmap used in the left side of the wizard. See also
       GetBitmap.

   pos 

       The position of the dialog, it will be centered on the screen by
       default.

   style

       Window style is passed to wxDialog.

=head2 Wx::Wizard::FitToPage

   void FitToPage(const wxWizardPage* firstPage)

   This method is obsolete, use GetPageAreaSizer instead.

   Sets the page size to be big enough for all the pages accessible via
   the given firstPage, i.e. this page, its next page and so on.

   This method may be called more than once and it will only change the
   page size if the size required by the new page is bigger than the
   previously set one. This is useful if the decision about which pages
   to show is taken during run-time, as in this case, the wizard won't be
   able to get to all pages starting from a single one and you should
   call Fit separately for the others.

=head2 Wx::Wizard::GetBitmap

   const wxBitmap& GetBitmap() const

   Returns the bitmap used for the wizard.

=head2 Wx::Wizard::GetCurrentPage

   wxWizardPage* GetCurrentPage() const

   Get the current page while the wizard is running. NULL is returned if
   RunWizard() is not being executed now.

=head2 Wx::Wizard::GetPageAreaSizer

   virtual wxSizer* GetPageAreaSizer() const

   Returns pointer to page area sizer. The wizard is laid out using
   sizers and the page area sizer is the place-holder for the pages. All
   pages are resized before being shown to match the wizard page area.

   Page area sizer has a minimal size that is the maximum of several
   values. First, all pages (or other objects) added to the sizer.
   Second, all pages reachable by repeatedly applying
   wxWizardPage::GetNext to any page inserted into the sizer. Third, the
   minimal size specified using SetPageSize and FitToPage. Fourth, the
   total wizard height may be increased to accommodate the bitmap height.
   Fifth and finally, wizards are never smaller than some built-in
   minimal size to avoid wizards that are too small.

   The caller can use wxSizer::SetMinSize to enlarge it beyond the
   minimal size. If wxRESIZE_BORDER was passed to constructor, user can
   resize wizard and consequently the page area (but not make it smaller
   than the minimal size).

   It is recommended to add the first page to the page area sizer. For
   simple wizards, this will enlarge the wizard to fit the biggest page.
   For non-linear wizards, the first page of every separate chain should
   be added. Caller-specified size can be accomplished using
   wxSizer::SetMinSize.

   Adding pages to the page area sizer affects the default border width
   around page area that can be altered with SetBorder.

=head2 Wx::Wizard::GetPageSize

   wxSize GetPageSize() const

   Returns the size available for the pages.

=head2 Wx::Wizard::HasNextPage

   virtual bool HasNextPage(wxWizardPage *page)

   Return true if this page is not the last one in the wizard. The base
   class version implements this by calling page->GetNext but this could
   be undesirable if, for example, the pages are created on demand only.

   See also

   HasPrevPage

=head2 Wx::Wizard::HasPrevPage

   virtual bool HasPrevPage(wxWizardPage *page)

   Returns true if this page is not the last one in the wizard. The base
   class version implements this by calling page->GetPrev but this could
   be undesirable if, for example, the pages are created on demand only.

   See also

   HasNextPage

=head2 Wx::Wizard::RunWizard

   bool RunWizard(wxWizardPage* firstPage)

   Executes the wizard starting from the given page, returning true if it
   was successfully finished or false if user cancelled it. The firstPage
   can not be NULL.

=head2 Wx::Wizard::SetBitmap

   void SetBitmap(const wxBitmap& bitmap)

   Sets the bitmap used for the wizard.

=head2 Wx::Wizard::SetPageSize

   void SetPageSize(const wxSize& sizePage)

   This method is obsolete, use GetPageAreaSizer instead.

   Sets the minimal size to be made available for the wizard pages. The
   wizard will take into account the size of the bitmap (if any) itself.
   Also, the wizard will never be smaller than the default size.

   The recommended way to use this function is to lay out all wizard
   pages using the sizers (even though the wizard is not resizeable) and
   then use wxSizer::CalcMin in a loop to calculate the maximum of
   minimal sizes of the pages and pass it to SetPageSize().

=head2 Wx::Wizard::SetBorder

   void SetBorder(int border)

   Sets width of border around page area. Default is zero. For backward
   compatibility, if there are no pages in GetPageAreaSizer, the default
   is 5 pixels.

   If there is a five point border around all controls in a page and the
   border around page area is left as zero, a five point white space
   along all dialog borders will be added to the control border in order
   to space page controls ten points from the dialog border and non-page
   controls.

=head1 Wx::WizardEvent

=head2 Wx::WizardEvent::new

   wxWizardEvent(wxEventType type = wxEVT_NULL, int id = -1, bool
   direction = true)

   Constructor. It is not normally used by the user code as the objects
   of this type are constructed by wxWizard.

=head2 Wx::WizardEvent::GetDirection

   bool GetDirection() const

   Return the direction in which the page is changing: for
   EVT_WIZARD_PAGE_CHANGING, return true if we're going forward or false
   otherwise and for EVT_WIZARD_PAGE_CHANGED return true if we came from
   the previous page and false if we returned from the next one.

=head2 Wx::WizardEvent::GetPage

   wxWizardPage* GetPage() const

   Returns the wxWizardPage which was active when this event was
   generated.

=head1 Wx::WizardPage

=head2 Wx::WizardPage::new

   wxWizardPage(wxWizard* parent, const wxBitmap& bitmap = wxNullBitmap,
   const wxChar *resource = NULL)

   Constructor accepts an optional bitmap which will be used for this
   page instead of the default one for this wizard (note that all bitmaps
   used should be of the same size). Notice that no other parameters are
   needed because the wizard will resize and reposition the page anyhow.

   Parameters

   parent

       The parent wizard

   bitmap

       The page-specific bitmap if different from the global one

   resource

       Load the page from the specified resource if non-NULL

=head2 Wx::WizardPage::GetPrev

   wxWizardPage* GetPrev() const

   Get the page which should be shown when the user chooses the "Back"
   button: if NULL is returned, this button will be disabled. The first
   page of the wizard will usually return NULL from here, but the others
   will not.

   See also

   GetNext

=head2 Wx::WizardPage::GetNext

   wxWizardPage* GetNext() const

   Get the page which should be shown when the user chooses the "Next"
   button: if NULL is returned, this button will be disabled. The last
   page of the wizard will usually return NULL from here, but the others
   will not.

   See also

   GetPrev

=head2 Wx::WizardPage::GetBitmap

   wxBitmap GetBitmap() const

   This method is called by wxWizard to get the bitmap to display
   alongside the page. By default, m_bitmap member variable which was set
   in the constructor.

   If the bitmap was not explicitly set (i.e. if wxNullBitmap is
   returned), the default bitmap for the wizard should be used.

   The only cases when you would want to override this function is if the
   page bitmap depends dynamically on the user choices, i.e. almost
   never.

=head1 Wx::WizardPageSimple

=head2 Wx::WizardPageSimple::new

   wxWizardPageSimple(wxWizard* parent = NULL, wxWizardPage* prev = NULL,
   wxWizardPage* next = NULL, const wxBitmap& bitmap = wxNullBitmap)

   Constructor takes the previous and next pages. They may be modified
   later by SetPrev() or SetNext().

=head2 Wx::WizardPageSimple::SetPrev

   void SetPrev(wxWizardPage* prev)

   Sets the previous page.

=head2 Wx::WizardPageSimple::SetNext

   void SetNext(wxWizardPage* next)

   Sets the next page.

=head2 Wx::WizardPageSimple::Chain

   static void Chain(wxWizardPageSimple* first, wxWizardPageSimple*
   second)

   A convenience function to make the pages follow each other.

   Example:

       wxRadioboxPage *page3 = new wxRadioboxPage(wizard);
       wxValidationPage *page4 = new wxValidationPage(wizard);

=head1 Wx::XmlDocument

=head2 Wx::XmlDocument::new

   wxXmlDocument()

=head2 Wx::XmlDocument::DESTROY

   ~wxXmlDocument()

   Virtual destructor. Frees the document root node.

=head2 Wx::XmlDocument::DetachRoot

   wxXmlNode* DetachRoot()

   Detaches the document root node and returns it. The document root node
   will be set to NULL and thus IsOk will return false after calling this
   function.

   Note that the caller is reponsible for deleting the returned node in
   order to avoid memory leaks.

=head2 Wx::XmlDocument::GetEncoding

   wxString GetEncoding() const

   Returns encoding of in-memory representation of the document (same as
   passed to Load or constructor, defaults to UTF-8).

   NB: this is meaningless in Unicode build where data are stored as
   wchar_t*.

=head2 Wx::XmlDocument::GetFileEncoding

   wxString GetFileEncoding() const

   Returns encoding of document (may be empty).

   Note: this is the encoding original file was saved in, not the
   encoding of in-memory representation!

=head2 Wx::XmlDocument::GetRoot

   wxXmlNode* GetRoot() const

   Returns the root node of the document.

=head2 Wx::XmlDocument::GetVersion

   wxString GetVersion() const

   Returns the version of document. This is the value in the <?xml
   version="1.0"?> header of the XML document. If the version property
   was not explicitely given in the header, this function returns an
   empty string.

=head2 Wx::XmlDocument::IsOk

   bool IsOk() const

   Returns true if the document has been loaded successfully.

=head2 Wx::XmlDocument::Load

   bool Load(const wxString& filename, const wxString& encoding =
   wxT("UTF-8"), int flags = wxXMLDOC_NONE)

   Parses filename as an xml document and loads its data.

   If flags does not contain wxXMLDOC_KEEP_WHITESPACE_NODES, then, while
   loading, all nodes of type wxXML_TEXT_NODE (see wxXmlNode) are
   automatically skipped if they contain whitespaces only. The removal of
   these nodes makes the load process slightly faster and requires less
   memory however makes impossible to recreate exactly the loaded text
   with a Save call later. Read the initial description of this class for
   more info.

   Returns true on success, false otherwise.

   bool Load(wxInputStream& stream, const wxString& encoding =
   wxT("UTF-8"), int flags = wxXMLDOC_NONE)

   Like above but takes the data from given input stream.

=head2 Wx::XmlDocument::Save

   bool Save(const wxString& filename, int indentstep = 1) const

   Saves XML tree creating a file named with given string.

   If indentstep is greater than or equal to zero, then, while saving, an
   automatic indentation is added with steps composed by indentstep
   spaces. If indentstep is wxXML_NO_INDENTATION, then, automatic
   indentation is turned off.

   bool Save(wxOutputStream& stream, int indentstep = 1) const

   Saves XML tree in the given output stream. See other overload for a
   description of indentstep.

=head2 Wx::XmlDocument::SetEncoding

   void SetEncoding(const wxString& enc)

   Sets the enconding of the document.

=head2 Wx::XmlDocument::SetFileEncoding

   void SetFileEncoding(const wxString& encoding)

   Sets the enconding of the file which will be used to save the
   document.

=head2 Wx::XmlDocument::SetRoot

   void SetRoot(wxXmlNode* node)

   Sets the root node of this document. Deletes previous root node. Use
   DetachRoot and then SetRoot if you want to replace the root node
   without deleting the old document tree.

=head2 Wx::XmlDocument::SetVersion

   void SetVersion(const wxString& version)

   Sets the version of the XML file which will be used to save the
   document.

=head1 Wx::XmlNode

=head2 Wx::XmlNode::new



=head2 Wx::XmlNode::DESTROY

   ~wxXmlNode()

   The virtual destructor. Deletes attached children and properties.

=head2 Wx::XmlNode::AddChild

   void AddChild(wxXmlNode* child)

   Adds the given node as child of this node. To attach a second children
   to this node, use the SetNext() function of the child node.

=head2 Wx::XmlNode::AddProperty

   void AddProperty(const wxString& name, const wxString& value)

   Appends a property with given name and value to the list of properties
   for this node.

   void AddProperty(wxXmlProperty* prop)

   Appends the given property to the list of properties for this node.

=head2 Wx::XmlNode::DeleteProperty

   bool DeleteProperty(const wxString& name)

   Removes the first properties which has the given name from the list of
   properties for this node.

=head2 Wx::XmlNode::GetChildren

   wxXmlNode* GetChildren() const

   Returns the first child of this node. To get a pointer to the second
   child of this node (if it does exist), use the GetNext() function on
   the returned value.

=head2 Wx::XmlNode::GetContent

   wxString GetContent() const

   Returns the content of this node. Can be an empty string. Be aware
   that for nodes of type wxXML_ELEMENT_NODE (the most used node type)
   the content is an empty string. See GetNodeContent() for more details.

=head2 Wx::XmlNode::GetDepth

   int GetDepth(wxXmlNode* grandparent = NULL) const

   Returns the number of nodes which separe this node from grandparent.

   This function searches only the parents of this node until it finds
   grandparent or the NULL node (which is the parent of non-linked nodes
   or the parent of a wxXmlDocument's root node).

=head2 Wx::XmlNode::GetNodeContent

   wxString GetNodeContent() const

   Returns the content of the first child node of type wxXML_TEXT_NODE or
   wxXML_CDATA_SECTION_NODE. This function is very useful since the XML
   snippet "<tagname>tagcontent</tagname>" is represented by expat with
   the following tag tree:

   wxXML_ENTITY_NODE name="tagname", content=""
   |-- wxXML_TEXT_NODE name="", content="tagcontent"

   or eventually:

   wxXML_ENTITY_NODE name="tagname", content=""
   |-- wxXML_CDATA_SECTION_NODE name="", content="tagcontent"

   An empty string is returned if the node has no children of type
   wxXML_TEXT_NODE or wxXML_CDATA_SECTION_NODE, or if the content of the
   first child of such types is empty.

=head2 Wx::XmlNode::GetName

   wxString GetName() const

   Returns the name of this node. Can be an empty string (e.g. for nodes
   of type wxXML_TEXT_NODE or wxXML_CDATA_SECTION_NODE).

=head2 Wx::XmlNode::GetNext

   wxXmlNode* GetNext() const

   Returns a pointer to the sibling of this node or NULL if there are no
   siblings.

=head2 Wx::XmlNode::GetParent

   wxXmlNode* GetParent() const

   Returns a pointer to the parent of this node or NULL if this node has
   no parent.

=head2 Wx::XmlNode::GetPropVal

   bool GetPropVal(const wxString& propName, wxString* value) const

   Returns true if a property named propName could be found. The value of
   that property is saved in value (which must not be NULL).

   wxString GetPropVal(const wxString& propName, const wxString&
   defaultVal) const

   Returns the value of the property named propName if it does exist. If
   it does not exist, the defaultVal is returned.

=head2 Wx::XmlNode::GetProperties

   wxXmlProperty * GetProperties() const

   Return a pointer to the first property of this node.

=head2 Wx::XmlNode::GetType

   wxXmlNodeType GetType() const

   Returns the type of this node.

=head2 Wx::XmlNode::HasProp

   bool HasProp(const wxString& propName) const

   Returns true if this node has a property named propName.

=head2 Wx::XmlNode::InsertChild

   bool InsertChild(wxXmlNode* child, wxXmlNode* followingNode)

   Inserts the child node immediately before followingNode in the
   children list. If followingNode is NULL, then child is prepended to
   the list of children and becomes the first child of this node. Returns
   true if followingNode has been found and the child node has been
   inserted.

=head2 Wx::XmlNode::InsertChildAfter

   bool InsertChildAfter(wxXmlNode* child, wxXmlNode* precedingNode)

   Inserts the child node immediately after precedingNode in the children
   list. Returns true if precedingNode has been found and the child node
   has been inserted.

   Parameters

   child

       Node to insert.

=head2 Wx::XmlNode::IsWhitespaceOnly

   bool IsWhitespaceOnly() const

   Returns true if the content of this node is a string containing only
   whitespaces (spaces, tabs, new lines, etc). Note that this function is
   locale-independent since the parsing of XML documents must always
   produce the exact same tree regardless of the locale it runs under.

=head2 Wx::XmlNode::RemoveChild

   bool RemoveChild(wxXmlNode* child)

   Removes the given node from the children list. Returns true if the
   node was found and removed or false if the node could not be found.

   Note that the caller is reponsible for deleting the removed node in
   order to avoid memory leaks.

=head2 Wx::XmlNode::SetChildren

   void SetChildren(wxXmlNode* child)

   Sets as first child the given node. The caller is responsible to
   delete any previously present children node.

=head2 Wx::XmlNode::SetContent

   void SetContent(const wxString& con)

   Sets the content of this node.

=head2 Wx::XmlNode::SetName

   void SetName(const wxString& name)

   Sets the name of this node.

=head2 Wx::XmlNode::SetNext

   void SetNext(wxXmlNode* next)

   Sets as sibling the given node. The caller is responsible to delete
   any previously present sibling node.

=head2 Wx::XmlNode::SetParent

   void SetParent(wxXmlNode* parent)

   Sets as parent the given node. The caller is responsible to delete any
   previously present parent node.

=head2 Wx::XmlNode::SetProperties

   void SetProperties(wxXmlProperty* prop)

   Sets as first property the given wxXmlProperty object. The caller is
   responsible to delete any previously present properties attached to
   this node.

=head2 Wx::XmlNode::SetType

   void SetType(wxXmlNodeType type)

   Sets the type of this node.

=head1 Wx::XmlProperty

=head2 Wx::XmlProperty::new

   wxXmlProperty()

=head2 Wx::XmlProperty::DESTROY

   ~wxXmlProperty()

   The virtual destructor.

=head2 Wx::XmlProperty::GetName

   wxString GetName() const

   Returns the name of this property.

=head2 Wx::XmlProperty::GetNext

   wxXmlProperty* GetNext() const

   Returns the sibling of this property or NULL if there are no siblings.

=head2 Wx::XmlProperty::GetValue

   wxString GetValue() const

   Returns the value of this property.

=head2 Wx::XmlProperty::SetName

   void SetName(const wxString& name)

   Sets the name of this property.

=head2 Wx::XmlProperty::SetNext

   void SetNext(wxXmlProperty* next)

   Sets the sibling of this property.

=head2 Wx::XmlProperty::SetValue

   void SetValue(const wxString& value)

   Sets the value of this property.

=head1 Wx::XmlResource

=head2 Wx::XmlResource::new

   wxXmlResource(const wxString& filemask, int flags = wxXRC_USE_LOCALE,
   const wxStringdomain = wxEmptyString)

   Constructor.

   filemask

       The XRC file, archive file, or wildcard specification that will be
       used to load all resource files inside a zip archive.

   flags

       wxXRC_USE_LOCALE: translatable strings will be translated via _().
       wxXRC_NO_SUBCLASSING: subclass property of object nodes will be
       ignored (useful for previews in XRC editors).

   domain

       The name of the gettext catalog to search for translatable
       strings. By default all loaded catalogs will be searched. This
       provides a way to allow the strings to only come from a specific
       catalog.

   wxXmlResource(int flags = wxXRC_USE_LOCALE, const wxStringdomain =
   wxEmptyString)

   Constructor.

   flags

       wxXRC_USE_LOCALE: translatable strings will be translated via _().
       wxXRC_NO_SUBCLASSING: subclass property of object nodes will be
       ignored (useful for previews in XRC editors). wxXRC_NO_RELOADING
       will prevent the XRC files from being reloaded from disk in case
       they have been modified there since being last loaded (may
       slightly speed up loading them).

   domain

       The name of the gettext catalog to search for translatable
       strings. By default all loaded catalogs will be searched. This
       provides a way to allow the strings to only come from a specific
       catalog.

=head2 Wx::XmlResource::DESTROY

   ~wxXmlResource()

   Destructor.

=head2 Wx::XmlResource::AddHandler

   void AddHandler(wxXmlResourceHandler* handler)

   Initializes only a specific handler (or custom handler). Convention
   says that the handler name is equal to the control's name plus
   'XmlHandler', for example wxTextCtrlXmlHandler,
   wxHtmlWindowXmlHandler. The XML resource compiler (wxxrc) can create
   include file that contains initialization code for all controls used
   within the resource. Note that this handler should be allocated on the
   heap, since it will be delete by ClearHandlers later.

=head2 Wx::XmlResource::AttachUnknownControl

   bool AttachUnknownControl(const wxString& name, wxWindow* control,
   wxWindow* parent = NULL)

   Attaches an unknown control to the given panel/window/dialog. Unknown
   controls are used in conjunction with <object class="unknown">.

=head2 Wx::XmlResource::ClearHandlers

   void ClearHandlers()

   Removes all handlers and deletes them (this means that any handlers
   added using AddHandler must be allocated on the heap).

=head2 Wx::XmlResource::CompareVersion

   int CompareVersion(int major, int minor, int release, int revision)
   const

   Compares the XRC version to the argument. Returns -1 if the XRC
   version is less than the argument, +1 if greater, and 0 if they equal.

=head2 Wx::XmlResource::Get

   wxXmlResource* Get()

   Gets the global resources object or creates one if none exists.

=head2 Wx::XmlResource::GetFlags

   int GetFlags()

   Returns flags, which may be a bitlist of wxXRC_USE_LOCALE and
   wxXRC_NO_SUBCLASSING.

=head2 Wx::XmlResource::GetVersion

   long GetVersion() const

   Returns version information (a.b.c.d = d+ 256*c + 2562*b + 2563*a).

=head2 Wx::XmlResource::GetXRCID

   int GetXRCID(const wxChar* str_id, int value_if_not_found = -2)

   Returns a numeric ID that is equivalent to the string ID used in an
   XML resource. If an unknown str_id is requested (i.e. other than
   wxID_XXX or integer), a new record is created which associates the
   given string with a number. If value_if_not_found is wxID_NONE, the
   number is obtained via wxNewId(). Otherwise value_if_not_found is
   used. Macro XRCID(name) is provided for convenient use in event
   tables.

=head2 Wx::XmlResource::InitAllHandlers

   void InitAllHandlers()

   Initializes handlers for all supported controls/windows. This will
   make the executable quite big because it forces linking against most
   of the wxWidgets library.

=head2 Wx::XmlResource::Load

   bool Load(const wxString& filemask)

   Loads resources from XML files that match given filemask. This method
   understands VFS (see filesys.h).

=head2 Wx::XmlResource::LoadBitmap

   wxBitmap LoadBitmap(const wxString& name)

   Loads a bitmap resource from a file.

=head2 Wx::XmlResource::LoadDialog

   wxDialog* LoadDialog(wxWindow* parent, const wxString& name)

   Loads a dialog. dlg points to a parent window (if any).

   bool LoadDialog(wxDialog* dlg, wxWindow* parent, const wxString& name)

   Loads a dialog. dlg points to parent window (if any).

   This form is used to finish creation of an already existing instance
   (the main reason for this is that you may want to use derived class
   with a new event table).

   Example:

     MyDialog dlg;
     wxTheXmlResource->LoadDialog(&dlg, mainFrame, "my_dialog");
     dlg.ShowModal();

=head2 Wx::XmlResource::LoadFrame

   bool LoadFrame(wxFrame* frame, wxWindow* parent, const wxString& name)

   Loads a frame.

=head2 Wx::XmlResource::LoadIcon

   wxIcon LoadIcon(const wxString& name)

   Loads an icon resource from a file.

=head2 Wx::XmlResource::LoadMenu

   wxMenu* LoadMenu(const wxString& name)

   Loads menu from resource. Returns NULL on failure.

=head2 Wx::XmlResource::LoadMenuBar

   wxMenuBar* LoadMenuBar(wxWindow* parent, const wxString& name)

   Loads a menubar from resource. Returns NULL on failure.

   wxMenuBar* LoadMenuBar(const wxString& name)

   Loads a menubar from resource. Returns NULL on failure.

=head2 Wx::XmlResource::LoadPanel

   wxPanel* LoadPanel(wxWindow* parent, const wxString& name)

   Loads a panel. panel points to parent window (if any).

   bool LoadPanel(wxPanel* panel, wxWindow* parent, const wxString& name)

   Loads a panel. panel points to parent window (if any). This form is
   used to finish creation of an already existing instance.

=head2 Wx::XmlResource::LoadToolBar

   wxToolBar* LoadToolBar(wxWindow* parent, const wxString& name)

   Loads a toolbar.

=head2 Wx::XmlResource::Set

   wxXmlResource* Set(wxXmlResource* res)

   Sets the global resources object and returns a pointer to the previous
   one (may be NULL).

=head2 Wx::XmlResource::SetFlags

   void SetFlags(int flags)

   Sets flags (bitlist of wxXRC_USE_LOCALE and wxXRC_NO_SUBCLASSING).

=head2 Wx::XmlResource::Unload

   bool Unload(const wxString& filename)

   This function unloads a resource previously loaded by Load().

   Returns true if the resource was successfully unloaded and false if it
   hasn't been found in the list of loaded resources.

=head2 Wx::XmlResource::GetDomain

   wxChar* GetDomain()

   Returns the domain (message catalog) that will be used to load
   translatable strings in the XRC.

=head2 Wx::XmlResource::SetDomain

   wxChar* SetDomain(const wxChar* domain)

   Sets the domain (message catalog) that will be used to load
   translatable strings in the XRC.

=head1 Wx::XmlResourceHandler

=head2 Wx::XmlResourceHandler::new

   wxXmlResourceHandler()

   Default constructor.

=head2 Wx::XmlResourceHandler::DESTROY

   ~wxXmlResourceHandler()

   Destructor.

=head2 Wx::XmlResourceHandler::AddStyle

   void AddStyle(const wxString& name, int value)

   Add a style flag (e.g. wxMB_DOCKABLE) to the list of flags understood
   by this handler.

=head2 Wx::XmlResourceHandler::AddWindowStyles

   void AddWindowStyles()

   Add styles common to all wxWindow-derived classes.

=head2 Wx::XmlResourceHandler::CanHandle

   bool CanHandle(wxXmlNode* node)

   Returns true if it understands this node and can create a resource
   from it, false otherwise.

   Note

   You must not call any wxXmlResourceHandler methods except IsOfClass
   from this method! The instance is not yet initialized with node data
   at the time CanHandle is called and it is only safe to operate on node
   directly or to call IsOfClass.

=head2 Wx::XmlResourceHandler::CreateChildren

   void CreateChildren(wxObject* parent, bool this_hnd_only = false)

   Creates children.

=head2 Wx::XmlResourceHandler::CreateChildrenPrivately

   void CreateChildrenPrivately(wxObject* parent, wxXmlNode* rootnode =
   NULL)

   Helper function.

=head2 Wx::XmlResourceHandler::CreateResFromNode

   wxObject* CreateResFromNode(wxXmlNode* node, wxObject* parent,
   wxObject* instance = NULL)

   Creates a resource from a node.

=head2 Wx::XmlResourceHandler::CreateResource

   wxObject* CreateResource(wxXmlNode* node, wxObject* parent, wxObject*
   instance)

   Creates an object (menu, dialog, control, ...) from an XML node.
   Should check for validity. parent is a higher-level object (usually
   window, dialog or panel) that is often necessary to create the
   resource. If instance is non-NULL it should not create a new instance
   via 'new' but should rather use this one, and call its Create method.

=head2 Wx::XmlResourceHandler::DoCreateResource

   wxObject* DoCreateResource()

   Called from CreateResource after variables were filled.

=head2 Wx::XmlResourceHandler::GetBitmap

   wxBitmap GetBitmap(const wxString& param = wxT("bitmap"), wxSize size
   = wxDefaultSize)

   Gets a bitmap.

=head2 Wx::XmlResourceHandler::GetBool

   bool GetBool(const wxString& param, bool defaultv = false)

   Gets a bool flag (1, t, yes, on, true are true, everything else is
   false).

=head2 Wx::XmlResourceHandler::GetColour

   wxColour GetColour(const wxString& param, const wxColour& default =
   wxNullColour)

   Gets colour in HTML syntax (#RRGGBB).

=head2 Wx::XmlResourceHandler::GetCurFileSystem

   wxFileSystem& GetCurFileSystem()

   Returns the current file system.

=head2 Wx::XmlResourceHandler::GetDimension

   wxCoord GetDimension(const wxString& param, wxCoord defaultv = 0)

   Gets a dimension (may be in dialog units).

=head2 Wx::XmlResourceHandler::GetFont

   wxFont GetFont(const wxString& param = wxT("font"))

   Gets a font.

=head2 Wx::XmlResourceHandler::GetID

   int GetID()

   Returns the XRCID.

=head2 Wx::XmlResourceHandler::GetIcon

   wxIcon GetIcon(const wxString& param = wxT("icon"), wxSize size =
   wxDefaultSize)

   Returns an icon.

=head2 Wx::XmlResourceHandler::GetLong

   long GetLong(const wxString& param, long defaultv = 0)

   Gets the integer value from the parameter.

=head2 Wx::XmlResourceHandler::GetName

   wxString GetName()

   Returns the resource name.

=head2 Wx::XmlResourceHandler::GetNodeContent

   wxString GetNodeContent(wxXmlNode* node)

   Gets node content from wxXML_ENTITY_NODE.

=head2 Wx::XmlResourceHandler::GetParamNode

   wxXmlNode* GetParamNode(const wxString& param)

   Finds the node or returns NULL.

=head2 Wx::XmlResourceHandler::GetParamValue

   wxString GetParamValue(const wxString& param)

   Finds the parameter value or returns the empty string.

=head2 Wx::XmlResourceHandler::GetPosition

   wxPoint GetPosition(const wxString& param = wxT("pos"))

   Gets the position (may be in dialog units).

=head2 Wx::XmlResourceHandler::GetSize

   wxSize GetSize(const wxString& param = wxT("size"))

   Gets the size (may be in dialog units).

=head2 Wx::XmlResourceHandler::GetStyle

   int GetStyle(const wxString& param = wxT("style"), int defaults = 0)

   Gets style flags from text in form "flag | flag2| flag3 |..." Only
   understands flags added with AddStyle.

=head2 Wx::XmlResourceHandler::GetText

   wxString GetText(const wxString& param)

   Gets text from param and does some conversions:

=head2 Wx::XmlResourceHandler::HasParam

   bool HasParam(const wxString& param)

   Check to see if a parameter exists.

=head2 Wx::XmlResourceHandler::IsOfClass

   bool IsOfClass(wxXmlNode* node, const wxString& classname)

   Convenience function. Returns true if the node has a property class
   equal to classname, e.g. <object class="wxDialog">.

=head2 Wx::XmlResourceHandler::SetParentResource

   void SetParentResource(wxXmlResource* res)

   Sets the parent resource.

=head2 Wx::XmlResourceHandler::SetupWindow

   void SetupWindow(wxWindow* wnd)

   Sets common window options.

=head1 Wx::ZipEntry

=head2 Wx::ZipEntry::new

   wxZipEntry(const wxString& name = wxEmptyString, const wxDateTime& dt
   = wxDateTime::Now(), off_t size = wxInvalidOffset)

   Constructor.

   wxZipEntry(const wxZipEntry& entry)

   Copy constructor.

=head2 Wx::ZipEntry::Clone

   wxZipEntry* Clone() const

   Make a copy of this entry.

=head2 Wx::ZipEntry::Get/SetComment

   wxString GetComment() const

   void SetComment(const wxString& comment)

   A short comment for this entry.

=head2 Wx::ZipEntry::GetCompressedSize

   off_t GetCompressedSize() const

   The compressed size of this entry in bytes.

=head2 Wx::ZipEntry::GetCrc

   wxUint32 GetCrc() const

   CRC32 for this entry's data.

=head2 Wx::ZipEntry::Get/SetExternalAttributes

   wxUint32 GetExternalAttributes() const

   void SetExternalAttributes(wxUint32 attr)

   The low 8 bits are always the DOS/Windows file attributes for this
   entry. The values of these attributes are given in the enumeration
   wxZipAttributes.

   The remaining bits can store platform specific permission bits or
   attributes, and their meaning depends on the value of
   SetSystemMadeBy(). If IsMadeByUnix() is true then the high 16 bits are
   unix mode bits.

   The following other accessors access these bits:

   IsReadOnly/SetIsReadOnly

=head2 Wx::ZipEntry::Get/SetExtra

   const char* GetExtra() const

   size_t GetExtraLen() const

   void SetExtra(const char* extra, size_t len)

   The extra field from the entry's central directory record.

   The extra field is used to store platform or application specific
   data. See Pkware's document 'appnote.txt' for information on its
   format.

=head2 Wx::ZipEntry::GetFlags

   int GetFlags() const

   Returns a combination of the bits flags in the enumeration wxZipFlags.

=head2 Wx::ZipEntry::GetInternalName

   wxString GetInternalName() const

   Returns the entry's filename in the internal format used within the
   archive. The name can include directory components, i.e. it can be a
   full path.

   The names of directory entries are returned without any trailing path
   separator. This gives a canonical name that can be used in
   comparisons.

   wxString GetInternalName(const wxString& name, wxPathFormat format =
   wxPATH_NATIVE, bool* pIsDir = NULL)

   A static member that translates a filename into the internal format
   used within the archive. If the third parameter is provided, the bool
   pointed to is set to indicate whether the name looks like a directory
   name (i.e. has a trailing path separator).

   See also

   Looking up an archive entry by name

=head2 Wx::ZipEntry::Get/SetLocalExtra

   const char* GetLocalExtra() const

   size_t GetLocalExtraLen() const

   void SetLocalExtra(const char* extra, size_t len)

   The extra field from the entry's local record.

   The extra field is used to store platform or application specific
   data. See Pkware's document 'appnote.txt' for information on its
   format.

=head2 Wx::ZipEntry::Get/SetMethod

   int GetMethod() const

   void SetMethod(int method)

   The compression method. The enumeration wxZipMethod lists the possible
   values.

   The default constructor sets this to wxZIP_METHOD_DEFAULT, which
   allows wxZipOutputStream to choose the method when writing the entry.

=head2 Wx::ZipEntry::Get/SetMode

   int GetMode() const

   If IsMadeByUnix() is true then returns the unix permission bits stored
   in GetExternalAttributes(). Otherwise synthesises them from the DOS
   attributes.

   void SetMode(int mode)

   Sets the DOS attributes in GetExternalAttributes() to be consistent
   with the mode given.

   If IsMadeByUnix() is true then also stores mode in
   GetExternalAttributes().

   Note that the default constructor sets GetSystemMadeBy() to
   wxZIP_SYSTEM_MSDOS by default. So to be able to store unix permissions
   when creating zips, call SetSystemMadeBy(wxZIP_SYSTEM_UNIX).

=head2 Wx::ZipEntry::SetNotifier

   void SetNotifier(wxZipNotifier& notifier)

   void UnsetNotifier()

   Sets the notifier for this entry. Whenever the wxZipInputStream
   updates this entry, it will then invoke the associated notifier's
   OnEntryUpdated method.

   Setting a notifier is not usually necessary. It is used to handle
   certain cases when modifying an zip in a pipeline (i.e. between
   non-seekable streams).

   See also

   Archives on non-seekable streams

=head2 Wx::ZipEntry::Get/SetSystemMadeBy

   int GetSystemMadeBy() const

   void SetSystemMadeBy(int system)

   The originating file-system. The default constructor sets this to
   wxZIP_SYSTEM_MSDOS. Set it to wxZIP_SYSTEM_UNIX in order to be able to
   store unix permissions using SetMode().

=head2 Wx::ZipEntry::IsMadeByUnix

   bool IsMadeByUnix() const

   Returns true if GetSystemMadeBy() is a flavour of unix.

=head2 Wx::ZipEntry::IsText/SetIsText

   bool IsText() const

   void SetIsText(bool isText = true)

   Indicates that this entry's data is text in an 8-bit encoding.

=head1 Wx::ZipInputStream

=head2 Wx::ZipInputStream::new

   wxZipInputStream(wxInputStream& stream, wxMBConv& conv = wxConvLocal)

   wxZipInputStream(wxInputStream*stream, wxMBConv& conv = wxConvLocal)

   Constructor. In a Unicode build the second parameter conv is used to
   translate the filename and comment fields into Unicode. It has no
   effect on the stream's data.

   If the parent stream is passed as a pointer then the new filter stream
   takes ownership of it. If it is passed by reference then it does not.

   wxZipInputStream(const wxString& archive, const wxString& file)

   Compatibility constructor (requires WXWIN_COMPATIBILITY_2_6).

   When this constructor is used, an emulation of seeking is switched on
   for compatibility with previous versions. Note however, that it is
   deprecated.

=head2 Wx::ZipInputStream::CloseEntry

   bool CloseEntry()

   Closes the current entry. On a non-seekable stream reads to the end of
   the current entry first.

=head2 Wx::ZipInputStream::GetComment

   wxString GetComment()

   Returns the zip comment.

   This is stored at the end of the zip, therefore when reading a zip
   from a non-seekable stream, it returns the empty string until the end
   of the zip has been reached, i.e. when GetNextEntry() returns NULL.

=head2 Wx::ZipInputStream::GetNextEntry

   wxZipEntry* GetNextEntry()

   Closes the current entry if one is open, then reads the meta-data for
   the next entry and returns it in a wxZipEntry object, giving away
   ownership. The stream is then open and can be read.

=head2 Wx::ZipInputStream::GetTotalEntries

   int GetTotalEntries()

   For a zip on a seekable stream returns the total number of entries in
   the zip. For zips on non-seekable streams returns the number of
   entries returned so far by GetNextEntry().

=head2 Wx::ZipInputStream::OpenEntry

   bool OpenEntry(wxZipEntry& entry)

   Closes the current entry if one is open, then opens the entry
   specified by the entry object.

   entry should be from the same zip file, and the zip should be on a
   seekable stream.

   See also

   Looking up an archive entry by name

=head1 Wx::ZipNotifier

=head2 Wx::ZipNotifier::OnEntryUpdated

   void OnEntryUpdated(wxZipEntry& entry)

   Override this to receive notifications when an wxZipEntry object
   changes.

=head1 Wx::ZipOutputStream

=head2 Wx::ZipOutputStream::new

   wxZipOutputStream(wxOutputStream& stream, int level = -1, wxMBConv&
   conv = wxConvLocal)

   wxZipOutputStream(wxOutputStream*stream, int level = -1, wxMBConv&
   conv = wxConvLocal)

   Constructor. level is the compression level to use. It can be a value
   between 0 and 9 or -1 to use the default value which currently is
   equivalent to 6.

   If the parent stream is passed as a pointer then the new filter stream
   takes ownership of it. If it is passed by reference then it does not.

   In a Unicode build the third parameter conv is used to translate the
   filename and comment fields to an 8-bit encoding. It has no effect on
   the stream's data.

=head2 Wx::ZipOutputStream::DESTROY

   ~wxZipOutputStream()

   The destructor calls Close() to finish writing the zip if it has not
   been called already.

=head2 Wx::ZipOutputStream::Close

   bool Close()

   Finishes writing the zip, returning true if successful. Called by the
   destructor if not called explicitly.

=head2 Wx::ZipOutputStream::CloseEntry

   bool CloseEntry()

   Close the current entry. It is called implicitly whenever another new
   entry is created with CopyEntry() or PutNextEntry(), or when the zip
   is closed.

=head2 Wx::ZipOutputStream::CopyArchiveMetaData

   bool CopyArchiveMetaData(wxZipInputStream& inputStream)

   Transfers the zip comment from the wxZipInputStream to this output
   stream.

=head2 Wx::ZipOutputStream::CopyEntry

   bool CopyEntry(wxZipEntry* entry, wxZipInputStream& inputStream)

   Takes ownership of entry and uses it to create a new entry in the zip.
   entry is then opened in inputStream and its contents copied to this
   stream.

   CopyEntry() is much more efficient than transferring the data using
   Read() and Write() since it will copy them without decompressing and
   recompressing them.

   For zips on seekable streams, entry must be from the same zip file as
   stream. For non-seekable streams, entry must also be the last thing
   read from inputStream.

=head2 Wx::ZipOutputStream::Get/SetLevel

   int GetLevel() const

   void SetLevel(int level)

   Set the compression level that will be used the next time an entry is
   created. It can be a value between 0 and 9 or -1 to use the default
   value which currently is equivalent to 6.

=head2 Wx::ZipOutputStream::PutNextDirEntry

   bool PutNextDirEntry(const wxString& name, const wxDateTime& dt =
   wxDateTime::Now())

   Create a new directory entry (see wxArchiveEntry::IsDir()) with the
   given name and timestamp.

   PutNextEntry() can also be used to create directory entries, by
   supplying a name with a trailing path separator.

=head2 Wx::ZipOutputStream::PutNextEntry

   bool PutNextEntry(wxZipEntry* entry)

   Takes ownership of entry and uses it to create a new entry in the zip.

   bool PutNextEntry(const wxString& name, const wxDateTime& dt =
   wxDateTime::Now(), off_t size = wxInvalidOffset)

   Create a new entry with the given name, timestamp and size.

=head2 Wx::ZipOutputStream::SetComment

   void SetComment(const wxString& comment)

   Sets a comment for the zip as a whole. It is written at the end of the
   zip.

=head1 Wx::ZlibInputStream

=head2 Wx::ZlibInputStream::new

   wxZlibInputStream(wxInputStream& stream, int flags = wxZLIB_AUTO)

   wxZlibInputStream(wxInputStream* stream, int flags = wxZLIB_AUTO)

   If the parent stream is passed as a pointer then the new filter stream
   takes ownership of it. If it is passed by reference then it does not.

   The flags wxZLIB_ZLIB and wxZLIB_GZIP specify whether the input data
   is in zlib or gzip format. If wxZLIB_AUTO is used, then zlib will
   autodetect the stream type, this is the default.

   If flags is wxZLIB_NO_HEADER, then the data is assumed to be a raw
   deflate stream without either zlib or gzip headers. This is a lower
   level mode, which is not usually used directly. It can be used to read
   a raw deflate stream embedded in a higher level protocol.

   This version is not by default compatible with the output produced by
   the version of wxZlibOutputStream in wxWidgets 2.4.x. However, there
   is a compatibility mode, which is switched on by passing
   wxZLIB_24COMPATIBLE for flags. Note that in when operating in
   compatibility mode error checking is very much reduced. The following
   symbols can be use for the flags:

   // Flags
   enum {
   #if WXWIN_COMPATIBILITY_2_4
       wxZLIB_24COMPATIBLE = 4, // read v2.4.x data without error
   #endif
       wxZLIB_NO_HEADER = 0,    // raw deflate stream, no header or checksum
       wxZLIB_ZLIB = 1,         // zlib header and checksum
       wxZLIB_GZIP = 2,         // gzip header and checksum, requires zlib 1.2.1+
       wxZLIB_AUTO = 3          // autodetect header zlib or gzip
   };

=head2 Wx::ZlibInputStream::CanHandleGZip

   static bool CanHandleGZip()

   Returns true if zlib library in use can handle gzip compressed data.

=head1 Wx::ZlibOutputStream

=head2 Wx::ZlibOutputStream::new

   wxZlibOutputStream(wxOutputStream& stream, int level = -1, int flags =
   wxZLIB_ZLIB)

   wxZlibOutputStream(wxOutputStream* stream, int level = -1, int flags =
   wxZLIB_ZLIB)

   Creates a new write-only compressed stream. level means level of
   compression. It is number between 0 and 9 (including these values)
   where 0 means no compression and 9 best but slowest compression. -1 is
   default value (currently equivalent to 6).

   If the parent stream is passed as a pointer then the new filter stream
   takes ownership of it. If it is passed by reference then it does not.

   The flags wxZLIB_ZLIB and wxZLIB_GZIP specify whether the output data
   will be in zlib or gzip format. wxZLIB_ZLIB is the default.

   If flags is wxZLIB_NO_HEADER, then a raw deflate stream is output
   without either zlib or gzip headers. This is a lower level mode, which
   is not usually used directly. It can be used to embed a raw deflate
   stream in a higher level protocol.

   The following symbols can be use for the compression level and flags:

   // Compression level
   enum {
       wxZ_DEFAULT_COMPRESSION = -1,
       wxZ_NO_COMPRESSION = 0,
       wxZ_BEST_SPEED = 1,
       wxZ_BEST_COMPRESSION = 9
   };

=head2 Wx::ZlibOutputStream::CanHandleGZip

   static bool CanHandleGZip()

   Returns true if zlib library in use can handle gzip compressed data.

=head1 COPYRIGHT AND LICENSE

Copyright 2010 C<< <ahmad.zawawi at gmail.com> >>

This document was generated by C<parse_wxwidgets_docs> which is found at
L<http://svn.perlide.org/padre/trunk/tools/parse_wxwidgets_docs>. The original
wxWidgets HTML documentation
L<http://garr.dl.sourceforge.net/project/wxwindows/Documents/2.8.10/wxWidgets-2.8.10-HTML.zip>
is copyrighted as the following:

    Copyright (c) 1992-2006 by Julian Smart, Robert Roebling, Vadim Zeitlin
    and other members of the wxWidgets team. Portions (c) 1996 Artificial
    Intelligence Applications Institute.

    The original wxWidgets HTML documentation is licensed under:
      wxWindows Library License version 3.1, http://docs.wxwidgets.org/2.8.10/wx_wxlicense.html
      GNU Library General Public License version 2, http://docs.wxwidgets.org/2.8.10/wx_gnulicense.html

This document is part of free software; you can redistribute it and/or modify it
under the same terms as Perl 5 itself.

