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

This commit was manufactured by cvs2svn to create tag 'WX_2_2_9'.

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/tags/WX_2_2_9@13364 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Bryan Petty
2002-01-04 16:15:08 +00:00
parent dc3d889d0b
commit f7f6abe24d
2324 changed files with 375095 additions and 121526 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -38,8 +38,9 @@ a reference to your application object) to be visible to other files.
Constructor. Called implicitly with a definition of a wxApp object.
The argument is a language identifier; this is an experimental
feature and will be expanded and documented in future versions.
% VZ: there is no such feature so far...
% The argument is a language identifier; this is an experimental
% feature and will be expanded and documented in future versions.
\membersection{wxApp::\destruct{wxApp}}
@@ -457,7 +458,7 @@ deleted. If FALSE, the application will continue to run.}
Sets the `top' window. You can call this from within \helpref{wxApp::OnInit}{wxapponinit} to
let wxWindows know which is the main window. You don't have to set the top window;
it's only a convenience so that (for example) certain dialogs without parents can use a
it is only a convenience so that (for example) certain dialogs without parents can use a
specific window as the top window. If no top window is specified by the application,
wxWindows just uses the first frame or dialog in its top-level window list, when it
needs to use the top window.

17
docs/latex/wx/array.tex
View File

@@ -51,7 +51,7 @@ wxArrayDouble class is scheduled for the next release of wxWindows).
wxSortedArray is a wxArray variant which should be used when searching in the
array is a frequently used operation. It requires you to define an additional
function for comparing two elements of the array element type and always stores
its items in the sorted order (according to this function). Thus, it's
its items in the sorted order (according to this function). Thus, it is
\helpref{Index()}{wxarrayindex} function execution time is $O(log(N))$ instead of
$O(N)$ for the usual arrays but the \helpref{Add()}{wxarrayadd} method is
slower: it is $O(log(N))$ instead of constant time (neglecting time spent in
@@ -75,7 +75,7 @@ example:
\begin{verbatim}
#include <wx/dynarray.h>
// we must forward declare the array because it's used inside the class
// we must forward declare the array because it is used inside the class
// declaration
class MyDirectory;
class MyFile;
@@ -249,7 +249,6 @@ This macro defines a new sorted array class named {\it name} and containing
the elements of type {\it T}. The second form is used when compiling DLL
under Windows and array needs to be visible outside the DLL.
Example:
\begin{verbatim}
@@ -259,7 +258,7 @@ class MyClass;
WX_DEFINE_SORTED_ARRAY(MyClass *, wxArrayOfMyClass);
\end{verbatim}
You will have to initialize the objects of this class by passing a comparaison
You will have to initialize the objects of this class by passing a comparison
function to the array object constructor like this:
\begin{verbatim}
@@ -356,7 +355,7 @@ Default constructor initializes an empty array object.
\func{}{wxSortedArray}{\param{int (*)(T first, T second)}{compareFunction}}
There is no default constructor for wxSortedArray classes - you must initialize it
with a function to use for item comparaison. It is a function which is passed
with a function to use for item comparison. It is a function which is passed
two arguments of type {\it T} where {\it T} is the array element type and which
should return a negative, zero or positive value according to whether the first
element passed to it is less than, equal to or greater than the second one.
@@ -530,14 +529,14 @@ the array classes.
\func{\void}{Remove}{\param{T }{item}}
Removes the element from the array either by value: the first item of the
Removes an element from the array by value: the first item of the
array equal to {\it item} is removed, an assert failure will result from an
attempt to remove an item which doesn't exist in the array.
When an element is removed from wxObjArray it is deleted by the array - use
\helpref{Detach()}{wxobjarraydetach} if you don't want this to happen. On the
other hand, when an object is removed from a wxArray nothing happens - you
should delete the it manually if required:
should delete it manually if required:
\begin{verbatim}
T *item = array[n];
@@ -552,11 +551,11 @@ elements of a wxArray (supposed to contain pointers).
\func{\void}{RemoveAt}{\param{size\_t }{index}}
Removes the element from the array either by index. When an element
Removes an element from the array by index. When an element
is removed from wxObjArray it is deleted by the array - use
\helpref{Detach()}{wxobjarraydetach} if you don't want this to happen. On the
other hand, when an object is removed from a wxArray nothing happens - you
should delete the it manually if required:
should delete it manually if required:
\begin{verbatim}
T *item = array[n];

30
docs/latex/wx/arrstrng.tex
View File

@@ -80,6 +80,20 @@ reasons it is not virtual, so this class should not be derived from.
Assignment operator.
\membersection{wxArrayString::operator==}\label{wxarraystringoperatorequal}
\constfunc{bool}{operator $==$}{\param{const wxArrayString\&}{ array}}
Compares 2 arrays respecting the case. Returns TRUE only if the arrays have
the same number of elements and the same strings in the same order.
\membersection{wxArrayString::operator!=}\label{wxarraystringoperatornotequal}
\constfunc{bool}{operator $!=$}{\param{const wxArrayString\&}{ array}}
Compares 2 arrays respecting the case. Returns TRUE if the arrays have
different number of elements or if the elements don't match pairwise.
\membersection{wxArrayString::operator[]}\label{wxarraystringoperatorindex}
\func{wxString\&}{operator[]}{\param{size\_t }{nIndex}}
@@ -205,23 +219,19 @@ Returns the last element of the array. Attempt to access the last element of
an empty array will result in assert failure in debug build, however no checks
are done in release mode.
\membersection{wxArrayString::Remove (by value)}\label{wxarraystringremoveval}
\membersection{wxArrayString::Remove}\label{wxarraystringremove}
\func{void}{Remove}{\param{const char *}{ sz}}
Removes the first item matching this value. An assert failure is provoked by
an attempt to remove an element which does not exist in debug build.
See also: \helpref{Index}{wxarraystringindex}, \helpref{Remove}{wxarraystringremove}
\membersection{wxArrayString::Remove (by index)}\label{wxarraystringremove}
See also: \helpref{Index}{wxarraystringindex}
\func{void}{Remove}{\param{size\_t }{nIndex}}
Removes the item at given position.
See also: \helpref{Remove}{wxarraystringremoveval}
\membersection{wxArrayString::Shrink}\label{wxarraystringshrink}
\func{void}{Shrink}{\void}
@@ -231,7 +241,7 @@ minimize the array memory consumption.
See also: \helpref{Alloc}{wxarraystringalloc}, \helpref{Dynamic array memory management}{wxarraymemorymanagement}
\membersection{wxArrayString::Sort (alphabetically)}\label{wxarraystringsort}
\membersection{wxArrayString::Sort}\label{wxarraystringsort}
\func{void}{Sort}{\param{bool}{ reverseOrder = FALSE}}
@@ -242,10 +252,6 @@ Sorts the array in alphabetical order or in reverse alphabetical order if
could break the order of items and, for example, subsequent calls to
\helpref{Index()}{wxarraystringindex} would then not work!
See also: \helpref{Sort}{wxarraystringsortcallback}
\membersection{wxArrayString::Sort (user defined)}\label{wxarraystringsortcallback}
\func{void}{Sort}{\param{CompareFunction }{compareFunction}}
Sorts the array using the specified {\it compareFunction} for item comparison.
@@ -280,5 +286,3 @@ array.Sort(CompareStringLen);
could break the order of items and, for example, subsequent calls to
\helpref{Index()}{wxarraystringindex} would then not work!
See also: \helpref{Sort}{wxarraystringsort}

BIN
docs/latex/wx/back.gif
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 225 B

After

Width:  |  Height:  |  Size: 978 B

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

@@ -20,7 +20,7 @@ almost any other window.
A bitmap button can be supplied with a single bitmap, and wxWindows will draw
all button states using this bitmap. If the application needs more control, additional bitmaps for
the selected state, unpressed focussed state, and greyed-out state may be supplied.
the selected state, unpressed focused state, and greyed-out state may be supplied.
\wxheading{Window styles}
@@ -29,7 +29,11 @@ the selected state, unpressed focussed state, and greyed-out state may be suppli
\twocolitem{\windowstyle{wxBU\_AUTODRAW}}{If
this is specified, the button will be drawn automatically using the label bitmap only, providing
a 3D-look border. If this style is not specified, the button will be drawn without borders and using all
provided bitmaps.}
provided bitmaps. WIN32 only.}
\twocolitem{\windowstyle{wxBU\_LEFT}}{Left-justifies the bitmap label. WIN32 only.}
\twocolitem{\windowstyle{wxBU\_TOP}}{Aligns the bitmap label to the top of the button. WIN32 only.}
\twocolitem{\windowstyle{wxBU\_RIGHT}}{Right-justifies the bitmap label. WIN32 only.}
\twocolitem{\windowstyle{wxBU\_BOTTOM}}{Aligns the bitmap label to the bottom of the button. WIN32 only.}
\end{twocollist}
See also \helpref{window styles overview}{windowstyles}.
@@ -115,7 +119,7 @@ Button creation function for two-step creation. For more details, see \helpref{w
\membersection{wxBitmapButton::GetBitmapDisabled}\label{wxbitmapbuttongetbitmapdisabled}
\constfunc{wxBitmap\&}{GetBitmapLabel}{\void}
\constfunc{wxBitmap\&}{GetBitmapDisabled}{\void}
Returns the bitmap for the disabled state.
@@ -131,11 +135,11 @@ A reference to the disabled state bitmap.
\constfunc{wxBitmap\&}{GetBitmapFocus}{\void}
Returns the bitmap for the focussed state.
Returns the bitmap for the focused state.
\wxheading{Return value}
A reference to the focussed state bitmap.
A reference to the focused state bitmap.
\wxheading{See also}

12
docs/latex/wx/bitmap.tex
View File

@@ -55,7 +55,7 @@ portable programs: in this case the {\it bits} parameter should contain an XBM
image.
For other bit depths, the behaviour is platform dependent: under Windows, the
data is passed withotu any changes to the underlying {\tt CreateBitmap()} API.
data is passed without any changes to the underlying {\tt CreateBitmap()} API.
Under other platforms, only monochrome bitmaps may be created using this
constructor and \helpref{wxImage}{wximage} should be used for creating colour
bitmaps from static data.
@@ -505,20 +505,14 @@ Sets the validity member (does not affect the bitmap data).
\membersection{wxBitmap::SetPalette}\label{wxbitmapsetpalette}
\func{void}{SetPalette}{\param{wxPalette* }{palette}}
\func{void}{SetPalette}{\param{const wxPalette\& }{palette}}
Sets the associated palette: it will be deleted in the wxBitmap
destructor, so if you do not wish it to be deleted automatically,
reset the palette to NULL before the bitmap is deleted.
Sets the associated palette.
\wxheading{Parameters}
\docparam{palette}{The palette to set.}
\wxheading{Remarks}
The bitmap object owns the palette once this has been called.
\wxheading{See also}
\helpref{wxPalette}{wxpalette}

36
docs/latex/wx/body.tex
View File

@@ -86,7 +86,7 @@ in Windows Help, HTML and Word RTF formats.
\item Simple-to-use, object-oriented API.
\item Flexible event system.
\item Graphics calls include lines, rounded rectangles, splines, polylines, etc.
\item Constraint-based and sizer-based layouting.
\item Constraint-based and sizer-based layouts.
\item Print/preview and document/view architectures.
\item Toolbar, notebook, tree control, advanced list control classes.
\item PostScript generation under Unix, normal MS Windows printing on the PC.
@@ -99,7 +99,7 @@ them to the clipboard.
\item Ready-to-use HTML window (supporting a subset of HTML).
\item Dialog Editor for building dialogs.
\item Network support via a family of socket and protocol classes.
\item Support for platform independent image procesing.
\item Support for platform independent image processing.
\item Built-in support for many file formats (BMP, PNG, JPEG, GIF, XPM, PNM, PCX).
\end{itemize}
@@ -123,7 +123,7 @@ Additions and changes:
\begin{itemize}\itemsep=0pt
\item class hierarchy changed, and restrictions about subwindow nesting lifted;
\item header files reorganised to conform to normal C++ standards;
\item header files reorganized to conform to normal C++ standards;
\item classes less dependent on each another, to reduce executable size;
\item wxString used instead of char* wherever possible;
\item the number of separate but mandatory utilities reduced;
@@ -190,7 +190,7 @@ Additions and changes:
\item Many optical improvements to GTK port.
\item Support for menu accelerators in GTK port.
\item Enhanced and improved support for scrolling, including child windows.
\item Complete rewrite of clipboard and drag'n'drop classes.
\item Complete rewrite of clipboard and drag and drop classes.
\item Improved support for ODBC databases.
\item Improved tab traversal in dialogs.
\end{itemize}
@@ -234,7 +234,7 @@ Julian Smart\\
Uppingham\\
Rutland\\
LE15 9SG\\
julian.smart@ukonline.co.uk
julian.smart@btopenworld.com
\section{Acknowledgments}
@@ -449,7 +449,7 @@ fine on some platforms, and then fail under Windows.
\section{Architecture dependency}
A problem which sometimes arises from writing multi-platform programs is that
the basic C types are not defiend the same on all platforms. This holds true
the basic C types are not defined the same on all platforms. This holds true
for both the length in bits of the standard types (such as int and long) as
well as their byte order, which might be little endian (typically
on Intel computers) or big endian (typically on some Unix workstations). wxWindows
@@ -492,7 +492,7 @@ its own run-time type information system, implemented using macros.
Some compilers (e.g. the native IRIX cc) define NULL to be 0L so that
no conversion to pointers is allowed. Because of that, all these
occurences of NULL in the GTK port use an explicit conversion such
occurrences of NULL in the GTK port use an explicit conversion such
as
{\small
@@ -527,7 +527,7 @@ X and Windows parts of the library) conditional
compilation that under Unix, includes a minimal set of headers;
and when using Visual C++, includes {\tt wx.h}. This should help provide
the optimal compilation for each compiler, although it is
biassed towards the precompiled headers facility available
biased towards the precompiled headers facility available
in Microsoft C++.
\section{File handling}
@@ -577,7 +577,7 @@ more easily accessed via the Contributions page on the Web site.
wxHelp is a stand-alone program, written using wxWindows,
for displaying hypertext help. It is necessary since not all target
systems (notably X) supply an adequate
standard for on-line help. wxHelp is modelled on the MS Windows help
standard for on-line help. wxHelp is modeled on the MS Windows help
system, with contents, search and browse buttons, but does not reformat
text to suit the size of window, as WinHelp does, and its input files
are uncompressed ASCII with some embedded font commands and an .xlp
@@ -690,9 +690,9 @@ it can alert you to problems later on.
\subsection{Use wxString in preference to character arrays}
Using wxString can be much safer and more convenient than using char *.
Again, I haven't practised what I'm preaching, but I'm now trying to use
Again, I haven't practiced what I'm preaching, but I'm now trying to use
wxString wherever possible. You can reduce the possibility of memory
leaks substantially, and it's much more convenient to use the overloaded
leaks substantially, and it is much more convenient to use the overloaded
operators than functions such as strcmp. wxString won't add a significant
overhead to your program; the overhead is compensated for by easier
manipulation (which means less code).
@@ -721,7 +721,7 @@ kinds of bitmap depending on platform (see the section on resource files).
\subsection{Positive thinking}
It's common to blow up the problem in one's imagination, so that it seems to threaten
It is common to blow up the problem in one's imagination, so that it seems to threaten
weeks, months or even years of work. The problem you face may seem insurmountable:
but almost never is. Once you have been programming for some time, you will be able
to remember similar incidents that threw you into the depths of despair. But
@@ -748,8 +748,8 @@ deallocation, this can still give totally spurious results!
\subsection{Use a debugger}
This sounds like facetious advice, but it's surprising how often people
don't use a debugger. Often it's an overhead to install or learn how to
This sounds like facetious advice, but it is surprising how often people
don't use a debugger. Often it is an overhead to install or learn how to
use a debugger, but it really is essential for anything but the most
trivial programs.
@@ -778,13 +778,13 @@ See the \helpref{debugging overview}{debuggingoverview} for further information.
\subsection{Check Windows debug messages}
Under Windows, it's worth running your program with
Under Windows, it is worth running your program with
\urlref{DbgView}{http://www.sysinternals.com} running or
some other program that shows Windows-generated debug messages. It's
possible it'll show invalid handles being used. You may have fun seeing
some other program that shows Windows-generated debug messages. It is
possible it will show invalid handles being used. You may have fun seeing
what commercial programs cause these normally hidden errors! Microsoft
recommend using the debugging version of Windows, which shows up even
more problems. However, I doubt it's worth the hassle for most
more problems. However, I doubt it is worth the hassle for most
applications. wxWindows is designed to minimize the possibility of such
errors, but they can still happen occasionally, slipping through unnoticed
because they are not severe enough to cause a crash.

BIN
docs/latex/wx/books.gif
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 242 B

After

Width:  |  Height:  |  Size: 440 B

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

@@ -1,12 +1,12 @@
\section{\class{wxBoxSizer}}\label{wxboxsizer}
The basic idea behind a box sizer is that windows will most often be laid out in rather
simple basic geomerty, typically in a row or a column or several hierachies of either.
simple basic geometry, typically in a row or a column or several hierarchies of either.
As an exmaple, we will construct a dialog that will contain a text field at the top and
As an example, we will construct a dialog that will contain a text field at the top and
two buttons at the bottom. This can be seen as a top-hierarchy column with the text at
the top and buttons at the bottom and a low-hierchary row with an OK button to the left
and a Cancel button to the right. In many cases (particulary dialogs under Unix and
the top and buttons at the bottom and a low-hierarchy row with an OK button to the left
and a Cancel button to the right. In many cases (particularly dialogs under Unix and
normal frames) the main window will be resizable by the user and this change of size
will have to get propagated to its children. In our case, we want the text area to grow
with the dialog, whereas the button shall have a fixed size. In addition, there will be
@@ -14,7 +14,7 @@ a thin border around all controls to make the dialog look nice and - to make mat
the buttons shall be centred as the width of the dialog changes.
It is the unique feature of a box sizer, that it can grow in both directions (height and
width) but can distribute its growth in the main direction (horizontal for a row) {\it unevenly}
width) but can distribute its growth in the main direction (horizontal for a row) {\it unevenly}
among its children. In our example case, the vertical sizer is supposed to propagate all its
height changes to only the text area, not to the button area. This is determined by the {\it option} parameter
when adding a window (or another sizer) to a sizer. It is interpreted
@@ -24,8 +24,8 @@ relative to the sum of all weight factors of the sizer, so when adding two windo
a value of 1, they will both get resized equally much and each half as much as the sizer
owning them. Then what do we do when a column sizer changes its width? This behaviour is
controlled by {\it flags} (the second parameter of the Add() function): Zero or no flag
indicates that the window will preserve it's original size, wxGROW flag (same as wxEXPAND)
forces the window to grow with the sizer, and wxSHAPED flag tells the window to change it's
indicates that the window will preserve it is original size, wxGROW flag (same as wxEXPAND)
forces the window to grow with the sizer, and wxSHAPED flag tells the window to change it is
size proportionally, preserving original aspect ratio. When wxGROW flag is not used,
the item can be aligned within available space. wxALIGN\_LEFT, wxALIGN\_TOP, wxALIGN\_RIGHT,
wxALIGN\_BOTTOM, wxALIGN\_CENTER\_HORIZONTAL and wxALIGN\_CENTER\_VERTICAL do what they say.
@@ -35,7 +35,7 @@ wxALIGN\_CENTER\_VERTICAL). Default alignment is wxALIGN\_LEFT | wxALIGN\_TOP.
As mentioned above, any window belonging to a sizer may have border, and it can be specified
which of the four sides may have this border, using the wxTOP, wxLEFT, wxRIGHT and wxBOTTOM
constants or wxALL for all directions (and you may also use wxNORTH, wxWEST etc instead). These
flags can be used in combintaion with the alignement flags above as the second paramter of the
flags can be used in combination with the alignment flags above as the second parameter of the
Add() method using the binary or operator |. The sizer of the border also must be made known,
and it is the third parameter in the Add() method. This means, that the entire behaviour of
a sizer and its children can be controlled by the three parameters of the Add() method.

8
docs/latex/wx/button.tex
View File

@@ -18,7 +18,13 @@ almost any other window.
\wxheading{Window styles}
There are no special styles for wxButton.
\twocolwidtha{5cm}%
\begin{twocollist}\itemsep=0pt
\twocolitem{\windowstyle{wxBU\_LEFT}}{Left-justifies the label. WIN32 only.}
\twocolitem{\windowstyle{wxBU\_TOP}}{Aligns the label to the top of the button. WIN32 only.}
\twocolitem{\windowstyle{wxBU\_RIGHT}}{Right-justifies the bitmap label. WIN32 only.}
\twocolitem{\windowstyle{wxBU\_BOTTOM}}{Aligns the label to the bottom of the button. WIN32 only.}
\end{twocollist}
See also \helpref{window styles overview}{windowstyles}.

433
docs/latex/wx/calctrl.tex
View File

@@ -6,18 +6,443 @@
%% Created: 03.01.00
%% RCS-ID: $Id$
%% Copyright: (c) Vadim Zeitlin
%% Licence: wxWindows licence
%% License: wxWindows license
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{\class{wxCalendarCtrl}}\label{wxcalendarctrl}
The calendar control allows the user to pick a date interactively.
The calendar control allows the user to pick a date interactively. For this,
it displays a window containing several parts: the control to pick the month
and the year at the top (either or both of them may be disabled) and a month
area below them which shows all the days in the month. The user can move the
current selection using the keyboard and select the date (generating
{\tt EVT\_CALENDAR} event) by pressing {\tt <Return>} or double clicking it.
It has advanced possibilities for the customization of its display. All global
settings (such as colours and fonts used) can, of course, be changed. But
also, the display style for each day in the month can be set independently
using \helpref{wxCalendarDateAttr}{wxcalendardateattr} class.
An item without custom attributes is drawn with the default colours and
font and without border, but setting custom attributes with
\helpref{SetAttr}{wxcalendarctrlsetattr} allows to modify its appearance. Just
create a custom attribute object and set it for the day you want to be
displayed specially (note that the control will take ownership of the pointer,
i.e. it will delete it itself). A day may be marked as being a holiday, even
if it is not reckognized as oen by \helpref{wxDateTime}{tdateholidays} using
\helpref{SetHoliday}{wxcalendardateattrsetholiday} method.
As the attributes are specified for each day, they may change when the month
is changed, so you will often want to update them in
{\tt EVT\_CALENDAR\_MONTH} event handler.
\wxheading{Derived from}
\helpref{wxControl}{wxcontrol}\\
\helpref{wxWindow}{wxwindow}\\
\helpref{wxEvtHandler}{wxevthandler}\\
\helpref{wxObject}{wxobject}
\wxheading{Include files}
<wx/calctrl.h>
\wxheading{See also:}
\wxheading{Window styles}
\helpref{Calendar sample}{samplecalendar}
\twocolwidtha{5cm}
\begin{twocollist}\itemsep=4pt
\twocolitem{\windowstyle{wxCAL\_SUNDAY\_FIRST}}{Show Sunday as the first day in the week}
\twocolitem{\windowstyle{wxCAL\_MONDAY\_FIRST}}{Show Monday as the first day in the week}
\twocolitem{\windowstyle{wxCAL\_SHOW\_HOLIDAYS}}{Highlight holidays in the calendar}
\twocolitem{\windowstyle{wxCAL\_NO\_YEAR\_CHANGE}}{Disable the year changing}
\twocolitem{\windowstyle{wxCAL\_NO\_MONTH\_CHANGE}}{Disable the month (and, implicitly, the year) changing}
\end{twocollist}
The default calendar style is {\tt wxCAL\_SHOW\_HOLIDAYS}.
\wxheading{Event table macros}
To process input from a calendar control, use these event handler macros to
direct input to member functions that take a
\helpref{wxCalendarEvent}{wxcalendarevent} argument.
\twocolwidtha{7cm}
\begin{twocollist}\itemsep=7pt
\twocolitem{{\bf EVT\_CALENDAR(id, func)}}{A day was double clickedi n the calendar.}
\twocolitem{{\bf EVT\_CALENDAR\_SEL\_CHANGED(id, func)}}{The selected date changed.}
\twocolitem{{\bf EVT\_CALENDAR\_DAY(id, func)}}{The selected day changed.}
\twocolitem{{\bf EVT\_CALENDAR\_MONTH(id, func)}}{The selected month changed.}
\twocolitem{{\bf EVT\_CALENDAR\_YEAR(id, func)}}{The selected year changed.}
\twocolitem{{\bf EVT\_CALENDAR\_WEEKDAY\_CLICKED(id, func)}}{User clicked on the week day header}
\end{twocollist}%
Note that changing the selected date will result in either of
{\tt EVT\_CALENDAR\_DAY}, {\tt MONTH} or {\tt YEAR} events and
{\tt EVT\_CALENDAR\_SEL\_CHANGED} one.
\wxheading{Constants}
The following are the possible return values for
\helpref{HitTest}{wxcalendarctrlhittest} method:
{\small \begin{verbatim}
enum wxCalendarHitTestResult
\{
wxCAL_HITTEST_NOWHERE, // outside of anything
wxCAL_HITTEST_HEADER, // on the header (weekdays)
wxCAL_HITTEST_DAY // on a day in the calendar
\};
\end{verbatim}}
\wxheading{See also}
\helpref{Calendar sample}{samplecalendar}\\
\helpref{wxCalendarDateAttr}{wxcalendardateattr}\\
\helpref{wxCalendarEvent}{wxcalendarevent}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxCalendarCtrl::wxCalendarCtrl}\label{wxcalendarctrlwxcalendarctrldef}
\func{}{wxCalendarCtrl}{\void}
Default constructor, use \helpref{Create}{wxcalendarctrlcreate} after it.
\membersection{wxCalendarCtrl::wxCalendarCtrl}\label{wxcalendarctrlwxcalendarctrl}
\func{}{wxCalendarCtrl}{\param{wxWindow* }{parent}, \param{wxWindowID }{id}, \param{const wxDateTime\& }{date = wxDefaultDateTime}, \param{const wxPoint\& }{pos = wxDefaultPosition}, \param{const wxSize\& }{size = wxDefaultSize}, \param{long }{style = wxCAL\_SHOW\_HOLIDAYS}, \param{const wxString\& }{name = wxCalendarNameStr}}
Does the same as \helpref{Create}{wxcalendarctrlcreate} method.
\membersection{wxCalendarCtrl::Create}\label{wxcalendarctrlcreate}
\func{bool}{Create}{\param{wxWindow* }{parent}, \param{wxWindowID }{id}, \param{const wxDateTime\& }{date = wxDefaultDateTime}, \param{const wxPoint\& }{pos = wxDefaultPosition}, \param{const wxSize\& }{size = wxDefaultSize}, \param{long }{style = wxCAL\_SHOW\_HOLIDAYS}, \param{const wxString\& }{name = wxCalendarNameStr}}
Creates the control. See \helpref{wxWindow}{wxwindowctor} for the meaning of
the parameters and the control overview for the possible styles.
\membersection{wxCalendarCtrl::\destruct{wxCalendarCtrl}}\label{wxcalendarctrldtor}
\func{}{\destruct{wxCalendarCtrl}}{\void}
Destroys the control.
\membersection{wxCalendarCtrl::SetDate}\label{wxcalendarctrlsetdate}
\func{void}{SetDate}{\param{const wxDateTime\& }{date}}
Sets the current date.
\membersection{wxCalendarCtrl::GetDate}\label{wxcalendarctrlgetdate}
\constfunc{const wxDateTime\&}{GetDate}{\void}
Gets the currently selected date.
\membersection{wxCalendarCtrl::EnableYearChange}\label{wxcalendarctrlenableyearchange}
\func{void}{EnableYearChange}{\param{bool }{enable = TRUE}}
This function should be used instead of changing {\tt wxCAL\_NO\_YEAR\_CHANGE}
style bit directly. It allows or disallows the user to chaneg the year
interactively.
\membersection{wxCalendarCtrl::EnableMonthChange}\label{wxcalendarctrlenablemonthchange}
\func{void}{EnableMonthChange}{\param{bool }{enable = TRUE}}
This function should be used instead of changing
{\tt wxCAL\_NO\_MONTH\_CHANGE} style bit. It allows or disallows the user to
change the month interactively. Note that if the month can not be changed, the
year can not be changed neither.
\membersection{wxCalendarCtrl::EnableHolidayDisplay}\label{wxcalendarctrlenableholidaydisplay}
\func{void}{EnableHolidayDisplay}{\param{bool }{display = TRUE}}
This function should be used instead of changing {\tt wxCAL\_SHOW\_HOLIDAYS}
style bit directly. It enables or disables the special highlighting of the
holidays.
\membersection{wxCalendarCtrl::SetHeaderColours}\label{wxcalendarctrlsetheadercolours}
\func{void}{SetHeaderColours}{\param{const wxColour\& }{colFg}, \param{const wxColour\& }{colBg}}
Set the colours used for painting the weekdays at the top of the control.
\membersection{wxCalendarCtrl::GetHeaderColourFg}\label{wxcalendarctrlgetheadercolourfg}
\constfunc{const wxColour\&}{GetHeaderColourFg}{\void}
Gets the foreground colour of the header part of the calendar window.
\wxheading{See also}
\helpref{SetHeaderColours}{wxcalendarctrlsetheadercolours}
\membersection{wxCalendarCtrl::GetHeaderColourBg}\label{wxcalendarctrlgetheadercolourbg}
\constfunc{const wxColour\&}{GetHeaderColourBg}{\void}
Gets the background colour of the header part of the calendar window.
\wxheading{See also}
\helpref{SetHeaderColours}{wxcalendarctrlsetheadercolours}
\membersection{wxCalendarCtrl::SetHighlightColours}\label{wxcalendarctrlsethighlightcolours}
\func{void}{SetHighlightColours}{\param{const wxColour\& }{colFg}, \param{const wxColour\& }{colBg}}
Set the colours to be used for highlighting the currently selected date.
\membersection{wxCalendarCtrl::GetHighlightColourFg}\label{wxcalendarctrlgethighlightcolourfg}
\constfunc{const wxColour\&}{GetHighlightColourFg}{\void}
Gets the foreground highlight colour.
\wxheading{See also}
\helpref{SetHighlightColours}{wxcalendarctrlsethighlightcolours}
\membersection{wxCalendarCtrl::GetHighlightColourBg}\label{wxcalendarctrlgethighlightcolourbg}
\constfunc{const wxColour\&}{GetHighlightColourBg}{\void}
Gets the background highlight colour.
\wxheading{See also}
\helpref{SetHighlightColours}{wxcalendarctrlsethighlightcolours}
\membersection{wxCalendarCtrl::SetHolidayColours}\label{wxcalendarctrlsetholidaycolours}
\func{void}{SetHolidayColours}{\param{const wxColour\& }{colFg}, \param{const wxColour\& }{colBg}}
Sets the colours to be used for the holidays highlighting (only used if the
window style includes {\tt wxCAL\_SHOW\_HOLIDAYS} flag).
\membersection{wxCalendarCtrl::GetHolidayColourFg}\label{wxcalendarctrlgetholidaycolourfg}
\constfunc{const wxColour\&}{GetHolidayColourFg}{\void}
Return the foregound colour currently used for holiday highlighting.
\wxheading{See also}
\helpref{SetHolidayColours}{wxcalendarctrlsetholidaycolours}
\membersection{wxCalendarCtrl::GetHolidayColourBg}\label{wxcalendarctrlgetholidaycolourbg}
\constfunc{const wxColour\&}{GetHolidayColourBg}{\void}
Return the background colour currently used for holiday highlighting.
\wxheading{See also}
\helpref{SetHolidayColours}{wxcalendarctrlsetholidaycolours}
\membersection{wxCalendarCtrl::GetAttr}\label{wxcalendarctrlgetattr}
\constfunc{wxCalendarDateAttr *}{GetAttr}{\param{size\_t }{day}}
Returns the attribute for the given date (should be in the range $1\ldots31$).
The returned pointer may be {\tt NULL}.
\membersection{wxCalendarCtrl::SetAttr}\label{wxcalendarctrlsetattr}
\func{void}{SetAttr}{\param{size\_t }{day}, \param{wxCalendarDateAttr* }{attr}}
Associates the attribute with the specified date (in the range $1\ldots31$).
If the pointer is {\tt NULL}, the items attribute is cleared.
\membersection{wxCalendarCtrl::SetHoliday}\label{wxcalendarctrlsetholiday}
\func{void}{SetHoliday}{\param{size\_t }{day}}
Marks the specified day as being a holiday in the current month.
\membersection{wxCalendarCtrl::ResetAttr}\label{wxcalendarctrlresetattr}
\func{void}{ResetAttr}{\param{size\_t }{day}}
Clears any attributes associated with the given day (in the range
$1\ldots31$).
\membersection{wxCalendarCtrl::HitTest}\label{wxcalendarctrlhittest}
\func{wxCalendarHitTestResult}{HitTest}{\param{const wxPoint\& }{pos}, \param{wxDateTime* }{date = NULL}, \param{wxDateTime::WeekDay* }{wd = NULL}}
Returns one of {\tt wxCAL\_HITTEST\_XXX}
\helpref{constants}{wxcalendarctrl} and fills either {\it date} or
{\it wd} pointer with the corresponding value depending on the hit test code.
\section{\class{wxCalendarDateAttr}}\label{wxcalendardateattr}
wxCalendarDateAttr is a custom attributes for a calendar date. The objects of
this class are used with \helpref{wxCalendarCtrl}{wxcalendarctrl}.
\wxheading{Derived from}
No base class
\wxheading{Constants}
Here are the possible kinds of borders which may be used to decorate a date:
{\small \begin{verbatim}
enum wxCalendarDateBorder
{
wxCAL\_BORDER\_NONE, // no border (default)
wxCAL\_BORDER\_SQUARE, // a rectangular border
wxCAL\_BORDER\_ROUND // a round border
}
\end{verbatim}}
\wxheading{See also}
\helpref{wxCalendarCtrl}{wxcalendarctrl}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxCalendarDateAttr::wxCalendarDateAttr}\label{wxcalendardateattrwxcalendardateattr}
\func{}{wxCalendarDateAttr}{\void}
\func{}{wxCalendarDateAttr}{\param{const wxColour\& }{colText}, \param{const wxColour\& }{colBack = wxNullColour}, \param{const wxColour\& }{colBorder = wxNullColour}, \param{const wxFont\& }{font = wxNullFont}, \param{wxCalendarDateBorder }{border = wxCAL\_BORDER\_NONE}}
\func{}{wxCalendarDateAttr}{\param{wxCalendarDateBorder }{border}, \param{const wxColour\& }{colBorder = wxNullColour}}
The constructors.
\membersection{wxCalendarDateAttr::SetTextColour}\label{wxcalendardateattrsettextcolour}
\func{void}{SetTextColour}{\param{const wxColour\& }{colText}}
Sets the text (foreground) colour to use.
\membersection{wxCalendarDateAttr::SetBackgroundColour}\label{wxcalendardateattrsetbackgroundcolour}
\func{void}{SetBackgroundColour}{\param{const wxColour\& }{colBack}}
Sets the text background colour to use.
\membersection{wxCalendarDateAttr::SetBorderColour}\label{wxcalendardateattrsetbordercolour}
\func{void}{SetBorderColour}{\param{const wxColour\& }{col}}
Sets the border colour to use.
\membersection{wxCalendarDateAttr::SetFont}\label{wxcalendardateattrsetfont}
\func{void}{SetFont}{\param{const wxFont\& }{font}}
Sets the font to use.
\membersection{wxCalendarDateAttr::SetBorder}\label{wxcalendardateattrsetborder}
\func{void}{SetBorder}{\param{wxCalendarDateBorder }{border}}
Sets the \helpref{border kind}{wxcalendardateattr}
\membersection{wxCalendarDateAttr::SetHoliday}\label{wxcalendardateattrsetholiday}
\func{void}{SetHoliday}{\param{bool }{holiday}}
Display the date with this attribute as a holiday.
\membersection{wxCalendarDateAttr::HasTextColour}\label{wxcalendardateattrhastextcolour}
\constfunc{bool}{HasTextColour}{\void}
Returns {\tt TRUE} if this item has a non default text foreground colour.
\membersection{wxCalendarDateAttr::HasBackgroundColour}\label{wxcalendardateattrhasbackgroundcolour}
\constfunc{bool}{HasBackgroundColour}{\void}
Returns {\tt TRUE} if this attribute specifies a non default text background colour.
\membersection{wxCalendarDateAttr::HasBorderColour}\label{wxcalendardateattrhasbordercolour}
\constfunc{bool}{HasBorderColour}{\void}
Returns {\tt TRUE} if this attribute specifies a non default border colour.
\membersection{wxCalendarDateAttr::HasFont}\label{wxcalendardateattrhasfont}
\constfunc{bool}{HasFont}{\void}
Returns {\tt TRUE} if this attribute specifies a non default font.
\membersection{wxCalendarDateAttr::HasBorder}\label{wxcalendardateattrhasborder}
\constfunc{bool}{HasBorder}{\void}
Returns {\tt TRUE} if this attribute specifies a non default (i.e. any) border.
\membersection{wxCalendarDateAttr::IsHoliday}\label{wxcalendardateattrisholiday}
\constfunc{bool}{IsHoliday}{\void}
Returns {\tt TRUE} if this attribute specifies that this item should be
displayed as a holiday.
\membersection{wxCalendarDateAttr::GetTextColour}\label{wxcalendardateattrgettextcolour}
\constfunc{const wxColour\&}{GetTextColour}{\void}
Returns the text colour to use for the item with this attribute.
\membersection{wxCalendarDateAttr::GetBackgroundColour}\label{wxcalendardateattrgetbackgroundcolour}
\constfunc{const wxColour\&}{GetBackgroundColour}{\void}
Returns the background colour to use for the item with this attribute.
\membersection{wxCalendarDateAttr::GetBorderColour}\label{wxcalendardateattrgetbordercolour}
\constfunc{const wxColour\&}{GetBorderColour}{\void}
Returns the border colour to use for the item with this attribute.
\membersection{wxCalendarDateAttr::GetFont}\label{wxcalendardateattrgetfont}
\constfunc{const wxFont\&}{GetFont}{\void}
Returns the font to use for the item with this attribute.
\membersection{wxCalendarDateAttr::GetBorder}\label{wxcalendardateattrgetborder}
\constfunc{wxCalendarDateBorder}{GetBorder}{\void}
Returns the \helpref{border}{wxcalendardateattr} to use for the item with this attribute.
\section{\class{wxCalendarEvent}}\label{wxcalendarevent}
The wxCalendarEvent class is used together with
\helpref{wxCalendarCtrl}{wxcalendarctrl}.
\wxheading{See also}
\helpref{wxCalendarCtrl}{wxcalendarctrl}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxCalendarEvent::GetDate}{wxcalendareventgetdate}
\constfunc{const wxDateTime&}{GetDate}{\void}
Returns the date. This function may be called for all event types except
{\tt EVT\_CALENDAR\_WEEKDAY\_CLICKED} one for which it doesn't make sense.
\membersection{wxCalendarEvent::GetWeekDay}{wxcalendareventgetweekday}
\constfunc{wxDateTime::WeekDay}{GetWeekDay}{\void}
Returns the week day on which the user clicked in
{\tt EVT\_CALENDAR\_WEEKDAY\_CLICKED} handler. It doesn't make sense to call
this function in other handlers.

147
docs/latex/wx/caret.tex Normal file
View File

@@ -0,0 +1,147 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Name: caret.tex
%% Purpose: wxCaret documentation
%% Author: Vadim Zeitlin
%% Modified by:
%% Created: 20.06.00
%% RCS-ID: $Id$
%% Copyright: (c) Vadim Zeitlin
%% License: wxWindows license
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{\class{wxCaret}}\label{wxcaret}
A caret is a blinking cursor showing the position where the typed text will
appear. The text controls usually have a caret but wxCaret class also allows
to use a caret in other windows.
Currently, the caret appears as a rectangle of the given size. In the future,
it will be possible to specify a bitmap to be used for the caret shape.
A caret is always associated with a window and the current caret can be
retrieved using \helpref{wxWindow::GetCaret}{wxwindowgetcaret}. The same caret
can't be reused in two different windows.
\wxheading{Derived from}
No base class
\wxheading{Include files}
<wx/caret.h>
\wxheading{Data structures}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxCaret::wxCaret}\label{wxcaretwxcaret}
\func{}{wxCaret}{\void}
Default constructor: you must use one of Create() functions later.
\func{}{wxCaret}{\param{wxWindow* }{window}, \param{int }{width}, \param{int }{height}}
\func{}{wxCaret}{\param{wxWindowBase* }{window}, \param{const wxSize\& }{size}}
Create the caret of given (in pixels) width and height and associates it
with the given window.
\membersection{wxCaret::Create}\label{wxcaretcreate}
\func{bool}{Create}{\param{wxWindowBase* }{window}, \param{int }{width}, \param{int }{height}}
\func{bool}{Create}{\param{wxWindowBase* }{window}, \param{const wxSize\& }{size}}
Create the caret of given (in pixels) width and height and associates it
with the given window (same as constructor).
\membersection{wxCaret::GetBlinkTime}\label{wxcaretgetblinktime}
\func{static int}{GetBlinkTime}{\void}
Returns the blink time which is measured in milliseconds and is the time elapsed
between 2 inversions of the caret (blink time of the caret is the same
for all carets, so this functions is static).
\membersection{wxCaret::GetPosition}\label{wxcaretgetposition}
\constfunc{void}{GetPosition}{\param{int* }{x}, \param{int* }{y}}
\constfunc{wxPoint}{GetPosition}{\void}
Get the caret position (in pixels).
\membersection{wxCaret::GetSize}\label{wxcaretgetsize}
\constfunc{void}{GetSize}{\param{int* }{width}, \param{int* }{height}}
\constfunc{wxSize}{GetSize}{\void}
Get the caret size.
\membersection{wxCaret::GetWindow}\label{wxcaretgetwindow}
\constfunc{wxWindow*}{GetWindow}{\void}
Get the window the caret is associated with.
\membersection{wxCaret::Hide}\label{wxcarethide}
\func{void}{Hide}{\void}
Same as \helpref{wxCaret::Show(FALSE)}{wxcaretshow}.
\membersection{wxCaret::IsOk}\label{wxcaretisok}
\constfunc{bool}{IsOk}{\void}
Returns TRUE if the caret was created successfully.
\membersection{wxCaret::IsVisible}\label{wxcaretisvisible}
\constfunc{bool}{IsVisible}{\void}
Returns TRUE if the caret is visible and FALSE if it is permanently
hidden (if it is is blinking and not shown currently but will be after the
next blink, this method still returns TRUE).
\membersection{wxCaret::Move}\label{wxcaretmove}
\func{void}{Move}{\param{int }{x}, \param{int }{y}}
\func{void}{Move}{\param{const wxPoint\& }{pt}}
Move the caret to given position (in logical coordinates).
\membersection{wxCaret::SetBlinkTime}\label{wxcaretsetblinktime}
\func{static void}{SetBlinkTime}{\param{int }{milliseconds}}
Sets the blink time for all the carets.
\wxheading{Remarks}
Under Windows, this function will change the blink time for {\bf all} carets
permanently (until the next time it is called), even for the carets in other
applications.
\wxheading{See also}
\helpref{GetBlinkTime}{wxcaretgetblinktime}
\membersection{wxCaret::SetSize}\label{wxcaretsetsize}
\func{void}{SetSize}{\param{int }{width}, \param{int }{height}}
\func{void}{SetSize}{\param{const wxSize\& }{size}}
Changes the size of the caret.
\membersection{wxCaret::Show}\label{wxcaretshow}
\func{void}{Show}{\param{bool }{show = TRUE}}
Shows or hides the caret. Notice that if the caret was hidden $N$ times, it
must be shown $N$ times as well to reappear on the screen.

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

@@ -17,6 +17,7 @@ Frames may contain windows, and dialog boxes may directly contain controls.
\twocolitem{\helpref{wxMDIParentFrame}{wxmdiparentframe}}{MDI parent frame}
\twocolitem{\helpref{wxMDIChildFrame}{wxmdichildframe}}{MDI child frame}
\twocolitem{\helpref{wxMiniFrame}{wxminiframe}}{A frame with a small title bar}
\twocolitem{\helpref{wxWizard}{wxwizard}}{A wizard dialog.}
\twocolitem{\helpref{wxTabbedDialog}{wxtabbeddialog}}{Tabbed dialog
(deprecated, use wxNotebook instead)}
\end{twocollist}
@@ -39,6 +40,8 @@ The following are a variety of classes that are derived from wxWindow.
\twocolitem{\helpref{wxPlotWindow}{wxplotwindow}}{A class to display data.}
\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{wxWizardPage}{wxwizardpage}}{A base class for the page in wizard dialog.}
\twocolitem{\helpref{wxWizardPageSimple}{wxwizardpagesimple}}{A page in wizard dialog.}
\end{twocollist}
{\large {\bf Common dialogs}}
@@ -61,6 +64,7 @@ in an application.
\twocolitem{\helpref{wxPrintDialog}{wxprintdialog}}{Standard print dialog}
\twocolitem{\helpref{wxPageSetupDialog}{wxpagesetupdialog}}{Standard page setup dialog}
\twocolitem{\helpref{wxMessageDialog}{wxmessagedialog}}{Simple message box dialog}
\twocolitem{\helpref{wxWizard}{wxwizard}}{A wizard dialog.}
\end{twocollist}
{\large {\bf Controls}}
@@ -72,6 +76,7 @@ that are not static can have \helpref{validators}{wxvalidator} associated with t
\twocolitem{\helpref{wxControl}{wxcontrol}}{The base class for controls}
\twocolitem{\helpref{wxButton}{wxbutton}}{Push button control, displaying text}
\twocolitem{\helpref{wxBitmapButton}{wxbitmapbutton}}{Push button control, displaying a bitmap}
\twocolitem{\helpref{wxCalendarCtrl}{wxcalendarctrl}}{Date picker control}
\twocolitem{\helpref{wxCheckBox}{wxcheckbox}}{Checkbox control}
\twocolitem{\helpref{wxCheckListBox}{wxchecklistbox}}{A listbox with a checkbox to the left of each item}
\twocolitem{\helpref{wxChoice}{wxchoice}}{Choice control (a combobox without the editable area)}
@@ -81,8 +86,8 @@ that are not static can have \helpref{validators}{wxvalidator} associated with t
\twocolitem{\helpref{wxListBox}{wxlistbox}}{A list of strings for single or multiple selection}
\twocolitem{\helpref{wxListCtrl}{wxlistctrl}}{A control for displaying lists of strings and/or icons, plus a multicolumn report view}
\twocolitem{\helpref{wxTabCtrl}{wxtabctrl}}{Manages several tabs}
\twocolitem{\helpref{wxTextCtrl}{wxtextctrl}}{Single or multline text editing control}
\twocolitem{\helpref{wxTreeCtrl}{wxtreectrl}}{Tree (hierachy) control}
\twocolitem{\helpref{wxTextCtrl}{wxtextctrl}}{Single or multiline text editing control}
\twocolitem{\helpref{wxTreeCtrl}{wxtreectrl}}{Tree (hierarchy) control}
\twocolitem{\helpref{wxScrollBar}{wxscrollbar}}{Scrollbar control}
\twocolitem{\helpref{wxSpinButton}{wxspinbutton}}{A spin or `up-down' control}
\twocolitem{\helpref{wxSpinCtrl}{wxspinctrl}}{A spin control - i.e. spin button and text control}
@@ -103,7 +108,7 @@ that are not static can have \helpref{validators}{wxvalidator} associated with t
{\large {\bf Window layout}}
There are two different systems for layouting windows (and dialogs in particluar).
There are two different systems for layouting windows (and dialogs in particular).
One is based upon so-called sizers and it requires less typing, thinking and calculating
and will in almost all cases produce dialogs looking equally well on all platforms, the
other is based on so-called constraints and allows for more detailed layouts.
@@ -112,6 +117,8 @@ These are the classes relevant to the sizer-based layout.
\begin{twocollist}\itemsep=0pt
\twocolitem{\helpref{wxSizer}{wxsizer}}{Abstract base class}
\twocolitem{\helpref{wxGridSizer}{wxgridsizer}}{A sizer for laying out windows in a grid with all fields having the same size}
\twocolitem{\helpref{wxFlexGridSizer}{wxflexgridsizer}}{A sizer for laying out windows in a flexible grid}
\twocolitem{\helpref{wxBoxSizer}{wxboxsizer}}{A sizer for laying out windows in a row or column}
\twocolitem{\helpref{wxStaticBoxSizer}{wxstaticboxsizer}}{Same as wxBoxSizer, but with surrounding static box}
\twocolitem{\helpref{wxNotebookSizer}{wxnotebooksizer}}{Sizer to use with the wxNotebook control.}
@@ -179,9 +186,11 @@ 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{wxCalendarEvent}{wxcalendarevent}}{Used with \helpref{wxCalendarCtrl}{wxcalendarctrl}}
\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{wxDialUpEvent}{wxdialupevent}}{Event send by \helpref{wxDialUpManager}{wxdialupmanager}}
\twocolitem{\helpref{wxDropFilesEvent}{wxdropfilesevent}}{A drop files event}
\twocolitem{\helpref{wxEraseEvent}{wxeraseevent}}{An erase background event}
\twocolitem{\helpref{wxEvent}{wxevent}}{The event base class}
@@ -203,10 +212,12 @@ An event object contains information about a specific event. Event handlers
\twocolitem{\helpref{wxScrollWinEvent}{wxscrollwinevent}}{A scroll event from scrolled windows}
\twocolitem{\helpref{wxSizeEvent}{wxsizeevent}}{A size event}
\twocolitem{\helpref{wxSocketEvent}{wxsocketevent}}{A socket event}
\twocolitem{\helpref{wxSpinEvent}{wxspinevent}}{An event from \helpref{wxSpinButton}{wxspinbutton}}
\twocolitem{\helpref{wxSysColourChangedEvent}{wxsyscolourchangedevent}}{A system colour change event}
\twocolitem{\helpref{wxTabEvent}{wxtabevent}}{A tab control event}
\twocolitem{\helpref{wxTreeEvent}{wxtreeevent}}{A tree control event}
\twocolitem{\helpref{wxUpdateUIEvent}{wxupdateuievent}}{A user interface update event}
\twocolitem{\helpref{wxWizardEvent}{wxwizardevent}}{A wizard event}
\end{twocollist}
{\large {\bf Validators}}
@@ -227,10 +238,12 @@ user input.
These are the data structure classes supported by wxWindows.
\begin{twocollist}\itemsep=0pt
\twocolitem{\helpref{wxCmdLineParser}{wxcmdlineparser}}{Command line parser class}
\twocolitem{\helpref{wxDate}{wxdate}}{A class for date manipulation (deprecated in favour of wxDateTime)}
\twocolitem{\helpref{wxDateSpan}{wxdatespan}}{A logical time interval.}
\twocolitem{\helpref{wxDateTime}{wxdatetime}}{A class for date/time manipulations}
\twocolitem{\helpref{wxExpr}{wxexpr}}{A class for flexible I/O}
\twocolitem{\helpref{wxExprDatabase}{wxexprdatabase}}{A class for flexible I/O}
\twocolitem{\helpref{wxDate}{wxdate}}{A class for date manipulation (deprecated in favour of wxDateTime)}
\twocolitem{\helpref{wxDateTime}{wxdatetime}}{A class for date/time manipulations}
\twocolitem{\helpref{wxHashTable}{wxhashtable}}{A simple hash table implementation}
% \twocolitem{\helpref{wxHashTableLong}{wxhashtablelong}}{A wxHashTable version for storing long data}
\twocolitem{\helpref{wxList}{wxlist}}{A simple linked list implementation}
@@ -247,6 +260,7 @@ These are the data structure classes supported by wxWindows.
\twocolitem{\helpref{wxRealPoint}{wxrealpoint}}{Representation of a point using floating point numbers}
\twocolitem{\helpref{wxSize}{wxsize}}{Representation of a size}
\twocolitem{\helpref{wxTime}{wxtime}}{A class for time manipulation (deprecated in favour of wxDateTime)}
\twocolitem{\helpref{wxTimeSpan}{wxtimespan}}{A time interval.}
\twocolitem{\helpref{wxVariant}{wxvariant}}{A class for storing arbitrary types that may change at run-time}
\end{twocollist}
@@ -288,7 +302,8 @@ classes, functions and macros.
wxWindows provides its own classes for socket based networking.
\begin{twocollist}\itemsep=0pt
\twocolitem{\helpref{wxIPV4address}{wxipv4address}}{Represents an Internet adress}
\twocolitem{\helpref{wxDialUpManager}{wxdialupmanager}}{Provides functions to check the status of network connection and to establish one}
\twocolitem{\helpref{wxIPV4address}{wxipv4address}}{Represents an Internet address}
\twocolitem{\helpref{wxSocketBase}{wxsocketbase}}{Represents a socket base object}
\twocolitem{\helpref{wxSocketClient}{wxsocketclient}}{Represents a socket client}
\twocolitem{\helpref{wxSocketServer}{wxsocketserver}}{Represents a socket server}
@@ -326,7 +341,7 @@ housekeeping for a document-centric application.
\begin{twocollist}\itemsep=0pt
\twocolitem{\helpref{wxDocument}{wxdocument}}{Represents a document}
\twocolitem{\helpref{wxView}{wxview}}{Represents a view}
\twocolitem{\helpref{wxDocTemplate}{wxdoctemplate}}{Manages the relationship between a document class and a veiw class}
\twocolitem{\helpref{wxDocTemplate}{wxdoctemplate}}{Manages the relationship between a document class and a view class}
\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}
@@ -339,7 +354,7 @@ housekeeping for a document-centric application.
\overview{Overview}{printingoverview}
A printing and previewing framework is implemented to
make it relatively straighforward to provide document printing
make it relatively straightforward to provide document printing
facilities.
\begin{twocollist}\itemsep=0pt
@@ -432,7 +447,7 @@ capabilities of the various platforms.
\twocolitem{\helpref{wxMutex}{wxmutex}}{Mutex class}
\twocolitem{\helpref{wxMutexLocker}{wxmutexlocker}}{Mutex locker utility class}
\twocolitem{\helpref{wxCriticalSection}{wxcriticalsection}}{Critical section class}
\twocolitem{\helpref{wxCriticalSectionLocker}{wxcriticalsectionlocker}}{ritical section locker utility class}
\twocolitem{\helpref{wxCriticalSectionLocker}{wxcriticalsectionlocker}}{Critical section locker utility class}
\twocolitem{\helpref{wxCondition}{wxcondition}}{Condition class}
\end{twocollist}
@@ -467,7 +482,10 @@ used internally by the HTML classes.
\begin{twocollist}\itemsep=0pt
\twocolitem{\helpref{wxApp}{wxapp}}{Application class}
\twocolitem{\helpref{wxConfig}{wxconfigbase}}{Classes for configuration reading/writing}
\twocolitem{\helpref{wxCaret}{wxcaret}}{A caret (cursor) object}
\twocolitem{\helpref{wxCmdLineParser}{wxcmdlineparser}}{Command line parser class}
\twocolitem{\helpref{wxConfig}{wxconfigbase}}{Classes for configuration reading/writing (using either INI files or registry)}
\twocolitem{\helpref{wxDllLoader}{wxdllloader}}{Class to work with shared libraries.}
\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}
@@ -479,20 +497,22 @@ used internally by the HTML classes.
\twocolitem{\helpref{wxAutomationObject}{wxautomationobject}}{OLE automation class}
\twocolitem{\helpref{wxFontMapper}{wxfontmapper}}{Font mapping, finding suitable font for given encoding}
\twocolitem{\helpref{wxEncodingConverter}{wxencodingconverter}}{Encoding conversions}
\twocolitem{\helpref{wxCalendarDateAttr}{wxcalendardateattr}}{Used with \helpref{wxCalendarCtrl}{wxcalendarctrl}}
\end{twocollist}
{\large {\bf Database classes}}
\overview{Database classes overview}{odbcoverview}
wxWindows provides two alternative sets of classes for accessing Microsoft's ODBC (Open Database Connectivity)
product. The new version by Remstar is documented in a separate manual.
The older classes are as follows:
wxWindows provides a set of classes for accessing Microsoft's ODBC (Open
Database Connectivity) product, also available for Unix and Linux. The
new version by Remstar is documented here:
\begin{twocollist}\itemsep=0pt
\twocolitem{\helpref{wxDatabase}{wxdatabase}}{Database class}
\twocolitem{\helpref{wxQueryCol}{wxquerycol}}{Class representing a column}
\twocolitem{\helpref{wxQueryField}{wxqueryfield}}{Class representing a field}
\twocolitem{\helpref{wxRecordSet}{wxrecordset}}{Class representing one or more record}
\twocolitem{\helpref{wxDb}{wxdb}}{Database class}
\twocolitem{\helpref{wxDbColFor}{wxdbcolfor}}{International formatting}
\twocolitem{\helpref{wxDbColInf}{wxdbcolinf}}{Information about a columns definition}
\twocolitem{\helpref{wxDbTable}{wxdbtable}}{Access to rows of data in a table}
\twocolitem{\helpref{wxDbTableInf}{wxdbtableinf}}{Information describing the table}
\twocolitem{\helpref{wxDbInf}{wxdbinf}}{Database connection}
\end{twocollist}

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

@@ -31,7 +31,7 @@ class, so there is no need to create such objects explicitly in an application.
\func{wxObject*}{CreateObject}{\void}
Creates an object of the appropriate kind. Returns NULL if the class has not been declared
dynamically createable (typically, it's an abstract class).
dynamically creatable (typically, it is an abstract class).
\membersection{wxClassInfo::FindClass}

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

@@ -21,6 +21,7 @@
\input strmbfrd.tex
\input calclevt.tex
\input calctrl.tex
\input caret.tex
\input checkbox.tex
\input checklst.tex
\input choice.tex
@@ -28,6 +29,7 @@
\input clientdc.tex
\input clipbrd.tex
\input closeevt.tex
\input cmdlpars.tex
\input colour.tex
\input colordlg.tex
\input combobox.tex
@@ -40,6 +42,7 @@
\input countstr.tex
\input critsect.tex
\input crtslock.tex
\input csconv.tex
\input custdobj.tex
\input cursor.tex
\input database.tex
@@ -49,15 +52,20 @@
\input dobjsmpl.tex
\input datstrm.tex
\input date.tex
\input datespan.tex
\input datetime.tex
\input db.tex
\input dc.tex
\input ddeclint.tex
\input ddeconn.tex
\input ddeservr.tex
\input debugcxt.tex
\input dialog.tex
\input dialevt.tex
\input dialup.tex
\input dir.tex
\input dirdlg.tex
\input dllload.tex
\input docchfrm.tex
\input docmanag.tex
\input docmdich.tex
@@ -84,6 +92,7 @@
\input filesys.tex
\input filesysh.tex
\input filetype.tex
\input flexsizr.tex
\input fltinstr.tex
\input fltoutst.tex
\input focusevt.tex
@@ -100,6 +109,7 @@
\input glcanvas.tex
\input valgen.tex
\input grid.tex
\input gridsizr.tex
\input hash.tex
\input helpinst.tex
\input htcell.tex
@@ -146,6 +156,10 @@
\input log.tex
\input longlong.tex
\input mask.tex
\input mbconv.tex
\input mbcnvfil.tex
\input mbcnvut7.tex
\input mbcnvut8.tex
\input mdi.tex
\input memorydc.tex
\input fs_mem.tex
@@ -233,6 +247,7 @@
\input strmsock.tex
\input spinbutt.tex
\input spinctrl.tex
\input spinevt.tex
\input splitevt.tex
\input splitter.tex
\input statbmp.tex
@@ -264,6 +279,7 @@
\input txtstrm.tex
\input textdlg.tex
\input txtdrptg.tex
\input timespan.tex
\input valtext.tex
\input textfile.tex
\input thread.tex
@@ -271,6 +287,7 @@
\input timer.tex
\input tipprov.tex
\input toolbar.tex
\input tooltip.tex
\input treectrl.tex
\input treeevt.tex
\input treelay.tex
@@ -283,6 +300,9 @@
\input window.tex
\input windowdc.tex
\input wnddisbl.tex
\input wizard.tex
\input wizevt.tex
\input wizpage.tex
\input zipstrm.tex
\input strmzlib.tex
\input function.tex

20
docs/latex/wx/cmdevent.tex
View File

@@ -36,7 +36,9 @@ which is generated by a wxListBox control.}
\twocolitem{{\bf EVT\_TEXT(id, func)}}{Process a wxEVT\_COMMAND\_TEXT\_UPDATED command,
which is generated by a wxTextCtrl control.}
\twocolitem{{\bf EVT\_TEXT\_ENTER(id, func)}}{Process a wxEVT\_COMMAND\_TEXT\_ENTER command,
which is generated by a wxTextCtrl control.}
which is generated by a wxTextCtrl control. Note that you must use
wxTE\_PROCESS\_ENTER flag when creating the control if you want it to generate
such events.}
\twocolitem{{\bf EVT\_MENU(id, func)}}{Process a wxEVT\_COMMAND\_MENU\_SELECTED command,
which is generated by a menu item.}
\twocolitem{{\bf EVT\_MENU\_RANGE(id1, id2, func)}}{Process a wxEVT\_COMMAND\_MENU\_RANGE command,
@@ -117,16 +119,16 @@ Constructor.
\membersection{wxCommandEvent::Checked}
\func{bool}{Checked}{\void}
\constfunc{bool}{Checked}{\void}
Returns TRUE or FALSE for a checkbox selection event.
Deprecated, use \helpref{IsChecked}{wxcommandeventischecked} instead.
\membersection{wxCommandEvent::GetClientData}
\func{void*}{GetClientData}{\void}
Returns client data pointer for a listbox or choice selection event
(not valid for a deselection). Beware, this is not implmented anywhere...
(not valid for a deselection).
\membersection{wxCommandEvent::GetExtraLong}
@@ -154,6 +156,16 @@ a deselection).
Returns item string for a listbox or choice selection event (not valid for
a deselection).
\membersection{wxCommandEvent::IsChecked}\label{wxcommandeventischecked}
\constfunc{bool}{IsChecked}{\void}
This method can be used with checkbox and menu events: for the checkboxes, the
method returns {\tt TRUE} for a selection event and {\tt FALSE} for a
deselection one. For the menu events, this method indicates if the menu item
just has become checked or unchecked (and thus only makes sense for checkable
menu items).
\membersection{wxCommandEvent::IsSelection}
\func{bool}{IsSelection}{\void}

451
docs/latex/wx/cmdlpars.tex Normal file
View File

@@ -0,0 +1,451 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Name: cmdlpars.tex
%% Purpose: wxCmdLineParser documentation
%% Author: Vadim Zeitlin
%% Modified by:
%% Created: 27.03.00
%% RCS-ID: $Id$
%% Copyright: (c) Vadim Zeitlin
%% License: wxWindows license
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{\class{wxCmdLineParser}}\label{wxcmdlineparser}
wxCmdLineParser is a class for parsing command line.
It has the following features:
\begin{enumerate}
\item distinguishes options, switches and parameters; allows option grouping
\item allows both short and long options
\item automatically generates the usage message from the command line description
\item does type checks on the options values (number, date, $\ldots$).
\end{enumerate}
To use it you should follow these steps:
\begin{enumerate}
\item \helpref{construct}{wxcmdlineparserconstruction} an object of this class
giving it the command line to parse and optionally its description or use
{\tt AddXXX()} functions later
\item call {\tt Parse()}
\item use {\tt Found()} to retrieve the results
\end{enumerate}
In the documentation below the following terminology is used:
\begin{twocollist}\itemsep=0pt
\twocolitem{switch}{This is a boolean option which can be given or not, but
which doesn't have any value. We use the word switch to distinguish such boolean
options from more generic options like those described below. For example,
{\tt -v} might be a switch meaning "enable verbose mode".}
\twocolitem{option}{Option for us here is something which comes with a value 0
unlike a switch. For example, {\tt -o:filename} might be an option which allows
to specify the name of the output file.}
\twocolitem{parameter}{This is a required program argument.}
\end{twocollist}
\wxheading{Derived from}
No base class
\wxheading{Include files}
<wx/cmdline.h>
\wxheading{Constants}
The structure wxCmdLineEntryDesc is used to describe the one command
line switch, option or parameter. An array of such structures should be passed
to \helpref{SetDesc()}{wxcmdlineparsersetdesc}. Also, the meanings of parameters
of the {\tt AddXXX()} functions are the same as of the corresponding fields in
this structure:
\begin{verbatim}
struct wxCmdLineEntryDesc
{
wxCmdLineEntryType kind;
const wxChar *shortName;
const wxChar *longName;
const wxChar *description;
wxCmdLineParamType type;
int flags;
};
\end{verbatim}
The type of a command line entity is in the {\tt kind} field and may be one of
the following constants:
{\small \begin{verbatim}
enum wxCmdLineEntryType
{
wxCMD\_LINE\_SWITCH,
wxCMD\_LINE\_OPTION,
wxCMD\_LINE\_PARAM,
wxCMD\_LINE\_NONE // use this to terminate the list
}
\end{verbatim}}
The field {\tt shortName} is the usual, short, name of the switch or the option.
{\tt longName} is the corresponding long name or NULL if the option has no long
name. Both of these fields are unused for the parameters. Both the short and
long option names can contain only letters, digits and the underscores.
{\tt description} is used by the \helpref{Usage()}{wxcmdlineparserusage} method
to construct a help message explaining the syntax of the program.
The possible values of {\tt type} which specifies the type of the value accepted
by an option or parameter are:
{\small \begin{verbatim}
enum wxCmdLineParamType
{
wxCMD\_LINE\_VAL\_STRING, // default
wxCMD\_LINE\_VAL\_NUMBER,
wxCMD\_LINE\_VAL\_DATE,
wxCMD\_LINE\_VAL\_NONE
}
\end{verbatim}}
Finally, the {\tt flags} field is a combination of the following bit masks:
{\small \begin{verbatim}
enum
{
wxCMD\_LINE\_OPTION\_MANDATORY = 0x01, // this option must be given
wxCMD\_LINE\_PARAM\_OPTIONAL = 0x02, // the parameter may be omitted
wxCMD\_LINE\_PARAM\_MULTIPLE = 0x04, // the parameter may be repeated
wxCMD\_LINE\_OPTION\_HELP = 0x08, // this option is a help request
wxCMD\_LINE\_NEEDS\_SEPARATOR = 0x10, // must have sep before the value
}
\end{verbatim}}
Notice that by default (i.e. if flags are just $0$), options are optional (sic)
and each call to \helpref{AddParam()}{wxcmdlineparseraddparam} allows one more
parameter - this may be changed by giving non-default flags to it, i.e. use
{\tt wxCMD\_LINE\_OPTION\_MANDATORY} to require that the option is given and
{\tt wxCMD\_LINE\_PARAM\_OPTIONAL} to make a parameter optional. Also,
{\tt wxCMD\_LINE\_PARAM\_MULTIPLE} may be specified if the programs accepts a
variable number of parameters - but it only can be given for the last parameter
in the command line description. If you use this flag, you will probably need to
use \helpref{GetParamCount}{wxcmdlineparsergetparamcount} to retrieve the number
of parameters effectively specified after calling
\helpref{Parse}{wxcmdlineparserparse}.
The last flag {\tt wxCMD\_LINE\_NEEDS\_SEPARATOR} can be specified to require a
separator (either a colon, an equal sign or white space) between the option
name and its value. By default, no separator is required.
\wxheading{See also}
\helpref{wxApp::argc}{wxappargc} and \helpref{wxApp::argv}{wxappargv}\\
console sample
%%%%%%%%%%%%% Methods by group %%%%%%%%%%%%%
\latexignore{\rtfignore{\wxheading{Function groups}}}
\membersection{Construction}\label{wxcmdlineparserconstruction}
Before \helpref{Parse}{wxcmdlineparserparse} can be called, the command line
parser object must have the command line to parse and also the rules saying
which switches, options and parameters are valid - this is called command line
description in what follows.
You have complete freedom of choice as to when specify the required information,
the only restriction is that it must be done before calling
\helpref{Parse}{wxcmdlineparserparse}.
To specify the command line to parse you may use either one of constructors
accepting it (\helpref{wxCmdLineParser(argc, argv)}{wxcmdlineparserwxcmdlineparserargc} or
\helpref{wxCmdLineParser}{wxcmdlineparserwxcmdlineparserdescargc} usually) or,
if you use \helpref{the default constructor}{wxcmdlineparserwxcmdlineparserdef},
you can do it later by calling
\helpref{SetCmdLine}{wxcmdlineparsersetcmdlineargc}.
The same holds for command line description: it can be specified either in
the constructor (\helpref{without command line}{wxcmdlineparserwxcmdlineparserdesc} or
\helpref{together with it}{wxcmdlineparserwxcmdlineparserdescargc}) or
constructed later using either \helpref{SetDesc}{wxcmdlineparsersetdesc} or
combination of \helpref{AddSwitch}{wxcmdlineparseraddswitch},
\helpref{AddOption}{wxcmdlineparseraddoption} and
\helpref{AddParam}{wxcmdlineparseraddparam} methods.
Using constructors or \helpref{SetDesc}{wxcmdlineparsersetdesc} uses a (usually
{\tt const static}) table containing the command line description. If you want
to decide which options to acccept during the run-time, using one of the
{\tt AddXXX()} functions above might be preferable.
\membersection{Customization}\label{wxcmdlineparsercustomization}
wxCmdLineParser has several global options which may be changed by the
application. All of the functions described in this section should be called
before \helpref{Parse}{wxcmdlineparserparse}.
First global option is the support for long (also known as GNU-style) options.
The long options are the ones which start with two dashes ({\tt "--"}) and look
like this: {\tt --verbose}, i.e. they generally are complete words and not some
abbreviations of them. As long options are used by more and more applications,
they are enabled by default, but may be disabled with
\helpref{DisableLongOptions}{wxcmdlineparserdisablelongoptions}.
Another global option is the set of characters which may be used to start an
option (otherwise, the word on the command line is assumed to be a parameter).
Under Unix, {\tt '-'} is always used, but Windows has at least two common
choices for this: {\tt '-'} and {\tt '/'}. Some programs also use {\tt '+'}.
The default is to use what suits most the current platform, but may be changed
with \helpref{SetSwitchChars}{wxcmdlineparsersetswitchchars} method.
Finally, \helpref{SetLogo}{wxcmdlineparsersetlogo} can be used to show some
application-specific text before the explanation given by
\helpref{Usage}{wxcmdlineparserusage} function.
\membersection{Parsing command line}\label{wxcmdlineparserparsing}
After the command line description was constructed and the desiredoptions were
set, you can finally call \helpref{Parse}{wxcmdlineparserparse} method.
It returns $0$ if the command line was correct and was parsed, $-1$ if the help
option was specified (this is a separate case as, normally, the program will
terminate after this) or a positive number if there was an error during the
command line parsing.
In the latter case, the appropriate error message and usage information are
logged by wxCmdLineParser itself using the standard wxWindows logging functions.
\membersection{Getting results}\label{wxcmdlineparsergettingresults}
After calling \helpref{Parse}{wxcmdlineparserparse} (and if it returned $0$),
you may access the results of parsing using one of overloaded {\tt Found()}
methods.
For a simple switch, you will simply call
\helpref{Found}{wxcmdlineparserfoundswitch} to determine if the switch was given
or not, for an option or a parameter, you will call a version of {\tt Found()}
which also returns the associated value in the provided variable. All
{\tt Found()} functions return TRUE if the switch or option were found in the
command line or FALSE if they were not specified.
%%%%%%%%%%%%% Methods in alphabetic order %%%%%%%%%%%%%
\helponly{\insertatlevel{2}{
\wxheading{Members}
}}
\membersection{wxCmdLineParser::wxCmdLineParser}\label{wxcmdlineparserwxcmdlineparserdef}
\func{}{wxCmdLineParser}{\void}
Default constructor. You must use
\helpref{SetCmdLine}{wxcmdlineparsersetcmdlineargc} or
\helpref{SetCmdLinelater.}{wxcmdlineparsersetcmdlinestr} later.
\membersection{wxCmdLineParser::wxCmdLineParser}\label{wxcmdlineparserwxcmdlineparserargc}
\func{}{wxCmdLineParser}{\param{int }{argc}, \param{char** }{argv}}
Constructor specifies the command line to parse. This is the traditional
(Unix) command line format. The parameters {\it argc} and {\it argv} have the
same meaning as for {\tt main()} function.
\membersection{wxCmdLineParser::wxCmdLineParser}\label{wxcmdlineparserwxcmdlineparserstr}
\func{}{wxCmdLineParser}{\param{const wxString\& }{cmdline}}
Constructor specifies the command line to parse in Windows format. The parameter
{\it cmdline} has the same meaning as the corresponding parameter of
{\tt WinMain()}.
\membersection{wxCmdLineParser::wxCmdLineParser}\label{wxcmdlineparserwxcmdlineparserdesc}
\func{}{wxCmdLineParser}{\param{const wxCmdLineEntryDesc* }{desc}}
Same as \helpref{wxCmdLineParser}{wxcmdlineparserwxcmdlineparserdef}, but also
specifies the \helpref{command line description}{wxcmdlineparsersetdesc}.
\membersection{wxCmdLineParser::wxCmdLineParser}\label{wxcmdlineparserwxcmdlineparserdescargc}
\func{}{wxCmdLineParser}{\param{const wxCmdLineEntryDesc* }{desc}, \param{int }{argc}, \param{char** }{argv}}
Same as \helpref{wxCmdLineParser}{wxcmdlineparserwxcmdlineparserargc}, but also
specifies the \helpref{command line description}{wxcmdlineparsersetdesc}.
\membersection{wxCmdLineParser::wxCmdLineParser}\label{wxcmdlineparserwxcmdlineparserdescstr}
\func{}{wxCmdLineParser}{\param{const wxCmdLineEntryDesc* }{desc}, \param{const wxString\& }{cmdline}}
Same as \helpref{wxCmdLineParser}{wxcmdlineparserwxcmdlineparserstr}, but also
specifies the \helpref{command line description}{wxcmdlineparsersetdesc}.
\membersection{wxCmdLineParser::SetCmdLine}\label{wxcmdlineparsersetcmdlineargc}
\func{void}{SetCmdLine}{\param{int }{argc}, \param{char** }{argv}}
Set command line to parse after using one of the constructors which don't do it.
\wxheading{See also}
\helpref{wxCmdLineParser}{wxcmdlineparserwxcmdlineparserargc}
\membersection{wxCmdLineParser::SetCmdLine}\label{wxcmdlineparsersetcmdlinestr}
\func{void}{SetCmdLine}{\param{const wxString\& }{cmdline}}
Set command line to parse after using one of the constructors which don't do it.
\wxheading{See also}
\helpref{wxCmdLineParser}{wxcmdlineparserwxcmdlineparserstr}
\membersection{wxCmdLineParser::\destruct{wxCmdLineParser}}\label{wxcmdlineparserdtor}
\func{}{\destruct{wxCmdLineParser}}{\void}
Frees resources allocated by the object.
{\bf NB:} destructor is not virtual, don't use this class polymorphically.
\membersection{wxCmdLineParser::SetSwitchChars}\label{wxcmdlineparsersetswitchchars}
\func{void}{SetSwitchChars}{\param{const wxString\& }{switchChars}}
{\it switchChars} contains all characters with which an option or switch may
start. Default is {\tt "-"} for Unix, {\tt "-/"} for Windows.
\membersection{wxCmdLineParser::EnableLongOptions}\label{wxcmdlineparserenablelongoptions}
\func{void}{EnableLongOptions}{\param{bool }{enable = TRUE}}
Enable or disable support for the long options.
As long options are not (yet) POSIX-compliant, this option allows to disable
them.
\wxheading{See also}
\helpref{Customization}{wxcmdlineparsercustomization}
\membersection{wxCmdLineParser::DisableLongOptions}\label{wxcmdlineparserdisablelongoptions}
\func{void}{DisableLongOptions}{\void}
Ientical to \helpref{EnableLongOptions(FALSE)}{wxcmdlineparserenablelongoptions}.
\membersection{wxCmdLineParser::SetLogo}\label{wxcmdlineparsersetlogo}
\func{void}{SetLogo}{\param{const wxString\& }{logo}}
{\it logo} is some extra text which will be shown by
\helpref{Usage}{wxcmdlineparserusage} method.
\membersection{wxCmdLineParser::SetDesc}\label{wxcmdlineparsersetdesc}
\func{void}{SetDesc}{\param{const wxCmdLineEntryDesc* }{desc}}
Construct the command line description
Take the command line description from the wxCMD\_LINE\_NONE terminated table.
Example of usage:
\begin{verbatim}
static const wxCmdLineEntryDesc cmdLineDesc[] =
{
{ wxCMD_LINE_SWITCH, "v", "verbose", "be verbose" },
{ wxCMD_LINE_SWITCH, "q", "quiet", "be quiet" },
{ wxCMD_LINE_OPTION, "o", "output", "output file" },
{ wxCMD_LINE_OPTION, "i", "input", "input dir" },
{ wxCMD_LINE_OPTION, "s", "size", "output block size", wxCMD_LINE_VAL_NUMBER },
{ wxCMD_LINE_OPTION, "d", "date", "output file date", wxCMD_LINE_VAL_DATE },
{ wxCMD_LINE_PARAM, NULL, NULL, "input file", wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_MULTIPLE },
{ wxCMD_LINE_NONE }
};
wxCmdLineParser parser;
parser.SetDesc(cmdLineDesc);
\end{verbatim}
\membersection{wxCmdLineParser::AddSwitch}\label{wxcmdlineparseraddswitch}
\func{void}{AddSwitch}{\param{const wxString\& }{name}, \param{const wxString\& }{lng = wxEmptyString}, \param{const wxString\& }{desc = wxEmptyString}, \param{int }{flags = 0}}
Add a switch {\it name} with an optional long name {\it lng} (no long name if it
is empty, which is default), description {\it desc} and flags {\it flags} to the
command line description.
\membersection{wxCmdLineParser::AddOption}\label{wxcmdlineparseraddoption}
\func{void}{AddOption}{\param{const wxString\& }{name}, \param{const wxString\& }{lng = wxEmptyString}, \param{const wxString\& }{desc = wxEmptyString}, \param{wxCmdLineParamType }{type = wxCMD\_LINE\_VAL\_STRING}, \param{int }{flags = 0}}
Add an option {\it name} with an optional long name {\it lng} (no long name if
it is empty, which is default) taking a value of the given type (string by
default) to the command line description.
\membersection{wxCmdLineParser::AddParam}\label{wxcmdlineparseraddparam}
\func{void}{AddParam}{\param{const wxString\& }{desc = wxEmptyString}, \param{wxCmdLineParamType }{type = wxCMD\_LINE\_VAL\_STRING}, \param{int }{flags = 0}}
Add a parameter of the given {\it type} to the command line description.
\membersection{wxCmdLineParser::Parse}\label{wxcmdlineparserparse}
\func{int}{Parse}{\void}
Parse the command line, return $0$ if ok, $-1$ if {\tt "-h"} or {\tt "--help"}
option was encountered and the help message was given or a positive value if a
syntax error occured.
\membersection{wxCmdLineParser::Usage}\label{wxcmdlineparserusage}
\func{void}{Usage}{\void}
Give the standard usage message describing all program options. It will use the
options and parameters descriptions specified earlier, so the resulting message
will not be helpful to the user unless the descriptions were indeed specified.
\wxheading{See also}
\helpref{SetLogo}{wxcmdlineparsersetlogo}
\membersection{wxCmdLineParser::Found}\label{wxcmdlineparserfoundswitch}
\constfunc{bool}{Found}{\param{const wxString\& }{name}}
Returns TRUE if the given switch was found, FALSE otherwise.
\membersection{wxCmdLineParser::Found}\label{wxcmdlineparserfoundstringoption}
\constfunc{bool}{Found}{\param{const wxString\& }{name}, \param{wxString* }{value}}
Returns TRUE if an option taking a string value was found and stores the
value in the provided pointer (which should not be NULL).
\membersection{wxCmdLineParser::Found}\label{wxcmdlineparserfoundintoption}
\constfunc{bool}{Found}{\param{const wxString\& }{name}, \param{long* }{value}}
Returns TRUE if an option taking an integer value was found and stores
the value in the provided pointer (which should not be NULL).
\membersection{wxCmdLineParser::Found}\label{wxcmdlineparserfounddateoption}
\constfunc{bool}{Found}{\param{const wxString\& }{name}, \param{wxDateTime* }{value}}
Returns TRUE if an option taking a date value was found and stores the
value in the provided pointer (which should not be NULL).
\membersection{wxCmdLineParser::GetParamCount}\label{wxcmdlineparsergetparamcount}
\constfunc{size\_t}{GetParamCount}{\void}
Returns the number of parameters found. This function makes sense mostly if you
had used {\tt wxCMD\_LINE\_PARAM\_MULTIPLE} flag.
\membersection{wxCmdLineParser::GetParam}\label{wxcmdlineparsergetparam}
\constfunc{wxString}{GetParam}{\param{size\_t }{n = 0u}}
Returns the value of Nth parameter (as string only for now).
\wxheading{See also}
\helpref{GetParamCount}{wxcmdlineparsergetparamcount}

8
docs/latex/wx/colordlg.tex
View File

@@ -19,7 +19,7 @@ This class represents the colour chooser dialog.
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxColourDialog::wxColourDialog}
\membersection{wxColourDialog::wxColourDialog}\label{wxcolourdialogwxcolourdialog}
\func{}{wxColourDialog}{\param{wxWindow* }{parent}, \param{wxColourData* }{data = NULL}}
@@ -36,6 +36,12 @@ data, which will be copied to the colour dialog's colour data.
Destructor.
\membersection{wxColourDialog::Create}
\func{bool}{Create}{\param{wxWindow* }{parent}, \param{wxColourData* }{data = NULL}}
Same as \helpref{constructor}{wxcolourdialogwxcolourdialog}.
\membersection{wxColourDialog::GetColourData}
\func{wxColourData\&}{GetColourData}{\void}

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

@@ -222,7 +222,7 @@ The default colour is black.
\membersection{wxColourData::SetCustomColour}\label{wxcolourdatasetcustomcolour}
\func{void}{SetColour}{\param{int}{ i}, \param{const wxColour\&}{ colour}}
\func{void}{SetCustomColour}{\param{int}{ i}, \param{const wxColour\&}{ colour}}
Sets the {\it i}th custom colour for the colour dialog. {\it i} should
be an integer between 0 and 15.

10
docs/latex/wx/combobox.tex
View File

@@ -16,15 +16,16 @@ A combobox permits a single selection only. Combobox items are numbered from zer
\wxheading{Include files}
<wx/combo.h>
<wx/combobox.h>
\wxheading{Window styles}
\begin{twocollist}\itemsep=0pt
\twocolitem{\windowstyle{wxCB\_SIMPLE}}{Creates a combobox with a permanently displayed list. Windows only. }
\twocolitem{\windowstyle{wxCB\_DROPDOWN}}{Creates a combobox with a drop-down list.}
\twocolitem{\windowstyle{wxCB\_READONLY}}{Creates a combo box consisting of a drop-down list and static text item
displaying the current selection.}
\twocolitem{\windowstyle{wxCB\_READONLY}}{Same as wxCB\_DROPDOWN but only the
strings specified as the combobox choices can be selected, it is impossible to
select (even from a program) a string which is not in the choices list.}
\twocolitem{\windowstyle{wxCB\_SORT}}{Sorts the entries in the list alphabetically.}
\end{twocollist}
@@ -319,6 +320,9 @@ wxPython.}
Sets the text for the combobox text field.
{\bf NB:} For a combobox with {\tt wxCB\_READONLY} style the string must be in
the combobox choices list, otherwise the call to SetValue() is ignored.
\wxheading{Parameters}
\docparam{text}{The text to set.}

11
docs/latex/wx/conditn.tex
View File

@@ -5,12 +5,15 @@ objects. They may be used in a multithreaded application to wait until the
given condition becomes true which happens when the condition becomes signaled.
For example, if a worker thread is doing some long task and another thread has
to wait until it's finished, the latter thread will wait on the condition
to wait until it is finished, the latter thread will wait on the condition
object and the worker thread will signal it on exit (this example is not
perfect because in this particular case it would be much better to just
\helpref{Wait()}{wxthreadwait} for the worker thread, but if there are several
worker threads it already makes much more sense).
Once the thread(s) are signaled, the condition then resets to the not
signaled state, ready to fire again.
\wxheading{Derived from}
None.
@@ -51,18 +54,16 @@ Signals the object.
\membersection{wxCondition::Wait}\label{wxconditionwait}
\func{void}{Wait}{\param{wxMutex\&}{ mutex}}
\func{void}{Wait}{\void}
Waits indefinitely.
\func{bool}{Wait}{\param{wxMutex\&}{ mutex}, \param{unsigned long}{ sec}, \param{unsigned long}{ nsec}}
\func{bool}{Wait}{\param{unsigned long}{ sec}, \param{unsigned long}{ nsec}}
Waits until a signal is raised or the timeout has elapsed.
\wxheading{Parameters}
\docparam{mutex}{wxMutex object.}
\docparam{sec}{Timeout in seconds}
\docparam{nsec}{Timeout nanoseconds component (added to {\it sec}).}

70
docs/latex/wx/config.tex
View File

@@ -1,7 +1,7 @@
\section{\class{wxConfigBase}}\label{wxconfigbase}
wxConfigBase class defines the basic interface of all config classes. It can
not be used by itself (it's an abstract base class) and you'll always use one
not be used by itself (it is an abstract base class) and you will always use one
of its derivations: wxIniConfig, wxFileConfig, wxRegConfig or any other.
However, usually you don't even need to know the precise nature of the class
@@ -118,7 +118,7 @@ support a file system-like hierarchy of keys (files) and groups (directories).
As in the file system case, to specify a key in the config class you must use
a path to it. Config classes also support the notion of the current group,
which makes it possible to use the relative paths. To clarify all this, here
is an example (it's only for the sake of demonstration, it doesn't do anything
is an example (it is only for the sake of demonstration, it doesn't do anything
sensible!):
\begin{verbatim}
@@ -139,11 +139,11 @@ sensible!):
wxASSERT( conf->Read("Subgroup/SubgroupEntry", 0l) == 3 );
// use absolute path: it's allowed, too
// use absolute path: it is allowed, too
wxASSERT( conf->Read("/RootEntry", 0l) == 1 );
\end{verbatim}
{\it Warning}: it's probably a good idea to always restore the path to its
{\it Warning}: it is probably a good idea to always restore the path to its
old value on function exit:
\begin{verbatim}
@@ -175,7 +175,7 @@ doesn't save and restore the path):
\end{verbatim}
Finally, the path separator in wxConfigBase and derived classes is always '/',
regardless of the platform (i.e. it's {\bf not} '$\backslash\backslash$' under Windows).
regardless of the platform (i.e. it is {\bf not} '$\backslash\backslash$' under Windows).
\helpref{SetPath}{wxconfigbasesetpath}\\
\helpref{GetPath}{wxconfigbasegetpath}
@@ -186,9 +186,9 @@ The functions in this section allow to enumerate all entries and groups in the
config file. All functions here return FALSE when there are no more items.
You must pass the same index to GetNext and GetFirst (don't modify it).
Please note that it's {\bf not} the index of the current item (you will have
Please note that it is {\bf not} the index of the current item (you will have
some great surprizes with wxRegConfig if you assume this) and you shouldn't
even look at it: it's just a "cookie" which stores the state of the
even look at it: it is just a "cookie" which stores the state of the
enumeration. It can't be stored inside the class because it would prevent you
from running several enumerations simultaneously, that's why you must pass it
explicitly.
@@ -241,10 +241,11 @@ actually enumerating them, but you will probably never need them.
\helpref{Exists}{wxconfigbaseexists}\\
\helpref{GetEntryType}{wxconfigbasegetentrytype}
\membersection{Miscellaneous accessors}
\membersection{Miscellaneous functions}
\helpref{GetAppName}{wxconfigbasegetappname}\\
\helpref{GetVendorName}{wxconfigbasegetvendorname}
\helpref{GetVendorName}{wxconfigbasegetvendorname}\\
\helpref{SetUmask}{wxfileconfigsetumask}
\membersection{Key access}
@@ -321,7 +322,7 @@ would be to prefix the offending symbols with a backslash.
The following functions control this option:
\helpref{IsExpandingEnvVars}{wxconfigbaseisexpandingenvvars}\\
\helpref{SetExpandingEnvVars}{wxconfigbasesetexpandingenvvars}\\
\helpref{SetExpandEnvVars}{wxconfigbasesetexpandenvvars}\\
\helpref{SetRecordDefaults}{wxconfigbasesetrecorddefaults}\\
\helpref{IsRecordingDefaults}{wxconfigbaseisrecordingdefaults}
@@ -407,8 +408,7 @@ for use by desinstallation routine.
\membersection{wxConfigBase::DeleteEntry}\label{wxconfigbasedeleteentry}
\func{bool}{DeleteEntry}{\param{const wxString\& }{ key}, \param{bool}{
bDeleteGroupIfEmpty = TRUE}}
\func{bool}{DeleteEntry}{\param{const wxString\& }{ key}, \param{bool}{ bDeleteGroupIfEmpty = TRUE}}
Deletes the specified entry and the group it belongs to if it was the last key
in it and the second parameter is true.
@@ -471,8 +471,7 @@ The result is an element of enum EntryType:
\membersection{wxConfigBase::GetFirstGroup}\label{wxconfigbasegetfirstgroup}
\constfunc{bool}{GetFirstGroup}{\param{wxString\& }{str}, \param{long\&}{
index}}
\constfunc{bool}{GetFirstGroup}{\param{wxString\& }{str}, \param{long\&}{ index}}
Gets the first group.
@@ -482,8 +481,7 @@ the next call.}
\membersection{wxConfigBase::GetFirstEntry}\label{wxconfigbasegetfirstentry}
\constfunc{bool}{GetFirstEntry}{\param{wxString\& }{str}, \param{long\&}{
index}}
\constfunc{bool}{GetFirstEntry}{\param{wxString\& }{str}, \param{long\&}{ index}}
Gets the first entry.
@@ -493,8 +491,7 @@ the next call.}
\membersection{wxConfigBase::GetNextGroup}\label{wxconfigbasegetnextgroup}
\constfunc{bool}{GetNextGroup}{\param{wxString\& }{str}, \param{long\&}{
index}}
\constfunc{bool}{GetNextGroup}{\param{wxString\& }{str}, \param{long\&}{ index}}
Gets the next group.
@@ -504,8 +501,7 @@ the next call.}
\membersection{wxConfigBase::GetNextEntry}\label{wxconfigbasegetnextentry}
\constfunc{bool}{GetNextEntry}{\param{wxString\& }{str}, \param{long\&}{
index}}
\constfunc{bool}{GetNextEntry}{\param{wxString\& }{str}, \param{long\&}{ index}}
Gets the next entry.
@@ -556,20 +552,18 @@ Returns TRUE if we are expanding environment variables in key values.
\membersection{wxConfigBase::IsRecordingDefaults}\label{wxconfigbaseisrecordingdefaults}
\func{bool}{IsRecordingDefaults}{\void} const
\constfunc{bool}{IsRecordingDefaults}{\void}
Returns TRUE if we are writing defaults back to the config file.
\membersection{wxConfigBase::Read}\label{wxconfigbaseread}
\constfunc{bool}{Read}{\param{const wxString\& }{key}, \param{wxString*}{
str}}
\constfunc{bool}{Read}{\param{const wxString\& }{key}, \param{wxString*}{ str}}
Read a string from the key, returning TRUE if the value was read. If the key
was not found, {\it str} is not changed.
\constfunc{bool}{Read}{\param{const wxString\& }{key}, \param{wxString*}{
str}, \param{const wxString\& }{defaultVal}}
\constfunc{bool}{Read}{\param{const wxString\& }{key}, \param{wxString*}{ str}, \param{const wxString\& }{defaultVal}}
Read a string from the key. The default value is returned if the key was not
found.
@@ -592,8 +586,7 @@ not found, {\it l} is not changed.
Reads a long value, returning TRUE if the value was found. If the value was
not found, {\it defaultVal} is used instead.
\constfunc{long }{Read}{\param{const wxString\& }{key}, \param{long}{
defaultVal}}
\constfunc{long }{Read}{\param{const wxString\& }{key}, \param{long}{ defaultVal}}
Reads a long value from the key and returns it. {\it defaultVal} is returned
if the key is not found.
@@ -667,7 +660,7 @@ exists.
Sets the config object as the current one, returns the pointer to the previous
current object (both the parameter and returned value may be NULL)
\membersection{wxConfigBase::SetExpandingEnvVars}\label{wxconfigbasesetexpandingenvvars}
\membersection{wxConfigBase::SetExpandEnvVars}\label{wxconfigbasesetexpandenvvars}
\func{void}{SetExpandEnvVars }{\param{bool }{bDoIt = TRUE}}
@@ -677,8 +670,8 @@ Determine whether we wish to expand environment variables in key values.
\func{void}{SetPath}{\param{const wxString\& }{strPath}}
Set current path: if the first character is '/', it's the absolute path,
otherwise it's a relative path. '..' is supported. If the strPath doesn't
Set current path: if the first character is '/', it is the absolute path,
otherwise it is a relative path. '..' is supported. If the strPath doesn't
exist it is created.
\membersection{wxConfigBase::SetRecordDefaults}\label{wxconfigbasesetrecorddefaults}
@@ -691,6 +684,19 @@ If on (default is off) all default values are written back to the config file.
This allows the user to see what config options may be changed and is probably
useful only for wxFileConfig.
\membersection{wxConfigBase::SetUmask}\label{wxfileconfigsetumask}
\func{void}{SetUmask}{\param{int }{mode}}
{\bf NB:} this function is not in the base wxConfigBase class but is only
implemented in wxFileConfig. Moreover, this function is Unix-specific and
doesn't do anything on other platforms.
SetUmask() allows to set the mode to be used for the config file creation.
For example, to create a config file which is not readable by other users
(useful if it stores some sensitive information, such as passwords), you
should do {\tt SetUmask(0077)}.
\membersection{wxConfigBase::Write}\label{wxconfigbasewrite}
\func{bool}{Write}{\param{const wxString\& }{ key}, \param{const wxString\& }{
@@ -714,7 +720,3 @@ implements the following methods:\par
\end{twocollist}}
}

BIN
docs/latex/wx/contents.gif
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 231 B

After

Width:  |  Height:  |  Size: 996 B

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

@@ -0,0 +1,60 @@
%
% automatically generated by HelpGen from
% ../include/wx/strconv.h at 25/Mar/00 10:20:56
%
\section{\class{wxCSConv}}\label{wxcsconv}
This class converts between any character sets and Unicode.
It has one predefined instance, {\bf wxConvLocal}, for the
default user character set.
\wxheading{Derived from}
\helpref{wxMBConv}{wxmbconv}
\wxheading{Include files}
<wx/strconv.h>
\wxheading{See also}
\helpref{wxMBConv}{wxmbconv},
\helpref{wxEncodingConverter}{wxencodingconverter},
\helpref{wxMBConv classes overview}{mbconvclasses}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxCSConv::wxCSConv}\label{wxcsconvwxcsconv}
\func{}{wxCSConv}{\param{const wxChar* }{charset}}
Constructor. Specify the name of the character set you want to convert
from/to.
\membersection{wxCSConv::\destruct{wxCSConv}}\label{wxcsconvdtor}
\func{}{\destruct{wxCSConv}}{\void}
Destructor.
\membersection{wxCSConv::LoadNow}\label{wxcsconvloadnow}
\func{void}{LoadNow}{\void}
If the conversion tables needs to be loaded from disk, this method
will do so. Otherwise, they will be loaded when any of the conversion
methods are called.
\membersection{wxCSConv::MB2WC}\label{wxcsconvmb2wc}
\constfunc{size\_t}{MB2WC}{\param{wchar\_t* }{buf}, \param{const char* }{psz}, \param{size\_t }{n}}
Converts from the selected character set to Unicode. Returns the size of the destination buffer.
\membersection{wxCSConv::WC2MB}\label{wxcsconvwc2mb}
\constfunc{size\_t}{WC2MB}{\param{char* }{buf}, \param{const wchar\_t* }{psz}, \param{size\_t }{n}}
Converts from Unicode to the selected character set. Returns the size of the destination buffer.

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

@@ -155,7 +155,7 @@ hotSpotY=0)}}{Constructs a cursor from a filename}
Destroys the cursor. A cursor can be reused for more
than one window, and does not get destroyed when the window is
destroyed. wxWindows destroys all cursors on application exit, although
it's best to clean them up explicitly.
it is best to clean them up explicitly.
\membersection{wxCursor::Ok}\label{wxcursorok}

9
docs/latex/wx/database.tex
View File

@@ -3,9 +3,6 @@
Every database object represents an ODBC connection.
The connection may be closed and reopened.
Note: this class is considered obsolete, replaced by the Remstar wxDB/wxTable classes
(documented separately in Word and PDF format, as odbc.doc and odbc.pdf).
\wxheading{Derived from}
\helpref{wxObject}{wxobject}
@@ -18,6 +15,12 @@ Note: this class is considered obsolete, replaced by the Remstar wxDB/wxTable cl
\overview{wxDatabase overview}{wxdatabaseoverview}, \helpref{wxRecordSet}{wxrecordset}
A much more robust and feature-rich set of ODBC classes is now
available and recommended for use in place of the wxDatabase class.
See details of these classes in:
\helpref{wxDB}{wxdb}, \helpref{wxDbTable}{wxdbtable}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxDatabase::wxDatabase}

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

@@ -6,7 +6,7 @@
%% Created: 03.11.99
%% RCS-ID: $Id$
%% Copyright: (c) Vadim Zeitlin
%% Licence: wxWindows licence
%% License: wxWindows license
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{\class{wxDataFormat}}\label{wxdataformat}

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

@@ -6,7 +6,7 @@
%% Created: 18.10.99
%% RCS-ID: $Id$
%% Copyright: (c) wxWindows team
%% Licence: wxWindows licence
%% License: wxWindows license
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{\class{wxDataObject}}\label{wxdataobject}

15
docs/latex/wx/datespan.tex Normal file
View File

@@ -0,0 +1,15 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Name: datespan.tex
%% Purpose: wxDateSpan documentation
%% Author: Vadim Zeitlin
%% Modified by:
%% Created: 04.04.00
%% RCS-ID: $Id$
%% Copyright: (c) Vadim Zeitlin
%% License: wxWindows license
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{\class{wxDateSpan}}\label{wxdatespan}
The documentation for this section has not yet been written.

1126
docs/latex/wx/datetime.tex
View File

File diff suppressed because it is too large Load Diff

1677
docs/latex/wx/db.tex Normal file
View File

File diff suppressed because it is too large Load Diff

59
docs/latex/wx/dc.tex
View File

@@ -108,6 +108,18 @@ See \helpref{wxMemoryDC}{wxmemorydc} for typical usage.
\helpref{wxMemoryDC}{wxmemorydc}, \helpref{wxBitmap}{wxbitmap}, \helpref{wxMask}{wxmask}
\membersection{wxDC::CalcBoundingBox}\label{wxdccalcboundingbox}
\func{void}{CalcBoundingBox}{\param{wxCoord }{x}, \param{wxCoord }{y}}
Adds the specified point to the bounding box which can be retrieved with
\helpref{MinX}{wxdcminx}, \helpref{MaxX}{wxdcmaxx} and
\helpref{MinY}{wxdcminy}, \helpref{MaxY}{wxdcmaxy} functions.
\wxheading{See also}
\helpref{ResetBoundingBox}{wxdcresetboundingbox}
\membersection{wxDC::Clear}\label{wxdcclear}
\func{void}{Clear}{\void}
@@ -201,8 +213,7 @@ filling the shape.
\param{double}{ start}, \param{double}{ end}}
Draws an arc of an ellipse. The current pen is used for drawing the arc and
the current brush is used for drawing the pie. This function is currently only available for
X window and PostScript device contexts.
the current brush is used for drawing the pie.
{\it x} and {\it y} specify the x and y coordinates of the upper-left corner of the rectangle that contains
the ellipse.
@@ -336,6 +347,11 @@ the string. See \helpref{wxDC::GetTextExtent}{wxdcgettextextent} for how
to get the dimensions of a text string, which can be used to position the
text more precisely.
{\bf NB:} under wxGTK the current
\helpref{logical function}{wxdcgetlogicalfunction} is used by this function
but it is ignored by wxMSW. Thus, you should avoid using logical functions
with this function in portable programs.
\membersection{wxDC::EndDoc}\label{wxdcenddoc}
\func{void}{EndDoc}{\void}
@@ -358,10 +374,10 @@ Ends a document page (only relevant when outputting to a printer).
\membersection{wxDC::FloodFill}\label{wxdcfloodfill}
\func{void}{FloodFill}{\param{wxCoord}{ x}, \param{wxCoord}{ y}, \param{wxColour *}{colour}, \param{int}{ style=wxFLOOD\_SURFACE}}
\func{void}{FloodFill}{\param{wxCoord}{ x}, \param{wxCoord}{ y}, \param{const wxColour\&}{ colour}, \param{int}{ style=wxFLOOD\_SURFACE}}
Flood fills the device context starting from the given point, in the given colour,
and using a style:
Flood fills the device context starting from the given point, using
the {\it current brush colour}, and using a style:
\begin{itemize}\itemsep=0pt
\item wxFLOOD\_SURFACE: the flooding occurs until a colour other than the given colour is encountered.
@@ -374,12 +390,26 @@ and using a style:
\func{wxBrush\&}{GetBackground}{\void}
\constfunc{const wxBrush\&}{GetBackground}{\void}
Gets the brush used for painting the background (see \helpref{wxDC::SetBackground}{wxdcsetbackground}).
\membersection{wxDC::GetBackgroundMode}\label{wxdcgetbackgroundmode}
\constfunc{int}{GetBackgroundMode}{\void}
Returns the current background mode: {\tt wxSOLID} or {\tt wxTRANSPARENT}.
\wxheading{See also}
\helpref{SetBackgroundMode}{wxdcsetbackgroundmode}
\membersection{wxDC::GetBrush}\label{wxdcgetbrush}
\func{wxBrush\&}{GetBrush}{\void}
\constfunc{const wxBrush\&}{GetBrush}{\void}
Gets the current brush (see \helpref{wxDC::SetBrush}{wxdcsetbrush}).
\membersection{wxDC::GetCharHeight}\label{wxdcgetcharheight}
@@ -407,6 +437,8 @@ rectangle are returned as a tuple.}
\func{wxFont\&}{GetFont}{\void}
\constfunc{const wxFont\&}{GetFont}{\void}
Gets the current font (see \helpref{wxDC::SetFont}{wxdcsetfont}).
\membersection{wxDC::GetLogicalFunction}\label{wxdcgetlogicalfunction}
@@ -432,6 +464,8 @@ See \helpref{wxDC::SetOptimization}{wxsetoptimization} for details.
\func{wxPen\&}{GetPen}{\void}
\constfunc{const wxPen\&}{GetPen}{\void}
Gets the current pen (see \helpref{wxDC::SetPen}{wxdcsetpen}).
\membersection{wxDC::GetPixel}\label{wxdcgetpixel}
@@ -478,6 +512,8 @@ implements the following methods:\par
\func{wxColour\&}{GetTextBackground}{\void}
\constfunc{const wxColour\&}{GetTextBackground}{\void}
Gets the current text background colour (see \helpref{wxDC::SetTextBackground}{wxdcsettextbackground}).
\membersection{wxDC::GetTextExtent}\label{wxdcgettextextent}
@@ -511,6 +547,8 @@ See also \helpref{wxFont}{wxfont}, \helpref{wxDC::SetFont}{wxdcsetfont}.
\func{wxColour\&}{GetTextForeground}{\void}
\constfunc{const wxColour\&}{GetTextForeground}{\void}
Gets the current text foreground colour (see \helpref{wxDC::SetTextForeground}{wxdcsettextforeground}).
@@ -579,6 +617,17 @@ Gets the minimum vertical extent used in drawing commands so far.
Returns TRUE if the DC is ok to use.
\membersection{wxDC::ResetBoundingBox}\label{wxdcresetboundingbox}
\func{void}{ResetBoundingBox}{\void}
Resets the bounding box: after a call to this function, the bounding box
doesn't contain anything.
\wxheading{See also}
\helpref{CalcBoundingBox}{wxdccalcboundingbox}
\membersection{wxDC::SetDeviceOrigin}\label{wxdcsetdeviceorigin}
\func{void}{SetDeviceOrigin}{\param{wxCoord}{ x}, \param{wxCoord}{ y}}

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

@@ -7,7 +7,7 @@ To create a client which can communicate with a suitable server,
you need to derive a class from wxDDEConnection and another from wxDDEClient.
The custom wxDDEConnection class will intercept communications in
a `conversation' with a server, and the custom wxDDEServer is required
so that a user-overriden \helpref{wxDDEClient::OnMakeConnection}{wxddeclientonmakeconnection} member can return
so that a user-overridden \helpref{wxDDEClient::OnMakeConnection}{wxddeclientonmakeconnection} member can return
a wxDDEConnection of the required class, when a connection is made.
This DDE-based implementation is

48
docs/latex/wx/dialevt.tex Normal file
View File

@@ -0,0 +1,48 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Name: dialevt.tex
%% Purpose: wxDialUpEvent documentation
%% Author: Vadim Zeitlin
%% Modified by:
%% Created: 08.04.00
%% RCS-ID: $Id$
%% Copyright: (c) Vadim Zeitlin
%% License: wxWindows license
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{\class{wxDialUpEvent}}\label{wxdialupevent}
This is the event class for the dialup events sent by
\helpref{wxDialUpManager}{wxdialupmanager}.
\wxheading{Derived from}
\helpref{wxEvent}{wxevent}\\
\helpref{wxObject}{wxobject}
\wxheading{Include files}
<wx/dialup.h>
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxDialUpEvent::wxDialUpEvent}\label{wxdialupeventwxdialupevent}
\func{}{wxDialUpEvent}{\param{bool }{isConnected}, \param{bool }{isOwnEvent}}
Constructor is only used by \helpref{wxDialUpManager}{wxdialupmanager}.
\membersection{wxDialUpEvent::IsConnectedEvent}\label{wxdialupeventisconnectedevent}
\constfunc{bool}{IsConnectedEvent}{\void}
Is this a {\tt CONNECTED} or {\tt DISCONNECTED} event? In other words, does it
notify about transition from offline to online state or vice versa?
\membersection{wxDialUpEvent::IsOwnEvent}\label{wxdialupeventisownevent}
\constfunc{bool}{IsOwnEvent}{\void}
Does this event come from wxDialUpManager::Dial() or from some extrenal
process (i.e. does it result from our own attempt to establish the
connection)?

13
docs/latex/wx/dialog.tex
View File

@@ -22,7 +22,10 @@ like a frame in that program flow continues, and input on other windows is still
You specify the type of dialog with the {\bf wxDIALOG\_MODAL} and {\bf wxDIALOG\_MODELESS} window
styles.
A dialog may be loaded from a wxWindows resource file (extension {\tt wxr}).
A dialog may be loaded from a wxWindows resource file (extension {\tt wxr}), which may itself
be created by Dialog Editor. For details,
see \helpref{The wxWindows resource system}{resourceformats}, \helpref{wxWindows resource functions}{resourcefuncs} and
the resource sample.
An application can define an \helpref{OnCloseWindow}{wxwindowonclosewindow} handler for the
dialog to respond to system close events.
@@ -31,9 +34,10 @@ dialog to respond to system close events.
\twocolwidtha{5cm}
\begin{twocollist}\itemsep=0pt
\twocolitem{\windowstyle{wxCAPTION}}{Puts a caption on the dialog box (Motif only).}
\twocolitem{\windowstyle{wxDIALOG\_MODAL}}{Specifies that the dialog box will be modal.}
\twocolitem{\windowstyle{wxCAPTION}}{Puts a caption on the dialog box.}
\twocolitem{\windowstyle{wxDEFAULT\_DIALOG\_STYLE}}{Equivalent to a combination of wxCAPTION, wxSYSTEM\_MENU and wxTHICK\_FRAME}
\twocolitem{\windowstyle{wxRESIZE\_BORDER}}{Display a resizeable frame around the window (Unix only).}
\twocolitem{\windowstyle{wxRESIZE\_BORDER}}{Display a resizeable frame around the window.}
\twocolitem{\windowstyle{wxSYSTEM\_MENU}}{Display a system menu.}
\twocolitem{\windowstyle{wxTHICK\_FRAME}}{Display a thick frame around the window.}
\twocolitem{\windowstyle{wxSTAY\_ON\_TOP}}{The dialog stays on top of all other windows (Windows only).}
@@ -279,6 +283,9 @@ propagate the notification to child windows and controls.
\func{void}{SetModal}{\param{const bool}{ flag}}
{\bf NB:} This function is deprecated and doesn't work for all ports, just use
\helpref{ShowModal}{wxdialogshowmodal} to show a modal dialog instead.
Allows the programmer to specify whether the dialog box is modal (wxDialog::Show blocks control
until the dialog is hidden) or modeless (control returns immediately).

215
docs/latex/wx/dialup.tex Normal file
View File

@@ -0,0 +1,215 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Name: dialup.tex
%% Purpose: wxDialUpManager documentation
%% Author: Vadim Zeitlin
%% Modified by:
%% Created: 08.04.00
%% RCS-ID: $Id$
%% Copyright: (c) Vadim Zeitlin
%% License: wxWindows license
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{\class{wxDialUpManager}}\label{wxdialupmanager}
This class encapsulates functions dealing with veryfying the connection status
of the workstation (connected to the Internet via a direct connection,
connected through a modem or not connected at all) and to establish this
connection if possible/required (i.e. in the case of the modem).
The program may also wish to be notified about the change in the connection
status (for example, to perform some action when the user connects to the
network the next time or, on the contrary, to stop receiving data from the net
when the user hangs up the modem). For this, you need to use one of the event
macros described below.
This class is different from other wxWindows classes in that there is at most
one instance of this class in the program accessed via
\helpref{wxDialUpManager::Create()}{wxdialupmanagercreate} and you can't
create the objects of this class directly.
\wxheading{Derived from}
No base class
\wxheading{Include files}
<wx/dialup.h>
\wxheading{Event table macros}
To be notified about the change in the network connection status, use these
event handler macros to direct input to member functions that take a
\helpref{wxDialUpEvent}{wxdialupevent} argument.
\twocolwidtha{7cm}
\begin{twocollist}\itemsep=0pt
\twocolitem{{\bf EVT\_DIALUP\_CONNECTED(func)}}{A connection with the network was established.}
\twocolitem{{\bf EVT\_DIALUP\_DISCONNECTED(func)}}{The connection with the network was lost.}
\end{twocollist}%
\wxheading{See also}
\helpref{dialup sample}{sampledialup}\\
\helpref{wxDialUpEvent}{wxdialupevent}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxDialUpManager::Create}\label{wxdialupmanagercreate}
\func{wxDialUpManager*}{Create}{\void}
This function should create and return the object of the platform-specific
class derived from wxDialUpManager. You should delete the pointer when you are
done with it.
\membersection{wxDialUpManager::IsOk}\label{wxdialupmanagerisok}
\constfunc{bool}{IsOk}{\void}
Returns {\tt TRUE} if the dialup manager was initialized correctly. If this
function returns {\tt FALSE}, no other functions will work neither, so it is a
good idea to call this function and check its result before calling any other
wxDialUpManager methods
\membersection{wxDialUpManager::\destruct{wxDialUpManager}}\label{wxdialupmanagerdtor}
\func{}{\destruct{wxDialUpManager}}{\void}
Destructor.
\membersection{wxDialUpManager::GetISPNames}\label{wxdialupmanagergetispnames}
\constfunc{size\_t}{GetISPNames}{\param{wxArrayString\& }{names}}
This function is only implemented under Windows.
Fills the array with the names of all possible values for the first
parameter to \helpref{Dial()}{wxdialupmanagerdial} on this machine and returns
their number (may be $0$).
\membersection{wxDialUpManager::Dial}\label{wxdialupmanagerdial}
\func{bool}{Dial}{\param{const wxString\& }{nameOfISP = wxEmptyString}, \param{const wxString\& }{username = wxEmptyString}, \param{const wxString\& }{password = wxEmptyString}, \param{bool }{async = TRUE}}
Dial the given ISP, use {\it username} and {\it password} to authentificate.
The parameters are only used under Windows currently, for Unix you should use
\helpref{SetConnectCommand}{wxdialupmanagersetconnectcommand} to customize this
functions behaviour.
If no {\it nameOfISP} is given, the function will select the default one
(proposing the user to choose among all connections defined on this machine)
and if no username and/or password are given, the function will try to do
without them, but will ask the user if really needed.
If {\it async} parameter is {\tt FALSE}, the function waits until the end of dialing
and returns {\tt TRUE} upon successful completion.
If {\it async} is {\tt TRUE}, the function only initiates the connection and
returns immediately - the result is reported via events (an event is sent
anyhow, but if dialing failed it will be a DISCONNECTED one).
\membersection{wxDialUpManager::IsDialing}\label{wxdialupmanagerisdialing}
\constfunc{bool}{IsDialing}{\void}
Returns TRUE if (async) dialing is in progress.
\wxheading{See also}
\helpref{Dial}{wxdialupmanagerdial}
\membersection{wxDialUpManager::CancelDialing}\label{wxdialupmanagercanceldialing}
\func{bool}{CancelDialing}{\void}
Cancel dialing the number initiated with \helpref{Dial}{wxdialupmanagerdial}
with async parameter equal to {\tt TRUE}.
Note that this won't result in DISCONNECTED event being sent.
\wxheading{See also}
\helpref{IsDialing}{wxdialupmanagerisdialing}
\membersection{wxDialUpManager::HangUp}\label{wxdialupmanagerhangup}
\func{bool}{HangUp}{\void}
Hang up the currently active dial up connection.
\membersection{wxDialUpManager::IsAlwaysOnline}\label{wxdialupmanagerisalwaysonline}
\constfunc{bool}{IsAlwaysOnline}{\void}
Returns {\tt TRUE} if the computer has a permanent network connection (i.e. is
on a LAN) and so there is no need to use Dial() function to go online.
{\bf NB:} this functions tries to guess the result and it is not always
guaranteed to be correct, so it is better to ask user for
confirmation or give him a possibility to override it.
\membersection{wxDialUpManager::IsOnline}\label{wxdialupmanagerisonline}
\constfunc{bool}{IsOnline}{\void}
Returns {\tt TRUE} if the computer is connected to the network: under Windows,
this just means that a RAS connection exists, under Unix we check that
the "well-known host" (as specified by
\helpref{SetWellKnownHost}{wxdialupmanagersetwellknownhost}) is reachable.
\membersection{wxDialUpManager::SetOnlineStatus}\label{wxdialupmanagersetonlinestatus}
\func{void}{SetOnlineStatus}{\param{bool }{isOnline = TRUE}}
Sometimes the built-in logic for determining the online status may fail,
so, in general, the user should be allowed to override it. This function
allows to forcefully set the online status - whatever our internal
algorithm may think about it.
\wxheading{See also}
\helpref{IsOnline}{wxdialupmanagerisonline}
\membersection{wxDialUpManager::EnableAutoCheckOnlineStatus}\label{wxdialupmanagerenableautocheckonlinestatus}
\func{bool}{EnableAutoCheckOnlineStatus}{\param{size\_t }{nSeconds = 60}}
Enable automatical checks for the connection status and sending of
{\tt wxEVT\_DIALUP\_CONNECTED/wxEVT\_DIALUP\_DISCONNECTED} events. The interval
parameter is only for Unix where we do the check manually and specifies how
often should we repeat the check (each minute by default). Under Windows, the
notification about the change of connection status is sent by the system and so
we don't do any polling and this parameter is ignored.
Returns {\tt FALSE} if couldn't set up automatic check for online status.
\membersection{wxDialUpManager::DisableAutoCheckOnlineStatus}\label{wxdialupmanagerdisableautocheckonlinestatus}
\func{void}{DisableAutoCheckOnlineStatus}{\void}
Disable automatic check for connection status change - notice that the
{\tt wxEVT\_DIALUP\_XXX} events won't be sent any more neither.
\membersection{wxDialUpManager::SetWellKnownHost}\label{wxdialupmanagersetwellknownhost}
\func{void}{SetWellKnownHost}{\param{const wxString\& }{hostname}, \param{int }{portno = 80}}
This method is for Unix only.
Under Unix, the value of well-known host is used to check whether we're
connected to the internet. It is unused under Windows, but this function
is always safe to call. The default value is {\tt www.yahoo.com:80}.
\membersection{wxDialUpManager::SetConnectCommand}\label{wxdialupmanagersetconnectcommand}
\func{}{SetConnectCommand}{\param{const wxString\& }{commandDial = wxT("/usr/bin/pon")}, \param{const wxString\& }{commandHangup = wxT("/usr/bin/poff")}}
This method is for Unix only.
Sets the commands to start up the network and to hang up again.
\wxheading{See also}
\helpref{Dial}{wxdialupmanagerdial}

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

@@ -94,7 +94,7 @@ class is not meant to be used polymorphically.
\func{bool}{Open}{\param{const wxString\& }{dir}}
Open the directory for enumerating, returns TRUE on success or FALSE if an
error occured.
error occurred.
\membersection{wxDir::IsOpened}\label{wxdirisopened}

145
docs/latex/wx/dllload.tex Normal file
View File

@@ -0,0 +1,145 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Name: dllload.tex
%% Purpose: wxDllLoader documentation
%% Author: Vadim Zeitlin
%% Modified by:
%% Created: 02.04.00
%% RCS-ID: $Id$
%% Copyright: (c) Vadim Zeitlin
%% License: wxWindows license
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{\class{wxDllLoader}}\label{wxdllloader}
wxDllLoader is a class providing an interface similar to Unix's {\tt
dlopen()}. It is used by the wxLibrary framework and manages the actual
loading of shared libraries and the resolving of symbols in them. There are no
instances of this class, it simply serves as a namespace for its static member
functions.
The terms {\it DLL} and {\it shared library/object} will both be used in the
documentation to refer to the same thing: a {\tt .dll} file under Windows or
{\tt .so} or {\tt .sl} one under Unix.
Example of using this class to dynamically load {\tt strlen()} function:
\begin{verbatim}
#if defined(__WXMSW__)
static const wxChar *LIB_NAME = _T("kernel32");
static const wxChar *FUNC_NAME = _T("lstrlenA");
#elif defined(__UNIX__)
static const wxChar *LIB_NAME = _T("/lib/libc-2.0.7.so");
static const wxChar *FUNC_NAME = _T("strlen");
#endif
wxDllType dllHandle = wxDllLoader::LoadLibrary(LIB_NAME);
if ( !dllHandle )
{
... error ...
}
else
{
typedef int (*strlenType)(char *);
strlenType pfnStrlen = (strlenType)wxDllLoader::GetSymbol(dllHandle, FUNC_NAME);
if ( !pfnStrlen )
{
... error ...
}
else
{
if ( pfnStrlen("foo") != 3 )
{
... error ...
}
else
{
... ok! ...
}
}
wxDllLoader::UnloadLibrary(dllHandle);
}
\end{verbatim}
\wxheading{Derived from}
No base class
\wxheading{Include files}
<wx/dynlib.h>
\wxheading{Data structures}
This header defines a platfrom-dependent {\tt wxDllType} typedef which stores
a handle to a loaded DLLs on the given platform.
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxDllLoader::GetDllExt}\label{wxdllloadergetdllext}
\func{static wxString}{GetDllExt}{\void}
Returns the string containing the usual extension for shared libraries for the
given systems (including the leading dot if not empty).
For example, this function will return {\tt ".dll"} under Windows or (usually)
{\tt ".so"} under Unix.
\membersection{wxDllLoader::GetProgramHandle}\label{wxdllloadergetprogramhandle}
\func{wxDllType}{GetProgramHandle}{\void}
This function returns a valid handle for the main program itself. Notice that
the {\tt NULL} return value is valid for some systems (i.e. doesn't mean that
the function failed).
{\bf NB:} This function is Unix specific. It will always fail under Windows
or OS/2.
\membersection{wxDllLoader::GetSymbol}\label{wxdllloadergetsymbol}
\func{void *}{GetSymbol}{\param{wxDllType }{dllHandle}, \param{const wxString\& }{name}}
This function resolves a symbol in a loaded DLL, such as a variable or
function name.
Returned value will be {\tt NULL} if the symbol was not found in the DLL or if
an error occured.
\wxheading{Parameters}
\docparam{dllHandle}{Valid handle previously returned by
\helpref{LoadLibrary}{wxdllloaderloadlibrary}}
\docparam{name}{Name of the symbol.}
\membersection{wxDllLoader::LoadLibrary}\label{wxdllloaderloadlibrary}
\func{wxDllType}{LoadLibrary}{\param{const wxString \& }{libname}, \param{bool* }{success = NULL}}
This function loads a shared library into memory, with {\it libname} being the
name of the library: it may be either the full name including path and
(platform-dependent) extenesion, just the basename (no path and no extension)
or a basename with extentsion. In the last two cases, the library will be
searched in all standard locations.
Returns a handle to the loaded DLL. Use {\it success} parameter to test if it
is valid. If the handle is valid, the library must be unloaded later with
\helpref{UnloadLibrary}{wxdllloaderunloadlibrary}.
\wxheading{Parameters}
\docparam{libname}{Name of the shared object to load.}
\docparam{success}{May point to a bool variable which will be set to TRUE or
FALSE; may also be {\tt NULL}.}
\membersection{wxDllLoader::UnloadLibrary}\label{wxdllloaderunloadlibrary}
\func{void}{UnloadLibrary}{\param{wxDllType }{dllhandle}}
This function unloads the shared library. The handle {\it dllhandle} must have
been returned by \helpref{LoadLibrary}{wxdllloaderloadlibrary} previously.

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

@@ -6,7 +6,7 @@
%% Created: 02.11.99
%% RCS-ID: $Id$
%% Copyright: (c) Vadim Zeitlin
%% Licence: wxWindows licence
%% License: wxWindows license
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{\class{wxDataObjectComposite}}\label{wxdataobjectcomposite}

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

@@ -6,7 +6,7 @@
%% Created: 02.11.99
%% RCS-ID: $Id$
%% Copyright: (c) Vadim Zeitlin
%% Licence: wxWindows licence
%% License: wxWindows license
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{\class{wxDataObjectSimple}}\label{wxdataobjectsimple}

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

@@ -336,10 +336,12 @@ framework.
\membersection{wxDocument::SetFilename}
\func{void}{SetFilename}{\param{const wxString\& }{filename}}
\func{void}{SetFilename}{\param{const wxString\& }{filename}, \param{bool}{ notifyViews = FALSE}}
Sets the filename for this document. Usually called by the framework.
If {\it notifyViews} is TRUE, wxView::OnChangeFilename is called for all views.
\membersection{wxDocument::SetTitle}
\func{void}{SetTitle}{\param{const wxString\& }{title}}

60
docs/latex/wx/dragimag.tex
View File

@@ -7,6 +7,9 @@ On Windows, the WIN32 API is used to do achieve smooth dragging. On other platfo
wxGenericDragImage is used. Applications may also prefer to use
wxGenericDragImage on Windows, too.
\pythonnote{wxPython uses wxGenericDragImage on all platforms, but
uses the wxDragImage name.}
To use this class, when you wish to start dragging an image, create a wxDragImage
object and store it somewhere you can access it as the drag progresses.
Call BeginDrag to start, and EndDrag to stop the drag. To move the image,
@@ -19,6 +22,10 @@ either across the whole screen, or just restricted to one area
of the screen to save resources. If you want the user to drag between
two windows, then you will need to use full-screen dragging.
If you wish to draw the image yourself, use wxGenericDragImage and
override \helpref{wxDragImage::DoDrawImage}{wxdragimagedodrawimage} and
\helpref{wxDragImage::GetImageRect}{wxdragimagegetimagerect}.
Please see {\tt samples/dragimag} for an example.
\wxheading{Derived from}
@@ -48,19 +55,34 @@ Constructs a drag image from a bitmap and optional cursor.
Constructs a drag image from an icon and optional cursor.
\pythonnote{This constructor is called wxDragIcon in wxPython.}
\func{}{wxDragImage}{\param{const wxString\& }{text}, \param{const wxCursor\& }{cursor = wxNullCursor},
\param{const wxPoint& }{hotspot = wxPoint(0, 0)}}
Constructs a drag image from a text string and optional cursor.
\pythonnote{This constructor is called wxDragString in wxPython.}
\func{}{wxDragImage}{\param{const wxTreeCtrl\& }{treeCtrl}, \param{wxTreeItemId\& }{id}}
Constructs a drag image from the text in the given tree control item, and optional cursor.
\pythonnote{This constructor is called wxDragTreeItem in wxPython.}
\func{}{wxDragImage}{\param{const wxListCtrl\& }{treeCtrl}, \param{long }{id}}
Constructs a drag image from the text in the given tree control item, and optional cursor.
\pythonnote{This constructor is called wxDragListItem in wxPython.}
\func{}{wxDragImage}{\param{const wxCursor\& }{cursor = wxNullCursor},
\param{const wxPoint& }{hotspot = wxPoint(0, 0)}}
Constructs a drag image an optional cursor. This constructor is only available for
wxGenericDragImage, and can be used when the application
supplies \helpref{wxDragImage::DoDrawImage}{wxdragimagedodrawimage} and \helpref{wxDragImage::GetImageRect}{wxdragimagegetimagerect}.
\wxheading{Parameters}
\docparam{image}{Icon or bitmap to be used as the drag image. The bitmap can
@@ -117,6 +139,16 @@ bounds the dragging operation. Specifying this can make the operation more effic
by cutting down on the area under consideration, and it can also make a visual difference
since the drag is clipped to this area.}
\membersection{wxDragImage::DoDrawImage}\label{wxdragimagedodrawimage}
\func{virtual bool}{DoDrawImage}{\param{wxDC\&}{ dc}, \param{const wxPoint\&}{ pos}}
Draws the image on the device context with top-left corner at the given position.
This function is only available with wxGenericDragImage, to allow applications to
draw their own image instead of using an actual bitmap. If you override this function,
you must also override \helpref{wxDragImage::GetImageRect}{wxdragimagegetimagerect}.
\membersection{wxDragImage::EndDrag}\label{wxdragimageenddrag}
\func{bool}{EndDrag}{\void}
@@ -125,6 +157,16 @@ Call this when the drag has finished.
Note that this call automatically calls ReleaseMouse.
\membersection{wxDragImage::GetImageRect}\label{wxdragimagegetimagerect}
\constfunc{virtual wxRect}{GetImageRect}{\param{const wxPoint\&}{ pos}}
Returns the rectangle enclosing the image, assuming that the image is drawn with its
top-left corner at the given point.
This function is available in wxGenericDragImage only, and may be overridden (together with
\helpref{wxDragImage::DoDrawImage}{wxdragimagedodrawimage}) to provide a virtual drawing capability.
\membersection{wxDragImage::Hide}\label{wxdragimagehide}
\func{bool}{Hide}{\void}
@@ -153,3 +195,21 @@ will be smoother if you move the image when it is shown.
Shows the image. Call this at least once when dragging.
\membersection{wxDragImage::UpdateBackingFromWindow}\label{wxdragimageupdatebackingfromwindow}
\constfunc{bool}{UpdateBackingFromWindow}{\param{wxDC\&}{ windowDC}, \param{wxMemoryDC\&}{ destDC},
\param{const wxRect\&}{ sourceRect}, \param{const wxRect\&}{ destRect}}
Override this if you wish to draw the window contents to the backing bitmap
yourself. This can be desirable if you wish to avoid flicker by not having to
redraw the updated window itself just before dragging, which can cause a flicker just
as the drag starts. Instead, paint the drag image's backing bitmap to show the appropriate
graphic {\it minus the objects to be dragged}, and leave the window itself to be updated
by the drag image. This can provide eerily smooth, flicker-free drag behaviour.
The default implementation copies the window contents to the backing bitmap. A new
implementation will normally copy information from another source, such as from its
own backing bitmap if it has one, or directly from internal data structures.
This function is available in wxGenericDragImage only.

29
docs/latex/wx/dropsrc.tex
View File

@@ -2,7 +2,7 @@
This class represents a source for a drag and drop operation.
See \helpref{Drag'n'Drop overview}{wxdndoverview} and \helpref{wxDataObject overview}{wxdataobjectoverview}
See \helpref{Drag and drop overview}{wxdndoverview} and \helpref{wxDataObject overview}{wxdataobjectoverview}
for more information.
\wxheading{Derived from}
@@ -37,12 +37,31 @@ enum wxDragResult
\membersection{wxDropSource::wxDropSource}\label{wxdropsourcewxdropsource}
\func{}{wxDropSource}{\param{wxWindow*}{ win = NULL}}
\func{}{wxDropSource}{\param{wxWindow*}{ win = NULL},\param{const wxIconOrCursor\& }{iconCopy = wxNullIconOrCursor}, \param{const wxIconOrCursor\& }{iconCopy = wxNullIconOrCursor}, \param{const wxIconOrCursor\& }{iconNone = wxNullIconOrCursor}}
Default/wxGTK-specific constructor. If you use the default constructor you must
call \helpref{SetData}{wxdropsourcesetdata} later.
\func{}{wxDropSource}{\param{wxDataObject\&}{ data}, \param{wxWindow*}{ win = NULL},\param{const wxIconOrCursor\& }{iconCopy = wxNullIconOrCursor}, \param{const wxIconOrCursor\& }{iconCopy = wxNullIconOrCursor}, \param{const wxIconOrCursor\& }{iconNone = wxNullIconOrCursor}}
Note that {\it win} is required by the GTK port and therefore should always be set.
The constructors for wxDataObject.
If you use the constructor without {\it data} parameter you must call
\helpref{SetData}{wxdropsourcesetdata} later.
Note that the exact type of {\it iconCopy} and subsequent parameters differs
between wxMSW and wxGTK: these are cursors under Windows but icons for GTK.
You should use the macro \helpref{wxDROP\_ICON}{wxdropicon} in portable
programs instead of directly using either of these types.
\wxheading{Parameters}
\docparam{win}{The window which initiates the drag and drop operation.}
\docparam{iconCopy}{The icon or cursor used for feedback for copy operation.}
\docparam{iconMove}{The icon or cursor used for feedback for move operation.}
\docparam{iconNone}{The icon or cursor used for feedback when operation can't be done.}
{\it win} is the window which initiates the drag and drop operation.
\membersection{wxDropSource::\destruct{wxDropSource}}\label{wxdropsourcedtor}

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

@@ -11,7 +11,7 @@ the whole window area, but only a small portion of it. The normal sequence of ca
\helpref{OnEnter}{wxdroptargetonenter}, possibly many times \helpref{OnDragOver}{wxdroptargetondragover},
\helpref{OnDrop}{wxdroptargetondrop} and finally \helpref{OnData}{wxdroptargetondata}.
See \helpref{Drag'n'Drop overview}{wxdndoverview} and \helpref{wxDataObject overview}{wxdataobjectoverview}
See \helpref{Drag and drop overview}{wxdndoverview} and \helpref{wxDataObject overview}{wxdataobjectoverview}
for more information.
\wxheading{Derived from}

31
docs/latex/wx/encconv.tex
View File

@@ -7,7 +7,7 @@
This class is capable of converting strings between any two
8-bit encodings/charsets. It can also convert from/to Unicode (but only
if you compiled wxWindows with wxUSE\_UNICODE set to 1).
if you compiled wxWindows with wxUSE\_WCHAR\_T set to 1).
\wxheading{Derived from}
@@ -20,6 +20,7 @@ if you compiled wxWindows with wxUSE\_UNICODE set to 1).
\wxheading{See also}
\helpref{wxFontMapper}{wxfontmapper},
\helpref{wxMBConv}{wxmbconv},
\helpref{Writing non-English applications}{nonenglishoverview}
@@ -48,14 +49,14 @@ cannot be converted because it does not exist in output encoding:
\begin{twocollist}\itemsep=0pt
\twocolitem{{\bf wxCONVERT\_STRICT}}{follow behaviour of GNU Recode -
just copy unconvertable characters to output and don't change them
just copy unconvertible characters to output and don't change them
(its integer value will stay the same)}
\twocolitem{{\bf wxCONVERT\_SUBSTITUTE}}{try some (lossy) substitutions
- e.g. replace unconvertable latin capitals with acute by ordinary
- e.g. replace unconvertible latin capitals with acute by ordinary
capitals, replace en-dash or em-dash by '-' etc.}
\end{twocollist}
Both modes gurantee that output string will have same length
Both modes guarantee that output string will have same length
as input string.
\wxheading{Return value}
@@ -107,10 +108,10 @@ unix CP1252 {ISO8859_1,ISO8859_15}
\end{verbatim}
Equivalence is defined in terms of convertibility:
2 encodings are equivalent if you can convert text between
then without loosing information (it may - and will - happen
that you loose special chars like quotation marks or em-dashes
but you shouldn't loose any diacritics and language-specific
two encodings are equivalent if you can convert text between
then without losing information (it may - and will - happen
that you lose special chars like quotation marks or em-dashes
but you shouldn't lose any diacritics and language-specific
characters when converting between equivalent encodings).
Remember that this function does {\bf NOT} check for presence of
@@ -121,14 +122,14 @@ encodings. (It usually returns only one encoding.)
\begin{itemize}\itemsep=0pt
\item Note that argument {\it enc} itself may be present in the returned array,
so that you can - as a side effect - detect whether the
so that you can, as a side-effect, detect whether the
encoding is native for this platform or not.
\item helpref{Convert}{wxencodingconverterconvert} is not limited to
converting between equivalent encodings, it can convert between arbitrary
two encodings.
\item If {\it enc} is present in returned array, then it is {\bf always} first
\item \helpref{Convert}{wxencodingconverterconvert} is not limited to
converting between equivalent encodings, it can convert between two arbitrary
encodings.
\item If {\it enc} is present in the returned array, then it is {\bf always} the first
item of it.
\item Please note that the returned array may not contain any items at all.
\item Please note that the returned array may contain no items at all.
\end{itemize}
\membersection{wxEncodingConverter::GetAllEquivalents}\label{wxencodingconvertergetallequivalents}
@@ -138,7 +139,7 @@ item of it.
Similar to
\helpref{GetPlatformEquivalents}{wxencodingconvertergetplatformequivalents},
but this one will return ALL
equivalent encodings, regardless the platform, and including itself.
equivalent encodings, regardless of the platform, and including itself.
This platform's encodings are before others in the array. And again, if {\it enc} is in the array,
it is the very first item in it.

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

@@ -63,13 +63,6 @@ Set to TRUE by {\bf Skip} if this event should be skipped.
Timestamp for this event.
\membersection{wxEvent::GetEventClass}
\func{WXTYPE}{GetEventClass}{\void}
Returns the identifier of the given event class,
such as wxTYPE\_MOUSE\_EVENT.
\membersection{wxEvent::GetEventObject}
\func{wxObject*}{GetEventObject}{\void}

23
docs/latex/wx/file.tex
View File

@@ -5,6 +5,8 @@ minimize the overhead of using it - in fact, there is hardly any overhead at
all, but using it brings you automatic error checking and hides differences
between platforms and compilers. wxFile also automatically closes the file in
its destructor making it unnecessary to worry about forgetting to do it.
wxFile is a wrapper around {\tt file descriptor.} - see also
\helpref{wxFFile}{wxffile} for a wrapper around {\tt FILE} structure.
\wxheading{Derived from}
@@ -39,7 +41,7 @@ These constants define the file access rights and are used with
\helpref{wxFile::Create}{wxfilecreate} and \helpref{wxFile::Open}{wxfileopen}.
The {\it OpenMode} enumeration defines the different modes for opening a file,
it's defined inside wxFile class so its members should be specified with {\it wxFile::} scope
it is defined inside wxFile class so its members should be specified with {\it wxFile::} scope
resolution prefix. It is also used with \helpref{wxFile::Access}{wxfileaccess} function.
\twocolwidtha{7cm}
@@ -50,7 +52,8 @@ or test if it can be opened for writing with Access()}
\twocolitem{{\bf wxFile::read\_write}}{Open file for reading and writing; can not be used with Access()}
\twocolitem{{\bf wxFile::write\_append}}{Open file for appending: the file is opened for writing, but the old
contents of the file is not erased and the file pointer is initially placed at the end of the file;
can not be used with Access()}
can not be used with Access(). This is the same as {\bf wxFile::write} if the
file doesn't exist.}
\end{twocollist}
Other constants defined elsewhere but used by wxFile functions are wxInvalidOffset which represents an
@@ -158,7 +161,10 @@ in the file.
Note also that this function doesn't work on unseekable file descriptors
(examples include pipes, terminals and sockets under Unix) and an attempt to
use it will result in an error message in such case.
use it will result in an error message in such case. So, to read the entire
file into memory, you should write a loop which uses
\helpref{Read}{wxfileread} repeatedly and tests its return condition instead
of using Eof() as this will not work for special files under Unix.
\membersection{wxFile::Exists}\label{wxfileexists}
@@ -252,11 +258,11 @@ The actual offset position achieved, or wxInvalidOffset on failure.
\constfunc{off\_t}{Tell}{\void}
Returns the current position or wxInvalidOffset if file is not opened or if another
error occured.
error occurred.
\membersection{wxFile::Write}\label{wxfilewrite}
\func{bool}{Write}{\param{const void*}{ buffer}, \param{off\_t}{ count}}
\func{size\_t}{Write}{\param{const void*}{ buffer}, \param{off\_t}{ count}}
Writes the specified number of bytes from a buffer.
@@ -268,7 +274,7 @@ Writes the specified number of bytes from a buffer.
\wxheading{Return value}
TRUE if the operation was successful.
the number of bytes actually written
\membersection{wxFile::Write}\label{wxfilewrites}
@@ -278,10 +284,11 @@ Writes the contents of the string to the file, returns TRUE on success.
\section{\class{wxFFile}}\label{wxffile}
A wxFFile performs raw file I/O. This is a very small class designed to
wxFFile implements buffered file I/O. This is a very small class designed to
minimize the overhead of using it - in fact, there is hardly any overhead at
all, but using it brings you automatic error checking and hides differences
between platforms and compilers.
between platforms and compilers. It wraps inside it a {\tt FILE *} handle used
by standard C IO library (also known as {\tt stdio}).
\wxheading{Derived from}

8
docs/latex/wx/filedlg.tex
View File

@@ -58,7 +58,7 @@ Constructor. Use \helpref{wxFileDialog::ShowModal}{wxfiledialogshowmodal} to sho
\docparam{defaultFile}{The default filename, or the empty string.}
\docparam{wildcard}{A wildcard, such as ``*.*".}
\docparam{wildcard}{A wildcard, such as ``*.*" or ``BMP files (*.bmp)|*.bmp|GIF files (*.gif)|*.gif".}
\docparam{style}{A dialog style. A bitlist of:
@@ -180,13 +180,15 @@ Sets the dialog style. See \helpref{wxFileDialog::wxFileDialog}{wxfiledialogcons
\func{void}{SetWildcard}{\param{const wxString\& }{wildCard}}
Sets the wildcard, which in Windows can contain multiple file types.
Sets the wildcard, which can contain multiple file types, for example:
``BMP files (*.bmp)|*.bmp|GIF files (*.gif)|*.gif"
\membersection{wxFileDialog::ShowModal}\label{wxfiledialogshowmodal}
\func{int}{ShowModal}{\void}
Shows the dialog, returning wxID\_OK if the user pressed OK, and wxOK\_CANCEL
Shows the dialog, returning wxID\_OK if the user pressed OK, and wxID\_CANCEL
otherwise.

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

@@ -13,7 +13,7 @@ will be returned if the corresponding information couldn't be found.
The objects of this class are never created by the application code but are
returned by \helpref{wxMimeTypesManager::GetFileTypeFromMimeType}{wxmimetypesmanagergetfiletypefrommimetype} and
\helpref{wxMimeTypesManager::GetFileTypeFromExtension}{wxmimetypesmanagergetfiletypefromextension} methods.
But it's your responsibility to delete the returned pointer when you're done
But it is your responsibility to delete the returned pointer when you're done
with it!
% TODO describe MIME types better than this...

24
docs/latex/wx/flexsizr.tex Normal file
View File

@@ -0,0 +1,24 @@
\section{\class{wxFlexGridSizer}}\label{wxflexgridsizer}
A flex grid sizer is a sizer which lays out its children in a two-dimensional
table with all table fields in one row having the same
height and all fields in one column having the same width.
\wxheading{Derived from}
\helpref{wxGridSizer}{wxsizer}\\
\helpref{wxSizer}{wxsizer}\\
\helpref{wxObject}{wxobject}
\membersection{wxFlexGridSizer::wxFlexGridSizer}\label{wxflexgridsizerwxflexgridsizer}
\func{}{wxFlexGridSizer}{\param{int }{rows}, \param{int }{cols}, \param{int }{vgap}, \param{int }{hgap}}
\func{}{wxFlexGridSizer}{\param{int }{cols}, \param{int }{vgap = 0}, \param{int }{hgap = 0}}
Constructor for a wxGridSizer. {\it rows} and {\it cols} determine the number of
columns and rows in the sizer - if either of the parameters is zero, it will be
calculated to form the total number of children in the sizer, thus making the
sizer grow dynamically. {\it vgap} and {\it hgap} define extra space between
all children.

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

@@ -6,7 +6,7 @@
%% Created: 03.11.99
%% RCS-ID: $Id$
%% Copyright: (c) Vadim Zeitlin
%% Licence: wxWindows licence
%% License: wxWindows license
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{\class{wxFontEnumerator}}\label{wxfontenumerator}

BIN
docs/latex/wx/forward.gif
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 164 B

After

Width:  |  Height:  |  Size: 959 B

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

@@ -24,25 +24,29 @@ application windows.
\twocolwidtha{5cm}
\begin{twocollist}\itemsep=0pt
\twocolitem{\windowstyle{wxDEFAULT\_FRAME\_STYLE}}{Defined as {\bf wxMINIMIZE\_BOX \pipe wxMAXIMIZE\_BOX \pipe wxRESIZE\_BOX \pipe wxSYSTEM\_MENU \pipe wxCAPTION}.}
\twocolitem{\windowstyle{wxICONIZE}}{Display the frame iconized (minimized). Windows only. }
\twocolitem{\windowstyle{wxCAPTION}}{Puts a caption on the frame.}
\twocolitem{\windowstyle{wxDEFAULT\_FRAME\_STYLE}}{Defined as {\bf wxMINIMIZE\_BOX \pipe wxMAXIMIZE\_BOX \pipe wxTHICK\_FRAME \pipe wxSYSTEM\_MENU \pipe wxCAPTION}.}
\twocolitem{\windowstyle{wxMINIMIZE}}{Identical to {\bf wxICONIZE}. Windows only. }
\twocolitem{\windowstyle{wxMINIMIZE\_BOX}}{Displays a minimize box on the frame. }
\twocolitem{\windowstyle{wxMAXIMIZE}}{Displays the frame maximized. Windows only. }
\twocolitem{\windowstyle{wxMAXIMIZE\_BOX}}{Displays a maximize box on the frame. }
\twocolitem{\windowstyle{wxSTAY\_ON\_TOP}}{Stay on top of other windows. Windows only. }
\twocolitem{\windowstyle{wxSYSTEM\_MENU}}{Displays a system menu. }
\twocolitem{\windowstyle{wxTHICK\_FRAME}}{Displays a thick frame around the window. Windows and Motif only.}
\twocolitem{\windowstyle{wxSIMPLE\_BORDER}}{Displays no border or decorations. GTK and Windows only (?). }
\twocolitem{\windowstyle{wxMINIMIZE}}{Identical to {\bf wxICONIZE}. Windows only.}
\twocolitem{\windowstyle{wxMINIMIZE\_BOX}}{Displays a minimize box on the frame.}
\twocolitem{\windowstyle{wxMAXIMIZE}}{Displays the frame maximized. Windows only.}
\twocolitem{\windowstyle{wxMAXIMIZE\_BOX}}{Displays a maximize box on the frame.}
\twocolitem{\windowstyle{wxSTAY\_ON\_TOP}}{Stay on top of other windows. Windows only.}
\twocolitem{\windowstyle{wxSYSTEM\_MENU}}{Displays a system menu.}
\twocolitem{\windowstyle{wxSIMPLE\_BORDER}}{Displays no border or decorations. GTK and Windows only.}
\twocolitem{\windowstyle{wxRESIZE\_BORDER}}{Displays a resizeable border around the window (Unix only).}
\twocolitem{\windowstyle{wxFRAME\_FLOAT\_ON\_PARENT}}{Causes the frame to be above the parent window in the
z-order and not shown in the taskbar. Without this style, frames are created as top-level windows that may be obscured by
the parent window, and frame titles are shown in the taskbar. Windows and GTK. }
the parent window, and frame titles are shown in the taskbar. Windows and GTK.}
\twocolitem{\windowstyle{wxFRAME\_TOOL\_WINDOW}}{Causes a frame with a small titlebar to be created;
the frame title does not appear in the taskbar. Windows only. }
the frame title does not appear in the taskbar. Windows only.}
\end{twocollist}
The default frame style is for normal, resizeable frames. To create a frame
which can not be resized by user, you may use the following combination of
styles: {\tt wxDEFAULT\_FRAME\_STYLE \& \~ (wxRESIZE\_BORDER \pipe wxRESIZE\_BOX \pipe wxMAXIMIZE\_BOX)}.
% Note: the space after the tilde is necessary or Tex2RTF complains.
See also \helpref{window styles overview}{windowstyles}.
\wxheading{Remarks}

53
docs/latex/wx/fs.tex
View File

@@ -2,36 +2,37 @@
The wxHTML library uses a {\bf virtual file systems} mechanism
similar to the one used in Midnight Commander, Dos Navigator,
FAR or almost any modern file manager. (Do you remember? You can
press enter on ZIP file and its contents is displayed as if it
were a local directory...)
FAR or almost any modern file manager. It allows the user to access
data stored in archives as if they were ordinary files. On-the-fly
generated files that exist only in memory are also supported.
\wxheading{Classes}
Three classes are used in order to provide full VFS:
Three classes are used in order to provide virtual file systems mechanism:
\begin{itemize}\itemsep=0pt
\item The \helpref{wxFSFile}{wxfsfile} class provides information
on opened file (name, input stream, mime type and anchor).
about opened file (name, input stream, mime type and anchor).
\item The \helpref{wxFileSystem}{wxfilesystem} class is the interface.
Its main methods are ChangePathTo() and OpenFile(). This class
is most often used by the end user.
\item The \helpref{wxFileSystemHandler}{wxfilesystemhandler} is the core
if VFS mechanism. You can derive your own handler and pass it to
of virtual file systems mechanism. You can derive your own handler and pass it to
of the VFS mechanism. You can derive your own handler and pass it to
wxFileSystem's AddHandler() method. In the new handler you only need to
overwrite OpenFile() and CanOpen() methods.
override the OpenFile() and CanOpen() methods.
\end{itemize}
\wxheading{Locations}
Locations (aka filenames aka addresses) are constructed from 4 parts:
Locations (aka filenames aka addresses) are constructed from four parts:
\begin{itemize}\itemsep=0pt
\item {\bf protocol} - handler can recognize if it is able to open a
file by checking its protocol. Examples are "http", "file" or "ftp".
\item {\bf right location} - is the name of file within the protocol.
In "http://www.wxwindows.org/index.html" the right location is "//www.wxwindows.org/index.html".
\item {\bf anchor} - anchor is optional and is usually not present.
\item {\bf anchor} - an anchor is optional and is usually not present.
In "index.htm\#chapter2" the anchor is "chapter2".
\item {\bf left location} - this is usually an empty string.
It is used by 'local' protocols such as ZIP.
@@ -40,33 +41,26 @@ See Combined Protocols paragraph for details.
\wxheading{Combined Protocols}
Left location pretends protocol in URL string.
It's not used by global protocols like HTTP but it's used
by local ones - for example you can see this address:
The left location precedes the protocol in the URL string.
It is not used by global protocols like HTTP but it becomes handy when nesting
protocols - for example you may want to access files in a ZIP archive:
file:archives/cpp\_doc.zip\#zip:reference/fopen.htm\#syntax
In this example, protocol is "zip", left location is
"reference/fopen.htm", anchor is "syntax" and right location
is "file:archives/cpp\_doc.zip". It is used by zip handler
to determine in what file this particular zip VFS is stored.
In this example, the protocol is "zip", the left location is
"reference/fopen.htm", the anchor is "syntax" and the right location
is "file:archives/cpp\_doc.zip".
In fact there are two protocols used in this example: zip and file.
You can construct even more complicated addresses like this one:
http://www.archives.org/myarchive.zip\#zip:local/docs/cpp/stdio.zip\#zip:index.htm
In this example you access zip VFS stdio.zip stored in another zip (myarchive.zip)
which is at WWW.
There are {\bf two} protocols used in this example: "zip" and "file".
\wxheading{File Systems Included in wxHTML}
Following VFS handlers are part of wxWindows so far:
The following virtual file system handlers are part of wxWindows so far:
\begin{twocollist}
\twocolitem{{\bf wxInternetFSHandler}}{Handler for accessing documents
\twocolitem{{\bf wxInternetFSHandler}}{A handler for accessing documents
via HTTP or FTP protocols. Include file is <wx/fs_inet.h>.}
\twocolitem{{\bf wxZipFSHandler}}{Handler for ZIP archives.
\twocolitem{{\bf wxZipFSHandler}}{A handler for ZIP archives.
Include file is <wx/fs_zip.h>. URL is in form "archive.zip\#zip:filename".}
\twocolitem{{\bf wxMemoryFSHandler}}{This handler allows you to access
data stored in memory (such as bitmaps) as if they were regular files.
@@ -75,9 +69,11 @@ Include file is <wx/fs_mem.h>. UURL is prefixed with memory:, e.g.
"memory:myfile.htm"}
\end{twocollist}
In addition, wxFileSystem can access local files.
In addition, wxFileSystem itself can access local files.
\wxheading{Initializing file system handlers}
Use \helpref{wxFileSystem::AddHandler}{wxfilesystemaddhandler} to initialize
a handler, for example:
@@ -90,7 +86,6 @@ bool MyApp::OnInit()
{
wxFileSystem::AddHandler(new wxMemoryFSHandler);
...
}
\end{verbatim}

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

@@ -87,6 +87,8 @@ data (bitmap, text or raw data)
will be copied into private memory stream and available under
name "memory:" + filename.
Note that when storing image/bitmap, you must use image format that wxWindows
can write (e.g. JPG, PNG, see \helpref{wxImage documentation}{wximage})!
\membersection{wxMemoryFSHandler::RemoveFile}\label{wxmemoryfshandlerremovefile}

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

@@ -12,7 +12,7 @@ It provides more information than wxWindow's input stream
{\bf Note:} Any pointer returned by wxFSFile's member is valid
only as long as wxFSFile object exists. For example a call to GetStream()
doesn't {\it create} the stream but only returns the pointer to it. In
other words after 10 calls to GetStream() you'll obtain ten identical
other words after 10 calls to GetStream() you will obtain ten identical
pointers.
\wxheading{Derived from}
@@ -52,7 +52,7 @@ functions.
\wxheading{Notes}
It is seldom used by the application programmer but you'll need it if
It is seldom used by the application programmer but you will need it if
you are writing your own virtual FS. For example you may need something
similar to wxMemoryInputStream, but because wxMemoryInputStream
doesn't free the memory when destroyed and thus passing a memory stream

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

@@ -181,7 +181,7 @@ You will be notified when the EOF is reached by an error.
\wxheading{Return value}
Returns NULL if an error occured (it could be a network failure or the fact
Returns NULL if an error occurred (it could be a network failure or the fact
that the file doesn't exist).
Returns the initialized stream. You will have to delete it yourself when you

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

@@ -2,7 +2,51 @@
\setheader{{\it CHAPTER \thechapter}}{}{}{}{}{{\it CHAPTER \thechapter}}%
\setfooter{\thepage}{}{}{}{}{\thepage}
The functions defined in wxWindows are described here.
The functions and macros defined in wxWindows are described here.
\section{Version macros}\label{versionfunctions}
The following constants are defined in wxWindows:
\begin{itemize}\itemsep=0pt
\item {\tt wxMAJOR\_VERSION} is the major version of wxWindows
\item {\tt wxMINOR\_VERSION} is the minor version of wxWindows
\item {\tt wxRELASE\_NUMBER} is the release number
\end{itemize}
For example, the values or these constants for wxWindows 2.1.15 are 2, 1 and
15.
Additionally, {\tt wxVERSION\_STRING} is a user-readable string containing
the full wxWindows version and {\tt wxVERSION\_NUMBER} is a combination of the
three version numbers above: for 2.1.15, it is 2115 and it is 2200 for
wxWindows 2.2.
\wxheading{Include files}
<wx/version.h> or <wx/defs.h>
\membersection{wxCHECK\_VERSION}\label{wxcheckversion}
\func{bool}{wxCHECK\_VERSION}{\param{}{major, minor, release}}
This is a macro which evaluates to true if the current wxWindows version is at
least major.minor.release.
For example, to test if the program is compiled with wxWindows 2.2 or higher,
the following can be done:
\begin{verbatim}
wxString s;
#if wxCHECK_VERSION(2, 2, 0)
if ( s.StartsWith("foo") )
#else // replacement code for old version
if ( strncmp(s, "foo", 3) == 0 )
#endif
{
...
}
\end{verbatim}
\section{Thread functions}\label{threadfunctions}
@@ -21,8 +65,8 @@ The functions defined in wxWindows are described here.
This function must be called when any thread other than the main GUI thread
wants to get access to the GUI library. This function will block the execution
of the calling thread until the main thread (or any other thread holding the
main GUI lock) leaves the GUI library and no other other thread will enter
the GUI library until the calling thread calls \helpref{::wxMutexGuiLeave()}{wxmutexguileave}.
main GUI lock) leaves the GUI library and no other thread will enter the GUI
library until the calling thread calls \helpref{::wxMutexGuiLeave()}{wxmutexguileave}.
Typically, these functions are used like this:
@@ -45,7 +89,7 @@ Note that under GTK, no creation of top-level windows is allowed in any
thread but the main one.
This function is only defined on platforms which support preemptive
threads.
threads.
\membersection{::wxMutexGuiLeave}\label{wxmutexguileave}
@@ -86,7 +130,7 @@ slashes.
Returns TRUE if the file exists. It also returns TRUE if the file is
a directory.
\membersection{::wxFileModificationTime}
\membersection{::wxFileModificationTime}\label{wxfilemodificationtime}
\func{time\_t}{wxFileModificationTime}{\param{const wxString\& }{filename}}
@@ -270,7 +314,7 @@ wxSplitPath() will correctly handle filenames with both DOS and Unix path separa
Windows, however it will not consider backslashes as path separators under Unix (where backslash
is a valid character in a filename).
On entry, {\it fullname} should be non NULL (it may be empty though).
On entry, {\it fullname} should be non-NULL (it may be empty though).
On return, {\it path} contains the file path (without the trailing separator), {\it name}
contains the file name and {\it ext} contains the file extension without leading dot. All
@@ -632,7 +676,7 @@ to be used for entering passwords as the function name implies.
\param{const wxString\& }{default\_value = ``"}, \param{wxWindow *}{parent = NULL},\\
\param{int}{ x = -1}, \param{int}{ y = -1}, \param{bool}{ centre = TRUE}}
Pop up a dialog box with title set to {\it caption}, message {\it message}, and a
Pop up a dialog box with title set to {\it caption}, {\it message}, and a
\rtfsp{\it default\_value}. The user may type in text and press OK to return this text,
or press Cancel to return the empty string.
@@ -730,7 +774,8 @@ wxYES\_NO or wxOK.}
\twocolitem{wxOK}{Puts an Ok button on the message box. May be combined with wxCANCEL.}
\twocolitem{wxCENTRE}{Centres the text.}
\twocolitem{wxICON\_EXCLAMATION}{Displays an exclamation mark symbol.}
\twocolitem{wxICON\_HAND}{Displays a hand symbol.}
\twocolitem{wxICON\_HAND}{Displays an error symbol.}
\twocolitem{wxICON\_ERROR}{Displays an error symbol - the same as wxICON\_HAND.}
\twocolitem{wxICON\_QUESTION}{Displays a question mark symbol.}
\twocolitem{wxICON\_INFORMATION}{Displays an information symbol.}
\end{twocollist}
@@ -1056,6 +1101,21 @@ The clipboard must have previously been opened for this call to succeed.
\section{Miscellaneous functions}\label{miscellany}
\membersection{::wxDROP\_ICON}\label{wxdropicon}
\func{wxIconOrCursor}{wxDROP\_ICON}{\param{const char *}{name}}
This macro creates either a cursor (MSW) or an icon (elsewhere) with the given
name. Under MSW, the cursor is loaded from the resource file and the icon is
loaded from XPM file under other platforms.
This macro should be used with
\helpref{wxDropSource constructor}{wxdropsourcewxdropsource}.
\wxheading{Include files}
<wx/dnd.h>
\membersection{::wxNewId}
\func{long}{wxNewId}{\void}
@@ -1260,6 +1320,8 @@ wxWindows errors. See also \helpref{wxFatalError}{wxfatalerror}.
\func{long}{wxExecute}{\param{const wxString\& }{command}, \param{wxArrayString\& }{output}}
\func{long}{wxExecute}{\param{const wxString\& }{command}, \param{wxArrayString\& }{output}, \param{wxArrayString\& }{errors}}
Executes another program in Unix or Windows.
The first form takes a command string, such as {\tt "emacs file.txt"}.
@@ -1267,8 +1329,8 @@ The first form takes a command string, such as {\tt "emacs file.txt"}.
The second form takes an array of values: a command, any number of
arguments, terminated by NULL.
The semantics of the third version is different from the first two and is
described in more details below.
The semantics of the third and fourth versions is different from the first two
and is described in more details below.
If {\it sync} is FALSE (the default), flow of control immediately returns.
If TRUE, the current application waits until the other program has terminated.
@@ -1282,16 +1344,22 @@ should ensure that this can cause no recursion, in the simplest case by
calling \helpref{wxEnableTopLevelWindows(FALSE)}{wxenabletoplevelwindows}.
For asynchronous execution, however, the return value is the process id and
zero value indicates that the command could not be executed.
zero value indicates that the command could not be executed. As an added
complication, the return value of $-1$ in this case indicattes that we didn't
launch a new process, but connected to the running one (this can only happen in
case of using DDE under Windows for command execution). In particular, in this,
and only this, case the calling code will not get the notification about
process termination.
If callback isn't NULL and if execution is asynchronous (note that callback
parameter can not be non NULL for synchronous execution),
parameter can not be non-NULL for synchronous execution),
\helpref{wxProcess::OnTerminate}{wxprocessonterminate} will be called when
the process finishes.
Finally, you may use the third overloaded version of this function to execute
a process (always synchronously) and capture its output in the array
{\it output}.
{\it output}. The fourth version adds the possibility to additionally capture
the messages from standard error output in the {\it errors} array.
See also \helpref{wxShell}{wxshell}, \helpref{wxProcess}{wxprocess},
\helpref{Exec sample}{sampleexec}.
@@ -1397,21 +1465,6 @@ Return the (current) user's home directory.
<wx/utils.h>
\membersection{::wxGetElapsedTime}\label{wxgetelapsedtime}
\func{long}{wxGetElapsedTime}{\param{bool}{ resetTimer = TRUE}}
Gets the time in milliseconds since the last \helpref{::wxStartTimer}{wxstarttimer}.
If {\it resetTimer} is TRUE (the default), the timer is reset to zero
by this call.
See also \helpref{wxTimer}{wxtimer}.
\wxheading{Include files}
<wx/timer.h>
\membersection{::wxGetFreeMemory}\label{wxgetfreememory}
\func{long}{wxGetFreeMemory}{\void}
@@ -1439,7 +1492,7 @@ Returns the mouse position in screen coordinates.
\func{wxString}{wxGetOsDescription}{\void}
Returns the string containing the description of the current platform in a
user-readable form. For example, this function may return strings like
user-readable form. For example, this function may return strings like
{\tt Windows NT Version 4.0} or {\tt Linux 2.2.2 i386}.
\wxheading{See also}
@@ -1457,7 +1510,7 @@ user-readable form. For example, this function may return strings like
Gets operating system version information.
\begin{twocollist}\itemsep=0pt
\twocolitemruled{Platform}{Return tyes}
\twocolitemruled{Platform}{Return types}
\twocolitem{Macintosh}{Return value is wxMACINTOSH.}
\twocolitem{GTK}{Return value is wxGTK, For GTK 1.0, {\it major} is 1, {\it minor} is 0. }
\twocolitem{Motif}{Return value is wxMOTIF\_X, {\it major} is X version, {\it minor} is X revision.}
@@ -1741,18 +1794,6 @@ as a keyboard shortkey in Windows and Motif) and $\backslash$t (tab in Windows).
<wx/utils.h>
\membersection{::wxStartTimer}\label{wxstarttimer}
\func{void}{wxStartTimer}{\void}
Starts a stopwatch; use \helpref{::wxGetElapsedTime}{wxgetelapsedtime} to get the elapsed time.
See also \helpref{wxTimer}{wxtimer}.
\wxheading{Include files}
<wx/timer.h>
\membersection{::wxToLower}\label{wxtolower}
\func{char}{wxToLower}{\param{char }{ch}}
@@ -1862,7 +1903,7 @@ function.
Note that wxYield will not flush the message logs. This is intentional as
calling wxYield is usually done to quickly update the screen and popping up a
message box dialog may be undesirable. If you do with to flush the log
message box dialog may be undesirable. If you do wish to flush the log
messages immediately (otherwise it will be done during the next idle loop
iteration), call \helpref{wxLog::FlushActive}{wxlogflushactive}.
@@ -1876,7 +1917,7 @@ iteration), call \helpref{wxLog::FlushActive}{wxlogflushactive}.
This functions wakes up the (internal and platform dependent) idle system, i.e. it
will force the system to send an idle event even if the system currently {\it is}
idle and thus would not send any idle event until after some other event would get
idle and thus would not send any idle event until after some other event would get
sent. This is also useful for sending events between two threads and is used by
the corresponding functions \helpref{::wxPostEvent}{wxpostevent} and
\helpref{wxEvtHandler::AddPendingEvent}{wxevthandleraddpendingevent}.
@@ -2008,7 +2049,7 @@ dynamically. The same as DECLARE\_ABSTRACT\_CLASS.
\func{}{DECLARE\_DYNAMIC\_CLASS}{className}
Used inside a class declaration to declare that the objects of this class should be dynamically
createable from run-time type information.
creatable from run-time type information.
Example:
@@ -2162,6 +2203,18 @@ avoid using {\tt \#ifdef}s when creating bitmaps.
<wx/gdicmn.h>
\membersection{wxConstCast}\label{wxconstcast}
\func{}{wxConstCast}{ptr, classname}
This macro expands into {\tt const\_cast<classname *>(ptr)} if the compiler
supports {\it const\_cast} or into an old, C-style cast, otherwise.
\wxheading{See also}
\helpref{wxDynamicCast}{wxdynamiccast}\\
\helpref{wxStaticCast}{wxstaticcast}
\membersection{WXDEBUG\_NEW}\label{debugnew}
\func{}{WXDEBUG\_NEW}{arg}
@@ -2185,7 +2238,7 @@ In non-debug mode, this is defined as the normal new operator.
This macro returns the pointer {\it ptr} cast to the type {\it classname *} if
the pointer is of this type (the check is done during the run-time) or NULL
otherwise. Usage of this macro is prefered over obsoleted wxObject::IsKindOf()
otherwise. Usage of this macro is preferred over obsoleted wxObject::IsKindOf()
function.
The {\it ptr} argument may be NULL, in which case NULL will be returned.
@@ -2201,13 +2254,15 @@ Example:
}
else
{
// no window has the focus or it's not a text control
// no window has the focus or it is not a text control
}
\end{verbatim}
\wxheading{See also}
\helpref{RTTI overview}{runtimeclassoverview}
\helpref{RTTI overview}{runtimeclassoverview}\\
\helpref{wxConstCast}{wxconstcast}\\
\helpref{wxStatiicCast}{wxstaticcast}
\membersection{wxICON}\label{wxiconmacro}
@@ -2226,6 +2281,17 @@ avoid using {\tt \#ifdef}s when creating icons.
<wx/gdicmn.h>
\membersection{wxStaticCast}\label{wxstaticcast}
\func{}{wxStaticCast}{ptr, classname}
This macro checks that the cast is valid in debug mode (an assert failure will
result if {\tt wxDynamicCast(ptr, classname) == NULL}) and then returns the
result of executing an equivalent of {\tt static\_cast<classname *>(ptr)}.
\helpref{wxDynamicCast}{wxdynamiccast}\\
\helpref{wxConstCast}{wxconstcast}
\membersection{WXTRACE}\label{trace}
\wxheading{Include files}
@@ -2268,15 +2334,13 @@ files and loading user interface elements from resources.
\normalbox{Please note that this use of the word `resource' is different from that used when talking
about initialisation file resource reading and writing, using such functions
as wxWriteResource and wxGetResource. It's just an unfortunate clash of terminology.}
as wxWriteResource and wxGetResource. It is just an unfortunate clash of terminology.}
\helponly{For an overview of the wxWindows resource mechanism, see \helpref{the wxWindows resource system}{resourceformats}.}
See also \helpref{wxWindow::LoadFromResource}{wxwindowloadfromresource} for
loading from resource data.
{\bf Warning:} this needs updating for wxWindows 2.
\membersection{::wxResourceAddIdentifier}\label{wxresourceaddidentifier}
\func{bool}{wxResourceAddIdentifier}{\param{const wxString\& }{name}, \param{int }{value}}
@@ -2300,15 +2364,15 @@ wxWindows bitmap resource identifier. For example, if the .WXR file contains
the following:
\begin{verbatim}
static const wxString\& aiai_resource = "bitmap(name = 'aiai_resource',\
bitmap = ['aiai', wxBITMAP_TYPE_BMP_RESOURCE, 'WINDOWS'],\
bitmap = ['aiai.xpm', wxBITMAP_TYPE_XPM, 'X']).";
static const wxString\& project_resource = "bitmap(name = 'project_resource',\
bitmap = ['project', wxBITMAP_TYPE_BMP_RESOURCE, 'WINDOWS'],\
bitmap = ['project.xpm', wxBITMAP_TYPE_XPM, 'X']).";
\end{verbatim}
then this function can be called as follows:
\begin{verbatim}
wxBitmap *bitmap = wxResourceCreateBitmap("aiai_resource");
wxBitmap *bitmap = wxResourceCreateBitmap("project_resource");
\end{verbatim}
\membersection{::wxResourceCreateIcon}
@@ -2320,15 +2384,15 @@ wxWindows icon resource identifier. For example, if the .WXR file contains
the following:
\begin{verbatim}
static const wxString\& aiai_resource = "icon(name = 'aiai_resource',\
icon = ['aiai', wxBITMAP_TYPE_ICO_RESOURCE, 'WINDOWS'],\
icon = ['aiai', wxBITMAP_TYPE_XBM_DATA, 'X']).";
static const wxString\& project_resource = "icon(name = 'project_resource',\
icon = ['project', wxBITMAP_TYPE_ICO_RESOURCE, 'WINDOWS'],\
icon = ['project', wxBITMAP_TYPE_XBM_DATA, 'X']).";
\end{verbatim}
then this function can be called as follows:
\begin{verbatim}
wxIcon *icon = wxResourceCreateIcon("aiai_resource");
wxIcon *icon = wxResourceCreateIcon("project_resource");
\end{verbatim}
\membersection{::wxResourceCreateMenuBar}
@@ -2387,9 +2451,9 @@ dialog(name = 'dialog1',
title = 'Test dialog box',
x = 312, y = 234, width = 400, height = 300,
modal = 0,
control = [wxGroupBox, 'Groupbox', '0', 'group6', 5, 4, 380, 262,
control = [1000, wxStaticBox, 'Groupbox', '0', 'group6', 5, 4, 380, 262,
[11, 'wxSWISS', 'wxNORMAL', 'wxNORMAL', 0]],
control = [wxMultiText, 'Multitext', 'wxVERTICAL_LABEL', 'multitext3',
control = [1001, wxTextCtrl, '', 'wxTE_MULTILINE', 'text3',
156, 126, 200, 70, 'wxWindows is a multi-platform, GUI toolkit.',
[11, 'wxSWISS', 'wxNORMAL', 'wxNORMAL', 0],
[11, 'wxSWISS', 'wxNORMAL', 'wxNORMAL', 0]]).
@@ -2415,7 +2479,7 @@ wxWindows resource data.
\membersection{::wxResourceParseString}\label{wxresourceparsestring}
\func{bool}{wxResourceParseString}{\param{const wxString\& }{resource}, \param{wxResourceTable *}{table = NULL}}
\func{bool}{wxResourceParseString}{\param{char*}{ s}, \param{wxResourceTable *}{table = NULL}}
Parses a string containing one or more wxWindows resource objects. If
the resource objects are global static data that are included into the
@@ -2425,17 +2489,17 @@ containing the resource data, to make it known to wxWindows.
{\it resource} should contain data with the following form:
\begin{verbatim}
static const wxString\& dialog1 = "dialog(name = 'dialog1',\
style = 'wxCAPTION | wxDEFAULT_DIALOG_STYLE',\
title = 'Test dialog box',\
x = 312, y = 234, width = 400, height = 300,\
modal = 0,\
control = [wxGroupBox, 'Groupbox', '0', 'group6', 5, 4, 380, 262,\
[11, 'wxSWISS', 'wxNORMAL', 'wxNORMAL', 0]],\
control = [wxMultiText, 'Multitext', 'wxVERTICAL_LABEL', 'multitext3',\
156, 126, 200, 70, 'wxWindows is a multi-platform, GUI toolkit.',\
[11, 'wxSWISS', 'wxNORMAL', 'wxNORMAL', 0],\
[11, 'wxSWISS', 'wxNORMAL', 'wxNORMAL', 0]]).";
dialog(name = 'dialog1',
style = 'wxCAPTION | wxDEFAULT_DIALOG_STYLE',
title = 'Test dialog box',
x = 312, y = 234, width = 400, height = 300,
modal = 0,
control = [1000, wxStaticBox, 'Groupbox', '0', 'group6', 5, 4, 380, 262,
[11, 'wxSWISS', 'wxNORMAL', 'wxNORMAL', 0]],
control = [1001, wxTextCtrl, '', 'wxTE_MULTILINE', 'text3',
156, 126, 200, 70, 'wxWindows is a multi-platform, GUI toolkit.',
[11, 'wxSWISS', 'wxNORMAL', 'wxNORMAL', 0],
[11, 'wxSWISS', 'wxNORMAL', 'wxNORMAL', 0]]).
\end{verbatim}
This function will typically be used after calling \helpref{wxLoadUserResource}{wxloaduserresource} to
@@ -2443,10 +2507,10 @@ load an entire {\tt .wxr file} into a string.
\membersection{::wxResourceRegisterBitmapData}\label{registerbitmapdata}
\func{bool}{wxResourceRegisterBitmapData}{\param{const wxString\& }{name}, \param{const wxString\& }{xbm\_data}, \param{int }{width},
\func{bool}{wxResourceRegisterBitmapData}{\param{const wxString\& }{name}, \param{char* }{xbm\_data}, \param{int }{width},
\param{int }{height}, \param{wxResourceTable *}{table = NULL}}
\func{bool}{wxResourceRegisterBitmapData}{\param{const wxString\& }{name}, \param{const wxString\& *}{xpm\_data}}
\func{bool}{wxResourceRegisterBitmapData}{\param{const wxString\& }{name}, \param{char** }{xpm\_data}}
Makes \verb$#$included XBM or XPM bitmap data known to the wxWindows resource system.
This is required if other resources will use the bitmap data, since otherwise there
@@ -2504,7 +2568,7 @@ meaningless.
\func{void}{wxLogVerbose}{\param{const char*}{ formatString}, \param{...}{}}
For verbose output. Normally, it's suppressed, but
For verbose output. Normally, it is 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}).
@@ -2528,7 +2592,7 @@ 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.
of this function takes the error code explicitly as the first argument.
\wxheading{See also}
@@ -2615,9 +2679,89 @@ Returns the error message corresponding to the given system error code. If
\helpref{wxSysErrorCode}{wxsyserrorcode},
\helpref{wxLogSysError}{wxlogsyserror}
\section{Time functions}\label{timefunctions}
The functions in this section deal with getting the current time and
starting/stopping the global timers. Please note that the timer functions are
deprecated because they work with one global timer only and
\helpref{wxTimer}{wxtimer} and/or \helpref{wxStopWatch}{wxstopwatch} classes
should be used instead. For retrieving the current time, you may also use
\helpref{wxDateTime::Now}{wxdatetimenow} or
\helpref{wxDateTime::UNow}{wxdatetimeunow} methods.
\membersection{::wxGetElapsedTime}\label{wxgetelapsedtime}
\func{long}{wxGetElapsedTime}{\param{bool}{ resetTimer = TRUE}}
Gets the time in milliseconds since the last \helpref{::wxStartTimer}{wxstarttimer}.
If {\it resetTimer} is TRUE (the default), the timer is reset to zero
by this call.
See also \helpref{wxTimer}{wxtimer}.
\wxheading{Include files}
<wx/timer.h>
\membersection{::wxGetLocalTime}\label{wxgetlocaltime}
\func{long}{wxGetLocalTime}{\void}
Returns the number of seconds since local time 00:00:00 Jan 1st 1970.
\wxheading{See also}
\helpref{wxDateTime::Now}{wxdatetimenow}
\wxheading{Include files}
<wx/timer.h>
\membersection{::wxGetLocalTimeMillis}\label{wxgetlocaltimemillis}
\func{wxLongLone}{wxGetLocalTimeMillis}{\void}
Returns the number of milliseconds since local time 00:00:00 Jan 1st 1970.
\wxheading{See also}
\helpref{wxDateTime::Now}{wxdatetimenow},\\
\helpref{wxLongLone}{wxlonglong}
\wxheading{Include files}
<wx/timer.h>
\membersection{::wxGetUTCTime}\label{wxgetutctime}
\func{long}{wxGetUTCTime}{\void}
Returns the number of seconds since GMT 00:00:00 Jan 1st 1970.
\wxheading{See also}
\helpref{wxDateTime::Now}{wxdatetimenow}
\wxheading{Include files}
<wx/timer.h>
\membersection{::wxStartTimer}\label{wxstarttimer}
\func{void}{wxStartTimer}{\void}
Starts a stopwatch; use \helpref{::wxGetElapsedTime}{wxgetelapsedtime} to get the elapsed time.
See also \helpref{wxTimer}{wxtimer}.
\wxheading{Include files}
<wx/timer.h>
\section{Debugging macros and functions}\label{debugmacros}
Useful macros and functins for error checking and defensive programming. ASSERTs are only
Useful macros and functions for error checking and defensive programming. ASSERTs are only
compiled if \_\_WXDEBUG\_\_ is defined, whereas CHECK macros stay in release
builds.

170
docs/latex/wx/gridattr.tex Normal file
View File

@@ -0,0 +1,170 @@
%
% automatically generated by HelpGen from
% grid.h at 11/May/00 18:30:19
%
\section{\class{wxGridCellAttr}}\label{wxgridcellattr}
wxGridCellAttr: this class can be used to alter the cells appearance in
the grid by changing their colour/font/... from default. An object of this
class may be returned by wxGridTable::GetAttr().
\wxheading{Derived from}
No base class
\wxheading{Data structures}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxGridCellAttr::wxGridCellAttr}\label{wxgridcellattrwxgridcellattr}
\func{}{wxGridCellAttr}{\void}
ctors
\membersection{wxGridCellAttr::wxGridCellAttr}\label{wxgridcellattrwxgridcellattr}
\func{}{wxGridCellAttr}{\param{const wxColour\& }{colText}, \param{const wxColour\& }{colBack}, \param{const wxFont\& }{font}, \param{int }{hAlign}, \param{int }{vAlign}}
VZ: considering the number of members wxGridCellAttr has now, this ctor
seems to be pretty useless... may be we should just remove it?
\membersection{wxGridCellAttr::Clone}\label{wxgridcellattrclone}
\constfunc{wxGridCellAttr*}{Clone}{\void}
creates a new copy of this object
\membersection{wxGridCellAttr::IncRef}\label{wxgridcellattrincref}
\func{void}{IncRef}{\void}
this class is ref counted: it is created with ref count of 1, so
calling DecRef() once will delete it. Calling IncRef() allows to lock
it until the matching DecRef() is called
\membersection{wxGridCellAttr::DecRef}\label{wxgridcellattrdecref}
\func{void}{DecRef}{\void}
\membersection{wxGridCellAttr::SetTextColour}\label{wxgridcellattrsettextcolour}
\func{void}{SetTextColour}{\param{const wxColour\& }{colText}}
setters
\membersection{wxGridCellAttr::SetBackgroundColour}\label{wxgridcellattrsetbackgroundcolour}
\func{void}{SetBackgroundColour}{\param{const wxColour\& }{colBack}}
\membersection{wxGridCellAttr::SetFont}\label{wxgridcellattrsetfont}
\func{void}{SetFont}{\param{const wxFont\& }{font}}
\membersection{wxGridCellAttr::SetAlignment}\label{wxgridcellattrsetalignment}
\func{void}{SetAlignment}{\param{int }{hAlign}, \param{int }{vAlign}}
\membersection{wxGridCellAttr::SetReadOnly}\label{wxgridcellattrsetreadonly}
\func{void}{SetReadOnly}{\param{bool }{isReadOnly = TRUE}}
\membersection{wxGridCellAttr::SetRenderer}\label{wxgridcellattrsetrenderer}
\func{void}{SetRenderer}{\param{wxGridCellRenderer* }{renderer}}
takes ownership of the pointer
\membersection{wxGridCellAttr::SetEditor}\label{wxgridcellattrseteditor}
\func{void}{SetEditor}{\param{wxGridCellEditor* }{editor}}
\membersection{wxGridCellAttr::HasTextColour}\label{wxgridcellattrhastextcolour}
\constfunc{bool}{HasTextColour}{\void}
accessors
\membersection{wxGridCellAttr::HasBackgroundColour}\label{wxgridcellattrhasbackgroundcolour}
\constfunc{bool}{HasBackgroundColour}{\void}
\membersection{wxGridCellAttr::HasFont}\label{wxgridcellattrhasfont}
\constfunc{bool}{HasFont}{\void}
\membersection{wxGridCellAttr::HasAlignment}\label{wxgridcellattrhasalignment}
\constfunc{bool}{HasAlignment}{\void}
\membersection{wxGridCellAttr::HasRenderer}\label{wxgridcellattrhasrenderer}
\constfunc{bool}{HasRenderer}{\void}
\membersection{wxGridCellAttr::HasEditor}\label{wxgridcellattrhaseditor}
\constfunc{bool}{HasEditor}{\void}
\membersection{wxGridCellAttr::GetTextColour}\label{wxgridcellattrgettextcolour}
\constfunc{const wxColour\&}{GetTextColour}{\void}
\membersection{wxGridCellAttr::GetBackgroundColour}\label{wxgridcellattrgetbackgroundcolour}
\constfunc{const wxColour\&}{GetBackgroundColour}{\void}
\membersection{wxGridCellAttr::GetFont}\label{wxgridcellattrgetfont}
\constfunc{const wxFont\&}{GetFont}{\void}
\membersection{wxGridCellAttr::GetAlignment}\label{wxgridcellattrgetalignment}
\constfunc{void}{GetAlignment}{\param{int* }{hAlign}, \param{int* }{vAlign}}
\membersection{wxGridCellAttr::GetRenderer}\label{wxgridcellattrgetrenderer}
\constfunc{wxGridCellRenderer*}{GetRenderer}{\param{wxGrid* }{grid}, \param{int }{row}, \param{int }{col}}
\membersection{wxGridCellAttr::GetEditor}\label{wxgridcellattrgeteditor}
\constfunc{wxGridCellEditor*}{GetEditor}{\param{wxGrid* }{grid}, \param{int }{row}, \param{int }{col}}
\membersection{wxGridCellAttr::IsReadOnly}\label{wxgridcellattrisreadonly}
\constfunc{bool}{IsReadOnly}{\void}
\membersection{wxGridCellAttr::SetDefAttr}\label{wxgridcellattrsetdefattr}
\func{void}{SetDefAttr}{\param{wxGridCellAttr* }{defAttr}}

134
docs/latex/wx/gridedit.tex Normal file
View File

@@ -0,0 +1,134 @@
%
% automatically generated by HelpGen from
% grid.h at 11/May/00 18:30:18
%
\section{\class{wxGridCellEditor}}\label{wxgridcelleditor}
wxGridCellEditor: This class is responsible for providing and manipulating
the in-place edit controls for the grid. Instances of wxGridCellEditor
(actually, instances of derived classes since it is an ABC) can be
associated with the cell attributes for individual cells, rows, columns, or
even for the entire grid.
\wxheading{Derived from}
\helpref{wxGridCellWorker}{wxgridcellworker}
\wxheading{Data structures}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxGridCellEditor::wxGridCellEditor}\label{wxgridcelleditorwxgridcelleditor}
\func{}{wxGridCellEditor}{\void}
\membersection{wxGridCellEditor::IsCreated}\label{wxgridcelleditoriscreated}
\func{bool}{IsCreated}{\void}
\membersection{wxGridCellEditor::Create}\label{wxgridcelleditorcreate}
\func{void}{Create}{\param{wxWindow* }{parent}, \param{wxWindowID }{id}, \param{wxEvtHandler* }{evtHandler}}
Creates the actual edit control
\membersection{wxGridCellEditor::SetSize}\label{wxgridcelleditorsetsize}
\func{void}{SetSize}{\param{const wxRect\& }{rect}}
Size and position the edit control
\membersection{wxGridCellEditor::Show}\label{wxgridcelleditorshow}
\func{void}{Show}{\param{bool }{show}, \param{wxGridCellAttr* }{attr = NULL}}
Show or hide the edit control, use the specified attributes to set
colours/fonts for it
\membersection{wxGridCellEditor::PaintBackground}\label{wxgridcelleditorpaintbackground}
\func{void}{PaintBackground}{\param{const wxRect\& }{rectCell}, \param{wxGridCellAttr* }{attr}}
Draws the part of the cell not occupied by the control: the base class
version just fills it with background colour from the attribute
\membersection{wxGridCellEditor::BeginEdit}\label{wxgridcelleditorbeginedit}
\func{void}{BeginEdit}{\param{int }{row}, \param{int }{col}, \param{wxGrid* }{grid}}
Fetch the value from the table and prepare the edit control
to begin editing. Set the focus to the edit control.
\membersection{wxGridCellEditor::EndEdit}\label{wxgridcelleditorendedit}
\func{bool}{EndEdit}{\param{int }{row}, \param{int }{col}, \param{wxGrid* }{grid}}
Complete the editing of the current cell. Returns true if the value has
changed. If necessary, the control may be destroyed.
\membersection{wxGridCellEditor::Reset}\label{wxgridcelleditorreset}
\func{void}{Reset}{\void}
Reset the value in the control back to its starting value
\membersection{wxGridCellEditor::StartingKey}\label{wxgridcelleditorstartingkey}
\func{void}{StartingKey}{\param{wxKeyEvent\& }{event}}
If the editor is enabled by pressing keys on the grid,
this will be called to let the editor do something about
that first key if desired.
\membersection{wxGridCellEditor::StartingClick}\label{wxgridcelleditorstartingclick}
\func{void}{StartingClick}{\void}
if the editor is enabled by clicking on the cell, this method will be
called
\membersection{wxGridCellEditor::HandleReturn}\label{wxgridcelleditorhandlereturn}
\func{void}{HandleReturn}{\param{wxKeyEvent\& }{event}}
Some types of controls on some platforms may need some help
with the Return key.
\membersection{wxGridCellEditor::Destroy}\label{wxgridcelleditordestroy}
\func{void}{Destroy}{\void}
Final cleanup
\membersection{wxGridCellEditor::Clone}\label{wxgridcelleditorclone}
\constfunc{wxGridCellEditor*}{Clone}{\void}
create a new object which is the copy of this one
\membersection{wxGridCellEditor::\destruct{wxGridCellEditor}}\label{wxgridcelleditordtor}
\func{}{\destruct{wxGridCellEditor}}{\void}
the dtor is private because only DecRef() can delete us

50
docs/latex/wx/gridrend.tex Normal file
View File

@@ -0,0 +1,50 @@
%
% automatically generated by HelpGen from
% grid.h at 11/May/00 18:30:18
%
\section{\class{wxGridCellRenderer}}\label{wxgridcellrenderer}
suppress the stupid gcc warning about the class having private dtor and
no friends
wxGridCellRenderer: this class is responsible for actually drawing the cell
in the grid. You may pass it to the wxGridCellAttr (below) to change the
format of one given cell or to wxGrid::SetDefaultRenderer() to change the
view of all cells. This is an ABC, you will normally use one of the
predefined derived classes or derive your own class from it.
\wxheading{Derived from}
\helpref{wxGridCellWorker}{wxgridcellworker}
\wxheading{Data structures}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxGridCellRenderer::Draw}\label{wxgridcellrendererdraw}
\func{void}{Draw}{\param{wxGrid\& }{grid}, \param{wxGridCellAttr\& }{attr}, \param{wxDC\& }{dc}, \param{const wxRect\& }{rect}, \param{int }{row}, \param{int }{col}, \param{bool }{isSelected}}
draw the given cell on the provided DC inside the given rectangle
using the style specified by the attribute and the default or selected
state corresponding to the isSelected value.
this pure virtual function has a default implementation which will
prepare the DC using the given attribute: it will draw the rectangle
with the bg colour from attr and set the text colour and font
\membersection{wxGridCellRenderer::GetBestSize}\label{wxgridcellrenderergetbestsize}
\func{wxSize}{GetBestSize}{\param{wxGrid\& }{grid}, \param{wxGridCellAttr\& }{attr}, \param{wxDC\& }{dc}, \param{int }{row}, \param{int }{col}}
get the preferred size of the cell for its contents
\membersection{wxGridCellRenderer::Clone}\label{wxgridcellrendererclone}
\constfunc{wxGridCellRenderer*}{Clone}{

24
docs/latex/wx/gridsizr.tex Normal file
View File

@@ -0,0 +1,24 @@
\section{\class{wxGridSizer}}\label{wxgridsizer}
A grid sizer is a sizer which lays out its children in a two-dimensional
table with all table fields having the same size,
i.e. the width of each field is the width of the widest child,
the height of each field is the height of the tallest child.
\wxheading{Derived from}
\helpref{wxSizer}{wxsizer}\\
\helpref{wxObject}{wxobject}
\membersection{wxGridSizer::wxGridSizer}\label{wxgridsizerwxgridsizer}
\func{}{wxGridSizer}{\param{int }{cols}, \param{int }{rows}, \param{int }{vgap}, \param{int }{hgap}}
\func{}{wxGridSizer}{\param{int }{cols}, \param{int }{vgap = 0}, \param{int }{hgap = 0}}
Constructor for a wxGridSizer. {\it rows} and {\it cols} determine the number of
columns and rows in the sizer - if either of the parameters is zero, it will be
calculated to form the total number of children in the sizer, thus making the
sizer grow dynamically. {\it vgap} and {\it hgap} define extra space between
all children.

236
docs/latex/wx/gridtbl.tex Normal file
View File

@@ -0,0 +1,236 @@
\section{\class{wxGridTableBase}}\label{wxgridtablebase}
Grid table classes
\wxheading{Derived from}
\helpref{wxObject}{wxobject}
\wxheading{Data structures}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxGridTableBase::wxGridTableBase}\label{wxgridtablebasewxgridtablebase}
\func{}{wxGridTableBase}{\void}
\membersection{wxGridTableBase::\destruct{wxGridTableBase}}\label{wxgridtablebasedtor}
\func{}{\destruct{wxGridTableBase}}{\void}
\membersection{wxGridTableBase::GetNumberRows}\label{wxgridtablebasegetnumberrows}
\func{int}{GetNumberRows}{\void}
You must override these functions in a derived table class
\membersection{wxGridTableBase::GetNumberCols}\label{wxgridtablebasegetnumbercols}
\func{int}{GetNumberCols}{\void}
\membersection{wxGridTableBase::IsEmptyCell}\label{wxgridtablebaseisemptycell}
\func{bool}{IsEmptyCell}{\param{int }{row}, \param{int }{col}}
\membersection{wxGridTableBase::GetValue}\label{wxgridtablebasegetvalue}
\func{wxString}{GetValue}{\param{int }{row}, \param{int }{col}}
\membersection{wxGridTableBase::SetValue}\label{wxgridtablebasesetvalue}
\func{void}{SetValue}{\param{int }{row}, \param{int }{col}, \param{const wxString\& }{value}}
\membersection{wxGridTableBase::GetTypeName}\label{wxgridtablebasegettypename}
\func{wxString}{GetTypeName}{\param{int }{row}, \param{int }{col}}
Data type determination and value access
\membersection{wxGridTableBase::CanGetValueAs}\label{wxgridtablebasecangetvalueas}
\func{bool}{CanGetValueAs}{\param{int }{row}, \param{int }{col}, \param{const wxString\& }{typeName}}
\membersection{wxGridTableBase::CanSetValueAs}\label{wxgridtablebasecansetvalueas}
\func{bool}{CanSetValueAs}{\param{int }{row}, \param{int }{col}, \param{const wxString\& }{typeName}}
\membersection{wxGridTableBase::GetValueAsLong}\label{wxgridtablebasegetvalueaslong}
\func{long}{GetValueAsLong}{\param{int }{row}, \param{int }{col}}
\membersection{wxGridTableBase::GetValueAsDouble}\label{wxgridtablebasegetvalueasdouble}
\func{double}{GetValueAsDouble}{\param{int }{row}, \param{int }{col}}
\membersection{wxGridTableBase::GetValueAsBool}\label{wxgridtablebasegetvalueasbool}
\func{bool}{GetValueAsBool}{\param{int }{row}, \param{int }{col}}
\membersection{wxGridTableBase::SetValueAsLong}\label{wxgridtablebasesetvalueaslong}
\func{void}{SetValueAsLong}{\param{int }{row}, \param{int }{col}, \param{long }{value}}
\membersection{wxGridTableBase::SetValueAsDouble}\label{wxgridtablebasesetvalueasdouble}
\func{void}{SetValueAsDouble}{\param{int }{row}, \param{int }{col}, \param{double }{value}}
\membersection{wxGridTableBase::SetValueAsBool}\label{wxgridtablebasesetvalueasbool}
\func{void}{SetValueAsBool}{\param{int }{row}, \param{int }{col}, \param{bool }{value}}
\membersection{wxGridTableBase::GetValueAsCustom}\label{wxgridtablebasegetvalueascustom}
\func{void*}{GetValueAsCustom}{\param{int }{row}, \param{int }{col}, \param{const wxString\& }{typeName}}
For user defined types
\membersection{wxGridTableBase::SetValueAsCustom}\label{wxgridtablebasesetvalueascustom}
\func{void}{SetValueAsCustom}{\param{int }{row}, \param{int }{col}, \param{const wxString\& }{typeName}, \param{void* }{value}}
\membersection{wxGridTableBase::SetView}\label{wxgridtablebasesetview}
\func{void}{SetView}{\param{wxGrid* }{grid}}
Overriding these is optional
\membersection{wxGridTableBase::GetView}\label{wxgridtablebasegetview}
\constfunc{wxGrid *}{GetView}{\void}
\membersection{wxGridTableBase::Clear}\label{wxgridtablebaseclear}
\func{void}{Clear}{\void}
\membersection{wxGridTableBase::InsertRows}\label{wxgridtablebaseinsertrows}
\func{bool}{InsertRows}{\param{size\_t }{pos = 0}, \param{size\_t }{numRows = 1}}
\membersection{wxGridTableBase::AppendRows}\label{wxgridtablebaseappendrows}
\func{bool}{AppendRows}{\param{size\_t }{numRows = 1}}
\membersection{wxGridTableBase::DeleteRows}\label{wxgridtablebasedeleterows}
\func{bool}{DeleteRows}{\param{size\_t }{pos = 0}, \param{size\_t }{numRows = 1}}
\membersection{wxGridTableBase::InsertCols}\label{wxgridtablebaseinsertcols}
\func{bool}{InsertCols}{\param{size\_t }{pos = 0}, \param{size\_t }{numCols = 1}}
\membersection{wxGridTableBase::AppendCols}\label{wxgridtablebaseappendcols}
\func{bool}{AppendCols}{\param{size\_t }{numCols = 1}}
\membersection{wxGridTableBase::DeleteCols}\label{wxgridtablebasedeletecols}
\func{bool}{DeleteCols}{\param{size\_t }{pos = 0}, \param{size\_t }{numCols = 1}}
\membersection{wxGridTableBase::GetRowLabelValue}\label{wxgridtablebasegetrowlabelvalue}
\func{wxString}{GetRowLabelValue}{\param{int }{row}}
\membersection{wxGridTableBase::GetColLabelValue}\label{wxgridtablebasegetcollabelvalue}
\func{wxString}{GetColLabelValue}{\param{int }{col}}
\membersection{wxGridTableBase::SetRowLabelValue}\label{wxgridtablebasesetrowlabelvalue}
\func{void}{SetRowLabelValue}{\param{int }{WXUNUSED(row)}, \param{const }{wxString\&}}
\membersection{wxGridTableBase::SetColLabelValue}\label{wxgridtablebasesetcollabelvalue}
\func{void}{SetColLabelValue}{\param{int }{WXUNUSED(col)}, \param{const }{wxString\&}}
\membersection{wxGridTableBase::SetAttrProvider}\label{wxgridtablebasesetattrprovider}
\func{void}{SetAttrProvider}{\param{wxGridCellAttrProvider* }{attrProvider}}
Attribute handling
give us the attr provider to use - we take ownership of the pointer
\membersection{wxGridTableBase::GetAttrProvider}\label{wxgridtablebasegetattrprovider}
\constfunc{wxGridCellAttrProvider*}{GetAttrProvider}{\void}
get the currently used attr provider (may be NULL)
\membersection{wxGridTableBase::CanHaveAttributes}\label{wxgridtablebasecanhaveattributes}
\func{bool}{CanHaveAttributes}{\void}
Does this table allow attributes? Default implementation creates
a wxGridCellAttrProvider if necessary.
\membersection{wxGridTableBase::UpdateAttrRows}\label{wxgridtablebaseupdateattrrows}
\func{void}{UpdateAttrRows}{\param{size\_t }{pos}, \param{int }{numRows}}
change row/col number in attribute if needed
\membersection{wxGridTableBase::UpdateAttrCols}\label{wxgridtablebaseupdateattrcols}
\func{void}{UpdateAttrCols}{\param{size\_t }{pos}, \param{int }{numCols}}
\membersection{wxGridTableBase::GetAttr}\label{wxgridtablebasegetattr}
\func{wxGridCellAttr*}{GetAttr}{\param{int }{row}, \param{int }{col}}
by default forwarded to wxGridCellAttrProvider if any. May be
overridden to handle attributes directly in the table.
\membersection{wxGridTableBase::SetAttr}\label{wxgridtablebasesetattr}
\func{void}{SetAttr}{\param{wxGridCellAttr* }{attr}, \param{int }{row}, \param{int }{col}}
these functions take ownership of the pointer
\membersection{wxGridTableBase::SetRowAttr}\label{wxgridtablebasesetrowattr}
\func{void}{SetRowAttr}{\param{wxGridCellAttr* }{attr}, \param{int }{row}}
\membersection{wxGridTableBase::SetColAttr}\label{wxgridtablebasesetcolattr}
\func{void}{SetColAttr}{\param{wxGridCellAttr* }{attr}, \param{int }{col}}

59
docs/latex/wx/gridwork.tex Normal file
View File

@@ -0,0 +1,59 @@
%
% automatically generated by HelpGen from
% grid.h at 11/May/00 18:30:18
%
\section{\class{wxGridCellWorker}}\label{wxgridcellworker}
wxGridCellWorker: common base class for wxGridCellRenderer and
wxGridCellEditor
NB: this is more an implementation convenience than a design issue, so this
class is not documented and is not public at all
\wxheading{Derived from}
No base class
\wxheading{Data structures}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxGridCellWorker::wxGridCellWorker}\label{wxgridcellworkerwxgridcellworker}
\func{}{wxGridCellWorker}{\void}
\membersection{wxGridCellWorker::IncRef}\label{wxgridcellworkerincref}
\func{void}{IncRef}{\void}
this class is ref counted: it is created with ref count of 1, so
calling DecRef() once will delete it. Calling IncRef() allows to lock
it until the matching DecRef() is called
\membersection{wxGridCellWorker::DecRef}\label{wxgridcellworkerdecref}
\func{void}{DecRef}{\void}
\membersection{wxGridCellWorker::SetParameters}\label{wxgridcellworkersetparameters}
\func{void}{SetParameters}{\param{const wxString\& }{params}}
interpret renderer parameters: arbitrary string whose interpretatin is
left to the derived classes
\membersection{wxGridCellWorker::\destruct{wxGridCellWorker}}\label{wxgridcellworkerdtor}
\func{}{\destruct{wxGridCellWorker}}{\void}
virtual dtor for any base class - private because only DecRef() can
delete us

5
docs/latex/wx/hash.tex
View File

@@ -95,7 +95,7 @@ is destroyed.
\func{wxObject *}{Get}{\param{long}{ key}}
\func{wxObject *}{Get}{\param{const wxString\& }{ key}}
\func{wxObject *}{Get}{\param{const char*}{ key}}
Gets data from the hash table, using an integer or string key (depending on which
has table constructor was used).
@@ -121,13 +121,12 @@ description for \helpref{wxNode}{wxnode}. The user will probably only wish to us
\func{void}{Put}{\param{long}{ key}, \param{wxObject *}{object}}
\func{void}{Put}{\param{const wxString\& }{ key}, \param{wxObject *}{object}}
\func{void}{Put}{\param{const char*}{ key}, \param{wxObject *}{object}}
Inserts data into the hash table, using an integer or string key (depending on which
has table constructor was used). The key string is copied and stored by the hash
table implementation.
\membersection{wxList::GetCount}
\constfunc{size\_t}{GetCount}{\void}

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

@@ -31,6 +31,8 @@ There are currently the following help controller classes defined:
\begin{itemize}\itemsep=0pt
\item wxWinHelpController, for controlling Windows Help.
\item wxCHMHelpController, for controlling MS HTML Help. To use this, you need to set wxUSE\_MS\_HTML\_HELP
to 0 in setup.h, and link your application with Microsoft's htmlhelp.lib. Currently VC++ only.
\item wxExtHelpController, for controlling external browsers under Unix.
The default browser is Netscape Navigator. The 'help' sample shows its use.
\item wxHelpControllerHtml, using \helpref{wxHTML}{wxhtml} to display help. See {\tt wx/helpwxht.h} for
@@ -51,6 +53,7 @@ wxHelpControllerBase\\
<wx/help.h> (wxWindows chooses the appropriate help controller class)\\
<wx/helpbase.h> (wxHelpControllerBase class)\\
<wx/helpwin.h> (Windows Help controller)\\
<wx/msw/helpchm.h> (MS HTML Help controller)\\
<wx/generic/helpext.h> (external HTML browser controller)\\
<wx/generic/helpwxht.h> (simple wxHTML-based help controller)\\
<wx/html/helpctrl.h> (advanced wxHTML based help controller: wxHtmlHelpController)
@@ -98,10 +101,14 @@ If the help viewer is not running, runs it and displays the file at the given bl
{\it WinHelp:} Refers to the context number.
{\it MS HTML Help:} Refers to the context number.
{\it External HTML help:} the same as for \helpref{wxHelpController::DisplaySection}{wxhelpcontrollerdisplaysection}.
{\it wxHtmlHelpController:} {\it sectionNo} is an identifier as specified in the {\tt .hhc} file. See \helpref{Help files format}{helpformat}.
This function is for backward compatibility only, and applications should use \helpref{wxHelpController}{wxhelpcontrollerdisplaysection} instead.
\membersection{wxHelpController::DisplayContents}\label{wxhelpcontrollerdisplaycontents}
\func{virtual bool}{DisplayContents}{\void}
@@ -111,13 +118,23 @@ contents.
\membersection{wxHelpController::DisplaySection}\label{wxhelpcontrollerdisplaysection}
\func{virtual bool}{DisplaySection}{\param{const wxString\&}{ section}}
If the help viewer is not running, runs it and displays the given section.
The interpretation of {\it section} differs between help viewers. For most viewers,
this call is equivalent to KeywordSearch. For MS HTML Help, external HTML help
and simple wxHTML help, if {\it section} has a .htm
or .html extension, that HTML file will be displayed; otherwise
a keyword search is done.
\func{virtual bool}{DisplaySection}{\param{int}{ sectionNo}}
If the help viewer is not running, runs it and displays the given section.
{\it WinHelp:} {\it sectionNo} is a context id.
{\it WinHelp, MS HTML Help:} {\it sectionNo} is a context id.
{\it External HTML help/wxHTML based help:} wxExtHelpController and wxHelpControllerHtml implement {\it sectionNo} as an id in a map file, which is of the form:
{\it External HTML help/simple wxHTML help:} wxExtHelpController and wxHelpControllerHtml implement {\it sectionNo} as an id in a map file, which is of the form:
\begin{verbatim}
0 wx.html ; Index
@@ -127,6 +144,8 @@ If the help viewer is not running, runs it and displays the given section.
{\it wxHtmlHelpController:} {\it sectionNo} is an identifier as specified in the {\tt .hhc} file. See \helpref{Help files format}{helpformat}.
See also the help sample for notes on how to specify section numbers for various help file formats.
\membersection{wxHelpController::GetFrameParameters}\label{wxhelpcontrollergetframeparameters}
\func{virtual wxFrame *}{GetFrameParameters}{\param{const wxSize * }{size = NULL}, \param{const wxPoint * }{pos = NULL},
@@ -159,10 +178,10 @@ that the viewer is a variant of Netscape Navigator.}
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.
{\it WinHelp:} If more than one match is found,
{\it WinHelp, MS HTML Help:} If more than one match is found,
the first topic is displayed.
{\it External HTML help:} If more than one match is found,
{\it External HTML help, simple wxHTML help:} If more than one match is found,
a choice of topics is displayed.
{\it wxHtmlHelpController:} see \helpref{wxHtmlHelpController::KeywordSearch}{wxhtmlhelpcontrollerkeywordsearch}.

41
docs/latex/wx/hteasypr.tex
View File

@@ -41,15 +41,24 @@ Constructor.
\membersection{wxHtmlEasyPrinting::PreviewFile}\label{wxhtmleasyprintingpreviewfile}
\func{void}{PreviewFile}{\param{const wxString\& }{htmlfile}}
\func{bool}{PreviewFile}{\param{const wxString\& }{htmlfile}}
Preview HTML file.
Returns FALSE in case of error -- call
\helpref{wxPrinter::GetLastError}{wxprintergetlasterror} to get detailed
information about the kind of the error.
Previews HTML file.
\membersection{wxHtmlEasyPrinting::PreviewText}\label{wxhtmleasyprintingpreviewtext}
\func{void}{PreviewText}{\param{const wxString\& }{htmltext}, \param{const wxString\& }{basepath = wxEmptyString}}
\func{bool}{PreviewText}{\param{const wxString\& }{htmltext}, \param{const wxString\& }{basepath = wxEmptyString}}
Previews HTML text (not file!).
Preview HTML text (not file!).
Returns FALSE in case of error -- call
\helpref{wxPrinter::GetLastError}{wxprintergetlasterror} to get detailed
information about the kind of the error.
\wxheading{Parameters}
@@ -60,15 +69,23 @@ file). It is used to determine path for loading images, for example.}
\membersection{wxHtmlEasyPrinting::PrintFile}\label{wxhtmleasyprintingprintfile}
\func{void}{PrintFile}{\param{const wxString\& }{htmlfile}}
\func{bool}{PrintFile}{\param{const wxString\& }{htmlfile}}
Prints HTML file.
Print HTML file.
Returns FALSE in case of error -- call
\helpref{wxPrinter::GetLastError}{wxprintergetlasterror} to get detailed
information about the kind of the error.
\membersection{wxHtmlEasyPrinting::PrintText}\label{wxhtmleasyprintingprinttext}
\func{void}{PrintText}{\param{const wxString\& }{htmltext}, \param{const wxString\& }{basepath = wxEmptyString}}
\func{bool}{PrintText}{\param{const wxString\& }{htmltext}, \param{const wxString\& }{basepath = wxEmptyString}}
Prints HTML text (not file!).
Print HTML text (not file!).
Returns FALSE in case of error -- call
\helpref{wxPrinter::GetLastError}{wxprintergetlasterror} to get detailed
information about the kind of the error.
\wxheading{Parameters}
@@ -81,19 +98,19 @@ file). It is used to determine path for loading images, for example.}
\func{void}{PrinterSetup}{\void}
Displays printer setup dialog and allows the user to modify settings.
Display printer setup dialog and allows the user to modify settings.
\membersection{wxHtmlEasyPrinting::PageSetup}\label{wxhtmleasyprintingpagesetup}
\func{void}{PageSetup}{\void}
Displays page setup dialog and allows the user to modify settings.
Display page setup dialog and allows the user to modify settings.
\membersection{wxHtmlEasyPrinting::SetHeader}\label{wxhtmleasyprintingsetheader}
\func{void}{SetHeader}{\param{const wxString\& }{header}, \param{int }{pg = wxPAGE\_ALL}}
Sets page header.
Set page header.
\wxheading{Parameters}
@@ -111,7 +128,7 @@ Sets page header.
\func{void}{SetFooter}{\param{const wxString\& }{footer}, \param{int }{pg = wxPAGE\_ALL}}
Sets page footer.
Set page footer.
\wxheading{Parameters}

5
docs/latex/wx/hthelpct.tex
View File

@@ -61,6 +61,7 @@ Constructor.
\begin{twocollist}\itemsep=0pt
\twocolitem{\windowstyle{wxHF\_TOOLBAR}}{Help frame has toolbar.}
\twocolitem{\windowstyle{wxHF\_FLATTOOLBAR}}{Help frame has toolbar with flat buttons (aka coolbar).}
\twocolitem{\windowstyle{wxHF\_CONTENTS}}{Help frame has contents panel.}
\twocolitem{\windowstyle{wxHF\_INDEX}}{Help frame has index panel.}
\twocolitem{\windowstyle{wxHF\_SEARCH}}{Help frame has search panel.}
@@ -89,7 +90,7 @@ If {\it show\_wait\_msg} is TRUE then a decorationless window with progress mess
\func{virtual wxHtmlHelpFrame*}{CreateHelpFrame}{\param{wxHtmlHelpData * }{data}}
This protected virtual method may be overriden so that the controller
This protected virtual method may be overridden so that the controller
uses slightly different frame. See {\it samples/html/helpview} sample for
an example.
\membersection{wxHtmlHelpController::Display}\label{wxhtmlhelpcontrollerdisplay}
@@ -144,7 +145,7 @@ Displays help window and focuses index panel.
Displays help window, focuses search panel and starts searching.
Returns TRUE if the keyword was found.
{\bf Important:} KeywordSearch searches only pages listed in .htc file(s).
{\bf Important:} KeywordSearch searches only pages listed in .hhc file(s).
You should list all pages in the contents file.
\membersection{wxHtmlHelpController::ReadCustomization}\label{wxhtmlhelpcontrollerreadcustomization}

5
docs/latex/wx/hthlpfrm.tex
View File

@@ -32,6 +32,7 @@ Constructor.
\begin{twocollist}\itemsep=0pt
\twocolitem{\windowstyle{wxHF\_TOOLBAR}}{Help frame has toolbar.}
\twocolitem{\windowstyle{wxHF\_FLATTOOLBAR}}{Help frame has toolbar with flat buttons (aka coolbar).}
\twocolitem{\windowstyle{wxHF\_CONTENTS}}{Help frame has contents panel.}
\twocolitem{\windowstyle{wxHF\_INDEX}}{Help frame has index panel.}
\twocolitem{\windowstyle{wxHF\_SEARCH}}{Help frame has search panel.}
@@ -50,9 +51,13 @@ Creates the frame.
\begin{twocollist}\itemsep=0pt
\twocolitem{\windowstyle{wxHF\_TOOLBAR}}{Help frame has toolbar.}
\twocolitem{\windowstyle{wxHF\_FLATTOOLBAR}}{Help frame has toolbar with flat buttons (aka coolbar).}
\twocolitem{\windowstyle{wxHF\_CONTENTS}}{Help frame has contents panel.}
\twocolitem{\windowstyle{wxHF\_INDEX}}{Help frame has index panel.}
\twocolitem{\windowstyle{wxHF\_SEARCH}}{Help frame has search panel.}
\twocolitem{\windowstyle{wxHF\_BOOKMARKS}}{Help frame has bookmarks controls.}
\twocolitem{\windowstyle{wxHF\_OPENFILES}}{Allow user to open arbitrary HTML document.}
\twocolitem{\windowstyle{wxHF\_PRINT}}{Toolbar contains "print" button.}
\end{twocollist}
\membersection{wxHtmlHelpFrame::CreateContents}\label{wxhtmlhelpframecreatecontents}

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

@@ -30,7 +30,7 @@ This image shows you cells and containers:
\wxheading{Using Containers in Tag Handler}
\helpref{wxHtmlWinParser}{wxhtmlwinparser} provides a user-friendly way
of managing containers. It's based on the idea of opening and closing containers.
of managing containers. It is based on the idea of opening and closing containers.
Use \helpref{OpenContainer}{wxhtmlwinparseropencontainer} to open new
a container {\it within an already opened container}. This new container is a
@@ -47,7 +47,7 @@ See explanation:
\helponly{\image{}{cont.bmp}}
\end{comment}
It's clear there must be same number of calls to
It is clear there must be same number of calls to
OpenContainer as to CloseContainer...
\wxheading{Example}

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

@@ -54,7 +54,7 @@ the structure of macros. See macros reference:
Starts handler definition. {\it name} is handler identifier (in fact
part of class name), {\it tags} is string containing list of tags
supported by this handler (in uppercase). This macro derives new class from
wxHtmlWinTagHandler and implements it's
wxHtmlWinTagHandler and implements it is
\helpref{GetSupportedTags}{wxhtmltaghandlergetsupportedtags} method.
Example: TAG\_HANDLER\_BEGIN(FONTS, "B,I,U,T")

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

@@ -6,7 +6,7 @@ your tex2rtf.ini file.
(See \helpref{wxHtmlHelpController}{wxhtmlhelpcontroller} for help controller description.)
A {\bf book} consists of three files : header file, contents file and index file.
A {\bf book} consists of three files: header file, contents file and index file.
You can make a regular zip archive of these files, plus the HTML and any image files,
for wxHTML (or helpview) to read; and the .zip file can optionally be renamed to .htb.

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

@@ -15,7 +15,7 @@ passed {\bf string}. See the example:
mywin -> LoadPage("test.htm");
mywin -> SetPage("<html><body>"
"<h1>Error</h1>"
"Some error occured :-H)"
"Some error occurred :-H)"
"</body></hmtl>");
\end{verbatim}
@@ -43,7 +43,7 @@ See the example:
html -> SetRelatedStatusBar(0);
\end{verbatim}
The first command associates html object with it's parent frame
The first command associates html object with it is parent frame
(this points to wxFrame object there) and sets format of title.
Page title "Hello, world!" will be displayed as "HTML : Hello, world!"
in this example.

6
docs/latex/wx/htparser.tex
View File

@@ -103,7 +103,7 @@ This must be called after DoParsing().
\constfunc{wxFileSystem*}{GetFS}{\void}
Returns pointer to the file system. Because each tag handler has
reference to it's parent parser it can easily request the file by
reference to it is parent parser it can easily request the file by
calling
\begin{verbatim}
@@ -131,7 +131,7 @@ Returns pointer to the source being parsed.
\func{virtual void}{InitParser}{\param{const wxString\& }{source}}
Setups the parser for parsing the {\it source} string. (Should be overriden
Setups the parser for parsing the {\it source} string. (Should be overridden
in derived class)
\membersection{wxHtmlParser::Parse}\label{wxhtmlparserparse}
@@ -188,7 +188,7 @@ It is obvious that you cannot use only one tag handler for <param> tag.
Instead you must use context-sensitive handlers for <param> inside <myitems>
and <param> inside <execute>.
This is the prefered solution:
This is the preferred solution:
\begin{verbatim}
TAG_HANDLER_BEGIN(MYITEM, "MYITEMS")

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

@@ -22,7 +22,7 @@ wxObject
\func{}{wxHtmlTag}{\param{const wxString\& }{source}, \param{int }{pos}, \param{int }{end\_pos}, \param{wxHtmlTagsCache* }{cache}}
Constructor. You'll probably never have to construct a wxHtmlTag object
Constructor. You will probably never have to construct a wxHtmlTag object
yourself. Feel free to ignore the constructor parameters.
Have a look at lib/htmlparser.cpp if you're interested in creating it.

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

@@ -28,7 +28,7 @@ tag handlers. It is used almost exclusively together with set of
\func{virtual void}{FillHandlersTable}{\param{wxHtmlWinParser }{*parser}}
You must override this method. In most common case it's body consists
You must override this method. In most common case it is body consists
only of lines of following type:
\begin{verbatim}

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

@@ -28,7 +28,7 @@ Constructor.
\wxheading{Parameters}
\docparam{wnd}{Connected window. It's parent window {\bf must} be the wxHtmlWindow object within
\docparam{wnd}{Connected window. It is parent window {\bf must} be the wxHtmlWindow object within
which it is displayed!}
\docparam{w}{Floating width. If non-zero width of {\it wnd} window is adjusted so that it is

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

@@ -127,7 +127,7 @@ htmlwin -> SetPage("help/myproject/index.htm");
\wxheading{Return value}
FALSE if an error occured, TRUE otherwise
FALSE if an error occurred, TRUE otherwise
\membersection{wxHtmlWindow::OnLinkClicked}\label{wxhtmlwindowonlinkclicked}
@@ -230,7 +230,7 @@ If you want to load a document from some location use
\wxheading{Return value}
FALSE if an error occured, TRUE otherwise.
FALSE if an error occurred, TRUE otherwise.
\membersection{wxHtmlWindow::SetRelatedFrame}\label{wxhtmlwindowsetrelatedframe}

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

@@ -80,7 +80,7 @@ Returns default horizontal alignment.
\constfunc{int}{GetCharHeight}{\void}
Returns (average) char height in standard font. It's used as DC-independent metrics.
Returns (average) char height in standard font. It is used as DC-independent metrics.
{\bf Note:} This function doesn't return the {\it actual} height. If you want to
know the height of the current font, call {\tt GetDC -> GetCharHeight()}.
@@ -89,7 +89,7 @@ know the height of the current font, call {\tt GetDC -> GetCharHeight()}.
\constfunc{int}{GetCharWidth}{\void}
Returns average char width in standard font. It's used as DC-independent metrics.
Returns average char width in standard font. It is used as DC-independent metrics.
{\bf Note:} This function doesn't return the {\it actual} width. If you want to
know the height of the current font, call {\tt GetDC -> GetCharWidth()}

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

@@ -1,11 +1,11 @@
\section{wxWindows "Hello World"}\label{helloworld}
As many people have requested a mini-sample to be published here
so that some quick judgements concerning syntax
so that some quick judgments concerning syntax
and basic principles can be made, you can now look at wxWindows'
"Hello World":
You have to include wxWindows's header files, of course. This can
You have to include wxWindows' header files, of course. This can
be done on a file by file basis (such as \#include "wx/window.h")
or using one global include (\#include "wx/wx.h"). This is
also useful on platforms which support precompiled headers such
@@ -75,7 +75,7 @@ enum
};
\end{verbatim}
We then procede to actually implement an event table in which the events
We then proceed to actually implement an event table in which the events
are routed to their respective handler functions in the class MyFrame.
There are predefined macros for routing all common events, ranging from
the selection of a list box entry to a resize event when a user resizes
@@ -101,11 +101,11 @@ using this macro, which creates an application instance and starts the program.
IMPLEMENT_APP(MyApp)
\end{verbatim}
As mentionend above, wxApp::OnInit() is called upon startup and should be
As mentioned above, wxApp::OnInit() is called upon startup and should be
used to initialize the program, maybe showing a "splash screen" and creating
the main window (or several). The frame should get a title bar text ("Hello World")
and a position and start-up size. One frame can also be declared to be the
top window. Returning TRUE indicates a successful intialization.
top window. Returning TRUE indicates a successful initialization.
\begin{verbatim}
bool MyApp::OnInit()
@@ -142,9 +142,9 @@ MyFrame::MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size)
\end{verbatim}
Here are the actual event handlers. MyFrame::OnQuit() closes the main window
by calling Close(). The paramter TRUE indicates that other windows have no veto
by calling Close(). The parameter TRUE indicates that other windows have no veto
power such as after asking "Do you really want to close?". If there is no other
main window left, the applicatin will quit.
main window left, the application will quit.
\begin{verbatim}
void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
@@ -159,7 +159,7 @@ case a typical "About" window with information about the program.
\begin{verbatim}
void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
{
wxMessageBox( "This is a wxWindows's Hello world sample",
wxMessageBox( "This is a wxWindows' Hello world sample",
"About Hello World", wxOK | wxICON_INFORMATION );
}
\end{verbatim}

74
docs/latex/wx/image.tex
View File

@@ -29,7 +29,7 @@ handler with \helpref{wxImage::AddHandler}{wximageaddhandler} or
\twocolitem{{\bf \indexit{wxGIFHandler}}}{Only for loading, due to legal issues.}
\twocolitem{{\bf \indexit{wxPCXHandler}}}{For loading and saving (see below).}
\twocolitem{{\bf \indexit{wxPNMHandler}}}{For loading and saving (see below).}
\twocolitem{{\bf \indexit{wxTIFFHandler}}}{For loading and saving.}
\twocolitem{{\bf \indexit{wxTIFFHandler}}}{For loading.}
\end{twocollist}
When saving in PCX format, {\bf wxPCXHandler} will count the number of
@@ -74,6 +74,13 @@ and forth without loss in that respect.
Creates an image with the given width and height.
\func{}{wxImage}{\param{int}{ width}, \param{int}{ height}, \param{unsigned char*}{ data}, \param{bool}{ static_data=FALSE}}
Creates an image from given data with the given width and height. If
{\it static_data} is TRUE, then wxImage will not delete the actual
image data in its destructor, otherwise it will free it by calling
{\it free()}.
\func{}{wxImage}{\param{const wxString\& }{name}, \param{long}{ type = wxBITMAP\_TYPE\_ANY}}
\func{}{wxImage}{\param{const wxString\& }{name}, \param{const wxString\&}{ mimetype}}
@@ -180,6 +187,16 @@ on program start-up to look up colors. This ensures a very fast conversion, but
the image quality won't be perfect (and could be better for photo images using more
sophisticated dithering algorithms).
On Windows, if there is a palette present (set with SetPalette), it will be used when
creating the wxBitmap (most useful in 8-bit display mode). On other platforms,
the palette is currently ignored.
\membersection{wxImage::Copy}\label{wximagecopy}
\constfunc{wxImage}{Copy}{\void}
Returns an identical copy of the image.
\membersection{wxImage::Create}\label{wximagecreate}
\func{bool}{Create}{\param{int}{ width}, \param{int}{ height}}
@@ -296,6 +313,15 @@ Gets the green value of the mask colour.
Gets the red value of the mask colour.
\membersection{wxImage::GetPalette}\label{wximagegetpalette}
\constfunc{const wxPalette\&}{GetPalette}{\void}
Returns the palette associated with the image. Currently the palette is only
used in ConvertToBitmap under Windows.
Eventually wxImage handlers will set the palette if one exists in the image file.
\membersection{wxImage::GetSubImage}\label{wximagegetsubimage}
\constfunc{wxImage}{GetSubImage}{\param{const wxRect\&}{ rect}}
@@ -458,7 +484,6 @@ Saves a image in the given stream.
\twocolitem{{\bf wxBITMAP\_TYPE\_PNG}}{Save a PNG image file.}
\twocolitem{{\bf wxBITMAP\_TYPE\_PCX}}{Save a PCX image file (tries to save as 8-bit if possible, falls back to 24-bit otherwise).}
\twocolitem{{\bf wxBITMAP\_TYPE\_PNM}}{Save a PNM image file (as raw RGB always).}
\twocolitem{{\bf wxBITMAP\_TYPE\_TIF}}{Save a TIFF image file.}
\end{twocollist}}
\docparam{mimetype}{MIME type.}
@@ -485,6 +510,13 @@ mimetype to the named file}
\end{twocollist}}
}
\membersection{wxImage::Mirror}\label{wximagemirror}
\constfunc{wxImage}{Mirror}{\param{bool}{ horizontally = TRUE}}
Returns a mirrored copy of the image. The parameter {\it horizontally}
indicates the orientation.
\membersection{wxImage::Replace}\label{wximagereplace}
\func{void}{Replace}{\param{unsigned char}{ r1}, \param{unsigned char}{ g1}, \param{unsigned char}{ b1},
@@ -517,6 +549,13 @@ rotated image background. Else, black (rgb 0, 0, 0) will be used.
Returns the rotated image, leaving this image intact.
\membersection{wxImage::Rotate90}\label{wximagerotate90}
\constfunc{wxImage}{Rotate90}{\param{bool}{ clockwise = TRUE}}
Returns a copy of the image rotated 90 degrees in the direction
indicated by {\it clockwise}.
\membersection{wxImage::Scale}\label{wximagescale}
\constfunc{wxImage}{Scale}{\param{int}{ width}, \param{int}{ height}}
@@ -526,7 +565,7 @@ scaling bitmaps in general as the only other way to scale bitmaps
is to blit a wxMemoryDC into another wxMemoryDC.
It may be mentioned that the GTK port uses this function internally
to scale bitmaps when using mapping mode in wxDC.
to scale bitmaps when using mapping modes in wxDC.
Example:
@@ -571,9 +610,15 @@ Specifies whether there is a mask or not. The area of the mask is determined by
Sets the mask colour for this image (and tells the image to use the mask).
\membersection{wxImage::SetPalette}\label{wximagesetpalette}
\func{void}{SetPalette}{\param{const wxPalette\&}{ palette}}
Associates a palette with the image. Currently, the palette is not used.
\membersection{wxImage::SetRGB}\label{wximagesetrgb}
\func{void}{SetRGB}{\param{int }{x}, \param{int }{y}, \param{unsigned char }{red}, \param{unsigned char }{blue}, \param{unsigned char }{green}}
\func{void}{SetRGB}{\param{int }{x}, \param{int }{y}, \param{unsigned char }{red}, \param{unsigned char }{green}, \param{unsigned char }{blue}}
Sets the pixel at the given coordinate. This routine performs bounds-checks
for the coordinate so it can be considered a safe way to manipulate the
@@ -779,6 +824,16 @@ Sets the handler extension.
\docparam{extension}{Handler extension.}
\membersection{wxImageHandler::SetMimeType}\label{wximagehandlersetmimetype}
\func{void}{SetMimeType}{\param{const wxString\& }{mimetype}}
Sets the handler MIME type.
\wxheading{Parameters}
\docparam{mimename}{Handler MIME type.}
\membersection{wxImageHandler::SetType}
\func{void}{SetType}{\param{long }{type}}
@@ -789,14 +844,3 @@ Sets the handler type.
\docparam{name}{Handler type.}
\membersection{wxImageHandler::SetMimeType}
\func{void}{SetMimeType}{\param{const wxString\& }{mimetype}}
Sets the handler MIME type.
\wxheading{Parameters}
\docparam{mimename}{Handler MIME type.}

20
docs/latex/wx/imaglist.tex
View File

@@ -131,6 +131,26 @@ that the background is solid.}
Returns the number of images in the list.
\membersection{wxImageList::GetSize}\label{wximagelistgetsize}
\constfunc{bool}{GetSize}{\param{int }{index}, \param{int\& }{width}, \param{int \&}{height}}
Retrieves the size of the images in the list. Currently, the {\it index}
parameter is ignored as all images in the list have the same size.
\wxheading{Parameters}
\docparam{index}{currently unused, should be 0}
\docparam{width}{receives the width of the images in the list}
\docparam{height}{receives the height of the images in the list}
\wxheading{Return value}
TRUE if the function succeeded, FALSE if it failed (for example, if the image
list was not yet initialized).
\membersection{wxImageList::Remove}\label{wximagelistremove}
\func{bool}{Remove}{\param{int}{ index}}

24
docs/latex/wx/keyevent.tex
View File

@@ -93,6 +93,14 @@ Returns TRUE if the Alt key was down at the time of the key event.
Returns TRUE if the control key was down at the time of the key event.
\membersection{wxKeyEvent::GetKeyCode}
\constfunc{int}{GetKeyCode}{\void}
Returns the virtual key code. ASCII events return normal ASCII values,
while non-ASCII events return values such as {\bf WXK\_LEFT} for the
left cursor key. See \helpref{Keycodes}{keycodes} for a full list of the virtual key codes.
\membersection{wxKeyEvent::GetX}
\constfunc{long}{GetX}{\void}
@@ -105,14 +113,6 @@ Returns the X position of the event.
Returns the Y position of the event.
\membersection{wxKeyEvent::KeyCode}
\constfunc{long}{KeyCode}{\void}
Returns the virtual key code. ASCII events return normal ASCII values,
while non-ASCII events return values such as {\bf WXK\_LEFT} for the
left cursor key. See \helpref{Keycodes}{keycodes} for a full list of the virtual key codes.
\membersection{wxKeyEvent::MetaDown}
\constfunc{bool}{MetaDown}{\void}
@@ -127,6 +127,14 @@ Returns TRUE if the Meta key was down at the time of the key event.
Obtains the position at which the key was pressed.
\membersection{wxKeyEvent::HasModifiers}
\constfunc{bool}{HasModifiers}{\void}
Returns TRUE if either of {\sc Ctrl}, {\sc Alt} or {\sc Meta} keys was down
at the time of the key event. Note that this function does not take into
account the {\sc Shift} key state.
\membersection{wxKeyEvent::ShiftDown}
\constfunc{bool}{ShiftDown}{\void}

6
docs/latex/wx/list.tex
View File

@@ -19,7 +19,7 @@ data but make all of its dangerous (because untyped) functions protected, so
that they can only be used from derived classes which, in turn, expose a type
safe interface. With this approach a new wxList-like class must be defined for
each list type (i.e. list of ints, of wxStrings or of MyObjects). This is done
with {\it WX\_DECLARE\_LIST} and {\it WX\_IMPLEMENT\_LIST} macros like this
with {\it WX\_DECLARE\_LIST} and {\it WX\_DEFINE\_LIST} macros like this
(notice the similarity with WX\_DECLARE\_OBJARRAY and WX\_IMPLEMENT\_OBJARRAY
macros):
@@ -51,8 +51,8 @@ macros):
// also have MyList::Node type which is the type-safe version of wxNode.
MyList list;
MyListElement element;
list.Add(element); // ok
list.Add(17); // error: incorrect type
list.Append(element); // ok
list.Append(17); // error: incorrect type
// let's iterate over the list
for ( MyList::Node *node = list.GetFirst(); node; node = node->GetNext() )

17
docs/latex/wx/listctrl.tex
View File

@@ -187,18 +187,21 @@ Ensures this item is visible.
\func{long}{FindItem}{\param{long }{start}, \param{const wxString\& }{str}, \param{const bool }{partial = FALSE}}
Find an item whose label matches this string, starting from the item after {\it start} or
the beginning if {\it start} is -1.
Find an item whose label matches this string, starting from the item
{\it start}.
\func{long}{FindItem}{\param{long }{start}, \param{long }{data}}
Find an item whose data matches this data, starting from the item after {\it start} or
the beginning if 'start' is -1.
Find an item whose data matches this data, starting from the item {\it start}.
\func{long}{FindItem}{\param{long }{start}, \param{const wxPoint\& }{pt}, \param{int }{direction}}
Find an item nearest this position in the specified direction, starting from
the item after {\it start} or the beginning if {\it start} is -1.
the item {\it start}.
{\bf NB:} The meaning of parameters {\it start} has changed in wxMSW
version 2.2.0, previously the item with this index was excluded from the
search but it is included now.
\pythonnote{In place of a single overloaded method name, wxPython
implements the following methods:\par
@@ -261,8 +264,8 @@ You must call {\it info.SetId()} to se ID of item you're interested in
before calling this method.
\pythonnote{The wxPython version of this method takes an integer parameter
for the item ID, and returns the wxListItem object.
}
for the item ID, an optional integer for the column number, and
returns the wxListItem object. }
\membersection{wxListCtrl::GetItemData}\label{wxlistctrlgetitemdata}

59
docs/latex/wx/listevt.tex
View File

@@ -48,45 +48,76 @@ functions that take a wxListEvent argument.
Constructor.
\membersection{wxListEvent::m\_code}
\membersection{wxListEvent::GetCode}\label{wxlisteventgetcode}
\member{int}{m\_code}
\constfunc{int}{GetCode}{\void}
Key code if the event is a keypress event.
\membersection{wxListEvent::m\_itemIndex}
\membersection{wxListEvent::GetIndex}\label{wxlisteventgetindex}
\member{long}{m\_itemIndex}
\constfunc{long}{GetIndex}{\void}
The item index.
\membersection{wxListEvent::m\_oldItemIndex}
\membersection{wxListEvent::GetOldIndex}\label{wxlisteventgetoldindex}
\member{long}{m\_oldItemIndex}
\constfunc{long}{GetOldIndex}{\void}
The old item index.
\membersection{wxListEvent::m\_col}
\membersection{wxListEvent::GetColumn}\label{wxlisteventgetcolumn}
\member{int}{m\_col}
\constfunc{int}{GetColumn}{\void}
The column position.
\membersection{wxListEvent::m\_cancelled}
\membersection{wxListEvent::Cancelled}\label{wxlisteventcancelled}
\member{bool}{m\_cancelled}
\constfunc{bool}{Cancelled}{\void}
TRUE if this event is an end edit event and the user cancelled the edit.
\membersection{wxListEvent::m\_pointDrag}
\membersection{wxListEvent::GetPoint}\label{wxlisteventgetpoint}
\member{wxPoint}{m\_pointDrag}
\constfunc{wxPoint}{GetPoint}{\void}
The position of the mouse pointer if the event is a drag event.
\membersection{wxListEvent::m\_item}
\member{wxListItem}{m\_item}
\membersection{wxListEvent::GetLabel}\label{wxlisteventgetlabel}
\constfunc{const wxString\&}{GetLabel}{\void}
The label.
\membersection{wxListEvent::GetText}\label{wxlisteventgettext}
\constfunc{const wxString\&}{GetText}{\void}
The text.
\membersection{wxListEvent::GetImage}\label{wxlisteventgetimage}
\constfunc{int}{GetImage}{\void}
The image.
\membersection{wxListEvent::GetData}\label{wxlisteventgetdata}
\constfunc{long}{GetData}{\void}
The data.
\membersection{wxListEvent::GetMask}\label{wxlisteventgetmask}
\constfunc{long}{GetMask}{\void}
The mask.
\membersection{wxListEvent::GetItem}\label{wxlisteventgetitem}
\constfunc{const wxListItem\&}{GetItem}{\void}
An item object, used by some events. See also \helpref{wxListCtrl::SetItem}{wxlistctrlsetitem}.

68
docs/latex/wx/locale.tex
View File

@@ -51,7 +51,11 @@ understand: first of all, the application locale is changed - note that this
will affect many of standard C library functions such as printf() or strftime().
Second, this wxLocale object becomes the new current global locale for the
application and so all subsequent calls to wxGetTranslation() will try to
translate the messages using the message catalogs for this locale.
translate the messages using the message catalogs for this locale. Finally,
unless bLoadDefault parameter is FALSE, the method also loads the wxstd.mo
catalog (which is looked for in all the usual places and, additionally, under
the location specified bythe environment variable WXDIR if it is set) which
will allow to translate all the messages generated by the library itself.
\membersection{wxLocale::\destruct{wxLocale}}\label{wxlocaledtor}
@@ -61,18 +65,11 @@ The destructor, like the constructor, also has global side effects: the previous
set locale is restored and so the changes described in
\helpref{Init}{wxlocaleinit} documentation are rolled back.
\membersection{wxLocale::GetLocale}\label{wxlocalegetlocale}
\constfunc{const char*}{GetLocale}{\void}
Returns the locale name as passed to the constructor or
\helpref{Init()}{wxlocaleinit}.
\membersection{wxLocale::AddCatalog}\label{wxlocaleaddcatalog}
\func{bool}{AddCatalog}{\param{const char }{*szDomain}}
Add a catalog for use with the current locale: it's searched for in standard
Add a catalog for use with the current locale: it is searched for in standard
places (current directory first, then the system one), but you may also prepend
additional directories to the search path with
\helpref{AddCatalogLookupPathPrefix()}{wxlocaleaddcataloglookuppathprefix}.
@@ -93,6 +90,36 @@ looked up under prefix/<lang>/LC\_MESSAGES, prefix/LC\_MESSAGES and prefix
This only applies to subsequent invocations of AddCatalog()!
\membersection{wxLocale::GetLocale}\label{wxlocalegetlocale}
\constfunc{const char*}{GetLocale}{\void}
Returns the locale name as passed to the constructor or
\helpref{Init()}{wxlocaleinit}.
\membersection{wxLocale::GetName}\label{wxlocalegetname}
\constfunc{const wxString\&}{GetName}{\void}
Returns the current short name for the locale (as given to the constructor or
the Init() function).
\membersection{wxLocale::GetString}\label{wxlocalegetstring}
\constfunc{const char*}{GetString}{\param{const char }{*szOrigString}, \param{const char }{*szDomain = NULL}}
Retrieves the translation for a string in all loaded domains unless the szDomain
parameter is specified (and then only this catalog/domain is searched).
Returns original string if translation is not available
(in this case an error message is generated the first time
a string is not found; use \helpref{wxLogNull}{wxlogoverview} to suppress it).
\wxheading{Remarks}
Domains are searched in the last to first order, i.e. catalogs
added later override those added before.
\membersection{wxLocale::Init}\label{wxlocaleinit}
\func{bool}{Init}{\param{const char }{*szName}, \param{const char }{*szShort = NULL}, \param{const char }{*szLocale = NULL}, \param{bool }{bLoadDefault = TRUE}}
@@ -129,26 +156,9 @@ normally corresponds to 'domain' which is more or less the application name.
See also: \helpref{AddCatalog}{wxlocaleaddcatalog}
\membersection{wxLocale::GetName}\label{wxlocalegetname}
\membersection{wxLocale::IsOk}\label{wxlocaleisok}
\constfunc{const wxString\&}{GetName}{\void}
\constfunc{bool}{IsOk}{\void}
Returns the current short name for the locale (as given to the constructor or
the Init() function).
\membersection{wxLocale::GetString}\label{wxlocalegetstring}
\constfunc{const char*}{GetString}{\param{const char }{*szOrigString}, \param{const char }{*szDomain = NULL}}
Retrieves the translation for a string in all loaded domains unless the szDomain
parameter is specified (and then only this catalog/domain is searched).
Returns original string if translation is not available
(in this case an error message is generated the first time
a string is not found; use \helpref{wxLogNull}{wxlogoverview} to suppress it).
\wxheading{Remarks}
Domains are searched in the last to first order, i.e. catalogs
added later override those added before.
Returns TRUE if the locale could be set successfully.

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

@@ -6,7 +6,7 @@
%% Created: 07.03.00
%% RCS-ID: $Id$
%% Copyright: (c) Vadim Zeitlin
%% Licence: wxWindows licence
%% License: wxWindows license
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{\class{wxLongLong}}\label{wxlonglong}

8
docs/latex/wx/manual.tex
View File

@@ -1,5 +1,5 @@
\documentstyle[a4,11pt,makeidx,verbatim,texhelp,fancyheadings,palatino]{report}
% JACS: doesn't make it through Tex2RTF, sorry. I'll put it into texhelp.sty
% JACS: doesn't make it through Tex2RTF, sorry. I will put it into texhelp.sty
% since Tex2RTF doesn't parse it.
% BTW, style MUST be report for it to work for Tex2RTF.
%KB:
@@ -25,13 +25,13 @@
%\special{!/@scaleunit 1 def}
\parskip=10pt
\parindent=0pt
\title{wxWindows 2.1.14: A portable C++ and Python GUI toolkit}
\title{wxWindows 2.2: A portable C++ and Python GUI toolkit}
\winhelponly{\author{by Julian Smart et al
%\winhelponly{\\$$\image{1cm;0cm}{wxwin.wmf}$$}
}}
\winhelpignore{\author{Julian Smart, Robert Roebling, Vadim Zeitlin,
Robin Dunn, et al}
\date{March 19th 2000}
\date{December 2001}
}
\makeindex
\begin{document}
@@ -91,7 +91,7 @@ members of the wxWindows team\\
Portions (c) 1996 Artificial Intelligence Applications Institute\\
\end{center}
Please also see the wxWindows licence files (preamble.txt, lgpl.txt, gpl.txt, licence.txt,
Please also see the wxWindows license files (preamble.txt, lgpl.txt, gpl.txt, license.txt,
licendoc.txt) for conditions of software and documentation use.
\section*{wxWindows Library License, Version 3}

3
docs/latex/wx/mask.tex
View File

@@ -1,7 +1,8 @@
\section{\class{wxMask}}\label{wxmask}
This class encapsulates a monochrome mask bitmap, where the masked area is black and
the unmasked area is white.
the unmasked area is white. When associated with a bitmap and drawn in a device context,
the unmasked area of the bitmap will be drawn, and the masked area will not be drawn.
\wxheading{Derived from}

49
docs/latex/wx/mbcnvfil.tex Normal file
View File

@@ -0,0 +1,49 @@
%
% automatically generated by HelpGen from
% ../include/wx/strconv.h at 25/Mar/00 10:20:56
%
\section{\class{wxMBConvFile}}\label{wxmbconvfile}
This class converts file names between filesystem multibyte encoding and
Unicode. It has one predefined instance, {\bf wxConvFile}.
Since some platforms (e.g. Win32) use Unicode in the filenames,
and others (e.g. Unix) use multibyte encodings, this class should only
be used directly if wxMBFILES is defined to 1. A convenience macro,
wxFNCONV, is defined to wxConvFile.cWX2MB in this case. You could use it
like this:
\begin{verbatim}
wxChar *name = wxT("rawfile.doc");
FILE *fil = fopen(wxFNCONV(name), "r");
\end{verbatim}
(although it would be better to use wxFopen(name, wxT("r")) in this case.)
\wxheading{Derived from}
\helpref{wxMBConv}{wxmbconv}
\wxheading{Include files}
<wx/strconv.h>
\wxheading{See also}
\helpref{wxMBConv classes overview}{mbconvclasses}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxMBConvFile::MB2WC}\label{wxmbconvfilemb2wc}
\constfunc{size\_t}{MB2WC}{\param{wchar\_t* }{buf}, \param{const char* }{psz}, \param{size\_t }{n}}
Converts from multibyte filename encoding to Unicode. Returns the size of the destination buffer.
\membersection{wxMBConvFile::WC2MB}\label{wxmbconvfilewc2mb}
\constfunc{size\_t}{WC2MB}{\param{char* }{buf}, \param{const wchar\_t* }{psz}, \param{size\_t }{n}}
Converts from Unicode to multibyte filename encoding. Returns the size of the destination buffer.

38
docs/latex/wx/mbcnvut7.tex Normal file
View File

@@ -0,0 +1,38 @@
%
% automatically generated by HelpGen from
% ../include/wx/strconv.h at 25/Mar/00 10:20:56
%
\section{\class{wxMBConvUTF7}}\label{wxmbconvutf7}
This class converts between the UTF-7 encoding and Unicode.
It has one predefined instance, {\bf wxConvUTF7}.
Unfortunately, this class is not quite implemented yet.
\wxheading{Derived from}
\helpref{wxMBConv}{wxmbconv}
\wxheading{Include files}
<wx/strconv.h>
\wxheading{See also}
\helpref{wxMBConvUTF8}{wxmbconvutf8},
\helpref{wxMBConv classes overview}{mbconvclasses}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxMBConvUTF7::MB2WC}\label{wxmbconvutf7mb2wc}
\constfunc{size\_t}{MB2WC}{\param{wchar\_t* }{buf}, \param{const char* }{psz}, \param{size\_t }{n}}
Converts from UTF-7 encoding to Unicode. Returns the size of the destination buffer.
\membersection{wxMBConvUTF7::WC2MB}\label{wxmbconvutf7wc2mb}
\constfunc{size\_t}{WC2MB}{\param{char* }{buf}, \param{const wchar\_t* }{psz}, \param{size\_t }{n}}
Converts from Unicode to UTF-7 encoding. Returns the size of the destination buffer.

59
docs/latex/wx/mbcnvut8.tex Normal file
View File

@@ -0,0 +1,59 @@
%
% automatically generated by HelpGen from
% ../include/wx/strconv.h at 25/Mar/00 10:20:56
%
\section{\class{wxMBConvUTF8}}\label{wxmbconvutf8}
This class converts between the UTF-8 encoding and Unicode.
It has one predefined instance, {\bf wxConvUTF8}.
\wxheading{Derived from}
\helpref{wxMBConv}{wxmbconv}
\wxheading{Include files}
<wx/strconv.h>
\wxheading{See also}
\helpref{wxMBConvUTF7}{wxmbconvutf7},
\helpref{wxMBConv classes overview}{mbconvclasses}
\wxheading{Remarks}
UTF-8 is a compatibility encoding used to encode Unicode text into anything that was
originally written for 8-bit strings, including (but not limited to) filenames, transfer
protocols, and database fields. Notable properties include:
\begin{itemize}
\item Variable-length encoding able to encode up to 31 bits per character
\item ASCII characters (character values under 128) are encoded as plain ASCII
(1 byte per character)
\item Null bytes do not occur in the encoding, except when there's an actual Unicode
null character
\item Preserves sort ordering for plain 8-bit comparison routines like strcmp()
\item High bit patterns unambiguates character boundaries, and makes it easy to
detect whether a string is encoded with UTF-8 or not
\end{itemize}
All of these properties make UTF-8 a very favorable solution in any situation
where full Unicode character support is desired while remaining compatible with
code written with only 8-bit extended-ASCII characters in mind.
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxMBConvUTF8::MB2WC}\label{wxmbconvutf8mb2wc}
\constfunc{size\_t}{MB2WC}{\param{wchar\_t* }{buf}, \param{const char* }{psz}, \param{size\_t }{n}}
Converts from UTF-8 encoding to Unicode. Returns the size of the destination buffer.
\membersection{wxMBConvUTF8::WC2MB}\label{wxmbconvutf8wc2mb}
\constfunc{size\_t}{WC2MB}{\param{char* }{buf}, \param{const wchar\_t* }{psz}, \param{size\_t }{n}}
Converts from Unicode to UTF-8 encoding. Returns the size of the destination buffer.

108
docs/latex/wx/mbconv.tex Normal file
View File

@@ -0,0 +1,108 @@
%
% automatically generated by HelpGen from
% ../include/wx/strconv.h at 25/Mar/00 10:20:56
%
\section{\class{wxMBConv}}\label{wxmbconv}
This class is the base class of a hierarchy of classes capable of converting
text strings between multibyte (SBCS or DBCS) encodings and Unicode. It is itself
a wrapper around the standard libc mbstowcs() and wcstombs() routines, and has
one predefined instance, {\bf wxConvLibc}.
\wxheading{Derived from}
No base class
\wxheading{Include files}
<wx/strconv.h>
\wxheading{See also}
\helpref{wxCSConv}{wxcsconv},
\helpref{wxEncodingConverter}{wxencodingconverter},
\helpref{wxMBConv classes overview}{mbconvclasses}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxMBConv::wxMBConv}\label{wxmbconvwxmbconv}
\func{}{wxMBConv}{\void}
Constructor.
\membersection{wxMBConv::MB2WC}\label{wxmbconvmb2wc}
\constfunc{virtual size\_t}{MB2WC}{\param{wchar\_t* }{buf}, \param{const char* }{psz}, \param{size\_t }{n}}
Converts from multibyte encoding to Unicode, using the libc routine mbstowcs()
(this is overridden by derived classes). Returns the size of the destination buffer.
\membersection{wxMBConv::WC2MB}\label{wxmbconvwc2mb}
\constfunc{virtual size\_t}{WC2MB}{\param{char* }{buf}, \param{const wchar\_t* }{psz}, \param{size\_t }{n}}
Converts from Unicode to multibyte encoding, using the libc routine wcstombs()
(this is overridden by derived classes). Returns the size of the destination buffer.
\membersection{wxMBConv::cMB2WC}\label{wxmbconvcmb2wc}
\constfunc{const wxWCharBuffer}{cMB2WC}{\param{const char* }{psz}}
Converts from multibyte encoding to Unicode by calling MB2WC,
allocating a temporary wxWCharBuffer to hold the result.
\membersection{wxMBConv::cWC2MB}\label{wxmbconvcwc2mb}
\constfunc{const wxCharBuffer}{cWC2MB}{\param{const wchar\_t* }{psz}}
Converts from Unicode to multibyte encoding by calling WC2MB,
allocating a temporary wxCharBuffer to hold the result.
\membersection{wxMBConv::cMB2WX}\label{wxmbconvcmb2wx}
\constfunc{const char*}{cMB2WX}{\param{const char* }{psz}}
\constfunc{const wxWCharBuffer}{cMB2WX}{\param{const char* }{psz}}
Converts from multibyte encoding to the current wxChar type
(which depends on whether wxUSE\_UNICODE is set to 1). If wxChar is char,
it returns the parameter unaltered. If wxChar is wchar\_t, it returns the
result in a wxWCharBuffer. The macro wxMB2WXbuf is defined as the correct
return type (without const).
\membersection{wxMBConv::cWX2MB}\label{wxmbconvcwx2mb}
\constfunc{const char*}{cWX2MB}{\param{const wxChar* }{psz}}
\constfunc{const wxCharBuffer}{cWX2MB}{\param{const wxChar* }{psz}}
Converts from the current wxChar type to multibyte encoding. If wxChar is char,
it returns the parameter unaltered. If wxChar is wchar\_t, it returns the
result in a wxCharBuffer. The macro wxWX2MBbuf is defined as the correct
return type (without const).
\membersection{wxMBConv::cWC2WX}\label{wxmbconvcwc2wx}
\constfunc{const wchar\_t*}{cWC2WX}{\param{const wchar\_t* }{psz}}
\constfunc{const wxCharBuffer}{cWC2WX}{\param{const wchar\_t* }{psz}}
Converts from Unicode to the current wxChar type. If wxChar is wchar\_t,
it returns the parameter unaltered. If wxChar is char, it returns the
result in a wxCharBuffer. The macro wxWC2WXbuf is defined as the correct
return type (without const).
\membersection{wxMBConv::cWX2WC}\label{wxmbconvcwx2wc}
\constfunc{const wchar\_t*}{cWX2WC}{\param{const wxChar* }{psz}}
\constfunc{const wxWCharBuffer}{cWX2WC}{\param{const wxChar* }{psz}}
Converts from the current wxChar type to Unicode. If wxChar is wchar\_t,
it returns the parameter unaltered. If wxChar is char, it returns the
result in a wxWCharBuffer. The macro wxWX2WCbuf is defined as the correct
return type (without const).

13
docs/latex/wx/mdi.tex
View File

@@ -245,7 +245,7 @@ Child frames may be either \helpref{wxMDIChildFrame}{wxmdichildframe}, or \helpr
An MDI parent frame always has a \helpref{wxMDIClientWindow}{wxmdiclientwindow} associated with it, which
is the parent for MDI client frames.
This client window may be resized to accomodate non-MDI windows, as seen in Microsoft Visual C++ (TM) and
This client window may be resized to accommodate non-MDI windows, as seen in Microsoft Visual C++ (TM) and
Microsoft Publisher (TM), where a documentation window is placed to one side of the workspace.
MDI remains popular despite dire warnings from Microsoft itself that MDI is an obsolete
@@ -476,7 +476,14 @@ is available under Windows only.
\func{virtual wxMDIClientWindow*}{OnCreateClient}{\void}
Override this to return a different kind of client window.
Override this to return a different kind of client window. If you override this function,
you must create your parent frame in two stages, or your function will never be called,
due to the way C++ treats virtual functions called from constructors. For example:
\begin{verbatim}
frame = new MyParentFrame;
frame->Create(parent, myParentFrameId, wxT("My Parent Frame"));
\end{verbatim}
\wxheading{Remarks}
@@ -486,7 +493,7 @@ on the background.
Note that it is probably impossible to have a client window that scrolls as well as painting
a bitmap or pattern, since in {\bf OnScroll}, the scrollbar positions always return zero.
(Solutions to: \verb$julian.smart@ukonline.co.uk$).
(Solutions to: \verb$julian.smart@btopenworld.com$).
\wxheading{See also}

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

@@ -527,7 +527,7 @@ Adds the item to the end of the menu bar.
\wxheading{Return value}
TRUE on success, FALSE if an error occured.
TRUE on success, FALSE if an error occurred.
\wxheading{See also}
@@ -720,7 +720,7 @@ position $0$ will insert it in the very beginning of it, inserting at position
\wxheading{Return value}
TRUE on success, FALSE if an error occured.
TRUE on success, FALSE if an error occurred.
\wxheading{See also}

20
docs/latex/wx/mouseevt.tex
View File

@@ -9,6 +9,20 @@ drawbacks: the LEAVE\_WINDOW event might be received some time after the mouse
left the window and the state variables for it may have changed during this
time.
{\bf NB: } Note the difference between methods like
\helpref{LeftDown}{wxmouseeventleftdown} and
\helpref{LeftIsDown}{wxmouseeventleftisdown}: the formet returns {\tt TRUE}
when the event corresponds to the left mouse button click while the latter
returns {\tt TRUE} if the left mouse button is currently being pressed. For
example, when the user is dragging the mouse you can use
\helpref{LeftIsDown}{wxmouseeventleftisdown} to test
whether the left mouse button is (still) depressed. Also, by convention, if
\helpref{LeftDown}{wxmouseeventleftdown} returns {\tt TRUE},
\helpref{LeftIsDown}{wxmouseeventleftisdown} will also return {\tt TRUE} in
wxWindows whatever the underlying GUI behaviour is (which is
platform-dependent). The same applies, of course, to other mouse buttons as
well.
\wxheading{Derived from}
\helpref{wxEvent}{wxevent}
@@ -242,7 +256,7 @@ Returns TRUE if the event was a left double click.
Returns TRUE if the left mouse button changed to down.
\membersection{wxMouseEvent::LeftIsDown}
\membersection{wxMouseEvent::LeftIsDown}\label{wxmouseeventleftisdown}
\constfunc{bool}{LeftIsDown}{\void}
@@ -281,7 +295,7 @@ Returns TRUE if the event was a middle double click.
Returns TRUE if the middle mouse button changed to down.
\membersection{wxMouseEvent::MiddleIsDown}
\membersection{wxMouseEvent::MiddleIsDown}\label{wxmouseeventmiddleisdown}
\constfunc{bool}{MiddleIsDown}{\void}
@@ -312,7 +326,7 @@ Returns TRUE if the event was a right double click.
Returns TRUE if the right mouse button changed to down.
\membersection{wxMouseEvent::RightIsDown}
\membersection{wxMouseEvent::RightIsDown}\label{wxmouseeventrightisdown}
\constfunc{bool}{RightIsDown}{\void}

6
docs/latex/wx/msgdlg.tex
View File

@@ -43,10 +43,12 @@ Constructor. Use \helpref{wxMessageDialog::ShowModal}{wxmessagedialogshowmodal}
\twocolitem{{\bf wxOK}}{Show an OK button.}
\twocolitem{{\bf wxCANCEL}}{Show a Cancel button.}
\twocolitem{{\bf wxYES\_NO}}{Show Yes and No buttons.}
\twocolitem{{\bf wx\_NO\_DEFAULT}}{Used with {\bf wxYES\_NO}, makes {\bf No} button the default.}
\twocolitem{{\bf wxYES\_DEFAULT}}{Used with {\bf wxYES\_NO}, makes {\bf Yes} button the default - which is the default behaviour.}
\twocolitem{{\bf wxNO\_DEFAULT}}{Used with {\bf wxYES\_NO}, makes {\bf No} button the default.}
\twocolitem{{\bf wxCENTRE}}{Centre the message. Not Windows.}
\twocolitem{{\bf wxICON\_EXCLAMATION}}{Shows an exclamation mark icon.}
\twocolitem{{\bf wxICON\_HAND}}{Shows a hand icon.}
\twocolitem{{\bf wxICON\_HAND}}{Shows an error icon.}
\twocolitem{{\bf wxICON\_ERROR}}{Shows an error icon - the same as wxICON\_HAND.}
\twocolitem{{\bf wxICON\_QUESTION}}{Shows a question mark icon.}
\twocolitem{{\bf wxICON\_INFORMATION}}{Shows an information (i) icon.}
\end{twocollist}

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

@@ -25,7 +25,7 @@ None.
\func{}{wxMutexLocker}{\param{wxMutex *}{mutex}}
Constructs a wxMutexLocker object associated with mutex which must be non NULL
Constructs a wxMutexLocker object associated with mutex which must be non-NULL
and locks it. Call \helpref{IsLocked}{wxmutexlockerisok} to check if the mutex was
successfully locked.

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

@@ -11,7 +11,7 @@ In order to query the size of notebook page, this page needs to have its
own sizer, otherwise the wxNotebookSizer will ignore it. Notebook pages
get there sizer by assiging one to them using \helpref{wxWindow::SetSizer}{wxwindowsetsizer}
and setting the auto-layout option to TRUE using
\helpref{wxWindow::SetAutolayout}{wxwindowsetautoLayout}. Here is one
\helpref{wxWindow::SetAutoLayout}{wxwindowsetautolayout}. Here is one
example showing how to add a notebook page that the notebook sizer is
aware of:

Some files were not shown because too many files have changed in this diff Show More