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

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

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@1010 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Julian Smart 1998-11-17 22:44:47 +00:00
parent ee5e802571
commit 6fb26ea3b3
15 changed files with 957 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
docs/latex/wx/calclevt.tex Normal file
View File

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

26
docs/latex/wx/category.tex
View File

@ -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{wxTrace}{wxtrace}}{Tracing facility}
\twocolitem{\helpref{wxTraceLevel}{wxtracelevel}}{Tracing facility with levels}
\twocolitem{\helpref{Log functions}{logfunctions}}{Error and warning logging functions}
%\twocolitem{\helpref{wxTrace}{wxtrace}}{Tracing facility}
%\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{WXTRACELEVEL}{tracelevel}}{Trace macro with levels}
%\twocolitem{\helpref{WXTRACE}{trace}}{Trace macro}
%\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}

7
docs/latex/wx/classes.tex
View File

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

16
docs/latex/wx/debugcxt.tex
View File

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

155
docs/latex/wx/function.tex
View File

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

54
docs/latex/wx/helpinst.tex
View File

@ -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>} (to include the platform-specific controller, e.g. wxWinHelpController)
{\tt <wx/help.h>}
\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}

133
docs/latex/wx/layalgor.tex Normal file
View File

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

2
docs/latex/wx/log.tex
View File

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

118
docs/latex/wx/qylayevt.tex Normal file
View File

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

86
docs/latex/wx/sashevt.tex Normal file
View File

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

128
docs/latex/wx/sashlayw.tex Normal file
View File

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

203
docs/latex/wx/sashwin.tex Normal file
View File

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

4
docs/latex/wx/tguide.tex
View File

@ -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
wxHelp. To add sparkle, you might use the wxToolBar class (documented separately)
need wxHelp and the \helpref{wxHelpController}{wxhelpcontroller} class to control
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

14
docs/latex/wx/tlog.tex
View File

@ -1,9 +1,10 @@
\section{Log classes overview}\label{wxlogoverview}
Classes: \helpref{wxLog}{wxlog}, \helpref{wxLogStderr}{wxlogstderr},
\helpref{wxLogOstream}{wxlogostream}, \helpref{wxLogTextCtrl}{wxlogtextctrl},
\helpref{wxLogWindow}{wxlogwindow}, \helpref{wxLogGui}{wxloggui},
\helpref{wxLogNull}{wxlognull}
Classes: \helpref{wxLog}{wxlog}
%\helpref{wxLogStderr}{wxlogstderr},%
%\helpref{wxLogOstream}{wxlogostream}, \helpref{wxLogTextCtrl}{wxlogtextctrl},%
%\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
{\it ::GetLastError()} depending on the platform) and the corresponding error
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.
\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

107
docs/latex/wx/winhelp.tex
View File

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