Update to docs incl. wxString first stab; added a couple of palette-related events (wxMSW)

needed for wxGLCanvas


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@392 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

distrib/msw/generic.rsp

@@ -48,6 +48,7 @@ src/zlib/*.3
 src/zlib/*.mms
 
 include/wx/*.h
+include/wx/*.cpp
 include/wx/wx_setup.vms
 include/wx/common/*.h
 include/wx/generic/*.h

docs/latex/wx/button.tex

@@ -99,7 +99,7 @@ box.
 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 \helpref{wxWindow::SetFocus}{wxwindowsetfocus}\rtfsp
-which sets the keyboard focus for windows and text panel items, \helpref{wxWindow::OnDefaultAction}{wxwindowondefaultaction}\rtfsp
+which sets the keyboard focus for windows and text panel items,\rtfsp
 and \helpref{wxWindow::GetDefaultItem}{wxwindowgetdefaultitem}.
 
 Note that under Motif, calling this function immediately after

docs/latex/wx/classes.tex

@@ -61,6 +61,8 @@ $$\image{14cm;0cm}{wxclass.ps}$$
 \input document.tex
 \input docchfrm.tex
 \input docmanag.tex
+\input docmdich.tex
+\input docmdipr.tex
 \input docprfrm.tex
 \input doctempl.tex
 \input dropevt.tex
@@ -144,7 +146,7 @@ $$\image{14cm;0cm}{wxclass.ps}$$
 \input statbox.tex
 \input stattext.tex
 \input statusbr.tex
-%\input wxstring.tex
+\input wxstring.tex
 \input strlist.tex
 \input sysclevt.tex
 \input settings.tex

docs/latex/wx/datstrm.tex

@@ -6,7 +6,7 @@ Sparc or anything else.
 
 \latexignore{\rtfignore{\wxheading{Members}}}
 
-\membersection{wxDataStream::wxDataStream}\label{wxwaveconstr}
+\membersection{wxDataStream::wxDataStream}\label{wxdatastreamconstr}
 
 \func{}{wxDataStream}{\param{istream\&}{ stream}}
 

docs/latex/wx/docchfrm.tex

@@ -35,7 +35,7 @@ The view associated with the frame.
 \membersection{wxDocChildFrame::wxDocChildFrame}
 
 \func{}{wxDocChildFrame}{\param{wxDocument* }{doc}, \param{wxView* }{view}, \param{wxFrame* }{parent},
- \param{const wxString\& }{title}, \param{const wxPoint\&}{ pos = wxDefaultPosition},
+ \param{wxWindowID}{ id}, \param{const wxString\& }{title}, \param{const wxPoint\&}{ pos = wxDefaultPosition},
  \param{const wxSize\&}{ size = wxDefaultSize},
  \param{long}{ style = wxDEFAULT\_FRAME\_STYLE}, \param{const wxString\& }{name = ``frame"}}
 

docs/latex/wx/docmdich.tex

@@ -0,0 +1,89 @@
+\section{\class{wxDocMDIChildFrame}}\label{wxdocmdichildframe}
+
+The wxDocMDIChildFrame class provides a default frame for displaying documents
+on separate windows. This class can only be used for MDI child frames.
+
+The class is part of the document/view framework supported by wxWindows,
+and cooperates with the \helpref{wxView}{wxview}, \helpref{wxDocument}{wxdocument},
+\rtfsp\helpref{wxDocManager}{wxdocmanager} and \helpref{wxDocTemplate}{wxdoctemplate} classes.
+
+See the example application in {\tt samples/docview}.
+
+\wxheading{Derived from}
+
+\helpref{wxMDIChildFrame}{wxmdichildframe}\\
+\helpref{wxFrame}{wxframe}\\
+\helpref{wxWindow}{wxwindow}\\
+\helpref{wxEvtHandler}{wxevthandler}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\helpref{Document/view overview}{docviewoverview}, \helpref{wxMDIChildFrame}{wxmdichildframe}
+
+\membersection{wxDocMDIChildFrame::m\_childDocument}
+
+\member{wxDocument*}{m\_childDocument}
+
+The document associated with the frame.
+
+\membersection{wxDocMDIChildFrame::m\_childView}
+
+\member{wxView*}{m\_childView}
+
+The view associated with the frame.
+
+\membersection{wxDocMDIChildFrame::wxDocMDIChildFrame}
+
+\func{}{wxDocMDIChildFrame}{\param{wxDocument* }{doc}, \param{wxView* }{view}, \param{wxFrame* }{parent},
+ \param{wxWindowID}{ id}, \param{const wxString\& }{title}, \param{const wxPoint\&}{ pos = wxDefaultPosition},
+ \param{const wxSize\&}{ size = wxDefaultSize},
+ \param{long}{ style = wxDEFAULT\_FRAME\_STYLE}, \param{const wxString\& }{name = ``frame"}}
+
+Constructor.
+
+\membersection{wxDocMDIChildFrame::\destruct{wxDocMDIChildFrame}}
+
+\func{}{\destruct{wxDocMDIChildFrame}}{\void}
+
+Destructor.
+
+\membersection{wxDocMDIChildFrame::GetDocument}
+
+\constfunc{wxDocument*}{GetDocument}{\void}
+
+Returns the document associated with this frame.
+
+\membersection{wxDocMDIChildFrame::GetView}
+
+\constfunc{wxView*}{GetView}{\void}
+
+Returns the view associated with this frame.
+
+\membersection{wxDocMDIChildFrame::OnActivate}
+
+\func{void}{OnActivate}{\param{bool}{ active}}
+
+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.
+
+\membersection{wxDocMDIChildFrame::OnClose}
+
+\func{virtual bool}{OnClose}{\void}
+
+Closes and deletes the current view and document.
+
+\membersection{wxDocMDIChildFrame::SetDocument}
+
+\func{void}{SetDocument}{\param{wxDocument *}{doc}}
+
+Sets the document for this frame.
+
+\membersection{wxDocMDIChildFrame::SetView}
+
+\func{void}{SetView}{\param{wxView *}{view}}
+
+Sets the view for this frame.
+
+

docs/latex/wx/docmdipr.tex

@@ -0,0 +1,79 @@
+\section{\class{wxDocMDIParentFrame}}\label{wxdocmdiparentframe}
+
+The wxDocMDIParentFrame class provides a default top-level frame for
+applications using the document/view framework. This class can only be used for MDI parent frames.
+
+It cooperates with the \helpref{wxView}{wxview}, \helpref{wxDocument}{wxdocument},
+\rtfsp\helpref{wxDocManager}{wxdocmanager} and \helpref{wxDocTemplates}{wxdoctemplate} classes.
+
+See the example application in {\tt samples/docview}.
+
+\wxheading{Derived from}
+
+\helpref{wxMDIParentFrame}{wxmdiparentframe}\\
+\helpref{wxFrame}{wxframe}\\
+\helpref{wxWindow}{wxwindow}\\
+\helpref{wxEvtHandler}{wxevthandler}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{See also}
+
+\helpref{Document/view overview}{docviewoverview}, \helpref{wxMDIParentFrame}{wxmdiparentframe}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxDocMDIParentFrame::wxDocMDIParentFrame}
+
+\func{}{wxDocMDIParentFrame}{\param{wxFrame *}{parent}, \param{wxWindowID}{ id},
+ \param{const wxString\& }{title}, \param{int}{ x}, \param{int}{ y}, \param{int}{ width}, \param{int}{ height},
+ \param{long}{ style}, \param{const wxString\& }{name}}
+
+Constructor.
+
+\membersection{wxDocMDIParentFrame::\destruct{wxDocMDIParentFrame}}
+
+\func{}{\destruct{wxDocMDIParentFrame}}{\void}
+
+Destructor.
+
+\membersection{wxDocMDIParentFrame::OnClose}
+
+\func{bool}{OnClose}{\void}
+
+Deletes all views and documents. If no user input cancelled the
+operation, the function returns TRUE 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.
+
+\begin{verbatim}
+bool wxDocMDIParentFrame::OnClose(void)
+{
+  // Delete all views and documents
+  wxNode *node = docManager->GetDocuments().First();
+  while (node)
+  {
+    wxDocument *doc = (wxDocument *)node->Data();
+    wxNode *next = node->Next();
+
+    if (!doc->Close())
+      return FALSE;
+
+    // Implicitly deletes the document when the last
+    // view is removed (deleted)
+    doc->DeleteAllViews();
+
+    // Check document is deleted
+    if (docManager->GetDocuments().Member(doc))
+      delete doc;
+
+    // This assumes that documents are not connected in
+    // any way, i.e. deleting one document does NOT
+    // delete another.
+    node = next;
+  }
+  return TRUE;
+}
+\end{verbatim}
+
+

docs/latex/wx/docprfrm.tex

@@ -23,7 +23,7 @@ See the example application in {\tt samples/docview}.
 
 \membersection{wxDocParentFrame::wxDocParentFrame}
 
-\func{}{wxDocParentFrame}{\param{wxFrame *}{parent},
+\func{}{wxDocParentFrame}{\param{wxFrame *}{parent}, \param{wxWindowID}{ id},
  \param{const wxString\& }{title}, \param{int}{ x}, \param{int}{ y}, \param{int}{ width}, \param{int}{ height},
  \param{long}{ style}, \param{const wxString\& }{name}}
 

docs/latex/wx/function.tex

@@ -479,113 +479,6 @@ This function is only available under Windows.
 Globally sets the cursor; only has an effect in MS Windows.
 See also \helpref{wxCursor}{wxcursor}, \helpref{wxWindow::SetCursor}{wxwindowsetcursor}.
 
-\section{System event functions}
-
-The wxWindows system event implementation is incomplete and
-experimental, but is intended to be a platform-independent way of
-intercepting and sending events, including defining
-application-specific events and handlers.
-
-Ultimately it is intended to be used as a way of testing wxWindows
-applications using scripts, although there are currently
-problems with this (especially with modal dialogs).
-
-All this is documented more to provoke comments and suggestions, and
-jog my own memory, rather than to be used, since it has not been
-tested. However {\bf wxSendEvent} will probably work if you
-instantiate the event structure properly for a command event type (see
-the code in {\tt wb\_panel.cpp} for \helpref{wxWindow::OnDefaultAction}{wxwindowondefaultaction}\rtfsp
-which uses {\bf wxSendEvent} to send a command to the default button).
-
-\membersection{::wxAddPrimaryEventHandler}
-
-\func{bool}{wxAddPrimaryEventHandler}{\param{wxEventHandler}{ handlerFunc}}
-
-Add a primary event handler---the normal event handler for this
-event. For built-in events, these would include moving and resizing
-windows. User-defined primary events might include the code to
-select an image in a diagram (which could of course be achieved by a series
-of external events for mouse-clicking, but would be more difficult to specify
-and less robust).
-
-Returns TRUE if it succeeds.
-
-An event handler takes a pointer to a wxEvent and a boolean flag which is
-TRUE if the event was externally generated, and returns a boolean which is
-TRUE if that event was handled.
-
-\membersection{::wxAddSecondaryEventHandler}
-
-\func{bool}{wxAddSecondaryEventHandler}{\param{wxEventHandler}{ handlerFunc}, \param{bool}{ pre},\\
-  \param{bool}{ override}, \param{bool }{append}}
-
-Add a secondary event handler, pre = TRUE iff it should be called before the
-event is executed. override = TRUE iff the handler is allowed to override
-all subsequent events by returning TRUE. Returns TRUE if succeeds.
-
-A secondary event handler is an application-defined handler that may
-intercept normal events, possibly overriding them. A primary event handler
-provides the normal behaviour for the event.
-
-An event handler takes a pointer to a wxEvent and a boolean flag which is
-TRUE if the event was externally generated, and returns a boolean which is
-TRUE if that event was handled.
-
-\membersection{::wxNotifyEvent}
-
-\func{bool}{wxNotifyEvent}{\param{wxEvent\&}{ event}, \param{bool}{ pre}}
-
-Notify the system of the event you are about to execute/have just
-executed.  If TRUE is returned and pre = TRUE, the calling code should
-not execute the event (since it has been intercepted by a handler and
-vetoed).
-
-These events are always internal, because they're generated from within
-the main application code.
-
-\membersection{::wxRegisterEventClass}
-
-\func{void}{wxRegisterEventClass}{\param{WXTYPE}{ eventClassId},\param{WXTYPE}{ superClassId},\\
-  \param{wxEventConstructor}{ constructor}, \param{const wxString\& }{description}}
-
-Register a new event class (derived from wxEvent), giving the new
-event class type, its superclass, a function for creating a new event
-object of this class, and an optional description.
-
-\membersection{::wxRegisterEventName}
-
-\func{void}{wxRegisterEventName}{\param{WXTYPE}{ eventTypeId},\param{WXTYPE}{ eventClassId},\\
-  \param{const wxString\& }{eventName}}
-
-Register the name of the event. This will allow a simple command
-language where giving the event type name and some arguments will
-cause a new event of class {\it eventClassId} to be created, with given
-event type, and some arguments, allows an event to be dynamically
-constructed and sent.
-
-\membersection{::wxRegisterExternalEventHandlers}
-
-\func{void}{wxRegisterExternalEventHandlers}{\void}
-
-Define this and link before wxWindows library to allow registering
-events from `outside' the main application.
-
-\membersection{::wxRemoveSecondaryEventHandler}
-
-\func{bool}{wxRemoveSecondaryEventHandler}{\param{wxEventHandler}{ handlerFunc}, \param{bool}{ pre}}
-
-Remove a secondary event handler. Returns TRUE if it succeeds.
-
-\membersection{::wxSendEvent}\label{wxsendevent}
-
-\func{bool}{wxSendEvent}{\param{wxEvent\&}{ event}, \param{bool}{ external}}
-
-Send an event to the system; usually it will be external, but set
-external to FALSE if calling from within the main application in
-response to other events.
-
-Returns TRUE if the event was processed.
-
 \section{Printer settings}\label{printersettings}
 
 The following functions are used to control PostScript printing. Under

docs/latex/wx/joystick.tex

@@ -147,11 +147,11 @@ Gets the position of the fifth axis of the joystick, if it exists.
 
 Returns the maximum V position.
 
-\membersection{wxJoystick::GetUMin}\label{wxjoystickgetumin}
+\membersection{wxJoystick::GetVMin}\label{wxjoystickgetvmin}
 
-\constfunc{int}{GetUMin}{\void}
+\constfunc{int}{GetVMin}{\void}
 
-Returns the minimum U position.
+Returns the minimum V position.
 
 \membersection{wxJoystick::GetVPosition}\label{wxjoystickgetvposition}
 

docs/latex/wx/tabctrl.tex

@@ -188,7 +188,7 @@ Sets the client data for a tab.
 \func{bool}{SetItemImage}{\param{int}{ item}, \param{int }{image}}
 
 Sets the image index for the given tab. {\it image} is an index into
-the image list which was set with \helpref{wxTabCtrl::SetImageList}{setimagelist}.
+the image list which was set with \helpref{wxTabCtrl::SetImageList}{wxtabctrlsetimagelist}.
 
 \membersection{wxTabCtrl::SetImageList}\label{wxtabctrlsetimagelist}
 

docs/latex/wx/tdocview.tex

@@ -2,6 +2,7 @@
 
 Classes: \helpref{wxDocument}{wxdocument}, \helpref{wxView}{wxview}, \helpref{wxDocTemplate}{wxdoctemplate},\rtfsp
 \helpref{wxDocManager}{wxdocmanager}, \helpref{wxDocParentFrame}{wxdocparentframe}, \helpref{wxDocChildFrame}{wxdocchildframe},
+\rtfsp\helpref{wxDocMDIParentFrame}{wxdocmdiparentframe}, \helpref{wxDocMDIChildFrame}{wxdocmdichildframe},
 \rtfsp\helpref{wxCommand}{wxcommand}, \helpref{wxCommandProcessor}{wxcommandprocessor}
 
 The document/view framework is found in most application frameworks, because it
@@ -254,42 +255,28 @@ the file history, that will be used for appending the filenames. They are
 appended using menu identifiers in the range wxID\_FILE1 to wxID\_FILE9.
 
 In order to respond to a file load command from one of these identifiers,
-you need to handle them in your wxFrame::OnMenuCommand. Below is the
+you need to handle them using an event handler, for example:
-code used by the default document/view parent frame.
 
+{\small
 \begin{verbatim}
-void wxDocParentFrame::OnMenuCommand(int id)
+BEGIN_EVENT_TABLE(wxDocParentFrame, wxFrame)
+    EVT_MENU(wxID_EXIT, wxDocParentFrame::OnExit)
+    EVT_MENU_RANGE(wxID_FILE1, wxID_FILE9, wxDocParentFrame::OnMRUFile)
+END_EVENT_TABLE()
+
+void wxDocParentFrame::OnExit(wxCommandEvent& WXUNUSED(event))
 {
-  switch (id)
+    Close();
-  {
+}
-    case wxID_EXIT:
+
-    {
+void wxDocParentFrame::OnMRUFile(wxCommandEvent& event)
-      if (GetEventHandler()->OnClose())
+{
-        delete this;
+      wxString f(m_docManager->GetHistoryFile(event.GetSelection() - wxID_FILE1));
-      break;
+      if (f != "")
-    }
+        (void)m_docManager->CreateDocument(f, wxDOC_SILENT);
-    case wxID_FILE1:
-    case wxID_FILE2:
-    case wxID_FILE3:
-    case wxID_FILE4:
-    case wxID_FILE5:
-    case wxID_FILE6:
-    case wxID_FILE7:
-    case wxID_FILE8:
-    case wxID_FILE9:
-    {
-      char *f = docManager->GetHistoryFile(id-wxID_FILE1);
-      if (f)
-        (void)docManager->CreateDocument(f, wxDOC_SILENT);
-      break;
-    }
-    default:
-    {
-      docManager->OnMenuCommand(id);
-    }
-  }
 }
 \end{verbatim}
+}
 
 \subsection{wxWindows predefined command identifiers}\label{predefinedids}
 

docs/latex/wx/thread.tex

@@ -52,7 +52,7 @@ calling thread.
 
 \func{wxThreadError}{Destroy}{\void}
 
-Destroys the thread immediately unless the application has specified deferral via \helpref{wxThread::DeferDestroy}{deferdestroy}.
+Destroys the thread immediately unless the application has specified deferral via \helpref{wxThread::DeferDestroy}{wxthreaddeferdestroy}.
 
 \wxheading{Return value}
 

docs/latex/wx/toolbar.tex

@@ -226,7 +226,7 @@ Enables or disables the tool.
 
 \wxheading{Remarks}
 
-For \helpref{wxToolBarSimple}{wxtoolbarsimple}, does nothing. Some other implementations
+For wxToolBarSimple, does nothing. Some other implementations
 will change the visible state of the tool to indicate that it is disabled.
 
 \wxheading{See also}

docs/latex/wx/topics.tex

@@ -8,7 +8,6 @@ This chapter contains a selection of topic overviews.
 \input tbitmap.tex
 \input tdialog.tex
 \input tfont.tex
-\input tstring.tex
 \input tsplittr.tex
 \input ttreectl.tex
 \input tlistctl.tex
@@ -33,5 +32,6 @@ This chapter contains a selection of topic overviews.
 \input tvalidat.tex
 \input texpr.tex
 \input tgrid.tex
+\input tstring.tex
 \input tusage.tex
 

docs/latex/wx/window.tex

@@ -1585,10 +1585,8 @@ handling of pages and ranges.
 \wxheading{See also}
 
 \helpref{wxWindow::SetScrollPos}{wxwindowsetscrollpos},\rtfsp
-\helpref{wxWindow::SetScrollRange}{wxwindowsetscrollpage},\rtfsp
 \helpref{wxWindow::GetScrollPos}{wxwindowsetscrollpos},\rtfsp
-\helpref{wxWindow::GetScrollRange}{wxwindowsetscrollrange},\rtfsp
+\helpref{wxWindow::GetScrollPage}{wxwindowsetscrollpage},\rtfsp
-\helpref{wxWindow::GetScrollPage}{wxwindowsetscrollrange},\rtfsp
 \helpref{wxScrollBar}{wxscrollbar}, \helpref{wxScrolledWindow}{wxscrolledwindow}
 \end{comment}
 
@@ -1615,8 +1613,7 @@ application to take note of scrollbar attributes and redraw contents accordingly
 
 \helpref{wxWindow::SetScrollbar}{wxwindowsetscrollbar},\rtfsp
 \helpref{wxWindow::GetScrollPos}{wxwindowsetscrollpos},\rtfsp
-\helpref{wxWindow::GetScrollRange}{wxwindowsetscrollrange},\rtfsp
+\helpref{wxWindow::GetScrollThumb}{wxwindowgetscrollthumb},\rtfsp
-\helpref{wxWindow::GetScrollThumb}{wxwindowsetscrollthumb},\rtfsp
 \helpref{wxScrollBar}{wxscrollbar}, \helpref{wxScrolledWindow}{wxscrolledwindow}
 
 \begin{comment}
@@ -1647,8 +1644,7 @@ and usually the scrollbar will be automatically hidden.
 \helpref{wxWindow::SetScrollPos}{wxwindowsetscrollpos},\rtfsp
 \helpref{wxWindow::SetScrollPage}{wxwindowsetscrollpage},\rtfsp
 \helpref{wxWindow::GetScrollPos}{wxwindowsetscrollpos},\rtfsp
-\helpref{wxWindow::GetScrollRange}{wxwindowsetscrollrange},\rtfsp
+\helpref{wxWindow::GetScrollPage}{wxwindowsetscrollpage},\rtfsp
-\helpref{wxWindow::GetScrollPage}{wxwindowsetscrollrange},\rtfsp
 \helpref{wxScrollBar}{wxscrollbar}, \helpref{wxScrolledWindow}{wxscrolledwindow}
 \end{comment}
 

docs/latex/wx/winhelp.tex

@@ -19,7 +19,7 @@ just before the first call to display something.
 
 \wxheading{See also}
 
-\helpref{wxHelpControllerBase}{wxwinhelpcontrollerbase}
+\helpref{wxHelpControllerBase}{wxhelpcontrollerbase}
 
 \wxheading{Include file}
 

docs/latex/wx/wxstring.tex

@@ -75,6 +75,26 @@ Returns the empty string if {\it ch} is not found.
 Gets all characters before the last occurence of {\it ch}.
 Returns empty string if {\it ch} is not found.
 
+\membersection{wxString::Cmp}\label{wxstringcmp}
+
+\constfunc{int}{Cmp}{\param{const char*}{ psz}}
+
+Case-sensitive comparison.
+
+Returns 0 if equal, +1 if greater or -1 if less.
+
+See also CmpNoCase, IsSameAs.
+
+\membersection{wxString::CmpNoCase}\label{wxstringcmpnocase}
+
+\constfunc{int}{CmpNoCase}{\param{const char*}{ psz}}
+
+Case-insensitive comparison.
+
+Returns 0 if equal, +1 if greater or -1 if less.
+
+See also Cmp, IsSameAs.
+
 \membersection{wxString::CompareTo}\label{wxstringCompareTo}
 
 \begin{verbatim}
@@ -92,9 +112,21 @@ Case-sensitive comparison. Returns 0 if equal, 1 if greater or -1 if less.
 
 Returns 1 if target appears anyhere in wxString; else 0.
 
-\membersection{wxString::IsEmpty}\label{wxstringisempty}
+\membersection{wxString::Empty}\label{wxstringempty}
 
-\constfunc{bool}{IsEmpty}{\void}
+\func{void}{Empty}{\void}
+
+Reinitializes the string and frees the data.
+
+\membersection{wxString::Find}\label{wxstringfind}
+
+\constfunc{int}{Find}{\param{char}{ ch}, \param{bool}{ fromEnd = FALSE}}
+
+Searches for the given character. Returns the starting index, or -1 if not found.
+
+\constfunc{int}{Find}{\param{const char*}{ sz}}
+
+Searches for the given string. Returns the starting index, or -1 if not found.
 
 \membersection{wxString::First}\label{wxstringfirst}
 
@@ -106,383 +138,386 @@ Returns 1 if target appears anyhere in wxString; else 0.
 
 \constfunc{size\_t}{First}{\param{const char}{ ch}}
 
-Returns first occurrence of item.
+Returns the first occurrence of the item.
 
+\membersection{wxString::GetChar}\label{wxstringgetchar}
 
+\constfunc{char}{GetChar}{\param{size\_t}{ n}}
 
-
+Returns the character at position {\it n} (read-only).
-
-
-
-
-
- 
-\membersection{wxString::Firstchar}\label{wxstringFirstchar}
-\func{char}{Firstchar}{\param{void}{}} \param{ const}{}
-
-Element extraction.
-
-\membersection{wxString::Freq}\label{wxstringFreq}
-
-\func{int}{Freq}{\param{char}{ c}} \param{ const}{}\\
-\func{int}{Freq}{\param{const wxString\&}{ y}} \param{ const}{}\\
-\func{int}{Freq}{\param{const wxSubString\&}{ y}} \param{ const}{}\\
-\func{int}{Freq}{\param{const char*}{ t}} \param{ const}{}
-
-Return number of occurrences of target in wxString.
-
-\membersection{wxString::From}\label{wxstringFrom}
-
-\func{wxSubString}{From}{\param{int}{ pos}}\\
-\func{wxSubString}{From}{\param{const wxString\&}{ x}, \param{int}{ startpos = 0}}\\
-\func{wxSubString}{From}{\param{const wxSubString\&}{ x}, \param{int}{ startpos = 0}}\\
-\func{wxSubString}{From}{\param{const char*}{ t}, \param{int}{ startpos = 0}}\\
-\func{wxSubString}{From}{\param{char}{ c}, \param{int}{ startpos = 0}}\\
-\func{wxSubString}{From}{\param{const wxRegex\&}{ r}, \param{int}{ startpos = 0}}
 
 \membersection{wxString::GetData}\label{wxstringGetData}
 
-\func{char*}{GetData}{\param{void}{}}
+\constfunc{const char*}{GetData}{\void}
 
-wxWindows compatibility conversion.
+wxWindows compatibility conversion. Returns a constant pointer to the data in the string.
 
-\membersection{wxString::GSub}\label{wxstringGSub}
+\membersection{wxString::GetWritableChar}\label{wxstringgetwritablechar}
-\func{int}{GSub}{\param{const wxString\&}{ pat}, \param{const wxString\&}{ repl}}\\
-\func{int}{GSub}{\param{const wxSubString\&}{ pat}, \param{const wxString\&}{ repl}}\\
-\func{int}{GSub}{\param{const char*}{ pat}, \param{const wxString\&}{ repl}}\\
-\func{int}{GSub}{\param{const char*}{ pat}, \param{const char*}{ repl}}\\
-\func{int}{GSub}{\param{const wxRegex\&}{ pat}, \param{const wxString\&}{ repl}}
 
-Global substitution: substitute all occurrences of {\it pat} with {\it repl},
+\func{char\&}{GetWritableChar}{\param{size\_t}{ n}}
-returning the number of matches.
+
+Returns a reference to the character at position {\it n}.
+
+\membersection{wxString::GetWriteBuf}\label{wxstringgetwritebuf}
+
+\func{char*}{GetWriteBuf}{\param{uint}{ len}}
+
+Returns a writable buffer of at least {\it len} bytes.
+
+Call \helpref{wxString::UngetWriteBuf}{wxstringungetwritebuf} as soon as possible
+to put the string back into a reasonable state.
 
 \membersection{wxString::Index}\label{wxstringIndex}
 
-\func{int}{Index}{\param{char}{ c}, \param{int}{ startpos = 0}} \param{ const}{}\\
+\constfunc{size\_t}{Index}{\param{char}{ ch}, \param{int}{ startpos = 0}}
-\func{int}{Index}{\param{const wxString\&}{ y}, \param{int}{ startpos = 0}} \param{ const}{}\\
-\func{int}{Index}{\param{const wxString\&}{ y}, \param{int}{ startpos}, \param{CaseCompare}{ cmp}} \param{ const}{}\\
-\func{int}{Index}{\param{const wxSubString\&}{ y}, \param{int}{ startpos = 0}} \param{ const}{}\\
-\func{int}{Index}{\param{const char*}{ t}, \param{int}{ startpos = 0}} \param{ const}{}\\
-\func{int}{Index}{\param{const char*}{ t}, \param{int}{ startpos}, \param{CaseCompare}{ cmp}} \param{ const}{}\\
-\func{int}{Index}{\param{const wxRegex\&}{ r}, \param{int}{ startpos = 0}} \param{ const}{}
 
-Return the position of target in string, or -1 for failure.
+Same as \helpref{wxString::Find}{wxstringfind}.
+
+\constfunc{size\_t}{Index}{\param{const char*}{ sz}}
+
+Same as \helpref{wxString::Find}{wxstringfind}.
+
+\constfunc{size\_t}{Index}{\param{const char*}{ sz}, \param{bool}{ caseSensitive = TRUE}, \param{bool}{ fromEnd = FALSE}}
+
+Search the element in the array, starting from either side.
+
+If {\it fromEnd} is TRUE, reverse search direction.
+
+If {\bf caseSensitive}, comparison is case sensitive (the default).
+
+Returns the index of the first item matched, or NOT\_FOUND.
 
 \membersection{wxString::Insert}\label{wxstringInsert}
 
-\func{wxString\&}{Insert}{\param{int}{ pos}, \param{const char*}{ s}}\\
+\func{void}{Insert}{\param{const wxString\&}{ str}, \param{uint}{ index}}
-\func{wxString\&}{Insert}{\param{int}{ pos}, \param{const wxString\&}{ s}}
 
-Insertion.
+Add new element at the given position.
  
 \membersection{wxString::IsAscii}\label{wxstringIsAscii}
 
-\func{int}{IsAscii}{\param{void}{}} \param{ const}{}
+\constfunc{bool}{IsAscii}{\void}
 
-Classification (should be capital, because of ctype.h macros).
+Returns TRUE if the string is ASCII.
 
-\membersection{wxString::IsDefined}\label{wxstringIsDefined}
+\membersection{wxString::IsEmpty}\label{wxstringisempty}
 
-\func{int}{IsDefined}{\param{void}{}} \param{ const}{}
+\constfunc{bool}{IsEmpty}{\void}
 
-Classification (should be capital, because of ctype.h macros).
+Returns TRUE if the string is NULL.
 
 \membersection{wxString::IsNull}\label{wxstringIsNull}
 
-\func{int}{IsNull}{\param{void}{}} \param{ const}{}
+\constfunc{bool}{IsNull}{\void}
 
-Classification (should be capital, because of ctype.h macros).
+Returns TRUE if the string is NULL (same as IsEmpty).
 
 \membersection{wxString::IsNumber}\label{wxstringIsNumber}
 
-\func{int}{IsNumber}{\param{void}{}} \param{ const}{}
+\constfunc{bool}{IsNumber}{\void}
 
-Classification (should be capital, because of ctype.h macros).
+Returns TRUE if the string is a number.
+
+\membersection{wxString::IsSameAs}\label{wxstringissameas}
+
+\constfunc{bool}{IsSameAs}{\param{const char*}{ psz}, \param{bool}{ caseSensitive = TRUE}}
+
+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.
 
 \membersection{wxString::IsWord}\label{wxstringIsWord}
 
-\func{int}{IsWord}{\param{void}{}} \param{ const}{}
+\constfunc{bool}{IsWord}{\void}
 
-Classification (should be capital, because of ctype.h macros).
+Returns TRUE if the string is a word. TODO: what's the definition of a word?
 
 \membersection{wxString::Last}\label{wxstringLast}
 
-\func{int}{Last}{\param{char}{ c}} \param{ const}{}\\
+\constfunc{char}{Last}{\void}
-\func{int}{Last}{\param{const char*}{ cs}} \param{ const}{}\\
-\func{int}{Last}{\param{const wxString\&}{ cs}} \param{ const}{}
 
-First or last occurrence of item.
+Returns the last character.
 
-\membersection{wxString::Lastchar}\label{wxstringLastchar}
+\func{char\&}{Last}{\void}
 
-\func{char}{Lastchar}{\param{void}{}} \param{ const}{}
+Returns a reference to the last character (writable).
 
-Element extraction.
+\membersection{wxString::Left}\label{wxstringleft}
 
-\membersection{wxString::Length}\label{wxstringLength}
+\constfunc{wxString}{Left}{\param{size\_t}{ count}}
 
-\func{unsigned int}{Length}{\param{void}{}} \param{ const}{}
+Returns the first {\it count} characters.
+
+\constfunc{wxString}{Left}{\param{char}{ ch}}
+
+Returns all characters before the first occurence of {\it ch}.
+Returns the whole string if {\it ch} is not found.
+
+\membersection{wxString::Len}\label{wxstringlen}
+
+\constfunc{size\_t}{Len}{\void}
+
+Returns the length of the string.
+
+\membersection{wxString::Length}\label{wxstringlength}
+
+\constfunc{size\_t}{Length}{\void}
+
+Returns the length of the string (same as Len).
 
 \membersection{wxString::LowerCase}\label{wxstringLowerCase}
 
-\func{void}{LowerCase}{\param{void}{}}
+\func{void}{LowerCase}{\void}
+
+Same as MakeLower.
+
+\membersection{wxString::MakeLower}\label{wxstringmakelower}
+
+\func{void}{MakeLower}{\void}
+
+Converts all characters to lower case.
+
+\membersection{wxString::MakeUpper}\label{wxstringmakeupper}
+
+\func{void}{MakeUpper}{\void}
+
+Converts all characters to upper case.
 
 \membersection{wxString::Matches}\label{wxstringMatches}
 
-\func{bool}{Matches}{\param{char}{ c}, \param{int}{ pos = 0}} \param{ const}{}\\
+\constfunc{bool}{Matches}{\param{const char*}{ szMask}}
-\func{bool}{Matches}{\param{const wxString\&}{ y}, \param{int}{ pos = 0}} \param{ const}{}\\
-\func{bool}{Matches}{\param{const wxSubString\&}{ y}, \param{int}{ pos = 0}} \param{ const}{}\\
-\func{bool}{Matches}{\param{const char*}{ t}, \param{int}{ pos = 0}} \param{ const}{}\\
-\func{bool}{Matches}{\param{const wxRegex\&}{ r}, \param{int}{ pos = 0}} \param{ const}{}
 
-Return 1 if target appears at position {\it pos} in wxString; else 0.
+Returns TRUE if the string contents matches a mask containing '*' and '?'.
 
-\membersection{wxString::OK}\label{wxstringOK}
+\membersection{wxString::Mid}\label{wxstringmid}
 
-\func{int}{OK}{\param{void}{}} \param{ const}{}
+\constfunc{wxString}{Mid}{\param{size\_t}{ first}, \param{size\_t}{ count = STRING\_MAXLEN}}
+
+Returns a substring starting at {\it first}, with length {\it count}, or the rest of
+the string if {\it count} is the default value.
+
+\membersection{wxString::Pad}\label{wxstringpad}
+
+\func{wxString\&}{Pad}{\param{size\_t}{ count}, \param{char}{ pad = ' '}, \param{bool}{ fromRight = TRUE}}
+
+Adds {\it count} copies of {\it pad} to the beginning, or to the end of the string (the default).
+
+Removes spaces from the left or from the right (default).
 
 \membersection{wxString::Prepend}\label{wxstringPrepend}
 
-\func{wxString\&}{Prepend}{\param{const wxString\&}{ y}}\\
+\func{wxString\&}{Prepend}{\param{const wxString\&}{ str}}
-\func{wxString\&}{Prepend}{\param{const wxSubString\&}{ y}}\\
-\func{wxString\&}{Prepend}{\param{const char*}{ t}}\\
-\func{wxString\&}{Prepend}{\param{char}{ c}}
 
-Prepend.
+Prepends {\it str} to this string, returning a reference to this string.
 
-\func{wxString\&}{Prepend}{\param{char}{ c}, \param{int}{ rep=1}}
+\membersection{wxString::Printf}\label{wxstringprintf}
 
-Prepend {\it c}, {\it rep} times.
+\func{int}{Printf}{\param{const char* }{pszFormat}, \param{}{...}}
- 
-\membersection{wxString::Readline}\label{wxstringReadline}
 
-\func{friend int}{Readline}{\param{istream\&}{ s}, \param{wxString\&}{ x}, 
+Similar to sprintf. Returns the number of characters written, or an integer less than zero
- \param{char}{ terminator = '$\backslash$n'}, 
+on error.
- \param{int}{ discard\_terminator = 1}}\\
+
-\func{friend int}{Readline}{\param{FILE *}{ f}, \param{wxString\&}{ x}, 
+\membersection{wxString::PrintfV}\label{wxstringprintfv}
- \param{char}{ terminator = '$\backslash$n'}, 
+
- \param{int}{ discard\_terminator = 1}}
+\func{int}{PrintfV}{\param{const char* }{pszFormat}, \param{va\_list}{ argPtr}}
+
+Similar to vprintf. Returns the number of characters written, or an integer less than zero
+on error.
 
 \membersection{wxString::Remove}\label{wxstringRemove}
 
-\func{wxString\&}{RemoveLast}{\param{void}{}}\\ 
+\func{wxString\&}{Remove}{\param{size\_t}{ pos}}
-\func{wxString\&}{Remove}{\param{int}{ pos}}\\
-\func{wxString\&}{Remove}{\param{int}{ pos}, \param{int}{ len}}
 
-Remove {\it pos} to end of string.
+Same as Truncate. Removes the portion from {\it pos} to the end of the string.
+
+\func{wxString\&}{Remove}{\param{size\_t}{ pos}, \param{size\_t}{ len}}
+
+Removes the last {\it len} characters from the string, starting at {\it pos}.
+
+\membersection{wxString::RemoveLast}\label{wxstringremovelast}
+
+\func{wxString\&}{RemoveLast}{\void}
+
+Removes the last character.
 
 \membersection{wxString::Replace}\label{wxstringReplace}
 
-\func{wxString\&}{Replace}{\param{int}{ pos}, \param{int}{ n}, \param{const char*}{ s}}\\
+\func{uint}{Replace}{\param{const char*}{ szOld}, \param{const char*}{ szNew}, \param{bool}{ replaceAll}}
-\func{wxString\&}{Replace}{\param{int}{ pos}, \param{int}{ n}, \param{const wxString\&}{ s}}
 
-\membersection{wxString::Replicate}\label{wxstringReplicate}
+Replace first (or all) occurences of substring with another one.
 
-\func{friend wxString}{Replicate}{\param{char}{ c}, \param{int}{ n}}\\
+{\it replaceAll}: global replace (default), or only the first occurence.
-\func{friend wxString}{Replicate}{\param{const wxString\&}{ y}, \param{int}{ n}}
 
-Replication.
+Returns the number of replacements made.
 
-\membersection{wxString::Reverse}\label{wxstringReverse}
+\membersection{wxString::Right}\label{wxstringright}
 
-\func{void}{Reverse}{\param{void}{}}\\
+\constfunc{wxString}{Right}{\param{size\_t}{ count}}
-\func{friend wxString}{Reverse}{\param{wxString\&}{ x}}
+
+Returns the last {\it count} characters.
+
+\constfunc{wxString}{Right}{\param{char}{ ch}}
+
+Returns all characters after the last occurence of {\it ch}.
+Returns the whole string if {\it ch} is not found.
+
+\membersection{wxString::SetChar}\label{wxstringsetchar}
+
+\func{void}{SetChar}{\param{size\_t}{ n}, \param{char}{ch}}
+
+Sets the character at position {\it n}.
+
+\membersection{wxString::Shrink}\label{wxstringshrink}
+
+\func{void}{Shrink}{\void}
+
+Minimizes the string's memory. Only works if the data of this string is not shared.
 
 \membersection{wxString::sprintf}\label{wxstringsprintf}
-\func{void}{sprintf}{\param{const wxString\& }{ fmt}}
 
-Formatted assignment. We do not use the 'sprintf' constructor anymore,
+\func{void}{sprintf}{\param{const char* }{ fmt}}
-because with that constructor, every initialisation with a string would
-go through sprintf and this is not desirable, because sprintf
-interprets some characters. With the above function we can write:
 
-\begin{verbatim}
+The same as Printf.
-wxString msg; msg.sprintf("Processing item %d\n", count);
-\end{verbatim}
 
 \membersection{wxString::Strip}\label{wxstringStrip}
 
 \begin{verbatim}
-enumStripType {leading = 0x1, trailing = 0x2, both = 0x3};
+enum stripType {leading = 0x1, trailing = 0x2, both = 0x3};
 \end{verbatim}
 
-\func{wxSubString}{Strip}{\param{StripType}{ s = trailing}, \param{char}{ c = ' '}}
+\constfunc{wxString}{Strip}{\param{stripType}{ s = trailing}}
 
-Strip characterss at the front and/or end.
+Strip characters at the front and/or end. The same as Trim except that it
-StripType is defined for bitwise ORing.
+doesn't change this string.
 
-\membersection{wxString::SubString}\label{wxstringSubString}
+\membersection{wxString::Trim}\label{wxstringtrim}
 
-\func{wxString}{SubString}{\param{int}{ from}, \param{int}{ to}}
+\func{wxString\&}{Trim}{\param{bool}{ fromRight = TRUE}}
 
-Edward Zimmermann's additions.
+Removes spaces from the left or from the right (default).
 
-\membersection{wxString::Through}\label{wxstringThrough}
+\membersection{wxString::Truncate}\label{wxstringtruncate}
 
-\func{wxSubString}{Through}{\param{int}{ pos}}\\
+\func{wxString\&}{Truncate}{\param{size\_t}{ len}}
-\func{wxSubString}{Through}{\param{const wxString\&}{ x}, \param{int}{ startpos = 0}}\\
-\func{wxSubString}{Through}{\param{const wxSubString\&}{ x}, \param{int}{ startpos = 0}}\\
-\func{wxSubString}{Through}{\param{const char*}{ t}, \param{int}{ startpos = 0}}\\
-\func{wxSubString}{Through}{\param{char}{ c}, \param{int}{ startpos = 0}}\\
-\func{wxSubString}{Through}{\param{const wxRegex\&}{ r}, \param{int}{ startpos = 0}}
 
-\membersection{wxString::Upcase}\label{wxstringUpcase}
+Truncate the string to the given length.
 
-\func{void}{Upcase}{\param{void}{}}\\
+\membersection{wxString::UngetWriteBuf}\label{wxstringungetwritebuf}
-\func{friend wxString}{Upcase}{\param{wxString\&}{ x}}
+
+\func{void}{UngetWriteBuf}{\void}
+
+Puts the string back into a reasonable state, after
+\rtfsp\helpref{wxString::GetWriteBuf}{wxstringgetwritebuf} was called.
 
 \membersection{wxString::UpperCase}\label{wxstringUpperCase}
 
-\func{void}{UpperCase}{\param{void}{}}\\
+\func{void}{UpperCase}{\void}
+
+The same as MakeUpper.
 
 \membersection{wxString::operator $=$}\label{wxstringoperatorassign}
 
-\func{wxString\&}{operator $=$}{\param{const wxString\&}{ y}}\\
+\func{wxString\&}{operator $=$}{\param{const wxString\&}{ str}}
-\func{wxString\&}{operator $=$}{\param{const char*}{ y}}\\
+
-\func{wxString\&}{operator $=$}{\param{char}{ c}}\\
+\func{wxString\&}{operator $=$}{\param{const char*}{ psz}}
-\func{wxString\&}{operator $=$}{\param{const wxSubString\&}{ y}}
+
+\func{wxString\&}{operator $=$}{\param{char}{ c}}
+
+\func{wxString\&}{operator $=$}{\param{const unsigned char*}{ psz}}
+
+\func{wxString\&}{operator $=$}{\param{const wchar\_t*}{ pwz}}
 
 Assignment.
  
 \membersection{wxString::operator $+=$}\label{wxstringPlusEqual}
 
-\func{wxString\&}{operator $+=$}{\param{const wxString\&}{ y}}\\
+\func{void}{operator $+=$}{\param{const wxString\&}{ str}}
-\func{wxString\&}{operator $+=$}{\param{const wxSubString\&}{ y}}\\
+
-\func{wxString\&}{operator $+=$}{\param{const char*}{ t}}\\
+\func{void}{operator $+=$}{\param{const char*}{ psz}}
-\func{wxString\&}{operator $+=$}{\param{char}{ c}}
+
+\func{void}{operator $+=$}{\param{char}{ c}}
 
 Concatenation.
 
 \membersection{wxString::operator []}\label{wxstringoperatorbracket}
 
-\func{char\&}{operator []}{\param{int}{ i}}
+\func{char\&}{operator []}{\param{size\_t}{ i}}
+
+\func{char}{operator []}{\param{size\_t}{ i}}
+
+\func{char}{operator []}{\param{int}{ i}}
 
 Element extraction.
 
 \membersection{wxString::operator ()}\label{wxstringoperatorparenth}
 
-\func{char\&}{operator ()}{\param{int}{ i}}
+\func{wxString}{operator ()}{\param{size\_t}{ start}, \param{size\_t}{ len}}
+
+Same as Mid (substring extraction).
 
 \membersection{wxString::operator \cinsert}\label{wxstringoperatorout}
-\func{friend ostream\&}{operator \cinsert}{\param{ostream\&}{ s}, \param{const wxString\&}{ x}}\\
+
-\func{friend ostream\&}{operator \cinsert}{\param{ostream\&}{ s}, \param{const wxSubString\&}{ x}}
+\func{wxString\&}{operator \cinsert}{\\param{const wxString\&}{ str}}
+
+\func{wxString\&}{operator \cinsert}{\\param{const char*}{ psz}}
+
+\func{wxString\&}{operator \cinsert}{\\param{char }{ch}}
+
+Same as $+=$.
 
 \membersection{wxString::operator \cextract}\label{wxstringoperatorin}
-\func{friend istream\&}{operator \cextract}{\param{istream\&}{ s}, \param{wxString\&}{ x}}
+
+\func{friend istream\&}{operator \cextract}{\param{istream\&}{ is}, \param{wxString\&}{ str}}
+
+Extraction from a stream.
 
 \membersection{wxString::operator const char*}\label{wxstringoperatorconstcharpt}
-\constfunc{}{operator const char*}{\param{void}{}}
 
-Conversion.
+\constfunc{}{operator const char*}{\void}
 
-\membersection{wxCHARARG}\label{wxstringwxCHARARG}
+Implicit conversion to a C string.
-
-\begin{verbatim}
-#define wxCHARARG(s) ((const wxString\& )(s).Chars())  
-\end{verbatim}
-
-Here is a very, very, very ugly macro, but it makes things more
-transparent in cases, where a library function requires a 
-(const wxString\& ) argument. This is especially the case in wxWindows,
-where all char-arguments are (const wxString\& ) and not (const char* ).
-This macro should only be used in such cases and NOT to
-modify the internal data.
-The conventional way would be 'function((char*)string.Chars())'.
-With the wxCHARARG macro, this can be achieved by 'function(wxCHARARG(string))'.
-This makes it clearer that the usage should be confined
-to arguments.
-
-\membersection{CommonPrefix}\label{wxstringCommonPrefix}
-
-\func{friend wxString}{CommonPrefix}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y},\\
- \param{int}{ startpos = 0}}\\
-
-\membersection{CommonSuffix}\label{wxstringCommonSuffix}
-
-\func{friend wxString}{CommonSuffix}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y},\\
- \param{int}{ startpos = -1}}
-
-\membersection{Compare}\label{wxstringCompare}
-
-\func{int}{Compare}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}\\
-\func{int}{Compare}{\param{const wxString\&}{ x}, \param{const wxSubString\&}{ y}}\\
-\func{int}{Compare}{\param{const wxString\&}{ x}, \param{const char*}{ y}}\\
-\func{int}{Compare}{\param{const wxSubString\&}{ x}, \param{const wxString\&}{ y}}\\
-\func{int}{Compare}{\param{const wxSubString\&}{ x}, \param{const wxSubString\&}{ y}}\\
-\func{int}{Compare}{\param{const wxSubString\&}{ x}, \param{const char*}{ y}}
-
-Case dependent comparison. Returns 0 if the match succeeded.
-
-\membersection{FCompare}\label{wxstringFCompare}
-
-\func{int}{FCompare}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}
-
-Case independent comparison. Returns 0 if the match succeeded.
 
 \membersection{Comparison operators}\label{wxstringComparison}
 
-\func{int}{operator $==$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}\\ 
+\func{bool}{operator $==$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}
-\func{int}{operator $!=$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}\\
+
-\func{int}{operator $>$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}\\
+\func{bool}{operator $==$}{\param{const wxString\&}{ x}, \param{const char*}{ t}}
-\func{int}{operator $>=$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}\\
+
-\func{int}{operator $<$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}\\
+\func{bool}{operator $!=$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}
-\func{int}{operator $<=$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}\\
+
-\func{int}{operator $==$}{\param{const wxString\&}{ x}, \param{const wxSubString\&}{ y}}\\
+\func{bool}{operator $!=$}{\param{const wxString\&}{ x}, \param{const char*}{ t}}
-\func{int}{operator $!=$}{\param{const wxString\&}{ x}, \param{const wxSubString\&}{ y}}\\
+
-\func{int}{operator $>$}{\param{const wxString\&}{ x}, \param{const wxSubString\&}{ y}}\\
+\func{bool}{operator $>$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}
-\func{int}{operator $>=$}{\param{const wxString\&}{ x}, \param{const wxSubString\&}{ y}}\\
+
-\func{int}{operator $<$}{\param{const wxString\&}{ x}, \param{const wxSubString\&}{ y}}\\
+\func{bool}{operator $>$}{\param{const wxString\&}{ x}, \param{const char*}{ t}}
-\func{int}{operator $<=$}{\param{const wxString\&}{ x}, \param{const wxSubString\&}{ y}}\\
+
-\func{int}{operator $==$}{\param{const wxString\&}{ x}, \param{const char*}{ t}}\\
+\func{bool}{operator $>=$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}
-\func{int}{operator $!=$}{\param{const wxString\&}{ x}, \param{const char*}{ t}}\\
+
-\func{int}{operator $>$}{\param{const wxString\&}{ x}, \param{const char*}{ t}}\\
+\func{bool}{operator $>=$}{\param{const wxString\&}{ x}, \param{const char*}{ t}}
-\func{int}{operator $>=$}{\param{const wxString\&}{ x}, \param{const char*}{ t}}\\
+
-\func{int}{operator $<$}{\param{const wxString\&}{ x}, \param{const char*}{ t}}\\
+\func{bool}{operator $<$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}
-\func{int}{operator $<=$}{\param{const wxString\&}{ x}, \param{const char*}{ t}}\\
+
-\func{int}{operator $==$}{\param{const wxSubString\&}{ x}, \param{const wxString\&}{ y}}\\
+\func{bool}{operator $<$}{\param{const wxString\&}{ x}, \param{const char*}{ t}}
-\func{int}{operator $!=$}{\param{const wxSubString\&}{ x}, \param{const wxString\&}{ y}}\\
+
-\func{int}{operator $>$}{\param{const wxSubString\&}{ x}, \param{const wxString\&}{ y}}\\
+\func{bool}{operator $<=$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}
-\func{int}{operator $>=$}{\param{const wxSubString\&}{ x}, \param{const wxString\&}{ y}}\\
+
-\func{int}{operator $<$}{\param{const wxSubString\&}{ x}, \param{const wxString\&}{ y}}\\
+\func{bool}{operator $<=$}{\param{const wxString\&}{ x}, \param{const char*}{ t}}
-\func{int}{operator $<=$}{\param{const wxSubString\&}{ x}, \param{const wxString\&}{ y}}\\
+
-\func{int}{operator $==$}{\param{const wxSubString\&}{ x}, \param{const wxSubString\&}{ y}}\\
+\wxheading{Remarks}
-\func{int}{operator $!=$}{\param{const wxSubString\&}{ x}, \param{const wxSubString\&}{ y}}\\
+
-\func{int}{operator $>$}{\param{const wxSubString\&}{ x}, \param{const wxSubString\&}{ y}}\\
+These comparisons are case-sensitive.
-\func{int}{operator $>=$}{\param{const wxSubString\&}{ x}, \param{const wxSubString\&}{ y}}\\
-\func{int}{operator $<$}{\param{const wxSubString\&}{ x}, \param{const wxSubString\&}{ y}}\\
-\func{int}{operator $<=$}{\param{const wxSubString\&}{ x}, \param{const wxSubString\&}{ y}}\\
-\func{int}{operator $==$}{\param{const wxSubString\&}{ x}, \param{const char*}{ t}}\\
-\func{int}{operator $!=$}{\param{const wxSubString\&}{ x}, \param{const char*}{ t}}\\
-\func{int}{operator $>$}{\param{const wxSubString\&}{ x}, \param{const char*}{ t}}\\
-\func{int}{operator $>=$}{\param{const wxSubString\&}{ x}, \param{const char*}{ t}}\\
-\func{int}{operator $<$}{\param{const wxSubString\&}{ x}, \param{const char*}{ t}}\\
-\func{int}{operator $<=$}{\param{const wxSubString\&}{ x}, \param{const char*}{ t}}
 
 \membersection{operator $+$}\label{wxstringoperatorplus}
 
-\func{wxString}{operator $+$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}\\
+\func{wxString}{operator $+$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}
-\func{wxString}{operator $+$}{\param{const wxString\&}{ x}, \param{const wxSubString\&}{ y}}\\
-\func{wxString}{operator $+$}{\param{const wxString\&}{ x}, \param{const char*}{ y}}\\
-\func{wxString}{operator $+$}{\param{const wxString\&}{ x}, \param{char}{ y}}\\
-\func{wxString}{operator $+$}{\param{const wxSubString\&}{ x}, \param{const wxString\&}{ y}}\\
-\func{wxString}{operator $+$}{\param{const wxSubString\&}{ x}, \param{const wxSubString\&}{ y}}\\
-\func{wxString}{operator $+$}{\param{const wxSubString\&}{ x}, \param{const char*}{ y}}\\
-\func{wxString}{operator $+$}{\param{const wxSubString\&}{ x}, \param{char}{ y}}\\
-\func{wxString}{operator $+$}{\param{const char*}{ x}, \param{const wxString\&}{ y}}\\
-\func{wxString}{operator $+$}{\param{const char*}{ x}, \param{const wxSubString\&}{ y}}
 
-\membersection{Join}\label{wxstringJoin}
+\func{wxString}{operator $+$}{\param{const wxString\&}{ x}, \param{const char*}{ y}}
 
-\func{friend wxString}{Join}{\param{wxString}{ src[]}, \param{int}{ n}, \param{const wxString\&}{ sep}}
+\func{wxString}{operator $+$}{\param{const wxString\&}{ x}, \param{char}{ y}}
-
-\membersection{Split}\label{wxstringSplit}
-
-\func{friend int}{Split}{\param{const wxString\&}{ x}, \param{wxString}{ res[]}, \param{int}{ maxn},\\
- \param{const wxString\&}{ sep}}\\
-\func{friend int}{Split}{\param{const wxString\&}{ x}, \param{wxString}{ res[]}, \param{int}{ maxn},\\
- \param{const wxRegex\&}{ sep}}\\
-
-Split string into array res at separators; return number of elements
 
+\func{wxString}{operator $+$}{\param{const char*}{ x}, \param{const wxString\&}{ y}}
 
 

docs/msw/todo.txt

@@ -5,8 +5,6 @@ Todo on wxWin 2.0, Windows platform
 HIGH PRIORITY
 -------------
 
-Integrate Robert's wxGrid enhancements.
-
 Find/add wxThread sample - Arthur T-D?
 
 wxControl dimensions should be optionally based on dialog font
@@ -14,15 +12,12 @@ size for portability (dialog units as per Windows).
 
 Implement wxDC floating point transformations.
 
-Remove transformation from device to logical coordinates from
-events e.g. mouse events.
-
 Add wxDC::DeviceToLogical -> wxPoint etc (convenience accessors).
 
 Revamp Dialog Editor for new controls and properties (e.g.
 window id).
 
-Registry classes (check out wxConfig class - see issues.txt).
+Tidy wxConfig API.
 
 Change DnD classes to use global symbols, and wxString.
 
@@ -47,18 +42,19 @@ Update manual.
     wxListBox changes (for ownerdraw functionality)
     wxThread            DONE (except for topic overview)
     wxHelpController classes DONE (except for Unix ones)
-    wxString
+    wxString            PARTLY DONE
-    wxTString
     Drag and drop (change API if required, e.g. const).
     wxCheckListBox
     wxBaseArray, other arrays
     (wxOwnerDrawn)
     Document the include file for each class
     Macros, e.g. wxASSERT
+    Stream classes
+    Functions
 
 Write tutorial.
 
-Other static classes.
+A wxDC function (or two) for drawing 3D edges.
 
 Makefiles for other compilers. Generic makefiles?
 Rewrite makefiles to maintain simultaneous debug/release
@@ -68,31 +64,15 @@ More wxSystemSettings (see comment in settings.cpp).
 
 wxSocket integration.
 
-wxListCtrl, wxTreeCtrl, wxImageList integration with Robert
+Convert remaining utilities e.g. (GLCanvas; wxGraphLayout) and samples
-Roebling's classes.
-
-Convert OGL, other utilities and samples.
 
 Check TODO entries.
 
-Change #include "wx/xxx.h" to #include <wx/xxx.h>
-
-Tidy code further, e.g. formatting from DevStudio, plus
-standard header.
-
 Shell function to invoke a document with open, print, whatever...
 
-wxTextCtrl (and wxMultiText/wxTextWindow in wxWin 1.xx) - differences between Edit
-and RichEdit controls.
-
 Make use of Vadim's gettext implementation throughout wxWin code.
 Document it.
 
-Change wxUpdateIterator to use wxRegion; or scrap
-wxUpdateIterator? See wxGTK.
-
-Check WXWIN_COMPATIBILITY mode, remove any unnecessary #ifdefs.
-
 Retain callback functions; have semi-compatible callback function prototypes
 for all controls, at least in WXWIN_COMPATIBLE mode, but
 retain (Set)Callback for all compilations. This is following a
@@ -100,18 +80,10 @@ panicky response to losing callbacks.
 
 Merge dib.cpp, dibutils.cpp.
 
-Simplify the toolbar samples.
-
 Add a wxTabCtrl sample.
 
-EVT_ENTER/LEAVE_WINDOW: Perhaps one approach to reliable implementation of
+Improve printing. More API functions for printer DCs (to get
-EVT_LEAVE_WINDOW is to set a flag when the mouse pointer is in a window,
+printer characteristics) and more reliable printing framework.
-then in idle time, check this window.
-If the flag is set but the mouse pointer is outside the window, then
-it's time to generate an EVT_LEAVE_WINDOW. This would be necessary at
-least for the case when the mouse cursor goes off the application windows,
-and no motion event was generated (i.e. you moved the mouse quickly!).
-If it goes from one app window to another, you could generate the event sooner.
 
 LOW PRIORITY
 ------------
@@ -132,12 +104,8 @@ BS_BITMAP, SS_BITMAP - but this may not allow wxBitmap
 argument, so instead just allow controls loaded from native
 resource to deal with this style and call default processing.
 
-Completion of drag and drop support (Vadim).
-
 Better clipboard support.
 
-Toolbars: use event tables not virtual functions.
-
 wxWizard class?
 
 Doc/view - have some standard views/docs e.g. wxTextView.
@@ -153,10 +121,6 @@ Integrate existing multimedia classes.
 
 Rich text class?
 
-Optimize size further.
-
-wxThread integration.
-
 Look at WinCE stuff incl. database classes.
 
 Improve conversion guide, compatibility classes, tools?

include/wx/event.h

@@ -907,6 +907,46 @@ class WXDLLEXPORT wxSysColourChangedEvent: public wxEvent
      { m_eventType = wxEVT_SYS_COLOUR_CHANGED; }
 };
 
+/*
+ wxEVT_PALETTE_CHANGED
+ */
+
+class WXDLLEXPORT wxPaletteChangedEvent: public wxEvent
+{
+  DECLARE_DYNAMIC_CLASS(wxPaletteChangedEvent)
+
+public:
+  inline wxPaletteChangedEvent(wxWindowID id = 0): wxEvent(id)
+     { m_eventType = wxEVT_PALETTE_CHANGED; m_changedWindow = NULL; }
+
+  inline void SetChangedWindow(wxWindow* win) { m_changedWindow = win; }
+  inline wxWindow* GetChangedWindow() const { return m_changedWindow; }
+
+protected:
+  wxWindow*     m_changedWindow;
+};
+
+/*
+ wxEVT_QUERY_NEW_PALETTE
+ Indicates the window is getting keyboard focus and should re-do its palette.
+ */
+
+class WXDLLEXPORT wxQueryNewPaletteEvent: public wxEvent
+{
+  DECLARE_DYNAMIC_CLASS(wxQueryNewPaletteEvent)
+
+public:
+  inline wxQueryNewPaletteEvent(wxWindowID id = 0): wxEvent(id)
+     { m_eventType = wxEVT_QUERY_NEW_PALETTE; m_paletteRealized = FALSE; }
+
+  // App sets this if it changes the palette.
+  inline void SetPaletteRealized(bool realized) { m_paletteRealized = realized; }
+  inline bool GetPaletteRealized() const { return m_paletteRealized; }
+
+protected:
+  bool      m_paletteRealized;
+};
+
 /*
  Event generated by dialog navigation keys
  wxEVT_NAVIGATION_KEY
@@ -940,8 +980,6 @@ public:
  wxEVT_DESTROY,
  wxEVT_MOUSE_CAPTURE_CHANGED,
  wxEVT_SETTING_CHANGED, // WM_WININICHANGE (NT) / WM_SETTINGCHANGE (Win95)
- wxEVT_QUERY_NEW_PALETTE,
- wxEVT_PALETTE_CHANGED,
 // wxEVT_FONT_CHANGED,  // WM_FONTCHANGE: roll into wxEVT_SETTING_CHANGED, but remember to propagate
                         // wxEVT_FONT_CHANGED to all other windows (maybe).
  wxEVT_DRAW_ITEM, // Leave these three as virtual functions in wxControl?? Platform-specific.
@@ -1046,6 +1084,8 @@ typedef void (wxEvtHandler::*wxShowEventFunction)(wxShowEvent&);
 typedef void (wxEvtHandler::*wxIconizeEventFunction)(wxShowEvent&);
 typedef void (wxEvtHandler::*wxMaximizeEventFunction)(wxShowEvent&);
 typedef void (wxEvtHandler::*wxNavigationKeyEventFunction)(wxNavigationKeyEvent&);
+typedef void (wxEvtHandler::*wxPaletteChangedEventFunction)(wxPaletteChangedEvent&);
+typedef void (wxEvtHandler::*wxQueryNewPaletteEventFunction)(wxQueryNewPaletteEvent&);
 
 // N.B. In GNU-WIN32, you *have* to take the address of a member function
 // (use &) or the compiler crashes...
@@ -1097,6 +1137,8 @@ const wxEventTableEntry theClass::sm_eventTableEntries[] = { \
 #define EVT_MAXIMIZE(func) { wxEVT_MAXIMIZE, -1, -1, (wxObjectEventFunction) (wxEventFunction) (wxMaximizeEventFunction) & func, NULL },
 #define EVT_ICONIZE(func) { wxEVT_ICONIZE, -1, -1, (wxObjectEventFunction) (wxEventFunction) (wxIconizeEventFunction) & func, NULL },
 #define EVT_NAVIGATION_KEY(func) { wxEVT_NAVIGATION_KEY, -1, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxNavigationKeyEventFunction) & func, NULL },
+#define EVT_PALETTE_CHANGED(func) { wxEVT_PALETTE_CHANGED, -1, -1, (wxObjectEventFunction) (wxEventFunction) (wxPaletteChangedEventFunction) & func, NULL },
+#define EVT_QUERY_NEW_PALETTE(func) { wxEVT_QUERY_NEW_PALETTE, -1, -1, (wxObjectEventFunction) (wxEventFunction) (wxQueryNewPaletteEventFunction) & func, NULL },
 
 // Mouse events
 #define EVT_LEFT_DOWN(func) { wxEVT_LEFT_DOWN, -1, -1, (wxObjectEventFunction) (wxEventFunction) (wxMouseEventFunction) & func, NULL },

include/wx/msw/window.h

@@ -503,6 +503,8 @@ public:
   virtual WXHBRUSH MSWOnCtlColor(WXHDC dc, WXHWND pWnd, WXUINT nCtlColor,
                               WXUINT message, WXWPARAM wParam, WXLPARAM lParam);
   virtual bool MSWOnColorChange(WXHWND hWnd, WXUINT message, WXWPARAM wParam, WXLPARAM lParam);
+  virtual long MSWOnPaletteChanged(WXHWND hWndPalChange);
+  virtual long MSWOnQueryNewPalette();
   virtual bool MSWOnEraseBkgnd(WXHDC pDC);
   virtual void MSWOnMenuHighlight(WXWORD item, WXWORD flags, WXHMENU sysmenu);
   virtual void MSWOnInitMenuPopup(WXHMENU menu, int pos, bool isSystem);

include/wx/string.h

@@ -112,10 +112,10 @@ inline int WXDLLEXPORT Stricmp(const char *psz1, const char *psz2)
 // ----------------------------------------------------------------------------
 
 // global pointer to empty string
-extern const char *g_szNul;
+WXDLLEXPORT_DATA(extern const char*) g_szNul;
 
 // return an empty wxString
-class wxString; // not yet defined
+class WXDLLEXPORT wxString; // not yet defined
 inline const wxString& wxGetEmptyString() { return *(wxString *)&g_szNul; }
 
 // ---------------------------------------------------------------------------
@@ -375,13 +375,13 @@ public:
   /** @name string comparison */
   //@{
     /**
-    case-sensitive comparaison
+    case-sensitive comparison
     @return 0 if equal, +1 if greater or -1 if less
     @see CmpNoCase, IsSameAs
     */
   int  Cmp(const char *psz) const { return strcmp(c_str(), psz); }
     /**
-    case-insensitive comparaison, return code as for wxString::Cmp()
+    case-insensitive comparison, return code as for wxString::Cmp()
     @see: Cmp, IsSameAs
     */
   int  CmpNoCase(const char *psz) const { return Stricmp(c_str(), psz); }
@@ -758,14 +758,14 @@ public:
       //@{
         /// just like strcmp()
         int compare(const wxString& str) const { return Cmp(str); }
-        /// comparaison with a substring
+        /// comparison with a substring
         int compare(size_t nStart, size_t nLen, const wxString& str) const;
-        /// comparaison of 2 substrings
+        /// comparison of 2 substrings
         int compare(size_t nStart, size_t nLen,
                     const wxString& str, size_t nStart2, size_t nLen2) const;
         /// just like strcmp()
         int compare(const char* sz) const { return Cmp(sz); }
-        /// substring comparaison with first nCount characters of sz
+        /// substring comparison with first nCount characters of sz
         int compare(size_t nStart, size_t nLen,
                     const char* sz, size_t nCount = npos) const;
       //@}
@@ -843,7 +843,7 @@ public:
     /**
       Search the element in the array, starting from the either side
       @param if bFromEnd reverse search direction
-      @param if bCase, comparaison is case sensitive (default)
+      @param if bCase, comparison is case sensitive (default)
       @return index of the first item matched or NOT_FOUND
       @see NOT_FOUND
      */
@@ -872,8 +872,8 @@ private:
 };
 
 // ---------------------------------------------------------------------------
-/** @name wxString comparaison functions
+/** @name wxString comparison functions
-    @memo Comparaisons are case sensitive
+    @memo Comparisons are case sensitive
  */
 // ---------------------------------------------------------------------------
 //@{

src/common/docmdi.cpp

@@ -40,7 +40,7 @@ IMPLEMENT_CLASS(wxDocMDIParentFrame, wxMDIParentFrame)
 
 BEGIN_EVENT_TABLE(wxDocMDIParentFrame, wxMDIParentFrame)
     EVT_MENU(wxID_EXIT, wxDocMDIParentFrame::OnExit)
-    EVT_MENU_RANGE(wxID_FILE1, wxID_FILE2, wxDocMDIParentFrame::OnMRUFile)
+    EVT_MENU_RANGE(wxID_FILE1, wxID_FILE9, wxDocMDIParentFrame::OnMRUFile)
 END_EVENT_TABLE()
 
 wxDocMDIParentFrame::wxDocMDIParentFrame(wxDocManager *manager, wxFrame *frame, wxWindowID id, const wxString& title,

src/common/docview.cpp

@@ -34,6 +34,9 @@
 #include "wx/menu.h"
 #include "wx/list.h"
 #include "wx/filedlg.h"
+#endif
+
+#ifdef __WXGTK__
 #include "wx/mdi.h"
 #endif
 
@@ -490,9 +493,11 @@ void wxView::OnChangeFilename(void)
     
     wxFrame *frame = NULL;
     wxMDIChildFrame *mdi_frame = NULL;
+#ifdef __WXGTK__
     if (GetFrame()->IsKindOf(CLASSINFO(wxMDIChildFrame)))
       mdi_frame = (wxMDIChildFrame*)GetFrame();
     else
+#endif
       frame = GetFrame();
       
     if (frame)
@@ -500,7 +505,7 @@ void wxView::OnChangeFilename(void)
       frame->SetTitle(name);
       return;
     }
-    
+#ifdef __WXGTK__
     if (mdi_frame)
     {
       if (wxTheApp->GetAppName() != "")
@@ -512,6 +517,7 @@ void wxView::OnChangeFilename(void)
       else
         mdi_frame->SetTitle(name);
     }
+#endif
   }
 }
 
@@ -1399,7 +1405,7 @@ bool wxDocChildFrame::OnClose(void)
 
 BEGIN_EVENT_TABLE(wxDocParentFrame, wxFrame)
     EVT_MENU(wxID_EXIT, wxDocParentFrame::OnExit)
-    EVT_MENU_RANGE(wxID_FILE1, wxID_FILE2, wxDocParentFrame::OnMRUFile)
+    EVT_MENU_RANGE(wxID_FILE1, wxID_FILE9, wxDocParentFrame::OnMRUFile)
 END_EVENT_TABLE()
 
 wxDocParentFrame::wxDocParentFrame(wxDocManager *manager, wxFrame *frame, wxWindowID id, const wxString& title,

src/common/event.cpp

@@ -56,6 +56,8 @@ IMPLEMENT_DYNAMIC_CLASS(wxSysColourChangedEvent, wxEvent)
 IMPLEMENT_DYNAMIC_CLASS(wxIdleEvent, wxEvent)
 IMPLEMENT_DYNAMIC_CLASS(wxUpdateUIEvent, wxEvent)
 IMPLEMENT_DYNAMIC_CLASS(wxNavigationKeyEvent, wxCommandEvent)
+IMPLEMENT_DYNAMIC_CLASS(wxPaletteChangedEvent, wxEvent)
+IMPLEMENT_DYNAMIC_CLASS(wxQueryNewPaletteEvent, wxEvent)
 
 const wxEventTable *wxEvtHandler::GetEventTable() const { return &wxEvtHandler::sm_eventTable; }
 

src/msw/window.cpp

@@ -1366,6 +1366,16 @@ long wxWindow::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
             return MSWDefWindowProc(message, wParam, lParam );
           break;
         }
+        case WM_PALETTECHANGED:
+        {
+            return MSWOnPaletteChanged((WXHWND) (HWND) wParam);
+            break;
+        }
+        case WM_QUERYNEWPALETTE:
+        {
+            return MSWOnQueryNewPalette();
+            break;
+        }
         case WM_ERASEBKGND:
         {
           // Prevents flicker when dragging
@@ -1862,7 +1872,7 @@ WXHBRUSH wxWindow::OnCtlColor(WXHDC pDC, WXHWND pWnd, WXUINT nCtlColor,
 bool wxWindow::MSWOnColorChange(WXHWND hWnd, WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
 {
   wxSysColourChangedEvent event;
-  event.m_eventObject = this;
+  event.SetEventObject(this);
 
   // Check if app handles this.
   if (GetEventHandler()->ProcessEvent(event))
@@ -1872,6 +1882,27 @@ bool wxWindow::MSWOnColorChange(WXHWND hWnd, WXUINT message, WXWPARAM wParam, WX
   return 1;
 }
 
+long wxWindow::MSWOnPaletteChanged(WXHWND hWndPalChange)
+{
+    wxPaletteChangedEvent event(GetId());
+    event.SetEventObject(this);
+    event.SetChangedWindow(wxFindWinFromHandle(hWndPalChange));
+    GetEventHandler()->ProcessEvent(event);
+    return 0;
+}
+
+long wxWindow::MSWOnQueryNewPalette()
+{
+    wxQueryNewPaletteEvent event(GetId());
+    event.SetEventObject(this);
+    if (!GetEventHandler()->ProcessEvent(event) || !event.GetPaletteRealized())
+    {
+        return (long) FALSE;
+    }
+    else
+        return (long) TRUE;
+}
+
 // Responds to colour changes: passes event on to children.
 void wxWindow::OnSysColourChanged(wxSysColourChangedEvent& event)
 {