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

removed docs for classes not existing any more (part of patch 1757479)

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@47638 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin 2007-07-21 23:59:07 +00:00
parent b0f76951bc
commit 08f35f8720
5 changed files with 0 additions and 1632 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,269 +0,0 @@
\section{\class{wxDatabase}}\label{wxdatabase}
Every database object represents an ODBC connection.
The connection may be closed and reopened.
\wxheading{Derived from}
\helpref{wxObject}{wxobject}
\wxheading{Include files}
<wx/odbc.h>
\wxheading{See also}
\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}
\func{}{wxDatabase}{\void}
Constructor. The constructor of the first wxDatabase instance of an
application initializes the ODBC manager.
\membersection{wxDatabase::\destruct{wxDatabase}}
\func{}{\destruct{wxDatabase}}{\void}
Destructor. Resets and destroys any associated wxRecordSet instances.
The destructor of the last wxDatabase instance will deinitialize
the ODBC manager.
\membersection{wxDatabase::BeginTrans}
\func{bool}{BeginTrans}{\void}
Not implemented.
\membersection{wxDatabase::Cancel}
\func{void}{Cancel}{\void}
Not implemented.
\membersection{wxDatabase::CanTransact}
\func{bool}{CanTransact}{\void}
Not implemented.
\membersection{wxDatabase::CanUpdate}
\func{bool}{CanUpdate}{\void}
Not implemented.
\membersection{wxDatabase::Close}
\func{bool}{Close}{\void}
Resets the statement handles of any associated wxRecordSet objects,
and disconnects from the current data source.
\membersection{wxDatabase::CommitTrans}
\func{bool}{CommitTrans}{\void}
Commits previous transactions. Not implemented.
\membersection{wxDatabase::GetDatabaseName}
\func{wxString}{GetDatabaseName}{\void}
Returns the name of the database associated with the current connection.
\membersection{wxDatabase::GetDataSource}
\func{wxString}{GetDataSource}{\void}
Returns the name of the connected data source.
\membersection{wxDatabase::GetErrorClass}
\func{wxString}{GetErrorClass}{\void}
Returns the error class of the last error. The error class consists of
five characters where the first two characters contain the class
and the other three characters contain the subclass of the ODBC error.
See ODBC documentation for further details.
\membersection{wxDatabase::GetErrorCode}
\func{wxRETCODE}{GetErrorCode}{\void}
Returns the error code of the last ODBC function call. This will be one of:
\begin{twocollist}\itemsep=0pt
\twocolitem{SQL\_ERROR}{General error.}
\twocolitem{SQL\_INVALID\_HANDLE}{An invalid handle was passed to an ODBC function.}
\twocolitem{SQL\_NEED\_DATA}{ODBC expected some data.}
\twocolitem{SQL\_NO\_DATA\_FOUND}{No data was found by this ODBC call.}
\twocolitem{SQL\_SUCCESS}{The call was successful.}
\twocolitem{SQL\_SUCCESS\_WITH\_INFO}{The call was successful, but further information can be
obtained from the ODBC manager.}
\end{twocollist}
\membersection{wxDatabase::GetErrorMessage}
\func{wxString}{GetErrorMessage}{\void}
Returns the last error message returned by the ODBC manager.
\membersection{wxDatabase::GetErrorNumber}
\func{long}{GetErrorNumber}{\void}
Returns the last native error. A native error is an ODBC driver dependent
error number.
\membersection{wxDatabase::GetHDBC}
\func{HDBC}{GetHDBC}{\void}
Returns the current ODBC database handle.
\membersection{wxDatabase::GetHENV}
\func{HENV}{GetHENV}{\void}
Returns the ODBC environment handle.
\membersection{wxDatabase::GetInfo}
\func{bool}{GetInfo}{\param{long}{ infoType}, \param{long *}{buf}}
\func{bool}{GetInfo}{\param{long}{ infoType}, \param{const wxString\& }{buf}, \param{int}{ bufSize=-1}}
Returns requested information. The return value is true if successful, false otherwise.
{\it infoType} is an ODBC identifier specifying the type of information to be returned.
{\it buf} is a character or long integer pointer to storage which must be allocated by the
application, and which will contain the information if the function is successful.
{\it bufSize} is the size of the character buffer. A value of -1 indicates that the size
should be computed by the GetInfo function.
\membersection{wxDatabase::GetPassword}
\func{wxString}{GetPassword}{\void}
Returns the password of the current user.
\membersection{wxDatabase::GetUsername}
\func{wxString}{GetUsername}{\void}
Returns the current username.
\membersection{wxDatabase::GetODBCVersionFloat}
\func{float}{GetODBCVersionFloat}{\param{bool}{ implementation=true}}
Returns the version of ODBC in floating point format, e.g. 2.50.
{\it implementation} should be true to get the DLL version, or false to get the
version defined in the {\tt sql.h} header file.
This function can return the value 0.0 if the header version number is not defined (for early
versions of ODBC).
\membersection{wxDatabase::GetODBCVersionString}
\func{wxString}{GetODBCVersionString}{\param{bool}{ implementation=true}}
Returns the version of ODBC in string format, e.g. ``02.50".
{\it implementation} should be true to get the DLL version, or false to get the
version defined in the {\tt sql.h} header file.
This function can return the value ``00.00" if the header version number is not defined (for early
versions of ODBC).
\membersection{wxDatabase::InWaitForDataSource}
\func{bool}{InWaitForDataSource}{\void}
Not implemented.
\membersection{wxDatabase::IsOpen}
\func{bool}{IsOpen}{\void}
Returns true if a connection is open.
\membersection{wxDatabase::Open}\label{wxdatabaseopen}
\func{bool}{Open}{\param{const wxString\& }{datasource}, \param{bool}{ exclusive = false}, \param{bool }{readOnly = true},
\param{const wxString\& }{username = ``ODBC"}, \param{const wxString\& }{password = ``"}}
Connect to a data source. {\it datasource} contains the name of the ODBC data
source. The parameters exclusive and readOnly are not used.
\membersection{wxDatabase::OnSetOptions}
\func{void}{OnSetOptions}{\param{wxRecordSet *}{recordSet}}
Not implemented.
\membersection{wxDatabase::OnWaitForDataSource}
\func{void}{OnWaitForDataSource}{\param{bool}{ stillExecuting}}
Not implemented.
\membersection{wxDatabase::RollbackTrans}
\func{bool}{RollbackTrans}{\void}
Sends a rollback to the ODBC driver. Not implemented.
\membersection{wxDatabase::SetDataSource}
\func{void}{SetDataSource}{\param{const wxString\& }{s}}
Sets the name of the data source. Not implemented.
\membersection{wxDatabase::SetLoginTimeout}
\func{void}{SetLoginTimeout}{\param{long}{ seconds}}
Sets the time to wait for an user login. Not implemented.
\membersection{wxDatabase::SetPassword}
\func{void}{SetPassword}{\param{const wxString\& }{s}}
Sets the password of the current user. Not implemented.
\membersection{wxDatabase::SetSynchronousMode}
\func{void}{SetSynchronousMode}{\param{bool }{synchronous}}
Toggles between synchronous and asynchronous mode. Currently only synchronous
mode is supported, so this function has no effect.
\membersection{wxDatabase::SetQueryTimeout}
\func{void}{SetQueryTimeout}{\param{long}{ seconds}}
Sets the time to wait for a response to a query. Not implemented.
\membersection{wxDatabase::SetUsername}
\func{void}{SetUsername}{\param{const wxString\& }{s}}
Sets the name of the current user. Not implemented.

496
docs/latex/wx/expr.tex
View File

@ -1,496 +0,0 @@
\section{\class{wxExpr}}\label{wxexpr}
The {\bf wxExpr} class is the building brick of expressions similar to Prolog
clauses, or objects. It can represent an expression of type long integer, float, string, word,
or list, and lists can be nested.
\wxheading{Derived from}
None
\wxheading{Include files}
<wx/wxexpr.h>
\wxheading{See also}
\helpref{wxExpr overview}{exproverview}, \helpref{wxExprDatabase}{wxexprdatabase}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxExpr::wxExpr}\label{wxexprconstr}
\func{}{wxExpr}{\param{const wxString\&}{functor}}
Construct a new clause with this form, supplying the functor name. A clause is an object
that will appear in the data file, with a list of attribute/value pairs.
\func{}{wxExpr}{\param{wxExprType}{ type}, \param{const wxString\&}{ wordOrString = ``"}}
Construct a new empty list, or a word (will be output with no quotes), or a string, depending on the
value of {\it type}.
{\it type} can be {\bf wxExprList}, {\bf wxExprWord}, or {\bf wxExprString}. If {\it type} is wxExprList,
the value of {\it wordOrString} will be ignored.
\func{}{wxExpr}{\param{long}{ value}}
Construct an integer expression.
\func{}{wxExpr}{\param{float}{ value}}
Construct a floating point expression.
\func{}{wxExpr}{\param{wxList* }{value}}
Construct a list expression. The list's nodes' data should
themselves be {\bf wxExpr}s.
wxExpr no longer uses the {\bf wxList} internally,
so this constructor turns the list into its internal
format (assuming a non-nested list) and then deletes the supplied
list.
\membersection{wxExpr::\destruct{wxExpr}}
\func{}{\destruct{wxExpr}}{\void}
Destructor.
\membersection{wxExpr::AddAttributeValue}\label{wxexpraddattributevalue}
Use these on clauses ONLY. Note that the functions for adding strings
and words must be differentiated by function name which is why
they are missing from this group (see \helpref{wxExpr::AddAttributeValueString}{wxexpraddattributevaluestring} and
\rtfsp\helpref{wxExpr::AddAttributeValueWord}{wxexpraddattributevalueword}).
\func{void}{AddAttributeValue}{\param{const wxString\&}{ attribute}, \param{float }{value}}
Adds an attribute and floating point value pair to the clause.
\func{void}{AddAttributeValue}{\param{const wxString\&}{ attribute}, \param{long }{value}}
Adds an attribute and long integer value pair to the clause.
\func{void}{AddAttributeValue}{\param{const wxString\&}{ attribute}, \param{wxList* }{value}}
Adds an attribute and list value pair to the clause, converting the list into
internal form and then deleting {\bf value}. Note that the list should not contain
nested lists (except if in internal {\bf wxExpr} form.)
\func{void}{AddAttributeValue}{\param{const wxString\&}{ attribute}, \param{wxExpr* }{value}}
Adds an attribute and wxExpr value pair to the clause. Do not delete\rtfsp
{\it value} once this function has been called.
\membersection{wxExpr::AddAttributeValueString}\label{wxexpraddattributevaluestring}
\func{void}{AddAttributeValueString}{\param{const wxString\&}{ attribute}, \param{const wxString\&}{ value}}
Adds an attribute and string value pair to the clause.
\membersection{wxExpr::AddAttributeValueStringList}\label{wxexpraddattributevaluestringlist}
\func{void}{AddAttributeValueStringList}{\param{const wxString\&}{ attribute}, \param{wxList* }{value}}
Adds an attribute and string list value pair to the clause.
Note that the list passed to this function is a list of strings, NOT a list
of {\bf wxExpr}s; it gets turned into a list of {\bf wxExpr}s
automatically. This is a convenience function, since lists of strings
are often manipulated in C++.
\membersection{wxExpr::AddAttributeValueWord}\label{wxexpraddattributevalueword}
\func{void}{AddAttributeValueWord}{\param{const wxString\&}{ attribute}, \param{const wxString\&}{ value}}
Adds an attribute and word value pair to the clause.
\membersection{wxExpr::Append}\label{wxexprappend}
\func{void}{Append}{\param{wxExpr*}{ value}}
Append the {\bf value} to the end of the list. `this' must be a list.
\membersection{wxExpr::Arg}\label{wxexprarg}
\constfunc{wxExpr* }{Arg}{\param{wxExprType}{ type}, \param{int}{ n}}
Get nth arg of the given clause (starting from 1). NULL is returned if
the expression is not a clause, or {\it n} is invalid, or the given type
does not match the actual type. See also \helpref{wxExpr::Nth}{wxexprnth}.
\membersection{wxExpr::Insert}\label{wxexprinsert}
\func{void}{Insert}{\param{wxExpr* }{value}}
Insert the {\bf value} at the start of the list. `this' must be a list.
\membersection{wxExpr::GetAttributeValue}\label{wxexprgetattributevalue}
These functions are the easiest way to retrieve attribute values, by
passing a pointer to variable. If the attribute is present, the
variable will be filled with the appropriate value. If not, the
existing value is left alone. This style of retrieving attributes
makes it easy to set variables to default values before calling these
functions; no code is necessary to check whether the attribute is
present or not.
\constfunc{bool}{GetAttributeValue}{\param{const wxString\&}{ attribute}, \param{wxString\&}{ value}}
Retrieve a string (or word) value.
\constfunc{bool}{GetAttributeValue}{\param{const wxString\&}{ attribute}, \param{float\& }{value}}
Retrieve a floating point value.
\constfunc{bool}{GetAttributeValue}{\param{const wxString\&}{ attribute}, \param{int\& }{value}}
Retrieve an integer value.
\constfunc{bool}{GetAttributeValue}{\param{const wxString\&}{ attribute}, \param{long\& }{value}}
Retrieve a long integer value.
\constfunc{bool}{GetAttributeValue}{\param{const wxString\&}{ attribute}, \param{wxExpr**}{ value}}
Retrieve a wxExpr pointer.
\membersection{wxExpr::GetAttributeValueStringList}\label{wxexprgetattributestringlist}
\constfunc{void}{GetAttributeValueStringList}{\param{const wxString\&}{attribute}, \param{wxList* }{value}}
Use this on clauses ONLY. See above for comments on this style of
attribute value retrieval. This function expects to receive a pointer to
a new list (created by the calling application); it will append strings
to the list if the attribute is present in the clause.
\membersection{wxExpr::AttributeValue}\label{wxexprattributevalue}
\constfunc{wxExpr*}{AttributeValue}{\param{const wxString\&}{ word}}
Use this on clauses ONLY. Searches the clause for an attribute
matching {\it word}, and returns the value associated with it.
\membersection{wxExpr::Copy}\label{wxexprcopy}
\constfunc{wxExpr*}{Copy}{\void}
Recursively copies the expression, allocating new storage space.
\membersection{wxExpr::DeleteAttributeValue}\label{wxexprdeletattributevalue}
\func{void}{DeleteAttributeValue}{\param{const wxString\&}{ attribute}}
Use this on clauses only. Deletes the attribute and its value (if any) from the
clause.
\membersection{wxExpr::Functor}\label{wxexprfunctor}
\constfunc{wxString}{Functor}{\void}
Use this on clauses only. Returns the clause's functor (object name).
\membersection{wxExpr::GetClientData}\label{wxexprgetclientdata}
\constfunc{wxObject*}{GetClientData}{\void}
Retrieve arbitrary data stored with this clause. This can be useful when
reading in data for storing a pointer to the C++ object, so when another
clause makes a reference to this clause, its C++ object can be retrieved.
See \helpref{wxExpr::SetClientData}{wxexprsetclientdata}.
\membersection{wxExpr::GetFirst}\label{wxexprgetfirst}
\constfunc{wxExpr*}{GetFirst}{\void}
If this is a list expression (or clause), gets the first element in the list.
See also \helpref{wxExpr::GetLast}{wxexprgetlast}, \helpref{wxExpr::GetNext}{wxexprgetnext}, \helpref{wxExpr::Nth}{wxexprnth}.
\membersection{wxExpr::GetLast}\label{wxexprgetlast}
\constfunc{wxExpr*}{GetLast}{\void}
If this is a list expression (or clause), gets the last element in the list.
See also \helpref{wxExpr::GetFirst}{wxexprgetfirst}, \helpref{wxExpr::GetNext}{wxexprgetnext}, \helpref{wxExpr::Nth}{wxexprnth}.
\membersection{wxExpr::GetNext}\label{wxexprgetnext}
\constfunc{wxExpr*}{GetNext}{\void}
If this is a node in a list (any wxExpr may be a node in a list), gets the
next element in the list.
See also \helpref{wxExpr::GetFirst}{wxexprgetfirst}, \helpref{wxExpr::GetLast}{wxexprgetlast}, \helpref{wxExpr::Nth}{wxexprnth}.
\membersection{wxExpr::IntegerValue}\label{wxexprintegervalue}
\constfunc{long}{IntegerValue}{\void}
Returns the integer value of the expression.
\membersection{wxExpr::Nth}\label{wxexprnth}
\constfunc{wxExpr*}{Nth}{\param{int}{ n}}
Get nth arg of the given list expression (starting from 0). NULL is returned if
the expression is not a list expression, or {\it n} is invalid. See also \helpref{wxExpr::Arg}{wxexprarg}.
Normally, you would use attribute-value pairs to add and retrieve data
from objects (clauses) in a data file. However, if the data gets complex,
you may need to store attribute values as lists, and pick them apart
yourself.
\membersection{wxExpr::RealValue}\label{wxexprrealvalue}
\constfunc{float}{RealValue}{\void}
Returns the floating point value of the expression.
\membersection{wxExpr::SetClientData}\label{wxexprsetclientdata}
\func{void}{SetClientData}{\param{wxObject *}{data}}
Associate arbitrary data with this clause. This can be useful when
reading in data for storing a pointer to the C++ object, so when another
clause makes a reference to this clause, its C++ object can be retrieved.
See \helpref{wxExpr::GetClientData}{wxexprgetclientdata}.
\membersection{wxExpr::StringValue}\label{wxexprstringvalue}
\constfunc{wxString}{StringValue}{\void}
Returns the string value of the expression.
\membersection{wxExpr::Type}\label{wxexprtype}
\constfunc{wxExprType}{Type}{\void}
Returns the type of the expression. {\bf wxExprType} is defined as follows:
\begin{verbatim}
typedef enum {
wxExprNull,
wxExprInteger,
wxExprReal,
wxExprWord,
wxExprString,
wxExprList
} wxExprType;
\end{verbatim}
\membersection{wxExpr::WordValue}\label{wxexprwordvalue}
\constfunc{wxString}{WordValue}{\void}
Returns the word value of the expression.
\membersection{wxExpr::WriteClause}\label{wxexprwriteprologclause}
\func{void}{WriteClause}{\param{FILE *}{ stream}}
Writes the clause to the given stream in Prolog format. Not normally needed, since
the whole {\bf wxExprDatabase} will usually be written at once. The format is:
functor, open parenthesis, list of comma-separated expressions, close parenthesis,
full stop.
\membersection{wxExpr::WriteExpr}\label{wxexprwriteexpr}
\func{void}{WriteExpr}{\param{FILE *}{ stream}}
Writes the expression (not clause) to the given stream in Prolog
format. Not normally needed, since the whole {\bf wxExprDatabase} will
usually be written at once. Lists are written in square bracketed,
comma-delimited format.
\membersection{Functions and macros}
Below are miscellaneous functions and macros associated with wxExpr objects.
\func{bool}{wxExprIsFunctor}{\param{wxExpr *}{expr}, \param{const wxString\&}{ functor}}
Checks that the functor of {\it expr} is {\it functor}.
\func{void}{wxExprCleanUp}{\void}
Cleans up the wxExpr system (YACC/LEX buffers) to avoid memory-checking warnings as the program exits.
\begin{verbatim}
#define wxMakeInteger(x) (new wxExpr((long)x))
#define wxMakeReal(x) (new wxExpr((float)x))
#define wxMakeString(x) (new wxExpr(PrologString, x))
#define wxMakeWord(x) (new wxExpr(PrologWord, x))
#define wxMake(x) (new wxExpr(x))
\end{verbatim}
Macros to help make wxExpr objects.
\section{\class{wxExprDatabase}}\label{wxexprdatabase}
The {\bf wxExprDatabase} class represents a database, or list,
of Prolog-like expressions. Instances of this class are used for reading,
writing and creating data files.
\wxheading{Derived from}
\helpref{wxList}{wxlist}\\
\helpref{wxObject}{wxobject}
\wxheading{See also}
\helpref{wxExpr overview}{exproverview}, \helpref{wxExpr}{wxexpr}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxExprDatabase::wxExprDatabase}\label{wxexprdatabaseconstr}
\func{void}{wxExprDatabase}{\param{proioErrorHandler}{ handler = 0}}
Construct a new, unhashed database, with an optional error handler. The
error handler must be a function returning a bool and taking an integer and a string
argument. When an error occurs when reading or writing a database, this function is
called. The error is given as the first argument (currently one of WXEXPR\_ERROR\_GENERAL,
WXEXPR\_ERROR\_SYNTAX) and an error message is given as the second argument. If false
is returned by the error handler, processing of the wxExpr operation stops.
Another way of handling errors is simply to call \helpref{wxExprDatabase::GetErrorCount}{wxexprdatabasegeterrorcount} after
the operation, to check whether errors have occurred, instead of installing an error handler.
If the error count is more than zero, \helpref{wxExprDatabase::Write}{wxexprdatabasewrite} and
\rtfsp\helpref{wxExprDatabase::Read}{wxexprdatabaseread} will return false to
the application.
For example:
\begin{verbatim}
bool myErrorHandler(int err, chat *msg)
{
if (err == WXEXPR_ERROR_SYNTAX)
{
wxMessageBox(msg, "Syntax error");
}
return false;
}
wxExprDatabase database(myErrorHandler);
\end{verbatim}
\func{}{wxExprDatabase}{\param{wxExprType}{ type}, \param{const wxString\&}{attribute},
\rtfsp\param{int}{ size = 500}, \param{proioErrorHandler}{ handler = 0}}
Construct a new database hashed on a combination of the clause functor and
a named attribute (often an integer identification).
See above for an explanation of the error handler.
\membersection{wxExprDatabase::\destruct{wxExprDatabase}}
\func{}{\destruct{wxExprDatabase}}{\void}
Delete the database and contents.
\membersection{wxExprDatabase::Append}\label{wxexprdatabaseappend}
\func{void}{Append}{\param{wxExpr* }{clause}}
Append a clause to the end of the database. If the database is hashing,
the functor and a user-specified attribute will be hashed upon, giving the
option of random access in addition to linear traversal of the database.
\membersection{wxExprDatabase::BeginFind}\label{wxexprdatabasebeginfind}
\func{void}{BeginFind}{\void}
Reset the current position to the start of the database. Subsequent
\rtfsp\helpref{wxExprDatabase::FindClause}{wxexprdatabasefindclause} calls will move the pointer.
\membersection{wxExprDatabase::ClearDatabase}\label{wxexprdatabasecleardatabase}
\func{void}{ClearDatabase}{\void}
Clears the contents of the database.
\membersection{wxExprDatabase::FindClause}\label{wxexprdatabasefindclause}
Various ways of retrieving clauses from the database. A return
value of NULL indicates no (more) clauses matching the given criteria.
Calling the functions repeatedly retrieves more matching clauses, if any.
\func{wxExpr* }{FindClause}{\param{long}{ id}}
Find a clause based on the special ``id'' attribute.
\func{wxExpr* }{FindClause}{\param{const wxString\&}{ attribute}, \param{const wxString\&}{ value}}
Find a clause which has the given attribute set to the given string or word value.
\func{wxExpr*}{FindClause}{\param{const wxString\&}{ attribute}, \param{long}{ value}}
Find a clause which has the given attribute set to the given integer value.
\func{wxExpr*}{FindClause}{\param{const wxString\&}{ attribute}, \param{float}{ value}}
Find a clause which has the given attribute set to the given floating point value.
\membersection{wxExprDatabase::FindClauseByFunctor}\label{wxexprdatabasefindclausebyfunctor}
\func{wxExpr*}{FindClauseByFunctor}{\param{const wxString\&}{ functor}}
Find the next clause with the specified functor.
\membersection{wxExprDatabase::GetErrorCount}\label{wxexprdatabasegeterrorcount}
\constfunc{int}{GetErrorCount}{\void}
Returns the number of errors encountered during the last read or write operation.
\membersection{wxExprDatabase::HashFind}\label{wxexprdatabasehashfind}
\constfunc{wxExpr*}{HashFind}{\param{const wxString\&}{ functor}, \param{long}{ value}}
Finds the clause with the given functor and with the attribute specified
in the database constructor having the given integer value.
For example,
\begin{verbatim}
// Hash on a combination of functor and integer "id" attribute when reading in
wxExprDatabase db(wxExprInteger, "id");
// Read it in
db.ReadProlog("data");
// Retrieve a clause with specified functor and id
wxExpr *clause = db.HashFind("node", 24);
\end{verbatim}
This would retrieve a clause which is written: {\tt node(id = 24, ..., )}.
\func{wxExpr*}{HashFind}{\param{const wxString\&}{ functor}, \param{const wxString\&}{ value}}
Finds the clause with the given functor and with the attribute specified
in the database constructor having the given string value.
\membersection{wxExprDatabase::Read}\label{wxexprdatabaseread}
\func{bool}{Read}{\param{const wxString\&}{ filename}}
Reads in the given file, returning true if successful.
\membersection{wxExprDatabase::ReadFromString}\label{wxexprdatabasereadfromstring}
\func{bool}{ReadFromString}{\param{const wxString\&}{ buffer}}
Reads a Prolog database from the given string buffer, returning true if
successful.
\membersection{wxExprDatabase::Write}\label{wxexprdatabasewrite}
\func{bool}{Write}{\param{FILE *}{stream}}
\func{bool}{Write}{\param{const wxString\&}{ filename}}
Writes the database as a Prolog-format file.

51
docs/latex/wx/gridwork.tex
View File

@ -1,51 +0,0 @@
%
% automatically generated by HelpGen from
% grid.h at 11/May/00 18:30:18
%
\section{\class{wxGridCellWorker}}\label{wxgridcellworker}
This is the 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 interpretation 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.

210
docs/latex/wx/query.tex
View File

@ -1,210 +0,0 @@
\section{\class{wxQueryCol}}\label{wxquerycol}
Every ODBC data column is represented by an instance of this class.
\wxheading{Derived from}
\helpref{wxObject}{wxobject}
\wxheading{Include files}
<wx/odbc.h>
\wxheading{See also}
\overview{wxQueryCol overview}{wxquerycoloverview}, \overview{wxDatabase overview}{wxdatabaseoverview}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxQueryCol::wxQueryCol}
\func{void}{wxQueryCol}{\void}
Constructor. Sets the attributes of the column to default values.
\membersection{wxQueryCol::\destruct{wxQueryCol}}
\func{void}{\destruct{wxQueryCol}}{\void}
Destructor. Deletes the wxQueryField list.
\membersection{wxQueryCol::BindVar}
\func{void *}{BindVar}{\param{void *}{v}, \param{long}{ sz}}
Binds a user-defined variable to a column. Whenever a column is bound to a
variable, it will automatically copy the data of the current field into this
buffer (to a maximum of {\it sz} bytes).
\membersection{wxQueryCol::FillVar}
\func{void}{FillVar}{\param{int}{ recnum}}
Fills the bound variable with the data of the field recnum. When no variable
is bound to the column nothing will happen.
\membersection{wxQueryCol::GetData}
\func{void *}{GetData}{\param{int}{ field}}
Returns a pointer to the data of the field.
\membersection{wxQueryCol::GetName}
\func{wxString}{GetName}{\void}
Returns the name of a column.
\membersection{wxQueryCol::GetType}
\func{short}{GetType}{\void}
Returns the data type of a column.
\membersection{wxQueryCol::GetSize}
\func{long}{GetSize}{\param{int}{ field}}
Return the size of the data of the field field.
\membersection{wxQueryCol::IsRowDirty}
\func{bool}{IsRowDirty}{\param{int}{ field}}
Returns true if the given field has been changed, but not saved.
\membersection{wxQueryCol::IsNullable}
\func{bool}{IsNullable}{\void}
Returns true if a column may contain no data.
\membersection{wxQueryCol::AppendField}
\func{void}{AppendField}{\param{void *}{buf}, \param{long}{ len}}
Appends a wxQueryField instance to the field list of the column. {\it len} bytes from\rtfsp
{\it buf} will be copied into the field's buffer.
\membersection{wxQueryCol::SetData}
\func{bool}{SetData}{\param{int}{ field}, \param{void *}{buf}, \param{long}{ len}}
Sets the data of a field. This function finds the wxQueryField corresponding to\rtfsp
{\it field} and calls wxQueryField::SetData with {\it buf} and {\it len} arguments.
\membersection{wxQueryCol::SetName}
\func{void}{SetName}{\param{const wxString\& }{name}}
Sets the name of a column. Only useful when creating new tables or
appending columns.
\membersection{wxQueryCol::SetNullable}
\func{void}{SetNullable}{\param{bool}{ nullable}}
Determines whether a column may contain no data. Only useful when creating new tables or
appending columns.
\membersection{wxQueryCol::SetFieldDirty}
\func{void}{SetFieldDirty}{\param{int}{ field}, \param{bool }{dirty = true}}
Sets the dirty tag of a given field.
\membersection{wxQueryCol::SetType}
\func{void}{SetType}{\param{short}{ type}}
Sets the data type of a column. Only useful when creating new tables or
appending columns.
\section{\class{wxQueryField}}\label{wxqueryfield}
Represents the data item for one or several columns.
\wxheading{Derivation}
\helpref{wxObject}{wxobject}
\wxheading{See also}
\overview{wxQueryField overview}{wxqueryfieldoverview}, \overview{wxDatabase overview}{wxdatabaseoverview}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxQueryField::wxQueryField}
\func{}{wxQueryField}{\void}
Constructor. Sets type and size of the field to default values.
\membersection{wxQueryField::\destruct{wxQueryField}}
\func{}{\destruct{wxQueryField}}{\void}
Destructor. Frees the associated memory depending on the field type.
\membersection{wxQueryField::AllocData}
\func{bool}{AllocData}{\void}
Allocates memory depending on the size and type of the field.
\membersection{wxQueryField::ClearData}
\func{void}{ClearData}{\void}
Deletes the contents of the field buffer without deallocating the memory.
\membersection{wxQueryField::GetData}
\func{void *}{GetData}{\void}
Returns a pointer to the field buffer.
\membersection{wxQueryField::GetSize}
\func{long}{GetSize}{\void}
Returns the size of the field buffer.
\membersection{wxQueryField::GetType}
\func{short}{GetType}{\void}
Returns the type of the field (currently SQL\_CHAR, SQL\_VARCHAR or SQL\_INTEGER).
\membersection{wxQueryField::IsDirty}
\func{bool}{IsDirty}{\void}
Returns true if the data of a field has been changed, but not saved.
\membersection{wxQueryField::SetData}
\func{bool}{SetData}{\param{void *}{data}, \param{long}{ sz}}
Allocates memory of the size {\it sz} and copies the contents of {\it d} into the
field buffer.
\membersection{wxQueryField::SetDirty}
\func{void}{SetDirty}{\param{bool}{ dirty = true}}
Sets the dirty tag of a field.
\membersection{wxQueryField::SetSize}
\func{void}{SetSize}{\param{long}{ size}}
Resizes the field buffer. Stored data will be lost.
\membersection{wxQueryField::SetType}
\func{void}{SetType}{\param{short }{type}}
Sets the type of the field. Currently the types SQL\_CHAR, SQL\_VARCHAR and
SQL\_INTEGER are supported.

606
docs/latex/wx/recrdset.tex
View File

@ -1,606 +0,0 @@
\section{\class{wxRecordSet}}\label{wxrecordset}
Each wxRecordSet represents an ODBC database query. You can make multiple queries
at a time by using multiple wxRecordSets with a wxDatabase or you can make
your queries in sequential order using the same wxRecordSet.
Note: this class is considered obsolete, replaced by the Remstar
wxDB/wxDbTable classes
\wxheading{Derived from}
\helpref{wxObject}{wxobject}
\wxheading{Include files}
<wx/odbc.h>
\wxheading{See also}
\helpref{wxRecordSet overview}{wxrecordsetoverview}, \helpref{wxDatabase overview}{wxdatabaseoverview}
\latexignore{\rtfignore{\wxheading{Members}}}
\membersection{wxRecordSet::wxRecordSet}
\func{}{wxRecordSet}{\param{wxDatabase *}{db}, \param{int}{ type = wxOPEN\_TYPE\_DYNASET},
\param{int}{ opt = wxOPTION\_DEFAULT}}
Constructor. {\it db} is a pointer to the wxDatabase instance you wish to use the
wxRecordSet with. Currently there are two possible values of {\it type}:
\begin{itemize}\itemsep=0pt
\item wxOPEN\_TYPE\_DYNASET: Loads only one record at a time into memory. The other
data of the result set will be loaded dynamically when
moving the cursor. This is the default type.
\item wxOPEN\_TYPE\_SNAPSHOT: Loads all records of a result set at once. This will
need much more memory, but will result in
faster access to the ODBC data.
\end{itemize}
The {\it option} parameter is not used yet.
The constructor appends the wxRecordSet object to the parent database's list of
wxRecordSet objects, for later destruction when the wxDatabase is destroyed.
\membersection{wxRecordSet::\destruct{wxRecordSet}}
\func{}{\destruct{wxRecordSet}}{\void}
Destructor. All data except that stored in user-defined variables will be lost.
It also unlinks the wxRecordSet object from the parent database's list of
wxRecordSet objects.
\membersection{wxRecordSet::AddNew}
\func{void}{AddNew}{\void}
Not implemented.
\membersection{wxRecordSet::BeginQuery}
\func{bool}{BeginQuery}{\param{int}{ openType}, \param{const wxString\& }{sql = NULL}, \param{int}{ options = wxOPTION\_DEFAULT}}
Not implemented.
\membersection{wxRecordSet::BindVar}
\func{void *}{BindVar}{\param{int}{ col}, \param{void *}{buf}, \param{long}{ size}}
Binds a user-defined variable to the column col. Whenever the current field's
data changes, it will be copied into buf (maximum {\it size} bytes).
\func{void *}{BindVar}{\param{const wxString\& }{col}, \param{void *}{buf}, \param{long}{ size}}
The same as above, but uses the column name as the identifier.
\membersection{wxRecordSet::CanAppend}
\func{bool}{CanAppend}{\void}
Not implemented.
\membersection{wxRecordSet::Cancel}
\func{void}{Cancel}{\void}
Not implemented.
\membersection{wxRecordSet::CanRestart}
\func{bool}{CanRestart}{\void}
Not implemented.
\membersection{wxRecordSet::CanScroll}
\func{bool}{CanScroll}{\void}
Not implemented.
\membersection{wxRecordSet::CanTransact}
\func{bool}{CanTransact}{\void}
Not implemented.
\membersection{wxRecordSet::CanUpdate}
\func{bool}{CanUpdate}{\void}
Not implemented.
\membersection{wxRecordSet::ConstructDefaultSQL}
\func{bool}{ConstructDefaultSQL}{\void}
Not implemented.
\membersection{wxRecordSet::Delete}
\func{bool}{Delete}{\void}
Deletes the current record. Not implemented.
\membersection{wxRecordSet::Edit}
\func{void}{Edit}{\void}
Not implemented.
\membersection{wxRecordSet::EndQuery}
\func{bool}{EndQuery}{\void}
Not implemented.
\membersection{wxRecordSet::ExecuteSQL}\label{wxrecordsetexecutesql}
\func{bool}{ExecuteSQL}{\param{const wxString\& }{sql}}
Directly executes a SQL statement. The data will be presented as a normal
result set. Note that the recordset must have been created as a snapshot, not
dynaset. Dynasets will be implemented in the near future.
Examples of common SQL statements are given in \helpref{A selection of SQL commands}{sqlcommands}.
\membersection{wxRecordSet::FillVars}
\func{void}{FillVars}{\param{int}{ recnum}}
Fills in the user-defined variables of the columns. You can set these
variables with wxQueryCol::BindVar. This function will be automatically
called after every successful database operation.
\membersection{wxRecordSet::GetColName}
\func{wxString}{GetColName}{\param{int}{ col}}
Returns the name of the column at position {\it col}. Returns NULL if {\it col} does not
exist.
\membersection{wxRecordSet::GetColType}
\func{short}{GetColType}{\param{int}{ col}}
Returns the data type of the column at position {\it col}. Returns SQL\_TYPE\_NULL
if {\it col} does not exist.
\func{short}{GetColType}{\param{const wxString\& }{ name}}
The same as above, but uses the column name as the identifier.
See \helpref{ODBC SQL data types}{sqltypes} for a list
of possible data types.
\membersection{wxRecordSet::GetColumns}
\func{bool}{GetColumns}{\param{const wxString\& }{table = NULL}}
Returns the columns of the table with the specified name. If no name is
given the class member {\it tablename} will be used. If both names are NULL
nothing will happen. The data will be presented as a normal result set, organized
as follows:
\begin{twocollist}\itemsep=0pt
\twocolitem{0 (VARCHAR)}{TABLE\_QUALIFIER}
\twocolitem{1 (VARCHAR)}{TABLE\_OWNER}
\twocolitem{2 (VARCHAR)}{TABLE\_NAME}
\twocolitem{3 (VARCHAR)}{COLUMN\_NAME}
\twocolitem{4 (SMALLINT)}{DATA\_TYPE}
\twocolitem{5 (VARCHAR)}{TYPE\_NAME}
\twocolitem{6 (INTEGER)}{PRECISION}
\twocolitem{7 (INTEGER)}{LENGTH}
\twocolitem{8 (SMALLINT)}{SCALE}
\twocolitem{9 (SMALLINT)}{RADIX}
\twocolitem{10 (SMALLINT)}{NULLABLE}
\twocolitem{11 (VARCHAR)}{REMARKS}
\end{twocollist}
\membersection{wxRecordSet::GetCurrentRecord}
\func{long}{GetCurrentRecord}{\void}
Not implemented.
\membersection{wxRecordSet::GetDatabase}
\func{wxDatabase *}{GetDatabase}{\void}
Returns the wxDatabase object bound to a wxRecordSet.
\membersection{wxRecordSet::GetDataSources}\label{wxrecordsetgetdatasources}
\func{bool}{GetDataSources}{\void}
Gets the currently-defined data sources via the ODBC manager. The data will be presented
as a normal result set. See the documentation for the ODBC function SQLDataSources for how the data
is organized.
Example:
\begin{verbatim}
wxDatabase Database;
wxRecordSet *Record = new wxRecordSet(&Database);
if (!Record->GetDataSources()) {
char buf[300];
sprintf(buf, "%s %s\n", Database.GetErrorClass(), Database.GetErrorMessage());
frame->output->SetValue(buf);
}
else {
do {
frame->DataSource->Append((char*)Record->GetFieldDataPtr(0, SQL_CHAR));
} while (Record->MoveNext());
}
\end{verbatim}
\membersection{wxRecordSet::GetDefaultConnect}
\func{wxString}{GetDefaultConnect}{\void}
Not implemented.
\membersection{wxRecordSet::GetDefaultSQL}
\func{wxString}{GetDefaultSQL}{\void}
Not implemented.
\membersection{wxRecordSet::GetErrorCode}
\func{wxRETCODE}{GetErrorCode}{\void}
Returns the error code of the last ODBC action. This will be one of:
\begin{twocollist}\itemsep=0pt
\twocolitem{SQL\_ERROR}{General error.}
\twocolitem{SQL\_INVALID\_HANDLE}{An invalid handle was passed to an ODBC function.}
\twocolitem{SQL\_NEED\_DATA}{ODBC expected some data.}
\twocolitem{SQL\_NO\_DATA\_FOUND}{No data was found by this ODBC call.}
\twocolitem{SQL\_SUCCESS}{The call was successful.}
\twocolitem{SQL\_SUCCESS\_WITH\_INFO}{The call was successful, but further information can be
obtained from the ODBC manager.}
\end{twocollist}
\membersection{wxRecordSet::GetFieldData}\label{wxrecordsetgetfielddata}
\func{bool}{GetFieldData}{\param{int}{ col}, \param{int}{ dataType}, \param{void *}{dataPtr}}
Copies the current data of the column at position {\it col} into the buffer
\rtfsp{\it dataPtr}. To be sure to get the right type of data, the user has to pass the
correct data type. The function returns false if {\it col} does not
exist or the wrong data type was given.
\func{bool}{GetFieldData}{\param{const wxString\& }{name}, \param{int}{ dataType}, \param{void *}{dataPtr}}
The same as above, but uses the column name as the identifier.
See \helpref{ODBC SQL data types}{sqltypes} for a list
of possible data types.
\membersection{wxRecordSet::GetFieldDataPtr}\label{wxrecordsetgetfielddataptr}
\func{void *}{GetFieldDataPtr}{\param{int}{ col}, \param{int}{ dataType}}
Returns the current data pointer of the column at position {\it col}.
To be sure to get the right type of data, the user has to pass the
data type. Returns NULL if {\it col} does not exist or if {\it dataType} is
incorrect.
\func{void *}{GetFieldDataPtr}{\param{const wxString\& }{name}, \param{int}{ dataType}}
The same as above, but uses the column name as the identifier.
See \helpref{ODBC SQL data types}{sqltypes} for a list
of possible data types.
\membersection{wxRecordSet::GetFilter}
\func{wxString}{GetFilter}{\void}
Returns the current filter.
\membersection{wxRecordSet::GetForeignKeys}
\func{bool}{GetPrimaryKeys}{\param{const wxString\& }{ptable = NULL}, \param{const wxString\& }{ftable
= NULL}}
Returns a list of foreign keys in the specified table (columns in the
specified table that refer to primary keys in other tables), or
a list of foreign keys in other tables that refer to the primary key in
the specified table.
If {\it ptable} contains a table name, this function returns a result
set containing the primary key of the specified table.
If {\it ftable} contains a table name, this functions returns a result set
of containing all of the foreign keys in the specified table and the
primary keys (in other tables) to which they refer.
If both {\it ptable} and {\it ftable} contain table names, this
function returns the foreign keys in the table specified in {\it
ftable} that refer to the primary key of the table specified in {\it
ptable}. This should be one key at most.
GetForeignKeys returns results as a standard result set. If the foreign
keys associated with a primary key are requested, the result set is
ordered by FKTABLE\_QUALIFIER, FKTABLE\_OWNER, FKTABLE\_NAME, and KEY\_SEQ.
If the primary keys associated with a foreign key are requested, the
result set is ordered by PKTABLE\_QUALIFIER, PKTABLE\_OWNER, PKTABLE\_NAME,
and KEY\_SEQ. The following table lists the columns in the result set.
\begin{twocollist}\itemsep=0pt
\twocolitem{0 (VARCHAR)}{PKTABLE\_QUALIFIER}
\twocolitem{1 (VARCHAR)}{PKTABLE\_OWNER}
\twocolitem{2 (VARCHAR)}{PKTABLE\_NAME}
\twocolitem{3 (VARCHAR)}{PKCOLUMN\_NAME}
\twocolitem{4 (VARCHAR)}{FKTABLE\_QUALIFIER}
\twocolitem{5 (VARCHAR)}{FKTABLE\_OWNER}
\twocolitem{6 (VARCHAR)}{FKTABLE\_NAME}
\twocolitem{7 (VARCHAR)}{FKCOLUMN\_NAME}
\twocolitem{8 (SMALLINT)}{KEY\_SEQ}
\twocolitem{9 (SMALLINT)}{UPDATE\_RULE}
\twocolitem{10 (SMALLINT)}{DELETE\_RULE}
\twocolitem{11 (VARCHAR)}{FK\_NAME}
\twocolitem{12 (VARCHAR)}{PK\_NAME}
\end{twocollist}
\membersection{wxRecordSet::GetNumberCols}
\func{long}{GetNumberCols}{\void}
Returns the number of columns in the result set.
\membersection{wxRecordSet::GetNumberFields}
\func{int}{GetNumberFields}{\void}
Not implemented.
\membersection{wxRecordSet::GetNumberParams}
\func{int}{GetNumberParams}{\void}
Not implemented.
\membersection{wxRecordSet::GetNumberRecords}
\func{long}{GetNumberRecords}{\void}
Returns the number of records in the result set.
\membersection{wxRecordSet::GetPrimaryKeys}
\func{bool}{GetPrimaryKeys}{\param{const wxString\& }{table = NULL}}
Returns the column names that comprise the primary key of the table with the specified name. If no name is
given the class member {\it tablename} will be used. If both names are NULL
nothing will happen. The data will be presented as a normal result set, organized
as follows:
\begin{twocollist}\itemsep=0pt
\twocolitem{0 (VARCHAR)}{TABLE\_QUALIFIER}
\twocolitem{1 (VARCHAR)}{TABLE\_OWNER}
\twocolitem{2 (VARCHAR)}{TABLE\_NAME}
\twocolitem{3 (VARCHAR)}{COLUMN\_NAME}
\twocolitem{4 (SMALLINT)}{KEY\_SEQ}
\twocolitem{5 (VARCHAR)}{PK\_NAME}
\end{twocollist}
\membersection{wxRecordSet::GetOptions}
\func{int}{GetOptions}{\void}
Returns the options of the wxRecordSet. Options are not supported yet.
\membersection{wxRecordSet::GetResultSet}
\func{bool}{GetResultSet}{\void}
Copies the data presented by ODBC into wxRecordSet. Depending on the
wxRecordSet type all or only one record(s) will be copied.
Usually this function will be called automatically after each successful
database operation.
\membersection{wxRecordSet::GetSortString}
\func{wxString}{GetSortString}{\void}
Not implemented.
\membersection{wxRecordSet::GetSQL}
\func{wxString}{GetSQL}{\void}
Not implemented.
\membersection{wxRecordSet::GetTableName}
\func{wxString}{GetTableName}{\void}
Returns the name of the current table.
\membersection{wxRecordSet::GetTables}
\func{bool}{GetTables}{\void}
Gets the tables of a database. The data will be presented as a normal result
set, organized as follows:
\begin{twocollist}\itemsep=0pt
\twocolitem{0 (VARCHAR)}{TABLE\_QUALIFIER}
\twocolitem{1 (VARCHAR)}{TABLE\_OWNER}
\twocolitem{2 (VARCHAR)}{TABLE\_NAME}
\twocolitem{3 (VARCHAR)}{TABLE\_TYPE (TABLE, VIEW, SYSTEM TABLE, GLOBAL TEMPORARY, LOCAL TEMPORARY,
ALIAS, SYNONYM, or database-specific type)}
\twocolitem{4 (VARCHAR)}{REMARKS}
\end{twocollist}
\membersection{wxRecordSet::GetType}
\func{int}{GetType}{\void}
Returns the type of the wxRecordSet: wxOPEN\_TYPE\_DYNASET or
wxOPEN\_TYPE\_SNAPSHOT. See the wxRecordSet description for details.
\membersection{wxRecordSet::GoTo}
\func{bool}{GoTo}{\param{long}{ n}}
Moves the cursor to the record with the number n, where the first record
has the number 0.
\membersection{wxRecordSet::IsBOF}
\func{bool}{IsBOF}{\void}
Returns true if the user tried to move the cursor before the first record
in the set.
\membersection{wxRecordSet::IsFieldDirty}
\func{bool}{IsFieldDirty}{\param{int}{ field}}
Returns true if the given field has been changed but not saved yet.
\func{bool}{IsFieldDirty}{\param{const wxString\& }{name}}
Same as above, but uses the column name as the identifier.
\membersection{wxRecordSet::IsFieldNull}
\func{bool}{IsFieldNull}{\param{int}{ field}}
Returns true if the given field has no data.
\func{bool}{IsFieldNull}{\param{const wxString\& }{ name}}
Same as above, but uses the column name as the identifier.
\membersection{wxRecordSet::IsColNullable}
\func{bool}{IsColNullable}{\param{int}{ col}}
Returns true if the given column may contain no data.
\func{bool}{IsColNullable}{\param{const wxString\& }{name}}
Same as above, but uses the column name as the identifier.
\membersection{wxRecordSet::IsEOF}
\func{bool}{IsEOF}{\void}
Returns true if the user tried to move the cursor behind the last record
in the set.
\membersection{wxRecordSet::IsDeleted}
\func{bool}{IsDeleted}{\void}
Not implemented.
\membersection{wxRecordSet::IsOpen}
\func{bool}{IsOpen}{\void}
Returns true if the parent database is open.
\membersection{wxRecordSet::Move}
\func{bool}{Move}{\param{long}{ rows}}
Moves the cursor a given number of rows. Negative values are allowed.
\membersection{wxRecordSet::MoveFirst}
\func{bool}{MoveFirst}{\void}
Moves the cursor to the first record.
\membersection{wxRecordSet::MoveLast}
\func{bool}{MoveLast}{\void}
Moves the cursor to the last record.
\membersection{wxRecordSet::MoveNext}\label{wxrecordsetmovenext}
\func{bool}{MoveNext}{\void}
Moves the cursor to the next record.
\membersection{wxRecordSet::MovePrev}\label{wxrecordsetmoveprev}
\func{bool}{MovePrev}{\void}
Moves the cursor to the previous record.
\membersection{wxRecordSet::Query}
\func{bool}{Query}{\param{const wxString\& }{columns}, \param{const wxString\& }{table}, \param{const wxString\& }{filter = NULL}}
Start a query. An SQL string of the following type will automatically be
generated and executed: ``SELECT columns FROM table WHERE filter".
\membersection{wxRecordSet::RecordCountFinal}
\func{bool}{RecordCountFinal}{\void}
Not implemented.
\membersection{wxRecordSet::Requery}
\func{bool}{Requery}{\void}
Re-executes the last query. Not implemented.
\membersection{wxRecordSet::SetFieldDirty}
\func{void}{SetFieldDirty}{\param{int}{ field}, \param{bool}{ dirty = true}}
Sets the dirty tag of the field field. Not implemented.
\func{void}{SetFieldDirty}{\param{const wxString\& }{name}, \param{bool}{ dirty = true}}
Same as above, but uses the column name as the identifier.
\membersection{wxRecordSet::SetDefaultSQL}
\func{void}{SetDefaultSQL}{\param{const wxString\& }{s}}
Not implemented.
\membersection{wxRecordSet::SetFieldNull}
\func{void}{SetFieldNull}{\param{void *}{p}, \param{bool }{isNull = true}}
Not implemented.
\membersection{wxRecordSet::SetOptions}
\func{void}{SetOptions}{\param{int}{ opt}}
Sets the options of the wxRecordSet. Not implemented.
\membersection{wxRecordSet::SetTableName}
\func{void}{SetTableName}{\param{const wxString\& }{tablename}}
Specify the name of the table you want to use.
\membersection{wxRecordSet::SetType}
\func{void}{SetType}{\param{int}{ type}}
Sets the type of the wxRecordSet. See the wxRecordSet class description for details.
\membersection{wxRecordSet::Update}
\func{bool}{Update}{\void}
Writes back the current record. Not implemented.