Added sash window and layout window docs; added wxLog... and assert functions

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

docs/latex/wx/calclevt.tex

@@ -0,0 +1,60 @@
+\section{\class{wxCalculateLayoutEvent}}\label{wxcalculatelayoutevent}
+
+This event is sent by \helpref{wxLayoutAlgorithm}{wxlayoutalgorithm} to
+calculate the amount of the remaining client area that the window should
+occupy.
+
+\wxheading{Derived from}
+
+\helpref{wxEvent}{wxevent}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{Event table macros}
+
+\twocolwidtha{7cm}%
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf EVT\_CALCULATE\_LAYOUT(func)}}{Process a wxEVT\_CALCULATE\_LAYOUT event,
+which asks the window to take a 'bite' out of a rectangle provided by the algorithm.}
+\end{twocollist}
+
+\wxheading{See also}
+
+\helpref{wxQueryLayoutInfoEvent}{wxquerylayoutinfoevent},\rtfsp
+\helpref{wxSashLayoutWindow}{wxsashlayoutwindow},\rtfsp
+\helpref{wxLayoutAlgorithm}{wxlayoutalgorithm}.
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxCalculateLayoutEvent::wxCalculateLayoutEvent}
+
+\func{}{wxCalculateLayoutEvent}{\param{wxWindowID }{id = 0}}
+
+Constructor.
+
+\membersection{wxCalculateLayoutEvent::GetFlags}\label{wxcalculatelayouteventgetflags}
+
+\constfunc{int}{GetFlags}{\void}
+
+Returns the flags associated with this event. Not currently used.
+
+\membersection{wxCalculateLayoutEvent::GetRect}\label{wxcalculatelayouteventgetrect}
+
+\constfunc{wxRect}{GetRect}{\void}
+
+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.
+
+\membersection{wxCalculateLayoutEvent::SetFlags}\label{wxcalculatelayouteventsetflags}
+
+\func{void}{SetFlags}{\param{int }{flags}}
+
+Sets the flags associated with this event. Not currently used.
+
+\membersection{wxCalculateLayoutEvent::SetRect}\label{wxcalculatelayouteventsetrect}
+
+\func{void}{SetRect}{\param{const wxRect\& }{rect}}
+
+Call this to specify the new remaining parent client area, after the space occupied by the
+window has been subtracted.
+

docs/latex/wx/category.tex

@@ -29,6 +29,8 @@ The following are a variety of windows that are derived from wxWindow.
 \begin{twocollist}\itemsep=0pt
 \twocolitem{\helpref{wxGrid}{wxgrid}}{A grid (table) window}
 \twocolitem{\helpref{wxPanel}{wxpanel}}{A window whose colour changes according to current user settings}
+\twocolitem{\helpref{wxSashWindow}{wxsashwindow}}{Window with four optional sashes that can be dragged}
+\twocolitem{\helpref{wxSashLayoutWindow}{wxsashlayoutwindow}}{Window that can be involved in an IDE-like layout arrangement}
 \twocolitem{\helpref{wxScrolledWindow}{wxscrolledwindow}}{Window with automatically managed scrollbars}
 \twocolitem{\helpref{wxSplitterWindow}{wxsplitterwindow}}{Window which can be split vertically or horizontally}
 \twocolitem{\helpref{wxStatusBar}{wxstatusbar}}{Implements the status bar on a frame}
@@ -158,6 +160,7 @@ An event object contains information about a specific event. Event handlers
 
 \begin{twocollist}\itemsep=0pt
 \twocolitem{\helpref{wxActivateEvent}{wxactivateevent}}{A window or application activation event}
+\twocolitem{\helpref{wxCalculateLayoutEvent}{wxcalculatelayoutevent}}{Used to calculate window layout}
 \twocolitem{\helpref{wxCloseEvent}{wxcloseevent}}{A close window or end session event}
 \twocolitem{\helpref{wxCommandEvent}{wxcommandevent}}{An event from a variety of standard controls}
 \twocolitem{\helpref{wxDropFilesEvent}{wxdropfilesevent}}{A drop files event}
@@ -175,7 +178,7 @@ An event object contains information about a specific event. Event handlers
 \twocolitem{\helpref{wxNotebookEvent}{wxnotebookevent}}{A notebook control event}
 \twocolitem{\helpref{wxPaintEvent}{wxpaintevent}}{A paint event}
 \twocolitem{\helpref{wxProcessEvent}{wxprocessevent}}{A process ending event}
-%\twocolitem{\helpref{wxSessionEvent}{wxsessionevent}}{A session ending event}
+\twocolitem{\helpref{wxQueryLayoutInfoEvent}{wxquerylayoutinfoevent}}{Used to query layout information}
 \twocolitem{\helpref{wxSizeEvent}{wxsizeevent}}{A size event}
 \twocolitem{\helpref{wxSocketEvent}{wxsocketevent}}{A socket event}
 \twocolitem{\helpref{wxSysColourChangedEvent}{wxsyscolourchangedevent}}{A system colour change event}
@@ -239,14 +242,14 @@ classes, functions and macros.
 
 \begin{twocollist}\itemsep=0pt
 \twocolitem{\helpref{wxDebugContext}{wxdebugcontext}}{Provides various debugging facilities}
-\twocolitem{\helpref{wxDebugStreamBuf}{wxdebugstreambuf}}{A stream buffer writing to the debug stream}
+%\twocolitem{\helpref{wxDebugStreamBuf}{wxdebugstreambuf}}{A stream buffer writing to the debug stream}
 \twocolitem{\helpref{wxLog}{wxlog}}{Logging facility}
-\twocolitem{\helpref{wxObject}{wxobject}}{Provides optional debugging versions of {\bf new} and {\bf delete}}
+\twocolitem{\helpref{Log functions}{logfunctions}}{Error and warning logging functions}
-\twocolitem{\helpref{wxTrace}{wxtrace}}{Tracing facility}
+%\twocolitem{\helpref{wxTrace}{wxtrace}}{Tracing facility}
-\twocolitem{\helpref{wxTraceLevel}{wxtracelevel}}{Tracing facility with levels}
+%\twocolitem{\helpref{wxTraceLevel}{wxtracelevel}}{Tracing facility with levels}
 \twocolitem{\helpref{WXDEBUG\_NEW}{debugnew}}{Use this macro to give further debugging information}
-\twocolitem{\helpref{WXTRACE}{trace}}{Trace macro}
+%\twocolitem{\helpref{WXTRACE}{trace}}{Trace macro}
-\twocolitem{\helpref{WXTRACELEVEL}{tracelevel}}{Trace macro with levels}
+%\twocolitem{\helpref{WXTRACELEVEL}{tracelevel}}{Trace macro with levels}
 \end{twocollist}
 
 {\large {\bf Interprocess communication}}
@@ -272,9 +275,6 @@ based on DDE.
 wxWindows supports a document/view framework which provides
 housekeeping for a document-centric application.
 
-TODO: MDI frame classes for documents; make it unnecessary to convert
-between streams and files (overridable method that uses filenames instead of streams).
-
 \begin{twocollist}\itemsep=0pt
 \twocolitem{\helpref{wxDocument}{wxdocument}}{Represents a document}
 \twocolitem{\helpref{wxView}{wxview}}{Represents a view}
@@ -282,6 +282,8 @@ between streams and files (overridable method that uses filenames instead of str
 \twocolitem{\helpref{wxDocManager}{wxdocmanager}}{Manages the documents and views in an application}
 \twocolitem{\helpref{wxDocChildFrame}{wxdocchildframe}}{A child frame for showing a document view}
 \twocolitem{\helpref{wxDocParentFrame}{wxdocparentframe}}{A parent frame to contain views}
+%\twocolitem{\helpref{wxMDIDocChildFrame}{wxmdidocchildframe}}{An MDI child frame for showing a document view}
+%\twocolitem{\helpref{wxMDIDocParentFrame}{wxmdidocparentframe}}{An MDI parent frame to contain views}
 \end{twocollist}
 
 {\large {\bf Printing framework}}
@@ -324,11 +326,11 @@ product.
 \twocolitem{\helpref{wxAcceleratorTable}{wxacceleratortable}}{Accelerator table}
 \twocolitem{\helpref{wxApp}{wxapp}}{Application class}
 \twocolitem{\helpref{wxConfig}{wxconfigbase}}{Classes for configuration reading/writing}
-\twocolitem{\helpref{wxHelpControllerBase}{wxhelpcontrollerbase}}{Base class for help controllers}
+\twocolitem{\helpref{wxHelpController}{wxhelpcontroller}}{Family of classes for controlling help windows}
+\twocolitem{\helpref{wxLayoutAlgorithm}{wxlayoutalgorithm}}{An alternative window layout facility}
 \twocolitem{\helpref{wxProcess}{wxprocess}}{Process class}
 \twocolitem{\helpref{wxTimer}{wxtimer}}{Timer class}
 \twocolitem{\helpref{wxSystemSettings}{wxsystemsettings}}{System settings class}
-\twocolitem{\helpref{wxWinHelpController}{wxwinhelpcontroller}}{Controls WinHelp instances}
 \end{twocollist}
 
 

docs/latex/wx/classes.tex

@@ -34,6 +34,7 @@ $$\image{14cm;0cm}{wxclass.ps}$$
 \input bitmap.tex
 \input bbutton.tex
 \input brush.tex
+\input calclevt.tex
 \input checkbox.tex
 \input checklst.tex
 \input choice.tex
@@ -94,6 +95,7 @@ $$\image{14cm;0cm}{wxclass.ps}$$
 \input joystick.tex
 \input joyevent.tex
 \input keyevent.tex
+\input layalgor.tex
 \input layout.tex
 \input list.tex
 \input listbox.tex
@@ -133,12 +135,16 @@ $$\image{14cm;0cm}{wxclass.ps}$$
 \input process.tex
 \input procevt.tex
 \input query.tex
+\input qylayevt.tex
 \input radiobox.tex
 \input radiobut.tex
 \input realpoin.tex
 \input rect.tex
 \input recrdset.tex
 \input region.tex
+\input sashevt.tex
+\input sashlayw.tex
+\input sashwin.tex
 \input screendc.tex
 \input scrolbar.tex
 \input scrolevt.tex
@@ -178,7 +184,6 @@ $$\image{14cm;0cm}{wxclass.ps}$$
 \input wave.tex
 \input window.tex
 \input windowdc.tex
-\input winhelp.tex
 
 \input function.tex
 \input keycode.tex

docs/latex/wx/debugcxt.tex

@@ -74,6 +74,8 @@ 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 \helpref{wxLog}{wxlog} functionality.
+
 \wxheading{See also}
 
 \helpref{wxDebugContext::SetLevel}{wxdebugcontextsetlevel}
@@ -84,6 +86,8 @@ specify a value other than one.
 
 Returns the output stream associated with the debug context.
 
+This is obsolete, replaced by \helpref{wxLog}{wxlog} functionality.
+
 \wxheading{See also}
 
 \helpref{wxDebugContext::SetStream}{wxdebugcontextsetstream}
@@ -96,6 +100,8 @@ 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 \helpref{wxLog}{wxlog} functionality.
+
 \membersection{wxDebugContext::HasStream}\label{wxdebugcontexthasstream}
 
 \func{bool}{HasStream}{\void}
@@ -103,6 +109,8 @@ by the user.
 Returns TRUE if there is a stream currently associated
 with the debug context.
 
+This is obsolete, replaced by \helpref{wxLog}{wxlog} functionality.
+
 \wxheading{See also}
 
 \helpref{wxDebugContext::SetStream}{wxdebugcontextsetstream}, \helpref{wxDebugContext::GetStream}{wxdebugcontextgetstream}
@@ -195,6 +203,8 @@ 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 \helpref{wxLog}{wxlog} functionality.
+
 \wxheading{See also}
 
 \helpref{wxDebugContext::GetLevel}{wxdebugcontextgetlevel}
@@ -206,6 +216,8 @@ specify a value other than one.
 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 \helpref{wxLog}{wxlog} functionality.
+
 \membersection{wxDebugContext::SetStream}\label{wxdebugcontextsetstream}
 
 \func{void}{SetStream}{\param{ostream* }{stream}, \param{streambuf* }{streamBuf = NULL}}
@@ -213,6 +225,8 @@ This is the default setting. The existing stream will be flushed and deleted.
 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 \helpref{wxLog}{wxlog} functionality.
+
 \wxheading{Parameters}
 
 \docparam{stream}{Stream to associate with the debug context. Do not set this to NULL.}
@@ -231,6 +245,8 @@ Windows, an ostream constructed with this buffer outputs
 to the debugger, or other program that intercepts debugging
 output. On other platforms, the output goes to standard error (cerr).
 
+This is soon to be obsolete, replaced by \helpref{wxLog}{wxlog} functionality.
+
 \wxheading{Derived from}
 
 streambuf

docs/latex/wx/function.tex

@@ -750,6 +750,8 @@ each wxDebugMsg call. wxDebugMsg seems to be broken under WIN32s
 (at least for Watcom C++): preformat your messages and use OutputDebugString
 instead.
 
+This function is now obsolete, replaced by \helpref{Log functions}{logfunctions}.
+
 \membersection{::wxDisplaySize}
 
 \func{void}{wxDisplaySize}{\param{int *}{width}, \param{int *}{height}}
@@ -1121,6 +1123,8 @@ Converts the character to upper case. This is implemented as a macro for efficie
 Takes printf-style variable argument syntax. Output
 is directed to the current output stream (see \helpref{wxDebugContext}{wxdebugcontextoverview}).
 
+This function is now obsolete, replaced by \helpref{Log functions}{logfunctions}.
+
 \membersection{::wxTraceLevel}\label{wxtracelevel}
 
 \func{void}{wxTraceLevel}{\param{int}{ level}, \param{const wxString\& }{fmt}, \param{...}{}}
@@ -1131,6 +1135,8 @@ The first argument should be the level at which this information is appropriate.
 It will only be output if the level returned by wxDebugContext::GetLevel is equal to or greater than
 this value.
 
+This function is now obsolete, replaced by \helpref{Log functions}{logfunctions}.
+
 \membersection{::wxWriteResource}\label{wxwriteresource}
 
 \func{bool}{wxWriteResource}{\param{const wxString\& }{section}, \param{const wxString\& }{entry},
@@ -1355,6 +1361,8 @@ base classes.
 Calls wxTrace with printf-style variable argument syntax. Output
 is directed to the current output stream (see \helpref{wxDebugContext}{wxdebugcontextoverview}).
 
+This macro is now obsolete, replaced by \helpref{Log functions}{logfunctions}.
+
 \membersection{WXTRACELEVEL}\label{tracelevel}
 
 \func{}{WXTRACELEVEL}{level, formatString, ...}
@@ -1365,6 +1373,8 @@ The first argument should be the level at which this information is appropriate.
 It will only be output if the level returned by wxDebugContext::GetLevel is equal to or greater than
 this value.
 
+This function is now obsolete, replaced by \helpref{Log functions}{logfunctions}.
+
 \section{wxWindows resource functions}\label{resourcefuncs}
 
 \overview{wxWindows resource system}{resourceformats}
@@ -1560,3 +1570,148 @@ is no connection between names used in resources, and the global bitmap data.
 
 Another name for \helpref{wxResourceRegisterBitmapData}{registerbitmapdata}.
 
+\section{Log functions}\label{logfunctions}
+
+These functions provide a variety of logging functions: see \helpref{Log classes overview}{wxlogoverview} for
+further information.
+
+\membersection{::wxLogError}\label{wxlogerror}
+
+\func{void}{wxLogError}{\param{const char*}{ formatString}, \param{...}{}}
+
+The function to use for error messages, i.e. the
+messages that must be shown to the user. The default processing is to pop up a
+message box to inform the user about it.
+
+\membersection{::wxLogFatalError}\label{wxlogfatalerror}
+
+\func{void}{wxLogFatalError}{\param{const char*}{ formatString}, \param{...}{}}
+
+Like \helpref{wxLogError}{wxlogerror}, but also
+terminates the program with the exit code 3. Using {\it abort()} standard
+function also terminates the program with this exit code.
+
+\membersection{::wxLogWarning}\label{wxlogwarning}
+
+\func{void}{wxLogWarning}{\param{const char*}{ formatString}, \param{...}{}}
+
+For warnings - they are also normally shown to the
+user, but don't interrupt the program work.
+
+\membersection{::wxLogMessage}\label{wxlogmessage}
+
+\func{void}{wxLogMessage}{\param{const char*}{ formatString}, \param{...}{}}
+
+for all normal, informational messages. They also
+appear in a message box by default (but it can be changed). Notice
+that the standard behaviour is to not show informational messages if there are
+any errors later - the logic being that the later error messages make the
+informational messages preceding them meaningless.
+
+\membersection{::wxLogVerbose}\label{wxlogverbose}
+
+\func{void}{wxLogVerbose}{\param{const char*}{ formatString}, \param{...}{}}
+
+For verbose output. Normally, it's suppressed, but
+might be activated if the user wishes to know more details about the program
+progress (another, but possibly confusing name for the same function is {\bf wxLogInfo}).
+
+\membersection{::wxLogStatus}\label{wxlogstatus}
+
+\func{void}{wxLogStatus}{\param{const char*}{ formatString}, \param{...}{}}
+
+For status messages - they will go into the status
+bar of the active or specified (as the first argument) \helpref{wxFrame}{wxframe} if it has one.
+
+\membersection{::wxLogSysError}\label{wxlogsyserror}
+
+\func{void}{wxLogSysError}{\param{const char*}{ formatString}, \param{...}{}}
+
+Mostly used by wxWindows itself, but might be
+handy for logging errors after system call (API function) failure. It logs the
+specified message text as well as the last system error code ({\it errno} or {\it ::GetLastError()} depending
+on the platform) and the corresponding error
+message. The second form of this function takes the error code explitly as the
+first argument.
+
+\membersection{::wxLogDebug}\label{wxlogdebug}
+
+\func{void}{wxLogDebug}{\param{const char*}{ formatString}, \param{...}{}}
+
+The right function for debug output. It only
+does anything at all in the debug mode (when the preprocessor symbol \_\_WXDEBUG\_\_ is defined)
+and expands to nothing in release mode (otherwise).
+
+\membersection{::wxLogTrace}\label{wxlogtrace}
+
+\func{void}{wxLogTrace}{\param{const char*}{ formatString}, \param{...}{}}
+
+\func{void}{wxLogTrace}{\param{wxTraceMask}{ mask}, \param{const char*}{ formatString}, \param{...}{}}
+
+As {\bf wxLogDebug}, only does something in debug
+build. The reason for making it a separate function from it is that usually
+there are a lot of trace messages, so it might make sense to separate them
+from other debug messages which would be flooded in them. Moreover, the second
+version of this function takes a trace mask as the first argument which allows
+to further restrict the amount of messages generated. The value of {\it mask} can be:
+
+\begin{itemize}\itemsep=0pt
+\item wxTraceMemAlloc: trace memory allocation (new/delete)
+\item wxTraceMessages: trace window messages/X callbacks
+\item wxTraceResAlloc: trace GDI resource allocation
+\item wxTraceRefCount: trace various ref counting operations
+\end{itemize}
+
+\section{Debugging macros and functions}\label{debugmacros}
+
+Useful macros and functins for error checking and defensive programming. ASSERTs are only
+compiled if \_\_WXDEBUG\_\_ is defined, whereas CHECK macros stay in release
+builds.
+
+\membersection{::wxOnAssert}\label{wxonassert}
+
+\func{void}{wxOnAssert}{\param{const char*}{ fileName}, \param{int}{ lineNumber}, \param{const char*}{ msg = NULL}}
+
+This function may be redefined to do something non trivial and is called
+whenever one of debugging macros fails (i.e. condition is false in an
+assertion). TODO: this should probably be an overridable in wxApp.
+
+\membersection{wxASSERT}\label{wxassert}
+
+\func{}{wxASSERT}{\param{}{condition}}
+
+Assert macro. An error message will be generated if the condition is FALSE.
+
+\membersection{wxASSERT\_MSG}\label{wxassertmsg}
+
+\func{}{wxASSERT\_MSG}{\param{}{condition}, \param{}{msg}}
+
+Assert macro with message. An error message will be generated if the condition is FALSE.
+
+\membersection{wxFAIL}\label{wxfail}
+
+\func{}{wxFAIL}{\param{}{condition}}
+
+Will always generate an assert error if this code is reached (in debug mode).
+
+\membersection{wxFAIL\_MSG}\label{wxfailmsg}
+
+\func{}{wxFAIL\_MSG}{\param{}{condition}, \param{}{msg}}
+
+Will always generate an assert error with specified message if this code is reached (in debug mode).
+
+\membersection{wxCHECK}\label{wxcheck}
+
+\func{}{wxCHECK}{\param{}{condition}, \param{}{retValue}}
+
+Checks that the condition is true, returns with the given return value if not (FAILs in debug mode).
+This check is done even in release mode.
+
+\membersection{wxCHECK\_MSG}\label{wxcheckmsg}
+
+\func{}{wxCHECK\_MSG}{\param{}{condition}, \param{}{retValue}, \param{}{msg}}
+
+Checks that the condition is true, returns with the given return value if not (FAILs in debug mode).
+This check is done even in release mode.
+
+

docs/latex/wx/helpinst.tex

@@ -1,11 +1,8 @@
-\section{\class{wxHelpControllerBase}}\label{wxhelpcontrollerbase}
+\section{\class{wxHelpController}}\label{wxhelpcontroller}
 
-This class defines the interface by which
+This is a family of classes by which
 applications may invoke a help viewer to provide on-line help.
 
-Other classes derive from this class to provide actual implementations
-of help controllers.
-
 A help controller allows an application to display help, at the contents
 or at a particular topic, and shut the help program down on termination.
 This avoids proliferation of many instances of the help viewer whenever the
@@ -16,36 +13,41 @@ when it starts, and immediately call {\bf Initialize}\rtfsp
 to associate a filename with it. The help viewer will only get run, however,
 just before the first call to display something.
 
+Although all classes actually derive from wxHelpControllerBase, the
+appropriate class is aliased to wxHelpController for each platform.
+
+There are currently the following help controller classes defined:
+
+\begin{itemize}\itemsep=0
+\item wxWinHelpController, for controlling Windows Help.
+\item wxExtHelpController, for controlling external browsers under Unix.
+The default browser is Netscape Navigator.
+\end{itemize}
+
 \wxheading{Derivation}
 
+wxHelpControllerBase\\
 \helpref{wxObject}{wxobject}
 
-\wxheading{See also}
-
-\helpref{wxWinHelpController}{wxwinhelpcontroller}
-
 \wxheading{Include file}
 
-{\tt <wx/helpbase.h>} (for just wxHelpControllerBase)
+{\tt <wx/help.h>}
-
-{\tt <wx/help.h>} (to include the platform-specific controller, e.g. wxWinHelpController)
-
 
 \latexignore{\rtfignore{\wxheading{Members}}}
 
-\membersection{wxHelpControllerBase::wxHelpControllerBase}
+\membersection{wxHelpController::wxHelpController}
 
-\func{}{wxHelpControllerBase}{\void}
+\func{}{wxHelpController}{\void}
 
 Constructs a help instance object, but does not invoke the help viewer.
 
-\membersection{wxHelpControllerBase::\destruct{wxHelpControllerBase}}
+\membersection{wxHelpController::\destruct{wxHelpController}}
 
-\func{}{\destruct{wxHelpControllerBase}}{\void}
+\func{}{\destruct{wxHelpController}}{\void}
 
 Destroys the help instance, closing down the viewer if it is running.
 
-\membersection{wxHelpControllerBase::Initialize}\label{wxhelpcontrollerbaseinitialize}
+\membersection{wxHelpController::Initialize}\label{wxhelpcontrollerinitialize}
 
 \func{virtual void}{Initialize}{\param{const wxString\& }{file}}
 
@@ -58,7 +60,7 @@ any attempts to communicate with the viewer.
 
 You may omit the file extension and a suitable one will be chosen.
 
-\membersection{wxHelpControllerBase::DisplayBlock}\label{wxhelpcontrollerbasedisplayblock}
+\membersection{wxHelpController::DisplayBlock}\label{wxhelpcontrollerdisplayblock}
 
 \func{virtual bool}{DisplayBlock}{\param{long}{ blockNo}}
 
@@ -66,14 +68,14 @@ If the help viewer is not running, runs it and displays the file at the given bl
 The interpretation of {\it blockNo} differs between help viewers. If using Windows Help, this
 refers to the context number. If wxHelp, this is the wxHelp block number.
 
-\membersection{wxHelpControllerBase::DisplayContents}\label{wxhelpcontrollerbasedisplaycontents}
+\membersection{wxHelpController::DisplayContents}\label{wxhelpcontrollerdisplaycontents}
 
 \func{virtual bool}{DisplayContents}{\void}
 
 If the help viewer is not running, runs it and displays the
 contents.
 
-\membersection{wxHelpControllerBase::DisplaySection}\label{wxhelpcontrollerbasedisplaysection}
+\membersection{wxHelpController::DisplaySection}\label{wxhelpcontrollerdisplaysection}
 
 \func{virtual bool}{DisplaySection}{\param{int}{ sectionNo}}
 
@@ -84,7 +86,7 @@ For wxHelp, section numbers may be viewed by running wxHelp in edit mode.
 
 DisplaySection does not apply to WinHelp.
 
-\membersection{wxHelpControllerBase::KeywordSearch}\label{wxhelpcontrollerbasekeywordsearch}
+\membersection{wxHelpController::KeywordSearch}\label{wxhelpcontrollerkeywordsearch}
 
 \func{virtual bool}{KeywordSearch}{\param{const wxString\& }{keyWord}}
 
@@ -93,7 +95,7 @@ match is found, the file is displayed at this section. If more than one
 match is found, the Search dialog is displayed with the matches (wxHelp)
 or the first topic is displayed (Windows Help).
 
-\membersection{wxHelpControllerBase::LoadFile}\label{wxhelpcontrollerbaseloadfile}
+\membersection{wxHelpController::LoadFile}\label{wxhelpcontrollerloadfile}
 
 \func{virtual bool}{LoadFile}{\param{const wxString\& }{file = NULL}}
 
@@ -104,15 +106,15 @@ 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.
 
-\membersection{wxHelpControllerBase::OnQuit}\label{wxhelpcontrollerbaseonquit}
+\membersection{wxHelpController::OnQuit}\label{wxhelpcontrolleronquit}
 
 \func{virtual bool}{OnQuit}{\void}
 
 Overridable member called when this application's viewer is quit by the user.
 
-This only works for wxXLPHelpController.
+This does not work for all help controllers.
 
-\membersection{wxHelpControllerBase::Quit}\label{wxhelpcontrollerbasequit}
+\membersection{wxHelpController::Quit}\label{wxhelpcontrollerquit}
 
 \func{virtual bool}{Quit}{\void}
 

docs/latex/wx/layalgor.tex

@@ -0,0 +1,133 @@
+\section{\class{wxLayoutAlgorithm}}\label{wxlayoutalgorithm}
+
+wxLayoutAlgorithm implements layout of subwindows in MDI or SDI frames.
+It sends a wxCalculateLayoutEvent event
+to children of the frame, asking them for information about
+their size. For MDI parent frames, the algorithm allocates
+the remaining space to the MDI client window (which contains the MDI child frames).
+For SDI (normal) frames, a 'main' window is specified as taking up the
+remaining space.
+
+Because the event system is used, this technique can be applied to any windows,
+which are not necessarily 'aware' of the layout classes (no virtual functions
+in wxWindow refer to wxLayoutAlgorithm or its events). However, you
+may wish to use \helpref{wxSashLayoutWindow}{wxsashlayoutwindow} for your subwindows
+since this class provides handlers for the required events, and accessors
+to specify the desired size of the window. The sash behaviour in the base class
+can be used, optionally, to make the windows user-resizable.
+
+wxLayoutAlgorithm is typically used in IDE (integrated development environment) applications,
+where there are several resizable windows in addition to the MDI client window, or
+other primary editing window. Resizable windows might include toolbars, a project
+window, and a window for displaying error and warning messages.
+
+When a window receives an OnCalculateLayout event, it should call SetRect in
+the given event object, to be the old supplied rectangle minus whatever space the
+window takes up. It should also set its own size accordingly.
+wxSashLayoutWindow::OnCalculateLayout generates an OnQueryLayoutInfo event
+which it sends to itself to determine the orientation, alignment and size of the window,
+which it gets from internal member variables set by the application.
+
+The algorithm works by starting off with a rectangle equal to the whole frame client area.
+It iterates through the frame children, generating OnCalculateLayout events which subtract
+the window size and return the remaining rectangle for the next window to process. It
+is assumed (by wxSashLayoutWindow::OnCalculateLayout) that a window stretches the full dimension
+of the frame client, according to the orientation it specifies. For example, a horizontal window
+will stretch the full width of the remaining portion of the frame client area.
+In the other orientation, the window will be fixed to whatever size was specified by
+OnQueryLayoutInfo. An alignment setting will make the window 'stick' to the left, top, right or
+bottom of the remaining client area. This scheme implies that order of window creation is important.
+Say you wish to have an extra toolbar at the top of the frame, a project window to the left of
+the MDI client window, and an output window above the status bar. You should therefore create
+the windows in this order: toolbar, output window, project window. This ensures that the toolbar and
+output window take up space at the top and bottom, then the remaining height in between is used for
+the project window.
+
+wxLayoutAlgorithm is quite independent of the way in which
+OnCalculateLayout chooses to interpret a window's size and alignment. Therefore you
+could implement a different window class with a new OnCalculateLayout event handler,
+that has a more sophisticated way of laying out the windows. It might allow
+specification of whether stretching occurs in the specified orientation, for example,
+rather than always assuming stretching. (This could, and probably should, be added to the existing
+implementation).
+
+{\it Note:} wxLayoutAlgorithm has nothing to do with wxLayoutConstraints. It is an alternative
+way of specifying layouts for which the normal constraint system is unsuitable.
+
+\wxheading{Derived from}
+
+\helpref{wxObject}{wxobject}
+
+\wxheading{Event handling}
+
+The algorithm object does not respond to events, but itself generates the
+following events in order to calculate window sizes.
+
+\twocolwidtha{7cm}%
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf EVT\_QUERY\_LAYOUT\_INFO(func)}}{Process a wxEVT\_QUERY\_LAYOUT\_INFO event,
+to get size, orientation and alignment from a window. See \helpref{wxQueryLayoutInfoEvent}{wxquerylayoutinfoevent}.}
+\twocolitem{{\bf EVT\_CALCULATE\_LAYOUT(func)}}{Process a wxEVT\_CALCULATE\_LAYOUT event,
+which asks the window to take a 'bite' out of a rectangle provided by the algorithm.
+See \helpref{wxCalculateLayoutEvent}{wxcalculatelayoutevent}.}
+\end{twocollist}
+
+\wxheading{Data types}
+
+{\small
+\begin{verbatim}
+enum wxLayoutOrientation {
+    wxLAYOUT_HORIZONTAL,
+    wxLAYOUT_VERTICAL
+};
+
+enum wxLayoutAlignment {
+    wxLAYOUT_NONE,
+    wxLAYOUT_TOP,
+    wxLAYOUT_LEFT,
+    wxLAYOUT_RIGHT,
+    wxLAYOUT_BOTTOM,
+};
+\end{verbatim}
+}
+
+\wxheading{See also}
+
+\helpref{wxSashEvent}{wxsashevent}, \helpref{wxSashLayoutWindow}{wxsashlayoutwindow}, \helpref{Event handling overview}{eventhandlingoverview}
+
+\helpref{wxCalculateLayoutEvent}{wxcalculatelayoutevent},\rtfsp
+\helpref{wxQueryLayoutInfoEvent}{wxquerylayoutinfoevent},\rtfsp
+\helpref{wxSashLayoutWindow}{wxsashlayoutwindow},\rtfsp
+\helpref{wxSashWindow}{wxsashwindow}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxLayoutAlgorithm::wxLayoutAlgorithm}
+
+\func{}{wxLayoutAlgorithm}{\void}
+
+Default constructor.
+
+\membersection{wxLayoutAlgorithm::\destruct{wxLayoutAlgorithm}}
+
+\func{}{\destruct{wxLayoutAlgorithm}}{\void}
+
+Destructor.
+
+\membersection{wxLayoutAlgorithm::LayoutMDIFrame}\label{wxlayoutalgorithmlayoutmdiframe}
+
+\constfunc{bool}{LayoutMDIFrame}{\param{wxMDIParentFrame* }{frame}, \param{wxRect*}{ rect = NULL}}
+
+Lays out the children of an MDI parent frame. If {\it 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.
+
+\membersection{wxLayoutAlgorithm::LayoutFrame}\label{wxlayoutalgorithmlayoutframe}
+
+\constfunc{bool}{LayoutFrame}{\param{wxFrame* }{frame}, \param{wxWindow*}{ mainWindow}}
+
+Lays out the children of a normal frame.
+
+{\it mainWindow} is set to occupy the remaining space.
+

docs/latex/wx/log.tex

@@ -40,7 +40,7 @@ of messages.
 \membersection{Message buffering}
 
 Some of wxLog implementations, most notably the standard
-\helpref{wxLogGui}{wxloggui} class, buffer the messages (for example, to avoid
+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). {\it Flush()} shows them all and clears the buffer
 contents. Although this function doesn't do anything if the buffer is already

docs/latex/wx/qylayevt.tex

@@ -0,0 +1,118 @@
+\section{\class{wxQueryLayoutInfoEvent}}\label{wxquerylayoutinfoevent}
+
+This event is sent when \helpref{wxLayoutAlgorithm}{wxlayoutalgorithm} wishes to get
+the size, orientation and alignment of a window. More precisely, the event is sent
+by the OnCalculateLayout handler which is itself invoked by wxLayoutAlgorithm.
+
+\wxheading{Derived from}
+
+\helpref{wxEvent}{wxevent}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{Event table macros}
+
+\twocolwidtha{7cm}%
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf EVT\_QUERY\_LAYOUT\_INFO(func)}}{Process a wxEVT\_QUERY\_LAYOUT\_INFO event,
+to get size, orientation and alignment from a window.}
+\end{twocollist}
+
+\wxheading{Data structures}
+
+{\small
+\begin{verbatim}
+enum wxLayoutOrientation {
+    wxLAYOUT_HORIZONTAL,
+    wxLAYOUT_VERTICAL
+};
+
+enum wxLayoutAlignment {
+    wxLAYOUT_NONE,
+    wxLAYOUT_TOP,
+    wxLAYOUT_LEFT,
+    wxLAYOUT_RIGHT,
+    wxLAYOUT_BOTTOM,
+};
+\end{verbatim}
+}
+
+\wxheading{See also}
+
+\helpref{wxCalculateLayoutEvent}{wxcalculatelayoutevent},\rtfsp
+\helpref{wxSashLayoutWindow}{wxsashlayoutwindow},\rtfsp
+\helpref{wxLayoutAlgorithm}{wxlayoutalgorithm}.
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxQueryLayoutInfoEvent::wxQueryLayoutInfoEvent}
+
+\func{}{wxQueryLayoutInfoEvent}{\param{wxWindowID }{id = 0}}
+
+Constructor.
+
+\membersection{wxQueryLayoutInfoEvent::GetAlignment}\label{wxquerylayoutinfoeventgetalignment}
+
+\constfunc{void}{GetAlignment}{\void}
+
+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.
+
+\membersection{wxQueryLayoutInfoEvent::GetFlags}\label{wxquerylayoutinfoeventgetflags}
+
+\constfunc{int}{GetFlags}{\void}
+
+Returns the flags associated with this event. Not currently used.
+
+\membersection{wxQueryLayoutInfoEvent::GetOrientation}\label{wxquerylayoutinfoeventgetorientation}
+
+\constfunc{wxLayoutOrientation}{GetOrientation}{\void}
+
+Returns the orientation that the event handler specified to the event object. May be one of wxLAYOUT\_HORIZONTAL,
+wxLAYOUT\_VERTICAL.
+
+\membersection{wxQueryLayoutInfoEvent::GetRequestedLength}\label{wxquerylayoutinfoeventgetrequestedlength}
+
+\constfunc{int}{GetRequestedLength}{\void}
+
+Returns the requested length of the window in the direction of the window orientation. This information
+is not yet used.
+
+\membersection{wxQueryLayoutInfoEvent::GetSize}\label{wxquerylayoutinfoeventgetsize}
+
+\constfunc{wxSize}{GetSize}{\void}
+
+Returns the size that the event handler specified to the event object as being the requested size of the window.
+
+\membersection{wxQueryLayoutInfoEvent::SetAlignment}\label{wxquerylayoutinfoeventsetalignment}
+
+\func{void}{SetAlignment}{\param{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.
+
+\membersection{wxQueryLayoutInfoEvent::SetFlags}\label{wxquerylayoutinfoeventsetflags}
+
+\func{void}{SetFlags}{\param{int }{flags}}
+
+Sets the flags associated with this event. Not currently used.
+
+\membersection{wxQueryLayoutInfoEvent::SetOrientation}\label{wxquerylayoutinfoeventsetorientation}
+
+\func{void}{SetOrientation}{\param{wxLayoutOrientation }{orientation}}
+
+Call this to specify the orientation of the window. May be one of wxLAYOUT\_HORIZONTAL,
+wxLAYOUT\_VERTICAL.
+
+\membersection{wxQueryLayoutInfoEvent::SetRequestedLength}\label{wxquerylayoutinfoeventsetrequestedlength}
+
+\func{void}{SetRequestedLength}{\param{int}{ length}}
+
+Sets the requested length of the window in the direction of the window orientation. This information
+is not yet used.
+
+\membersection{wxQueryLayoutInfoEvent::SetSize}\label{wxquerylayoutinfoeventsetsize}
+
+\func{void}{SetSize}{\param{const wxSize\& }{size}}
+
+Call this to let the calling code know what the size of the window is.
+

docs/latex/wx/sashevt.tex

@@ -0,0 +1,86 @@
+\section{\class{wxSashEvent}}\label{wxsashevent}
+
+A sash event is sent when the sash of a \helpref{wxSashWindow}{wxsashwindow} has been
+dragged by the user.
+
+\wxheading{Derived from}
+
+\helpref{wxCommandEvent}{wxcommandevent}\\
+\helpref{wxEvent}{wxevent}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{Event table macros}
+
+To process an activate event, use these event handler macros to direct input to a member
+function that takes a wxSashEvent argument.
+
+\twocolwidtha{7cm}%
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf EVT\_SASH\_DRAGGED(id, func)}}{Process a wxEVT\_SASH\_DRAGGED event,
+when the user has finished dragging a sash.}
+\twocolitem{{\bf EVT\_SASH\_DRAGGED\_RANGE(id1, id2, func)}}{Process a wxEVT\_SASH\_DRAGGED\_RANGE event,
+when the user has finished dragging a sash. The event handler is called when windows with ids in the
+given range have their sashes dragged.}
+\end{twocollist}
+
+\wxheading{Data structures}
+
+{\small
+\begin{verbatim}
+enum wxSashDragStatus
+{
+    wxSASH_STATUS_OK,
+    wxSASH_STATUS_OUT_OF_RANGE
+};
+\end{verbatim}
+}
+
+\wxheading{Remarks}
+
+When a sash belonging to a sash window is dragged by the user, and then released,
+this event is sent to the window, where it may be processed by an event table
+entry in a derived class, a plug-in event handler or an ancestor class.
+
+Note that the wxSashWindow doesn't change the window's size itself. It relies on the application's
+event handler to do that. This is because the application may have to handle other consequences
+of the resize, or it may wish to veto it altogether. The event handler should
+look at the drag rectangle: see \helpref{wxSashEvent::GetDragRect}{wxsasheventgetdragrect} to see
+what the new size of the window would be if the resize were to be applied. It should
+also call \helpref{wxSashEvent::GetDragStatus}{wxsasheventgetdragstatus} to see whether the
+drag was OK or out of the current allowed range.
+
+\wxheading{See also}
+
+\helpref{wxWindow::OnSash}{wxwindowonactivate},\rtfsp
+\helpref{wxApp::OnSash}{wxapponactivate},\rtfsp
+\helpref{Event handling overview}{eventhandlingoverview}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxSashEvent::wxSashEvent}
+
+\func{}{wxSashEvent}{\param{int }{id = 0}, \param{wxSashEdgePosition}{ edge = wxSASH\_NONE}}
+
+Constructor.
+
+\membersection{wxSashEvent::GetEdge}\label{wxsasheventgetedge}
+
+\constfunc{wxSashEdgePosition}{GetEdge}{\void}
+
+Returns the dragged edge. The return value is one of wxSASH\_TOP, wxSASH\_RIGHT, wxSASH\_BOTTOM, wxSASH\_LEFT.
+
+\membersection{wxSashEvent::GetDragRect}\label{wxsasheventgetdragrect}
+
+\constfunc{wxRect}{GetDragRect}{\void}
+
+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.
+
+\membersection{wxSashEvent::GetDragStatus}\label{wxsasheventgetdragstatus}
+
+\constfunc{wxSashDragStatus}{GetDragStatus}{\void}
+
+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.
+
+

docs/latex/wx/sashlayw.tex

@@ -0,0 +1,128 @@
+\section{\class{wxSashLayoutWindow}}\label{wxsashlayoutwindow}
+
+wxSashLayoutWindow responds to OnCalculateLayout events generated
+by \helpref{wxLayoutAlgorithm}{wxlayoutalgorithm}. It allows the
+application to use simple accessors to specify how the window should be
+laid out, rather than having to respond to events. The fact that
+the class derives from wxSashWindow allows sashes to be used if required,
+to allow the windows to be user-resizable.
+
+The documentation for \helpref{wxLayoutAlgorithm}{wxlayoutalgorithm} explains
+the purpose of this class in more detail.
+
+\wxheading{Derived from}
+
+\helpref{wxSashWindow}{wxsashwindow}\\
+\helpref{wxWindow}{wxwindow}\\
+\helpref{wxEvtHandler}{wxevthandler}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{Window styles}
+
+See \helpref{wxSashWindow}{wxsashwindow}.
+
+\wxheading{Event handling}
+
+This class handles the EVT\_QUERY\_LAYOUT\_INFO and EVT\_CALCULATE\_LAYOUT events
+for you. However, if you use sashes, see \helpref{wxSashWindow}{wxsashwindow} for
+relevant event information.
+
+See also \helpref{wxLayoutAlgorithm}{wxlayoutalgorithm} for information
+about the layout events.
+
+\wxheading{See also}
+
+\helpref{wxLayoutAlgorithm}{wxlayoutalgorithm}, \helpref{wxSashWindow}{wxsashwindow}, \helpref{Event handling overview}{eventhandlingoverview}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxSashLayoutWindow::wxSashLayoutWindow}
+
+\func{}{wxSashLayoutWindow}{\void}
+
+Default constructor.
+
+\func{}{wxSashLayoutWindow}{\param{wxSashLayoutWindow*}{ parent}, \param{wxSashLayoutWindowID }{id},
+ \param{const wxPoint\& }{pos = wxDefaultPosition},
+ \param{const wxSize\& }{size = wxDefaultSize},
+ \param{long }{style = wxCLIP\_CHILDREN \pipe wxSW\_3D},
+ \param{const wxString\& }{name = "layoutWindow"}}
+
+Constructs a sash layout window, which can be a child of a frame, dialog or any other non-control window.
+
+\wxheading{Parameters}
+
+\docparam{parent}{Pointer to a parent window.}
+
+\docparam{id}{Window identifier. If -1, will automatically create an identifier.}
+
+\docparam{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.}
+
+\docparam{size}{Window size. wxDefaultSize is (-1, -1) which indicates that wxSashLayoutWindows
+should generate a default size for the window.}
+
+\docparam{style}{Window style. For window styles, please see \helpref{wxSashLayoutWindow}{wxsashlayoutwindow}.}
+
+\docparam{name}{Window name.}
+
+\membersection{wxSashLayoutWindow::\destruct{wxSashLayoutWindow}}
+
+\func{}{\destruct{wxSashLayoutWindow}}{\void}
+
+Destructor.
+
+\membersection{wxSashLayoutWindow::GetAlignment}\label{wxsashlayoutwindowgetalignment}
+
+\constfunc{wxLayoutAlignment}{GetAlignment}{\void}
+
+Returns the alignment of the window: one of wxLAYOUT\_TOP, wxLAYOUT\_LEFT, wxLAYOUT\_RIGHT, wxLAYOUT\_BOTTOM.
+
+\membersection{wxSashLayoutWindow::GetOrientation}\label{wxsashlayoutwindowgetorientation}
+
+\constfunc{wxLayoutOrientation}{GetOrientation}{\void}
+
+Returns the orientation of the window: one of wxLAYOUT\_HORIZONTAL, wxLAYOUT\_VERTICAL.
+
+\membersection{wxSashLayoutWindow::OnCalculateLayout}\label{wxsashlayoutwindowoncalculatelayout}
+
+\func{void}{OnCalculateLayout}{\param{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 \helpref{wxLayoutAlgorithm}{wxlayoutalgorithm} and \helpref{wxCalculateLayoutEvent}{wxcalculatelayoutevent}.
+
+\membersection{wxSashLayoutWindow::OnQueryLayoutInfo}\label{wxsashlayoutwindowonquerylayoutinfo}
+
+\func{void}{OnQueryLayoutInfo}{\param{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 \helpref{wxLayoutAlgorithm}{wxlayoutalgorithm} and \helpref{wxQueryLayoutInfoEvent}{wxquerylayoutinfoevent}.
+
+\membersection{wxSashLayoutWindow::SetAlignment}\label{wxsashlayoutwindowsetalignment}
+
+\func{void}{SetAlignment}{\param{wxLayoutAlignment}{ alignment}}
+
+Sets the alignment of the window (which edge of the available parent client area the window
+is attached to). {\it alignment} is one of wxLAYOUT\_TOP, wxLAYOUT\_LEFT, wxLAYOUT\_RIGHT, wxLAYOUT\_BOTTOM.
+
+\membersection{wxSashLayoutWindow::SetDefaultSize}\label{wxsashlayoutwindowsetdefaultsize}
+
+\func{void}{SetDefaultSize}{\param{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.
+
+\membersection{wxSashLayoutWindow::SetOrientation}\label{wxsashlayoutwindowsetorientation}
+
+\func{void}{SetOrientation}{\param{wxLayoutOrientation}{ orientation}}
+
+Sets the orientation of the window (the direction the window will stretch in, to fill the available
+parent client area). {\it orientation} is one of wxLAYOUT\_HORIZONTAL, wxLAYOUT\_VERTICAL.
+
+
+

docs/latex/wx/sashwin.tex

@@ -0,0 +1,203 @@
+\section{\class{wxSashWindow}}\label{wxsashwindow}
+
+wxSashWindow allows any of its edges to have a sash which can be dragged
+to resize the window. The actual content window will be created by the application
+as a child of wxSashWindow. The window (or an ancestor) will be notified of a drag
+via a \helpref{wxSashEvent}{wxsashevent} notification.
+
+\wxheading{Derived from}
+
+\helpref{wxWindow}{wxwindow}\\
+\helpref{wxEvtHandler}{wxevthandler}\\
+\helpref{wxObject}{wxobject}
+
+\wxheading{Window styles}
+
+The following styles apply in addition to the normal wxWindow styles.
+
+\twocolwidtha{5cm}%
+\begin{twocollist}\itemsep=0pt
+\twocolitem{\windowstyle{wxSW\_3D}}{Draws the sashes in 3D.}
+\end{twocollist}
+
+See also \helpref{window styles overview}{windowstyles}.
+
+\wxheading{Event handling}
+
+\twocolwidtha{7cm}%
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf EVT\_SASH\_DRAGGED(id, func)}}{Process a wxEVT\_SASH\_DRAGGED event,
+when the user has finished dragging a sash.}
+\twocolitem{{\bf EVT\_SASH\_DRAGGED\_RANGE(id1, id2, func)}}{Process a wxEVT\_SASH\_DRAGGED\_RANGE event,
+when the user has finished dragging a sash. The event handler is called when windows with ids in the
+given range have their sashes dragged.}
+\end{twocollist}
+
+\wxheading{Data types}
+
+{\small
+\begin{verbatim}
+enum wxSashEdgePosition {
+    wxSASH_TOP = 0,
+    wxSASH_RIGHT,
+    wxSASH_BOTTOM,
+    wxSASH_LEFT,
+    wxSASH_NONE = 100
+};
+\end{verbatim}
+}
+
+\wxheading{See also}
+
+\helpref{wxSashEvent}{wxsashevent}, \helpref{wxSashLayoutWindow}{wxsashlayoutwindow}, \helpref{Event handling overview}{eventhandlingoverview}
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxSashWindow::wxSashWindow}
+
+\func{}{wxSashWindow}{\void}
+
+Default constructor.
+
+\func{}{wxSashWindow}{\param{wxSashWindow*}{ parent}, \param{wxSashWindowID }{id},
+ \param{const wxPoint\& }{pos = wxDefaultPosition},
+ \param{const wxSize\& }{size = wxDefaultSize},
+ \param{long }{style = wxCLIP\_CHILDREN \pipe wxSW\_3D},
+ \param{const wxString\& }{name = "sashWindow"}}
+
+Constructs a sash window, which can be a child of a frame, dialog or any other non-control window.
+
+\wxheading{Parameters}
+
+\docparam{parent}{Pointer to a parent window.}
+
+\docparam{id}{Window identifier. If -1, will automatically create an identifier.}
+
+\docparam{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.}
+
+\docparam{size}{Window size. wxDefaultSize is (-1, -1) which indicates that wxSashWindows
+should generate a default size for the window.}
+
+\docparam{style}{Window style. For window styles, please see \helpref{wxSashWindow}{wxsashwindow}.}
+
+\docparam{name}{Window name.}
+
+\membersection{wxSashWindow::\destruct{wxSashWindow}}
+
+\func{}{\destruct{wxSashWindow}}{\void}
+
+Destructor.
+
+\membersection{wxSashWindow::GetSashVisible}\label{wxsashwindowgetsashvisible}
+
+\constfunc{bool}{GetSashVisible}{\param{wxSashEdgePosition }{edge}}
+
+Returns TRUE if a sash is visible on the given edge, FALSE otherwise.
+
+\wxheading{Parameters}
+
+\docparam{edge}{Edge. One of wxSASH\_TOP, wxSASH\_RIGHT, wxSASH\_BOTTOM, wxSASH\_LEFT.}
+
+\wxheading{See also}
+
+\helpref{wxSashWindow::SetSashVisible}{wxsashwindowsetsashvisible}
+
+\membersection{wxSashWindow::GetMaximumSizeX}\label{wxsashwindowgetmaximumsizex}
+
+\constfunc{int}{GetMaximumSizeX}{\void}
+
+Gets the maximum window size in the x direction.
+
+\membersection{wxSashWindow::GetMaximumSizeY}\label{wxsashwindowgetmaximumsizey}
+
+\constfunc{int}{GetMaximumSizeY}{\void}
+
+Gets the maximum window size in the y direction.
+
+\membersection{wxSashWindow::GetMinimumSizeX}\label{wxsashwindowgetminimumsizex}
+
+\func{int}{GetMinimumSizeX}{\void}
+
+Gets the minimum window size in the x direction.
+
+\membersection{wxSashWindow::GetMinimumSizeY}\label{wxsashwindowgetminimumsizey}
+
+\constfunc{int}{GetMinimumSizeY}{\param{int}{ min}}
+
+Gets the minimum window size in the y direction.
+
+\membersection{wxSashWindow::HasBorder}\label{wxsashwindowhasborder}
+
+\constfunc{bool}{HasBorder}{\param{wxSashEdgePosition }{edge}}
+
+Returns TRUE if the sash has a border, FALSE otherwise.
+
+\wxheading{Parameters}
+
+\docparam{edge}{Edge. One of wxSASH\_TOP, wxSASH\_RIGHT, wxSASH\_BOTTOM, wxSASH\_LEFT.}
+
+\wxheading{See also}
+
+\helpref{wxSashWindow::SetSashBorder}{wxsashwindowsetsashborder}
+
+\membersection{wxSashWindow::SetMaximumSizeX}\label{wxsashwindowsetmaximumsizex}
+
+\func{void}{SetMaximumSizeX}{\param{int}{ min}}
+
+Sets the maximum window size in the x direction.
+
+\membersection{wxSashWindow::SetMaximumSizeY}\label{wxsashwindowsetmaximumsizey}
+
+\func{void}{SetMaximumSizeY}{\param{int}{ min}}
+
+Sets the maximum window size in the y direction.
+
+\membersection{wxSashWindow::SetMinimumSizeX}\label{wxsashwindowsetminimumsizex}
+
+\func{void}{SetMinimumSizeX}{\param{int}{ min}}
+
+Sets the minimum window size in the x direction.
+
+\membersection{wxSashWindow::SetMinimumSizeY}\label{wxsashwindowsetminimumsizey}
+
+\func{void}{SetMinimumSizeY}{\param{int}{ min}}
+
+Sets the minimum window size in the y direction.
+
+\membersection{wxSashWindow::SetSashVisible}\label{wxsashwindowsetsashvisible}
+
+\func{void}{SetSashVisible}{\param{wxSashEdgePosition }{edge}, \param{bool}{ visible}}
+
+Call this function to make a sash visible or invisible on a particular edge.
+
+\wxheading{Parameters}
+
+\docparam{edge}{Edge to change. One of wxSASH\_TOP, wxSASH\_RIGHT, wxSASH\_BOTTOM, wxSASH\_LEFT.}
+
+\docparam{visible}{TRUE to make the sash visible, FALSE to make it invisible.}
+
+\wxheading{See also}
+
+\helpref{wxSashWindow::GetSashVisible}{wxsashwindowgetsashvisible}
+
+    // Set whether there's a border in this position
+    inline void SetSashBorder(wxSashEdgePosition edge, bool border) { m_sashes[edge].m_border = border; }
+
+\membersection{wxSashWindow::SetSashBorder}\label{wxsashwindowsetsashborder}
+
+\func{void}{SetSashBorder}{\param{wxSashEdgePosition }{edge}, \param{bool}{ hasBorder}}
+
+Call this function to give the sash a border, or remove the border.
+
+\wxheading{Parameters}
+
+\docparam{edge}{Edge to change. One of wxSASH\_TOP, wxSASH\_RIGHT, wxSASH\_BOTTOM, wxSASH\_LEFT.}
+
+\docparam{hasBorder}{TRUE to give the sash a border visible, FALSE to remove it.}
+
+\wxheading{See also}
+
+\helpref{wxSashWindow::HashBorder}{wxsashwindowhasborder}
+

docs/latex/wx/tguide.tex

@@ -38,8 +38,8 @@ These might override predefined event handlers such as \helpref{wxWindow::OnChar
 \rtfsp\helpref{wxWindow::OnMouseEvent}{wxwindowonmouseevent}.
 
 Most modern applications will have an on-line, hypertext help system; for this, you
-need wxHelp and the \helpref{wxHelpControllerBase}{wxhelpcontrollerbase} class to control
+need wxHelp and the \helpref{wxHelpController}{wxhelpcontroller} class to control
-wxHelp. To add sparkle, you might use the wxToolBar class (documented separately)
+wxHelp. To add sparkle, you might use the wxToolBar class
 which makes heavy use of the \helpref{wxBitmap}{wxbitmap}.
 
 GUI applications aren't all graphical wizardry. List and hash table needs are

docs/latex/wx/tlog.tex

@@ -1,9 +1,10 @@
 \section{Log classes overview}\label{wxlogoverview}
 
-Classes: \helpref{wxLog}{wxlog}, \helpref{wxLogStderr}{wxlogstderr},
+Classes: \helpref{wxLog}{wxlog}
- \helpref{wxLogOstream}{wxlogostream}, \helpref{wxLogTextCtrl}{wxlogtextctrl},
+%\helpref{wxLogStderr}{wxlogstderr},%
- \helpref{wxLogWindow}{wxlogwindow}, \helpref{wxLogGui}{wxloggui},
+%\helpref{wxLogOstream}{wxlogostream}, \helpref{wxLogTextCtrl}{wxlogtextctrl},%
- \helpref{wxLogNull}{wxlognull}
+%\helpref{wxLogWindow}{wxlogwindow}, \helpref{wxLogGui}{wxloggui},%
+%\helpref{wxLogNull}{wxlognull}%
 
 This is a general overview of logging classes provided by wxWindows. The word
 logging here has a broad sense, including all of the program output, not only
@@ -39,8 +40,8 @@ wxLogInfo}).
 bar of the active or specified (as the first argument) \helpref{wxFrame}{wxframe} if it has one.
 \item{\bf wxLogSysError} is mostly used by wxWindows itself, but might be
 handy for logging errors after system call (API function) failure. It logs the
-specified message text as well as the last system error code ({\it errno} or
+specified message text as well as the last system error
-{\it ::GetLastError()} depending on the platform) and the corresponding error
+code ({\it errno} or {\it ::GetLastError()} depending on the platform) and the corresponding error
 message. The second form of this function takes the error code explitly as the
 first argument.
 \item{\bf wxLogDebug} is {\bf the} right function for debug output. It only
@@ -54,7 +55,6 @@ version of this function takes a trace mask as the first argument which allows
 to further restrict the amount of messages generated.
 \end{itemize}
 
-% VZ: Julian, am I pushing too much here?
 The usage of these functions should be fairly straightforward, however it may
 be asked why not use the other logging facilities, such as C standard stdio
 functions or C++ streams. The short answer is that they're all very good

docs/latex/wx/winhelp.tex

@@ -1,107 +0,0 @@
-\section{\class{wxWinHelpController}}\label{wxwinhelpcontroller}
-
-This class provides the means to control a WinHelp instance.
-Under Windows, wxHelpController is defined to be a synonym for wxWinHelpController.
-
-A help controller allows an application to display help, at the contents
-or at a particular topic, and shut the help program down on termination.
-This avoids proliferation of many instances of the help viewer whenever the
-user requests a different topic via the application's menus or buttons.
-
-Typically, an application will create a help controller instance
-when it starts, and immediately call {\bf Initialize}\rtfsp
-to associate a filename with it. The help viewer will only get run, however,
-just before the first call to display something.
-
-\wxheading{Derivation}
-
-\helpref{wxObject}{wxobject}
-
-\wxheading{See also}
-
-\helpref{wxHelpControllerBase}{wxhelpcontrollerbase}
-
-\wxheading{Include file}
-
-{\tt <wx/help.h>}
-
-\latexignore{\rtfignore{\wxheading{Members}}}
-
-\membersection{wxWinHelpController::wxWinHelpController}
-
-\func{}{wxWinHelpController}{\void}
-
-Constructs a help instance object, but does not invoke the help viewer.
-
-\membersection{wxWinHelpController::\destruct{wxWinHelpController}}
-
-\func{}{\destruct{wxWinHelpController}}{\void}
-
-Destroys the help instance, closing down the viewer if it is running.
-
-\membersection{wxWinHelpController::Initialize}\label{wxwinhelpcontrollerinitialize}
-
-\func{void}{Initialize}{\param{const wxString\& }{file}}
-
-Initializes the help instance with a help filename. 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.
-
-\membersection{wxWinHelpController::DisplayBlock}\label{wxwinhelpcontrollerdisplayblock}
-
-\func{bool}{DisplayBlock}{\param{long}{ blockNo}}
-
-If the help viewer is not running, runs it and displays the file at the given block number.
-The interpretation of {\it blockNo} differs between help viewers. If using Windows Help, this
-refers to the context number.
-
-\membersection{wxWinHelpController::DisplayContents}\label{wxwinhelpcontrollerdisplaycontents}
-
-\func{bool}{DisplayContents}{\void}
-
-If the help viewer is not running, runs it and displays the
-contents.
-
-\membersection{wxWinHelpController::DisplaySection}\label{wxwinhelpcontrollerdisplaysection}
-
-\func{bool}{DisplaySection}{\param{int}{ sectionNo}}
-
-DisplaySection does not apply to WinHelp.
-
-\membersection{wxWinHelpController::KeywordSearch}\label{wxwinhelpcontrollerkeywordsearch}
-
-\func{bool}{KeywordSearch}{\param{const wxString\& }{keyWord}}
-
-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. If more than one
-match is found, the first topic is displayed (Windows Help).
-
-\membersection{wxWinHelpController::LoadFile}\label{wxwinhelpcontrollerloadfile}
-
-\func{bool}{LoadFile}{\param{const wxString\& }{file = NULL}}
-
-If the help viewer is not running, runs it and loads the given file.
-If the filename is not supplied or is
-NULL, the file specified in {\bf 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.
-
-\membersection{wxWinHelpController::OnQuit}\label{wxwinhelpcontrolleronquit}
-
-\func{bool}{OnQuit}{\void}
-
-Overridable member called when this application's viewer is quit by the user.
-
-Not implemented.
-
-\membersection{wxWinHelpController::Quit}\label{wxwinhelpcontrollerquit}
-
-\func{bool}{Quit}{\void}
-
-If the viewer is running, quits it by disconnecting.
-
-For Windows Help, the viewer will only close if no other application is using it.
-