d&d implementation and checklistbox enabled

[wxWidgets.git] / contrib / docs / latex / ogl / classes.tex

\chapter{Class reference}\label{classref}
\setheader{{\it CHAPTER \thechapter}}{}{}{}{}{{\it CHAPTER \thechapter}}%
\setfooter{\thepage}{}{}{}{}{\thepage}

These are the main \ogl\ classes.

\section{\class{wxOGLConstraint}}\label{wxoglconstraint}

\overview{wxCompositeShape overview}{compositeshapeoverview}

An wxOGLConstraint object helps specify how child shapes are laid out with respect
to siblings and parents.

\wxheading{Derived from}

wxObject

\wxheading{See also}

\helpref{wxCompositeShape}{wxcompositeshape}

\latexignore{\rtfignore{\wxheading{Members}}}

\membersection{wxOGLConstraint::wxOGLConstraint}\label{wxoglconstraintconstr}

\func{}{wxOGLConstraint}{\void}

Default constructor.

\func{}{wxOGLConstraint}{\param{int}{ type}, \param{wxShape *}{constraining}, \param{wxList\& }{constrained}}

Constructor.

\wxheading{Parameters}

\docparam{constraining}{The shape which is used as the reference for positioning the {\it constrained} objects.}

\docparam{constrained}{Contains a list of wxShapes which are to be constrained (with respect
to {\it constraining}) using {\it type}.}

\docparam{type}{Can be one of:

\begin{itemize}\itemsep=0pt
\item {\bf gyCONSTRAINT\_CENTRED\_VERTICALLY}: the Y co-ordinates of the centres of the
bounding boxes of the constrained objects and the constraining object
will be the same
\item {\bf gyCONSTRAINT\_CENTRED\_HORIZONTALLY}: the X co-ordinates of the centres of the
bounding boxes of the constrained objects and the constraining object
will be the same
\item {\bf gyCONSTRAINT\_CENTRED\_BOTH}: the co-ordinates of the centres of the bounding boxes
of the constrained objects and the constraining object will be the same
\item {\bf gyCONSTRAINT\_LEFT\_OF}: the X co-ordinates of the right hand vertical edges
of the bounding boxes of the constrained objects will be less than
the X co-ordinate of the left hand vertical edge of the bounding box
of the constraining object
\item {\bf gyCONSTRAINT\_RIGHT\_OF}: the X co-ordinates of the left hand vertical edges
of the bounding boxes of the constrained objects will be greater than
the X co-ordinate of the right hand vertical edge of the bounding box
of the constraining object
\item {\bf gyCONSTRAINT\_ABOVE}: the Y co-ordinates of the bottom horizontal edges of the
bounding boxes of the constrained objects will be less than the
Y co-ordinate of the top horizontal edge of the bounding box of the
constraining object
\item {\bf gyCONSTRAINT\_BELOW}: the Y co-ordinates of the top horizontal edges of the
bounding boxes of the constrained objects will be greater than
the X co-ordinate of the bottom horizontal edge of the bounding box
of the constraining object
\item {\bf gyCONSTRAINT\_ALIGNED\_TOP}: the Y co-ordinates of the top horizontal edges of the
bounding boxes of the constrained objects will be the same as the
Y co-ordinate of the top horizontal edge of the bounding box of the
constraining object
\item {\bf gyCONSTRAINT\_ALIGNED\_BOTTOM}: the Y co-ordinates of the bottom horizontal edges
of the bounding boxes of the constrained objects will be the same as
the Y co-ordinate of the bottom horizontal edge of the bounding box
of the constraining object
\item {\bf gyCONSTRAINT\_ALIGNED\_LEFT}: the X co-ordinates of the left hand vertical edges
of the bounding boxes of the constrained objects will be the same as
the X co-ordinate of the left hand vertical edge of the bounding box
of the constraining object
\item {\bf gyCONSTRAINT\_ALIGNED\_RIGHT}: the X co-ordinates of the right hand vertical edges
of the bounding boxes of the constrained objects will be the same as
the X co-ordinate of the right hand vertical edge of the bounding box
of the constraining object
\item {\bf gyCONSTRAINT\_MIDALIGNED\_TOP}: the Y co-ordinates of the centres of
the bounding boxes of the constrained objects will be the same
as the Y co-ordinate of the top horizontal edge of
the bounding box of the constraining object
\item {\bf gyCONSTRAINT\_MIDALIGNED\_BOTTOM}: the Y co-ordinates of the centres of
the bounding boxes of the constrained objects will be the same
as the Y co-ordinate of the bottom horizontal edge of
the bounding box of the constraining object
\item {\bf gyCONSTRAINT\_MIDALIGNED\_LEFT}: the X co-ordinates of the centres of
the bounding boxes of the constrained objects will be the same
as the X co-ordinate of the left hand vertical edge of
the bounding box of the constraining object
\item {\bf gyCONSTRAINT\_MIDALIGNED\_RIGHT}: the X co-ordinates of the centres of
the bounding boxes of the constrained objects will be the same as
the X co-ordinate of the right hand vertical edge of
the bounding box of the constraining object
\end{itemize}
}

\membersection{wxOGLConstraint::\destruct{wxOGLConstraint}}

\func{}{\destruct{wxOGLConstraint}}{\void}

Destructor.

\membersection{wxOGLConstraint::Equals}

\func{bool}{Equals}{\param{double}{ x}, \param{double}{ y}}

Returns TRUE if {\it x} and {\it y} are approximately equal (for the purposes
of evaluating the constraint).

\membersection{wxOGLConstraint::Evaluate}

\func{bool}{Evaluate}{\void}

Evaluates this constraint, returning TRUE if anything changed.

\membersection{wxOGLConstraint::SetSpacing}\label{wxoglconstraintsetspacing}

\func{void}{SetSpacing}{\param{double}{ x}, \param{double}{ y}}

Sets the horizontal and vertical spacing for the constraint.

\section{\class{wxBitmapShape}}\label{wxbitmapshape}

Draws a bitmap (non-resizable).

\wxheading{Derived from}

\helpref{wxRectangleShape}{wxrectangleshape}

\latexignore{\rtfignore{\wxheading{Members}}}

\membersection{wxBitmapShape::wxBitmapShape}

\func{}{wxBitmapShape}{\void}

Constructor.

\membersection{wxBitmapShape::\destruct{wxBitmapShape}}

\func{}{\destruct{wxBitmapShape}}{\void}

Destructor.

\membersection{wxBitmapShape::GetBitmap}

\constfunc{wxBitmap\&}{GetBitmap}{\void}

Returns a reference to the bitmap associated with this shape.

\membersection{wxBitmapShape::GetFilename}

\constfunc{wxString}{GetFilename}{\void}

Returns the bitmap filename.

\membersection{wxBitmapShape::SetBitmap}

\func{void}{SetBitmap}{\param{const wxBitmap\&}{ bitmap}}

Sets the bitmap associated with this shape. You can delete the bitmap
from the calling application, since reference counting will take care of
holding on to the internal bitmap data.

\membersection{wxBitmapShape::SetFilename}

\func{void}{SetFilename}{\param{const wxString\& }{filename}}

Sets the bitmap filename.

\section{\class{wxDiagram}}\label{wxdiagram}

Encapsulates an entire diagram, with methods for reading/writing and drawing.
A diagram has an associated wxShapeCanvas.

\wxheading{Derived from}

wxObject

\wxheading{See also}

\helpref{wxShapeCanvas}{wxshapecanvas}

\latexignore{\rtfignore{\wxheading{Members}}}

\membersection{wxDiagram::wxDiagram}

\func{}{wxDiagram}{\void}

Constructor.

\membersection{wxDiagram::\destruct{wxDiagram}}

\func{}{\destruct{wxDiagram}}{\void}

Destructor.

\membersection{wxDiagram::AddShape}

\func{void}{AddShape}{\param{wxShape*}{shape}, \param{wxShape *}{addAfter = NULL}}

Adds a shape to the diagram. If {\it addAfter} is non-NULL, the shape will be added after this
one.

\membersection{wxDiagram::Clear}

\func{void}{Clear}{\param{wxDC\&}{ dc}}

Clears the specified device context.

\membersection{wxDiagram::DeleteAllShapes}

\func{void}{DeletesAllShapes}{\void}

Removes and deletes all shapes in the diagram.

\membersection{wxDiagram::DrawOutline}

\func{void}{DrawOutline}{\param{wxDC\&}{ dc}, \param{double}{ x1}, \param{double}{ y1}, \param{double}{ x2}, \param{double}{ y2}}

Draws an outline rectangle on the current device context.

\membersection{wxDiagram::FindShape}\label{wxdiagramfindshape}

\constfunc{wxShape*}{FindShape}{\param{long}{ id}}

Returns the shape for the given identifier.

\membersection{wxDiagram::GetCanvas}

\constfunc{wxShapeCanvas*}{GetCanvas}{\void}

Returns the shape canvas associated with this diagram.

\membersection{wxDiagram::GetCount}\label{wxdiagramgetcount}

\constfunc{int}{GetCount}{\void}

Returns the number of shapes in the diagram.

\membersection{wxDiagram::GetGridSpacing}

\constfunc{double}{GetGridSpacing}{\void}

Returns the grid spacing.

\membersection{wxDiagram::GetMouseTolerance}

\func{int}{GetMouseTolerance}{\void}

Returns the tolerance within which a mouse move is ignored.

\membersection{wxDiagram::GetShapeList}

\constfunc{wxList*}{GetShapeList}{\void}

Returns a pointer to the internal shape list.

\membersection{wxDiagram::GetQuickEditMode}

\constfunc{bool}{GetQuickEditMode}{\void}

Returns quick edit mode.

\membersection{wxDiagram::GetSnapToGrid}

\constfunc{bool}{GetSnapToGrid}{\void}

Returns snap-to-grid mode.

\membersection{wxDiagram::InsertShape}

\func{void}{InsertShape}{\param{wxShape *}{shape}}

Inserts a shape at the front of the shape list.

\membersection{wxDiagram::LoadFile}

\func{bool}{LoadFile}{\param{const wxString\& }{filename}}

Loads the diagram from a file.

\membersection{wxDiagram::OnDatabaseLoad}

\func{void}{OnDatabaseLoad}{\param{wxExprDatabase\&}{ database}}

Called just after the nodes and lines have been read from the wxExprDatabase. You may override this;
the default member does nothing.

\membersection{wxDiagram::OnDatabaseSave}

\func{void}{OnDatabaseSave}{\param{wxExprDatabase\&}{ database}}

Called just after the nodes and lines have been written to the wxExprDatabase. You may override this;
the default member does nothing.

\membersection{wxDiagram::OnHeaderLoad}

\func{bool}{OnHeaderLoad}{\param{wxExprDatabase\&}{ database}, \param{wxExpr\&}{ expr}}

Called to allow the `diagram' header object to be read. The default member reads no further information.
You may wish to override this to read version information, author name, etc.

\membersection{wxDiagram::OnHeaderSave}

\func{bool}{OnHeaderSave}{\param{wxExprDatabase\&}{ database}, \param{wxExpr\&}{ expr}}

Called to allow instantiation of the `diagram' header object. The default member writes no further information.
You may wish to override this to include version information, author name, etc.

\membersection{wxDiagram::OnShapeLoad}

\func{bool}{OnShapeLoad}{\param{wxExprDatabase\&}{ database}, \param{wxShape\&}{ shape}, \param{wxExpr\&}{ expr}}

Called to read the shape from the {\it expr}. You may override this, but call this function first.
The default member calls ReadAttributes for the shape.

\membersection{wxDiagram::OnShapeSave}

\func{bool}{OnShapeSave}{\param{wxExprDatabase\&}{ database}, \param{wxShape\&}{ shape}, \param{wxExpr\&}{ expr}}

Called to save the shape to the {\it expr} and {\it database}. You may override this, but call this function first.
The default member calls WriteAttributes for the shape, appends the shape to the database, and of the shape
is a composite, recursively calls OnShapeSave for its children.

\membersection{wxDiagram::ReadContainerGeometry}

\func{void}{ReadContainerGeometry}{\param{wxExprDatabase\&}{ database}}

Reads container geometry from a wxExprDatabase, linking up nodes which
are part of a composite. You probably won't need to redefine this.

\membersection{wxDiagram::ReadLines}

\func{void}{ReadLines}{\param{wxExprDatabase\&}{ database}}

Reads lines from a wxExprDatabase. You probably won't need to redefine this.

\membersection{wxDiagram::ReadNodes}

\func{void}{ReadNodes}{\param{wxExprDatabase\&}{ database}}

Reads nodes from a wxExprDatabase. You probably won't need to redefine this.

\membersection{wxDiagram::RecentreAll}

\func{void}{RecentreAll}{\param{wxDC\&}{ dc}}

Make sure all text that should be centred, is centred.

\membersection{wxDiagram::Redraw}

\func{void}{Redraw}{\param{wxDC\&}{ dc}}

Draws the shapes in the diagram on the specified device context.

\membersection{wxDiagram::RemoveAllShapes}

\func{void}{RemoveAllShapes}{\void}

Removes all shapes from the diagram but does not delete the shapes.

\membersection{wxDiagram::RemoveShape}

\func{void}{RemoveShape}{\param{wxShape*}{ shape}}

Removes the shape from the diagram (non-recursively) but does not delete it.

\membersection{wxDiagram::SaveFile}

\func{bool}{SaveFile}{\param{const wxString\& }{filename}}

Saves the diagram in a file.

\membersection{wxDiagram::SetCanvas}\label{wxdiagramsetcanvas}

\func{void}{SetCanvas}{\param{wxShapeCanvas*}{ canvas}}

Sets the canvas associated with this diagram.

\membersection{wxDiagram::SetGridSpacing}

\func{void}{SetGridSpacing}{\param{double}{ spacing}}

Sets the grid spacing. The default is 5.

\membersection{wxDiagram::SetMouseTolerance}

\func{void}{SetMouseTolerance}{\param{int}{ tolerance}}

Sets the tolerance within which a mouse move is ignored. The default is 3 pixels.

\membersection{wxDiagram::SetQuickEditMode}

\func{void}{SetQuickEditMode}{\param{bool}{ mode}}

Sets quick-edit-mode on or off. In this mode, refreshes are minimized, but the
diagram may need manual refreshing occasionally.

\membersection{wxDiagram::SetSnapToGrid}

\func{void}{SetSnapToGrid}{\param{bool}{ snap}}

Sets snap-to-grid mode on or off. The default is on.

\membersection{wxDiagram::ShowAll}

\func{void}{ShowAll}{\param{bool}{ show}}

Calls Show for each shape in the diagram.

\membersection{wxDiagram::Snap}

\func{void}{Snap}{\param{double *}{x}, \param{double *}{y}}

`Snaps' the coordinate to the nearest grid position, if snap-to-grid is on.

\section{\class{wxDrawnShape}}\label{wxdrawnshape}

Draws a pseduo-metafile shape, which can be loaded from a simple Windows metafile.

wxDrawnShape allows you to specify a different shape for each of four orientations (North, West,
South and East). It also provides a set of drawing functions for programmatic drawing of a shape,
so that during construction of the shape you can draw into it as if it were a device context.

\wxheading{Derived from}

\helpref{wxRectangleShape}{wxrectangleshape}

See also \helpref{wxRectangleShape}{wxrectangleshape}.

\latexignore{\rtfignore{\wxheading{Members}}}

\membersection{wxDrawnShape::wxDrawnShape}

\func{}{wxDrawnShape}{\void}

Constructor.

\membersection{wxDrawnShape::\destruct{wxDrawnShape}}

\func{}{\destruct{wxDrawnShape}}{\void}

Destructor.

\membersection{wxDrawnShape::CalculateSize}

\func{void}{CalculateSize}{\void}

Calculates the wxDrawnShape size from the current metafile. Call this after you have drawn
into the shape.

\membersection{wxDrawnShape::DestroyClippingRect}\label{wxdrawnshapedestroyclippingrect}

\func{void}{DestroyClippingRect}{\void}

Destroys the clipping rectangle. See also \helpref{wxDrawnShape::SetClippingRect}{wxdrawnshapesetclippingrect}.

\membersection{wxDrawnShape::DrawArc}\label{wxdrawnshapedrawarc}

\func{void}{DrawArc}{\param{const wxPoint\&}{ centrePoint}, \param{const wxPoint\&}{ startPoint},
 \param{const wxPoint\&}{ endPoint}}

Draws an arc (see wxWindows documentation for details).

\membersection{wxDrawnShape::DrawAtAngle}\label{wxdrawnshapedrawatangle}

\func{void}{DrawAtAngle}{\param{int}{ angle}}

Sets the metafile for the given orientation, which can be one of:

\begin{itemize}\itemsep=0pt
\item oglDRAWN\_ANGLE\_0
\item oglDRAWN\_ANGLE\_90
\item oglDRAWN\_ANGLE\_180
\item oglDRAWN\_ANGLE\_270
\end{itemize}

See also \helpref{wxDrawnShape::GetAngle}{wxdrawnshapegetangle}.

\membersection{wxDrawnShape::DrawEllipticArc}\label{wxdrawnshapedrawellipticarc}

\func{void}{DrawEllipticArc}{\param{const wxRect\&}{ rect}, \param{double}{ startAngle}, \param{double}{ endAngle}}

Draws an elliptic arc (see wxWindows documentation for details).

\membersection{wxDrawnShape::DrawLine}\label{wxdrawnshapedrawline}

\func{void}{DrawLine}{\param{const wxPoint\&}{ point1}, \param{const wxPoint\&}{ point2}}

Draws a line from {\it point1} to {\it point2}.

\membersection{wxDrawnShape::DrawLines}\label{wxdrawnshapedrawlines}

\func{void}{DrawLines}{\param{int}{ n}, \param{wxPoint\&}{ points[]}}

Draws {\it n} lines.

\membersection{wxDrawnShape::DrawPoint}\label{wxdrawnshapedrawpoint}

\func{void}{DrawPoint}{\param{const wxPoint\&}{ point}}

Draws a point.

\membersection{wxDrawnShape::DrawPolygon}\label{wxdrawnshapedrawpolygon}

\func{void}{DrawPolygon}{\param{int}{ n}, \param{wxPoint\&}{ points[]}, \param{int}{ flags = 0}}

Draws a polygon. {\it flags} can be one or more of {\bf oglMETAFLAGS\_OUTLINE} (use this polygon for the drag outline)
and {\bf oglMETAFLAGS\_ATTACHMENTS} (use the vertices of this polygon for attachments).

\membersection{wxDrawnShape::DrawRectangle}\label{wxdrawnshapedrawrectangle}

\func{void}{DrawRectangle}{\param{const wxRect\&}{ rect}}

Draws a rectangle.

\membersection{wxDrawnShape::DrawRoundedRectangle}\label{wxdrawnshapedrawroundedrectangle}

\func{void}{DrawRoundedRectangle}{\param{const wxRect\&}{ rect}, \param{double}{ radius}}

Draws a rounded rectangle. {\it radius} is the corner radius. If {\it radius} is negative,
it expresses the radius as a proportion of the smallest dimension of the rectangle.

\membersection{wxDrawnShape::DrawSpline}\label{wxdrawnshapedrawspline}

\func{void}{DrawSpline}{\param{int}{ n}, \param{wxPoint\&}{ points[]}}

Draws a spline curve.

\membersection{wxDrawnShape::DrawText}\label{wxdrawnshapedrawtext}

\func{void}{DrawText}{\param{const wxString\&}{ text}, \param{const wxPoint\&}{ point}}

Draws text at the given point.

\membersection{wxDrawnShape::GetAngle}\label{wxdrawnshapegetangle}

\constfunc{int}{GetAngle}{\void}

Returns the current orientation, which can be one of:

\begin{itemize}\itemsep=0pt
\item oglDRAWN\_ANGLE\_0
\item oglDRAWN\_ANGLE\_90
\item oglDRAWN\_ANGLE\_180
\item oglDRAWN\_ANGLE\_270
\end{itemize}

See also \helpref{wxDrawnShape::DrawAtAngle}{wxdrawnshapedrawatangle}.

\membersection{wxDrawnShape::GetMetaFile}

\constfunc{wxPseudoMetaFile\& }{GetMetaFile}{\void}

Returns a reference to the internal `pseudo-metafile'.

\membersection{wxDrawnShape::GetRotation}\label{wxdrawnshapegetrotation}

\constfunc{double}{GetRotation}{\void}

Returns the current rotation of the shape in radians.

\membersection{wxDrawnShape::LoadFromMetaFile}

\func{bool}{LoadFromMetaFile}{\param{const wxString\& }{filename}}

Loads a (very simple) Windows metafile, created for example by Top Draw, the Windows shareware graphics package.

\membersection{wxDrawnShape::Rotate}

\func{void}{Rotate}{\param{double }{x}, \param{double }{y}, \param{double }{theta}}

Rotate about the given axis by the given amount in radians.

\membersection{wxDrawnShape::SetClippingRect}\label{wxdrawnshapesetclippingrect}

\func{void}{SetClippingRect}{\param{const wxRect\&}{ rect}}

Sets the clipping rectangle. See also \helpref{wxDrawnShape::DestroyClippingRect}{wxdrawnshapedestroyclippingrect}.

\membersection{wxDrawnShape::SetDrawnBackgroundColour}\label{wxdrawnshapesetdrawnbackgroundcolour}

\func{void}{SetDrawnBackgroundColour}{\param{const wxColour\&}{ colour}}

Sets the current background colour for the current metafile.

\membersection{wxDrawnShape::SetDrawnBackgroundMode}\label{wxdrawnshapesetdrawnbackgroundmode}

\func{void}{SetDrawnBackgroundMode}{\param{int}{ mode}}

Sets the current background mode for the current metafile.

\membersection{wxDrawnShape::SetDrawnBrush}\label{wxdrawnshapesetdrawnbrush}

\func{void}{SetDrawnBrush}{\param{wxPen*}{ pen}, \param{bool}{ isOutline = FALSE}}

Sets the pen for this metafile. If {\it isOutline} is TRUE, this pen is taken to indicate the outline
(and if the outline pen is changed for the whole shape, the pen will be replaced with the outline pen).

\membersection{wxDrawnShape::SetDrawnFont}\label{wxdrawnshapesetdrawnfont}

\func{void}{SetDrawnFont}{\param{wxFont*}{ font}}

Sets the current font for the current metafile.

\membersection{wxDrawnShape::SetDrawnPen}\label{wxdrawnshapesetdrawnpen}

\func{void}{SetDrawnPen}{\param{wxPen*}{ pen}, \param{bool}{ isOutline = FALSE}}

Sets the pen for this metafile. If {\it isOutline} is TRUE, this pen is taken to indicate the outline
(and if the outline pen is changed for the whole shape, the pen will be replaced with the outline pen).

\membersection{wxDrawnShape::SetDrawnTextColour}\label{wxdrawnshapesetdrawntextcolour}

\func{void}{SetDrawnTextColour}{\param{const wxColour\&}{ colour}}

Sets the current text colour for the current metafile.

\membersection{wxDrawnShape::Scale}

\func{void}{Scale}{\param{double }{sx}, \param{double }{sy}}

Scales the shape by the given amount.

\membersection{wxDrawnShape::SetSaveToFile}

\func{void}{SetSaveToFile}{\param{bool }{save}}

If {\it save} is TRUE, the image will be saved along with the shape's other attributes. The reason
why this might not be desirable is that if there are many shapes with the same image, it would be
more efficient for the application to save one copy, and not duplicate the information for every
shape. The default is TRUE.

\membersection{wxDrawnShape::Translate}

\func{void}{Translate}{\param{double }{x}, \param{double }{y}}

Translates the shape by the given amount.

\section{\class{wxCircleShape}}\label{wxcircleshape}

An wxEllipseShape whose width and height are the same.

\wxheading{Derived from}

\helpref{wxEllipseShape}{wxellipseshape}.

\latexignore{\rtfignore{\wxheading{Members}}}

\membersection{wxCircleShape::wxCircleShape}

\func{}{wxCircleShape}{\param{double}{ width = 0.0}}

Constructor.

\membersection{wxCircleShape::\destruct{wxCircleShape}}

\func{}{\destruct{wxCircleShape}}{\void}

Destructor.

\section{\class{wxCompositeShape}}\label{wxcompositeshape}

This is an object with a list of child objects, and a list of size
and positioning constraints between the children.

\wxheading{Derived from}

\helpref{wxRectangleShape}{wxrectangleshape}

\wxheading{See also}

\helpref{wxCompositeShape overview}{compositeshapeoverview}

\latexignore{\rtfignore{\wxheading{Members}}}

\membersection{wxCompositeShape::wxCompositeShape}

\func{}{wxCompositeShape}{\void}

Constructor.

\membersection{wxCompositeShape::\destruct{wxCompositeShape}}

\func{}{\destruct{wxCompositeShape}}{\void}

Destructor.

\membersection{wxCompositeShape::AddChild}\label{wxcompositeshapeaddchild}

\func{void}{AddChild}{\param{wxShape *}{child}, \param{wxShape *}{addAfter = NULL}}

Adds a child shape to the composite. If {\it addAfter} is non-NULL, the shape will be added
after this shape.

\membersection{wxCompositeShape::AddConstraint}\label{wxcompositeshapeaddconstraint}

\func{wxOGLConstraint *}{AddConstraint}{\param{wxOGLConstraint *}{constraint}}

\func{wxOGLConstraint *}{AddConstraint}{\param{int}{ type}, \param{wxShape *}{constraining}, \param{wxList\&}{constrained}}

\func{wxOGLConstraint *}{AddConstraint}{\param{int}{ type}, \param{wxShape *}{constraining}, \param{wxShape *}{constrained}}

Adds a constraint to the composite.

\membersection{wxCompositeShape::CalculateSize}

\func{void}{CalculateSize}{\void}

Calculates the size and position of the composite based on child sizes and positions.

\membersection{wxCompositeShape::ContainsDivision}

\func{bool}{FindContainerImage}{\param{wxDivisionShape *}{division}}

Returns TRUE if {\it division} is a descendant of this container.

\membersection{wxCompositeShape::DeleteConstraint}

\func{void}{DeleteConstraint}{\param{wxOGLConstraint *}{constraint}}

Deletes constraint from composite.

\membersection{wxCompositeShape::DeleteConstraintsInvolvingChild}

\func{void}{DeleteConstraintsInvolvingChild}{\param{wxShape *}{child}}

This function deletes constraints which mention the given child. Used when
deleting a child from the composite.

\membersection{wxCompositeShape::FindConstraint}

\func{wxOGLConstraint *}{FindConstraint}{\param{long}{ id}, \param{wxCompositeShape **}{actualComposite}}

Finds the constraint with the given id, also returning the actual composite the constraint was in,
in case that composite was a descendant of this composite.

\membersection{wxCompositeShape::FindContainerImage}

\func{wxShape *}{FindContainerImage}{\void}

Finds the image used to visualize a container. This is any child
of the composite that is not in the divisions list.

\membersection{wxCompositeShape::GetConstraints}

\constfunc{wxList\&}{GetConstraints}{\void}

Returns a reference to the list of constraints.

\membersection{wxCompositeShape::GetDivisions}

\constfunc{wxList\&}{GetDivisions}{\void}

Returns a reference to the list of divisions.

\membersection{wxCompositeShape::MakeContainer}\label{wxcompositeshapemakecontainer}

\func{void}{MakeContainer}{\void}

Makes this composite into a container by creating one child wxDivisionShape.

\membersection{wxCompositeShape::OnCreateDivision}

\func{wxDivisionShape *}{OnCreateDivision}{\void}

Called when a new division shape is required. Can be overriden to allow an application
to use a different class of division.

\membersection{wxCompositeShape::Recompute}\label{wxcompositeshaperecompute}

\func{bool}{Recompute}{\void} 

Recomputes any constraints associated with the object. If FALSE is returned,
the constraints could not be satisfied (there was an inconsistency).

\membersection{wxCompositeShape::RemoveChild}

\func{void}{RemoveChild}{\param{wxShape *}{child}}

Removes the child from the composite and any constraint relationships, but does not
delete the child.

\section{\class{wxDividedShape}}\label{wxdividedshape}

A wxDividedShape is a rectangle with a number of vertical divisions. Each
division may have its text formatted with independent characteristics, and
the size of each division relative to the whole image may be specified.

\wxheading{Derived from}

\helpref{wxRectangleShape}{wxrectangleshape}

\wxheading{See also}

\helpref{wxDividedShape overview}{dividedshapeoverview}

\latexignore{\rtfignore{\wxheading{Members}}}

\membersection{wxDividedShape::wxDividedShape}

\func{}{wxDividedShape}{\param{double}{ width = 0.0}, \param{double}{ height = 0.0}}

Constructor.

\membersection{wxDividedShape::\destruct{wxDividedShape}}

\func{}{\destruct{wxDividedShape}}{\void}

Destructor.

\membersection{wxDividedShape::EditRegions}

\func{void}{EditRegions}{\void}

Edit the region colours and styles.

\membersection{wxDividedShape::SetRegionSizes}

\func{void}{SetRegionSizes}{\void}

Set all region sizes according to proportions and
this object total size.

\section{\class{wxDivisionShape}}\label{wxdivisionshape}

A division shape is like a composite in that it can contain further objects, but is used exclusively to
divide another shape into regions, or divisions. A wxDivisionShape is never free-standing.

\wxheading{Derived from}

\helpref{wxCompositeShape}{wxcompositeshape}

\wxheading{See also}

\helpref{wxCompositeShape overview}{compositeshapeoverview}

\latexignore{\rtfignore{\wxheading{Members}}}

\membersection{wxDivisionShape::wxDivisionShape}

\func{}{wxDivisionShape}{\void}

Constructor.

\membersection{wxDivisionShape::\destruct{wxDivisionShape}}

\func{}{\destruct{wxDivisionShape}}{\void}

Destructor.

\membersection{wxDivisionShape::AdjustBottom}

\func{void}{AdjustBottom}{\param{double}{ bottom}, \param{bool}{ test}}

Adjust a side, returning FALSE if it's not physically possible to adjust it to this point.

\membersection{wxDivisionShape::AdjustLeft}

\func{void}{AdjustLeft}{\param{double}{ left}, \param{bool}{ test}}

Adjust a side, returning FALSE if it's not physically possible to adjust it to this point.

\membersection{wxDivisionShape::AdjustRight}

\func{void}{AdjustRight}{\param{double}{ right}, \param{bool}{ test}}

Adjust a side, returning FALSE if it's not physically possible to adjust it to this point.

\membersection{wxDivisionShape::AdjustTop}

\func{void}{AdjustTop}{\param{double}{ top}, \param{bool}{ test}}

Adjust a side, returning FALSE if it's not physically possible to adjust it to this point.

\membersection{wxDivisionShape::Divide}\label{wxdivisionshapedivide}

\func{void}{Divide}{\param{int}{ direction}}

Divide this division into two further divisions, horizontally ({\it direction} is wxHORIZONTAL) or
vertically ({\it direction} is wxVERTICAL).

\membersection{wxDivisionShape::EditEdge}

\func{void}{EditEdge}{\param{int}{ side}}

Interactively edit style of left or top side.

\membersection{wxDivisionShape::GetBottomSide}

\func{wxDivisionShape *}{GetBottomSide}{\void}

Returns a pointer to the division on the bottom side of this division.

\membersection{wxDivisionShape::GetHandleSide}

\func{int}{GetHandleSide}{\void}

Returns the side which the handle appears on (DIVISION\_SIDE\_LEFT or DIVISION\_SIDE\_TOP).

\membersection{wxDivisionShape::GetLeftSide}

\func{wxDivisionShape *}{GetLeftSide}{\void}

Returns a pointer to the division on the left side of this division.

\membersection{wxDivisionShape::GetLeftSideColour}

\func{wxString}{GetLeftSideColour}{\void}

Returns a pointer to the colour used for drawing the left side of the division.

\membersection{wxDivisionShape::GetLeftSidePen}

\func{wxPen *}{GetLeftSidePen}{\void}

Returns a pointer to the pen used for drawing the left side of the division.

\membersection{wxDivisionShape::GetRightSide}

\func{wxDivisionShape *}{GetRightSide}{\void}

Returns a pointer to the division on the right side of this division.

\membersection{wxDivisionShape::GetTopSide}

\func{wxDivisionShape *}{GetTopSide}{\void}

Returns a pointer to the division on the top side of this division.

\membersection{wxDivisionShape::GetTopSideColour}

\func{wxString}{GetTopSideColour}{\void}

Returns a pointer to the colour used for drawing the top side of the division.

\membersection{wxDivisionShape::GetTopSidePen}

\func{wxPen *}{GetTopSidePen}{\void}

Returns a pointer to the pen used for drawing the left side of the division.

\membersection{wxDivisionShape::ResizeAdjoining}

\func{void}{ResizeAdjoining}{\param{int}{ side}, \param{double}{ newPos}, \param{bool}{ test}}

Resize adjoining divisions at the given side. If {\it test} is TRUE,
just see whether it's possible for each adjoining region,
returning FALSE if it's not.

{\it side} can be one of:

\begin{itemize}\itemsep=0pt
\item DIVISION\_SIDE\_NONE
\item DIVISION\_SIDE\_LEFT
\item DIVISION\_SIDE\_TOP
\item DIVISION\_SIDE\_RIGHT
\item DIVISION\_SIDE\_BOTTOM
\end{itemize}

\membersection{wxDivisionShape::PopupMenu}

\func{void}{PopupMenu}{\param{double}{ x}, \param{double}{ y}}

Popup the division menu.

\membersection{wxDivisionShape::SetBottomSide}

\func{void}{SetBottomSide}{\param{wxDivisionShape *}{shape}}

Set the pointer to the division on the bottom side of this division.

\membersection{wxDivisionShape::SetHandleSide}

\func{int}{SetHandleSide}{\void}

Sets the side which the handle appears on (DIVISION\_SIDE\_LEFT or DIVISION\_SIDE\_TOP).

\membersection{wxDivisionShape::SetLeftSide}

\func{void}{SetLeftSide}{\param{wxDivisionShape *}{shape}}

Set the pointer to the division on the left side of this division.

\membersection{wxDivisionShape::SetLeftSideColour}

\func{void}{SetLeftSideColour}{\param{const wxString\& }{colour}}

Sets the colour for drawing the left side of the division.

\membersection{wxDivisionShape::SetLeftSidePen}

\func{void}{SetLeftSidePen}{\param{wxPen *}{pen}}

Sets the pen for drawing the left side of the division.

\membersection{wxDivisionShape::SetRightSide}

\func{void}{SetRightSide}{\param{wxDivisionShape *}{shape}}

Set the pointer to the division on the right side of this division.

\membersection{wxDivisionShape::SetTopSide}

\func{void}{SetTopSide}{\param{wxDivisionShape *}{shape}}

Set the pointer to the division on the top side of this division.

\membersection{wxDivisionShape::SetTopSideColour}

\func{void}{SetTopSideColour}{\param{const wxString\& }{colour}}

Sets the colour for drawing the top side of the division.

\membersection{wxDivisionShape::SetTopSidePen}

\func{void}{SetTopSidePen}{\param{wxPen *}{pen}}

Sets the pen for drawing the top side of the division.

\section{\class{wxEllipseShape}}\label{wxellipseshape}

The wxEllipseShape behaves similarly to the wxRectangleShape but is
elliptical.

\wxheading{Derived from}

\helpref{wxShape}{wxshape}

\latexignore{\rtfignore{\wxheading{Members}}}

\membersection{wxEllipseShape::wxEllipseShape}

\func{}{wxEllipseShape}{\param{double}{ width = 0.0}, \param{double}{ height = 0.0}}

Constructor.

\membersection{wxEllipseShape::\destruct{wxEllipseShape}}

\func{}{\destruct{wxEllipseShape}}{\void}

Destructor.

\section{\class{wxLineShape}}\label{wxlineshape}

A wxLineShape may be attached to two nodes; it may be segmented, in which
case a control point is drawn for each joint.

A wxLineShape may have arrows at the beginning, end and centre.

\wxheading{Derived from}

\helpref{wxShape}{wxshape}

\latexignore{\rtfignore{\wxheading{Members}}}

\membersection{wxLineShape::wxLineShape}

\func{}{wxLineShape}{\void}

Constructor.

Usually you will call \helpref{wxLineShape::MakeLineControlPoints}{wxlineshapemakelinecontrolpoints} to
specify the number of segments in the line.

\membersection{wxLineShape::\destruct{wxLineShape}}

\func{}{\destruct{wxLineShape}}{\void}

Destructor.

\membersection{wxLineShape::AddArrow}\label{wxlineshapeaddarrow}

\func{void}{AddArrow}{\param{WXTYPE}{ type}, \param{bool}{ end = ARROW\_POSITION\_END}, \param{double}{ arrowSize = 10.0},
 \param{double}{ xOffset = 0.0}, \param{const wxString\& }{name = ""}, \param{wxPseudoMetaFile *}{mf = NULL}, \param{long}{ arrowId = -1}}

Adds an arrow (or annotation) to the line.

{\it type} may currently be one of:

\begin{description}\itemsep=0pt
\item[ARROW\_HOLLOW\_CIRCLE] Hollow circle.
\item[ARROW\_FILLED\_CIRCLE] Filled circle.
\item[ARROW\_ARROW] Conventional arrowhead.
\item[ARROW\_SINGLE\_OBLIQUE] Single oblique stroke.
\item[ARROW\_DOUBLE\_OBLIQUE] Double oblique stroke.
\item[ARROW\_DOUBLE\_METAFILE] Custom arrowhead.
\end{description}

{\it end} may currently be one of:

\begin{description}\itemsep=0pt
\item[ARROW\_POSITION\_END] Arrow appears at the end.
\item[ARROW\_POSITION\_START] Arrow appears at the start.
\end{description}

{\it arrowSize} specifies the length of the arrow.

{\it xOffset} specifies the offset from the end of the line.

{\it name} specifies a name for the arrow.

{\it mf} can be a wxPseduoMetaFile, perhaps loaded from a simple Windows metafile.

{\it arrowId} is the id for the arrow.

\membersection{wxLineShape::AddArrowOrdered}

\func{void}{AddArrowOrdered}{\param{wxArrowHead *}{arrow}, \param{wxList\&}{ referenceList}, \param{int}{ end}}

Add an arrowhead in the position indicated by the reference
list of arrowheads, which contains all legal arrowheads for this
line, in the correct order.
E.g.

\begin{verbatim}
  Reference list:      a b c d e
  Current line list:   a d
\end{verbatim}

Add c, then line list is: a c d.

If no legal arrowhead position, return FALSE.  Assume reference list is
for one end only, since it potentially defines the ordering for any one
of the 3 positions. So we don't check the reference list for arrowhead
position.

\membersection{wxLineShape::ClearArrow}

\func{bool}{ClearArrow}{\param{const wxString\& }{name}}

Delete the arrow with the given name.

\membersection{wxLineShape::ClearArrowsAtPosition}

\func{void}{ClearArrowsAtPosition}{\param{int}{ position = -1}}

Delete the arrows at the specified position, or at any position if {\it position} is -1.

\membersection{wxLineShape::DrawArrow}

\func{void}{DrawArrow}{\param{ArrowHead *}{arrow}, \param{double}{ xOffset}, \param{bool}{ proportionalOffset}}

Draws the given arrowhead (or annotation).

\membersection{wxLineShape::DeleteArrowHead}

\func{bool}{DeleteArrowHead}{\param{long}{ arrowId}}

\func{bool}{DeleteArrowHead}{\param{int}{ position}, \param{const wxString\& }{name}}

Delete arrowhead by id or position and name.

\membersection{wxLineShape::DeleteLineControlPoint}

\func{bool}{DeleteLineControlPoint}{\void}

Deletes an arbitary point on the line.

\membersection{wxLineShape::DrawArrows}

\func{void}{DrawArrows}{\param{wxDC\&}{ dc}}

Draws all arrows.

\membersection{wxLineShape::DrawRegion}

\func{void}{DrawRegion}{\param{wxDC\&}{ dc}, \param{wxShapeRegion *}{region}, \param{double}{ x}, \param{double}{ y}}

Format one region at this position.

\membersection{wxLineShape::EraseRegion}

\func{void}{EraseRegion}{\param{wxDC\&}{ dc}, \param{wxShapeRegion *}{region}, \param{double}{ x}, \param{double}{ y}}

Format one region at this position.

\membersection{wxLineShape::FindArrowHead}

\func{wxArrowHead *}{FindArrowHead}{\param{long}{ arrowId}}

\func{wxArrowHead *}{FindArrowHead}{\param{int}{ position}, \param{const wxString\& }{name}}

Find arrowhead by id or position and name.

\membersection{wxLineShape::FindLineEndPoints}

\func{void}{FindLineEndPoints}{\param{double *}{fromX}, \param{double *}{fromY}, \param{double *}{toX}, \param{double *}{toY}}

Finds the x, y points at the two ends of the line. This function can be
used by e.g. line-routing routines to get the actual points on the two
node images where the lines will be drawn to/from.

\membersection{wxLineShape::FindLinePosition}

\func{int}{FindLinePosition}{\param{double }{x}, \param{double }{y}}

Find which position we're talking about at this x, y.
Returns ARROW\_POSITION\_START, ARROW\_POSITION\_MIDDLE, ARROW\_POSITION\_END.

\membersection{wxLineShape::FindMinimumWidth}

\func{double}{FindMinimumWidth}{\void}

Finds the horizontal width for drawing a line with arrows in minimum
space. Assume arrows at end only.

\membersection{wxLineShape::FindNth}

\func{void}{FindNth}{\param{wxShape *}{image}, \param{int *}{nth}, \param{int *}{noArcs}, \param{bool}{ incoming}}

Finds the position of the line on the given object. Specify whether incoming or outgoing lines are
being considered with {\it incoming}.

\membersection{wxLineShape::GetAttachmentFrom}

\constfunc{int}{GetAttachmentFrom}{\void}

Returns the attachment point on the `from' node.

\membersection{wxLineShape::GetAttachmentTo}

\constfunc{int}{GetAttachmentTo}{\void}

Returns the attachment point on the `to' node.

\membersection{wxLineShape::GetEnds}

\func{void}{GetEnds}{\param{double *}{x1}, \param{double *}{y1}, \param{double *}{x2}, \param{double *}{y2}}

Gets the visible endpoints of the lines for drawing between two objects.

\membersection{wxLineShape::GetFrom}

\constfunc{wxShape *}{GetFrom}{\void}

Gets the `from' object.

\membersection{wxLineShape::GetLabelPosition}

\func{void}{GetLabelPosition}{\param{int}{ position}, \param{double *}{x}, \param{double *}{y}}

Get the reference point for a label. Region x and y are offsets from this.
position is 0 (middle), 1 (start), 2 (end).

\membersection{wxLineShape::GetNextControlPoint}

\func{wxPoint *}{GetNextControlPoint}{\param{wxShape *}{shape}}

Find the next control point in the line after the start/end point,
depending on whether the shape is at the start or end.

\membersection{wxLineShape::GetTo}

\func{wxShape *}{GetTo}{\void}

Gets the `to' object.

\membersection{wxLineShape::Initialise}

\func{void}{Initialise}{\void}

Initialises the line object.

\membersection{wxLineShape::InsertLineControlPoint}

\func{void}{InsertLineControlPoint}{\void}

Inserts a control point at an arbitrary position.

\membersection{wxLineShape::IsEnd}

\func{bool}{IsEnd}{\param{wxShape *}{shape}}

Returns TRUE if {\it shape} is at the end of the line.

\membersection{wxLineShape::IsSpline}

\func{bool}{IsSpline}{\void}

Returns TRUE if a spline is drawn through the control points, and FALSE otherwise.

\membersection{wxLineShape::MakeLineControlPoints}\label{wxlineshapemakelinecontrolpoints}

\func{void}{MakeLineControlPoints}{\param{int}{ n}}

Make a given number of control points (minimum of two).

\membersection{wxLineShape::OnMoveLink}

\func{void}{OnMoveLink}{\param{wxDC\&}{ dc}, \param{bool}{ moveControlPoints = TRUE}}

Called when a connected object has moved, to move the link to
correct position.

\membersection{wxLineShape::SetAttachmentFrom}

\func{void}{SetAttachmentTo}{\param{int}{ fromAttach}}

Sets the `from' shape attachment.

\membersection{wxLineShape::SetAttachments}

\func{void}{SetAttachments}{\param{int}{ fromAttach}, \param{int}{ toAttach}}

Specifies which object attachment points should be used at each end of the line.

\membersection{wxLineShape::SetAttachmentTo}

\func{void}{SetAttachmentTo}{\param{int}{ toAttach}}

Sets the `to' shape attachment.

\membersection{wxLineShape::SetEnds}

\func{void}{SetEnds}{\param{double}{ x1}, \param{double}{ y1}, \param{double}{ x2}, \param{double}{ y2}}

Sets the end positions of the line.

\membersection{wxLineShape::SetFrom}

\func{void}{SetFrom}{\param{wxShape *}{object}}

Sets the `from' object for the line.

\membersection{wxLineShape::SetIgnoreOffsets}

\func{void}{SetIgnoreOffsets}{\param{bool}{ ignore}}

Tells the shape whether to ignore offsets from the end of the line when drawing.

\membersection{wxLineShape::SetSpline}

\func{void}{SetSpline}{\param{bool}{ spline}}

Specifies whether a spline is to be drawn through the control points (TRUE), or a line (FALSE).

\membersection{wxLineShape::SetTo}

\func{void}{SetTo}{\param{wxShape *}{object}}

Sets the `to' object for the line.

\membersection{wxLineShape::Straighten}

\func{void}{Straighten}{\param{wxDC*}{ dc = NULL}}

Straighten verticals and horizontals. {\it dc} is optional.

\membersection{wxLineShape::Unlink}

\func{void}{Unlink}{\void}

Unlinks the line from the nodes at either end.

\section{\class{wxPolygonShape}}\label{wxpolygonshape}

A wxPolygonShape's shape is defined by a number of points passed to the object's
constructor. It can be used to create new shapes such as diamonds and triangles.

\wxheading{Derived from}

\helpref{wxShape}{wxshape}

\latexignore{\rtfignore{\wxheading{Members}}}

\membersection{wxPolygonShape::wxPolygonShape}

\func{}{wxPolygonShape}{void}

Constructor. Call \helpref{wxPolygonShape::Create}{wxpolygonshapecreate} to specify the polygon's vertices.

\membersection{wxPolygonShape::\destruct{wxPolygonShape}}

\func{}{\destruct{wxPolygonShape}}{\void}

Destructor.

\membersection{wxPolygonShape::Create}\label{wxpolygonshapecreate}

\func{void}{Create}{\param{wxList*}{ points}}

Takes a list of wxRealPoints; each point is an {\it offset} from the centre.
The polygon's destructor will delete these points, so do not delete them yourself.

\membersection{wxPolygonShape::AddPolygonPoint}

\func{void}{AddPolygonPoint}{\param{int}{ pos = 0}}

Add a control point after the given point.

\membersection{wxPolygonShape::CalculatePolygonCentre}

\func{void}{CalculatePolygonCentre}{\void}

Recalculates the centre of the polygon.

\membersection{wxPolygonShape::DeletePolygonPoint}

\func{void}{DeletePolygonPoint}{\param{int}{ pos = 0}}

Deletes a control point.

\membersection{wxPolygonShape::GetPoints}

\func{wxList *}{GetPoints}{\void}

Returns a pointer to the internal list of polygon vertices (wxRealPoints).

\membersection{wxPolygonShape::UpdateOriginalPoints}

\func{void}{UpdateOriginalPoints}{\void}

If we've changed the shape, must make the original
points match the working points with this function.

\section{\class{wxRectangleShape}}\label{wxrectangleshape}

The wxRectangleShape has rounded or square corners.

\wxheading{Derived from}

\helpref{wxShape}{wxshape}

\latexignore{\rtfignore{\wxheading{Members}}}

\membersection{wxRectangleShape::wxRectangleShape}

\func{}{wxRectangleShape}{\param{double}{ width = 0.0}, \param{double}{ height = 0.0}}

Constructor.

\membersection{wxRectangleShape::\destruct{wxRectangleShape}}

\func{}{\destruct{wxRectangleShape}}{\void}

Destructor.

\membersection{wxRectangleShape::SetCornerRadius}

\func{void}{SetCornerRadius}{\param{double}{ radius}}

Sets the radius of the rectangle's rounded corners. If the radius is zero, a non-rounded
rectangle will be drawn. If the radius is negative, the value is the proportion of the
smaller dimension of the rectangle.

\section{\class{wxPseudoMetaFile}}\label{wxpseudometafile}

A simple metafile-like class which can load data from a Windows metafile on all platforms.

\wxheading{Derived from}

wxObject

\section{\class{wxShape}}\label{wxshape}

The wxShape is the top-level, abstract object that all other
objects are derived from. All common functionality is represented by
wxShape's members, and overriden members that appear in derived
classes and have behaviour as documented for wxShape, are not
documented separately.

\wxheading{Derived from}

\helpref{wxShapeEvtHandler}{wxshapeevthandler}

\latexignore{\rtfignore{\wxheading{Members}}}

\membersection{wxShape::wxShape}

\func{}{wxShape}{\param{wxShapeCanvas*}{ canvas = NULL}}

Constructs a new wxShape.

\membersection{wxShape::\destruct{wxShape}}

\func{}{\destruct{wxShape}}{\void}

Destructor.

\membersection{wxShape::AddLine}

\func{void}{AddLine}{\param{wxLineShape*}{ line}, \param{wxShape*}{ other}, \param{int}{ attachFrom = 0}, \param{int}{ attachTo = 0},
 \param{int}{ positionFrom = -1}, \param{int}{ positionTo = -1}}

Adds a line between the specified canvas shapes, at the specified attachment points.

The position in the list of lines at each end can also be specified, so that the line will be drawn
at a particular point on its attachment point.

\membersection{wxShape::AddRegion}

\func{void}{AddRegion}{\param{wxShapeRegion*}{ region}}

Adds a region to the shape.

\membersection{wxShape::AddText}

\func{void}{AddText}{\param{const wxString\& }{string}}

Adds a line of text to the shape's default text region.

\membersection{wxShape::AddToCanvas}

\func{void}{AddToCanvas}{\param{wxShapeCanvas*}{ theCanvas}, \param{wxShape*}{ addAfter=NULL}}

Adds the shape to the canvas's shape list. If {\it addAfter} is
non-NULL, will add the shape after this one.

\membersection{wxShape::AncestorSelected}

\constfunc{bool}{AncestorSelected}{\void}

TRUE if the shape's ancestor is currently selected.

\membersection{wxShape::ApplyAttachmentOrdering}\label{wxshapeapplyattachmentordering}

\func{void}{ApplyAttachmentOrdering}{\param{wxList\&}{ linesToSort}}

Applies the line ordering in {\it linesToSort} to the shape, to reorder the way lines are attached.

\membersection{wxShape::AssignNewIds}

\func{void}{AssignNewIds}{\void}

Assigns new ids to this image and its children.

\membersection{wxShape::Attach}\label{wxshapeattach}

\func{void}{Attach}{\param{wxShapeCanvas*}{ can}}

Sets the shape's internal canvas pointer to point to the given canvas.

\membersection{wxShape::AttachmentIsValid}\label{wxshapeattachmentisvalid}

\constfunc{bool}{AttachmentIsValid}{\param{int}{ attachment}}

Returns TRUE if {\it attachment} is a valid attachment point.

\membersection{wxShape::AttachmentSortTest}\label{wxshapeattachmentsorttest}

\constfunc{bool}{AttachmentSortTest}{\param{int}{ attachment}, \param{const wxRealPoint\&}{ pt1},
 \param{const wxRealPoint\&}{ pt2}}

Returns TRUE if {\it pt1} is less than or equal to {\it pt2}, in the sense
that one point comes before another on an edge of the shape. {\it attachment} is
the attachment point (side) in question.

This function is used in \helpref{wxShape::MoveLineToNewAttachment}{wxshapemovelinetonewattachment} to
determine the new line ordering.

\membersection{wxShape::CalcSimpleAttachment}\label{wxshapecalcsimpleattachment}

\func{wxRealPoint}{CalcSimpleAttachment}{\param{const wxRealPoint\&}{ pt1},
 \param{const wxRealPoint\&}{ pt2}, \param{int}{ nth}, \param{int}{ noArcs}, \param{wxLineShape*}{ line}}

Assuming the attachment lies along a vertical or horizontal line,
calculates the position on that point.

\wxheading{Parameters}

\docparam{pt1}{The first point of the line repesenting the edge of the shape.}

\docparam{pt2}{The second point of the line representing the edge of the shape.}

\docparam{nth}{The position on the edge (for example there may be 6 lines at this attachment point,
and this may be the 2nd line.}

\docparam{noArcs}{The number of lines at this edge.}

\docparam{line}{The line shape.}

\wxheading{Remarks}

This function expects the line to be either vertical or horizontal, and determines which.

\membersection{wxShape::CalculateSize}

\func{void}{CalculateSize}{\void}

Called to calculate the shape's size if dependent on children sizes.

\membersection{wxShape::ClearAttachments}

\func{void}{ClearAttachments}{\void}

Clears internal custom attachment point shapes (of class wxAttachmentPoint).

\membersection{wxShape::ClearRegions}

\func{void}{ClearRegions}{\void}

Clears the wxShapeRegions from the shape.

\membersection{wxShape::ClearText}

\func{void}{ClearText}{\param{int}{ regionId = 0}}

Clears the text from the specified text region.

\membersection{wxShape::Constrain}

\func{bool}{Constrain}{\void}

Calculates the shape's constraints (if any). Applicable
only to wxCompositeShape, does nothing if the shape is of
a different class.

\membersection{wxShape::Copy}\label{wxshapecopy}

\func{void}{Copy}{\param{wxShape\&}{ copy}}

Copy this shape into {\it copy}. Every derived class must have one of these, and each Copy implementation
must call the derived class's implementation to ensure everything is copied. See also \helpref{wxShape::CreateNewCopy}{wxshapecreatenewcopy}.

\membersection{wxShape::CreateNewCopy}\label{wxshapecreatenewcopy}

\func{wxShape* }{CreateNewCopy}{\param{bool}{ resetMapping = TRUE}, \param{bool}{ recompute = TRUE}}

Creates and returns a new copy of this shape (calling \helpref{wxShape::Copy}{wxshapecopy}). Do not override this function.

This function should always be used to create a new copy, since it must do special processing
for copying constraints associated with constraints.

If {\it resetMapping} is TRUE, a mapping table used for complex shapes is reset; this may not be desirable
if the shape being copied is a child of a composite (and so the mapping table is in use).

If {\it recompute} is TRUE, \helpref{wxShape::Recompute}{wxshaperecompute} is called for the new shape.

\wxheading{Remarks}

This function uses the wxWindows dynamic object creation system to create a new shape of the same
type as `this', before calling Copy.

If the event handler for this shape is not the same as the shape itself, the event handler is also copied
using \helpref{wxShapeEvtHandler::CreateNewCopy}{wxshapeevthandlercreatenewcopy}.

\membersection{wxShape::DeleteControlPoints}

\func{void}{DeleteControlPoints}{\void}

Deletes the control points (or handles) for the shape. Does not redraw
the shape.

\membersection{wxShape::Detach}

\func{void}{Detach}{\void}

Disassociates the shape from its canvas by setting the internal shape
canvas pointer to NULL.

\membersection{wxShape::Draggable}

\func{bool}{Draggable}{\void} 

TRUE if the shape may be dragged by the user.

\membersection{wxShape::Draw}

\func{void}{Draw}{\param{wxDC\&}{ dc}}

Draws the whole shape and any lines attached to it.

Do not override this function: override OnDraw, which is called
by this function.

\membersection{wxShape::DrawContents}

\func{void}{DrawContents}{\param{wxDC\&}{ dc}}

Draws the internal graphic of the shape (such as
text).

Do not override this function: override OnDrawContents, which is called
by this function.

\membersection{wxShape::DrawLinks}

\func{void}{DrawLinks}{\param{wxDC\&}{ dc}, \param{int}{ attachment = -1}}

Draws any lines linked to this shape.

\membersection{wxShape::Erase}

\func{void}{Erase}{\param{wxDC\&}{ dc}}

Erases the shape, but does not repair damage caused to other
shapes.

\membersection{wxShape::EraseContents}

\func{void}{EraseContents}{\param{wxDC\&}{ dc}}

Erases the shape contents, that is, the area within the shape's
minimum bounding box.

\membersection{wxShape::EraseLinks}

\func{void}{EraseLinks}{\param{wxDC\&}{ dc}, \param{int}{ attachment = -1}}

Erases links attached to this shape, but does not repair
damage caused to other shapes.

\membersection{wxShape::FindRegion}

\func{wxShape *}{FindRegion}{\param{const wxString\& }{regionName}, \param{int *}{regionId}}

Finds the actual image (`this' if non-composite) and region id for the given
region name.

\membersection{wxShape::FindRegionNames}

\func{void}{FindRegionNames}{\param{wxStringList\&}{ list}}

Finds all region names for this image (composite or simple).
Supply an empty string list.

\membersection{wxShape::Flash}

\func{void}{Flash}{\void}

Flashes the shape.

\membersection{wxShape::FormatText}

\func{void}{FormatText}{\param{const wxString\& }{s}, \param{int}{ i = 0}}

Reformats the given text region; defaults to formatting the default region.

\membersection{wxShape::GetAttachmentMode}

\constfunc{bool}{GetAttachmentMode}{\void}

Returns the attachment mode, which is TRUE if attachments are used, FALSE otherwise (in which case
lines will be drawn as if to the centre of the shape). See \helpref{wxShape::SetAttachmentMode}{wxshapesetattachmentmode}.

\membersection{wxShape::GetAttachmentPosition}\label{wxshapegetattachmentposition}

\func{bool}{GetAttachmentPosition}{\param{int}{ attachment}, \param{double*}{ x}, \param{double*}{ y},
 \param{int}{ nth = 0}, \param{int}{ noArcs = 1}, \param{wxLineShape*}{ line = NULL}}

Gets the position at which the given attachment point should be drawn.

If {\it attachment} isn't found among the attachment points of the shape, returns FALSE.

\membersection{wxShape::GetBoundingBoxMax}

\func{void}{GetBoundingBoxMax}{\param{double *}{width}, \param{double *}{height}}

Gets the maximum bounding box for the shape, taking into
account external features such as shadows.

\membersection{wxShape::GetBoundingBoxMin}

\func{void}{GetBoundingBoxMin}{\param{double *}{width}, \param{double *}{height}}

Gets the minimum bounding box for the shape, that defines
the area available for drawing the contents (such as text).

\membersection{wxShape::GetBrush}

\constfunc{wxBrush*}{GetBrush}{\void}

Returns the brush used for filling the shape.

\membersection{wxShape::GetCanvas}

\constfunc{wxShapeCanvas*}{GetCanvas}{\void}

Gets the internal canvas pointer.

\membersection{wxShape::GetCentreResize}

\constfunc{bool}{GetCentreResize}{\void}

Returns TRUE if the shape is to be resized from the centre (the centre
stands still), or FALSE if from the corner or side being dragged (the
other corner or side stands still).

\membersection{wxShape::GetChildren}

\constfunc{wxList\&}{GetChildren}{\void}

Returns a reference to the list of children for this shape.

\membersection{wxShape::GetClientData}

\func{wxObject*}{GetClientData}{\void}

Gets the client data associated with the shape (NULL if there is
none).

\membersection{wxShape::GetDisableLabel}

\constfunc{bool}{GetDisableLabel}{\void}

Returns TRUE if the default region will not be shown, FALSE otherwise.

\membersection{wxShape::GetEventHandler}

\constfunc{wxShapeEvtHandler*}{GetEventHandler}{\void}

Returns the event handler for this shape.

\membersection{wxShape::GetFixedHeight}

\constfunc{bool}{GetFixedHeight}{\void}

Returns TRUE if the shape cannot be resized in the vertical plane.

\membersection{wxShape::GetFixedSize}

\func{void}{GetFixedSize}{\param{bool *}{ x}, \param{bool *}{ y}}

Returns flags indicating whether the shape is of fixed size in either direction.

\membersection{wxShape::GetFixedWidth}

\constfunc{bool}{GetFixedWidth}{\void}

Returns TRUE if the shape cannot be resized in the horizontal plane.

\membersection{wxShape::GetFont}

\constfunc{wxFont*}{GetFont}{\param{int}{ regionId = 0}}

Gets the font for the specified text region.

\membersection{wxShape::GetFunctor}

\constfunc{wxString}{GetFunctor}{\void}

Gets a string representing the type of the shape, to be used when
writing out shape descriptions to a file. This is overridden by
each derived shape class to provide an appropriate type string. By default,
"node\_image" is used for non-line shapes, and "arc\_image" for lines.

\membersection{wxShape::GetId}

\constfunc{long}{GetId}{\void}

Returns the integer identifier for this shape.

\membersection{wxShape::GetLinePosition}\label{wxshapegetlineposition}

\func{int}{GetLinePosition}{\param{wxLineShape*}{ line}}

Gets the zero-based position of {\it line} in the list of lines for this shape.

\membersection{wxShape::GetLines}

\constfunc{wxList\&}{GetLines}{\void}

Returns a reference to the list of lines connected to this shape.

\membersection{wxShape::GetMaintainAspectRatio}\label{wxshapegetmaintainaspectratio}

\constfunc{bool}{GetMaintainAspectRatio}{\void}

If returns TRUE, resizing the shape will not change the aspect ratio
(width and height will be in the original proportion).

\membersection{wxShape::GetNumberOfAttachments}\label{wxshapegetnumberofattachments}

\constfunc{int}{GetNumberOfAttachments}{\void}

Gets the number of attachment points for this shape.

\membersection{wxShape::GetNumberOfTextRegions}

\constfunc{int}{GetNumberOfTextRegions}{\void}

Gets the number of text regions for this shape.

\membersection{wxShape::GetParent}

\constfunc{wxShape *}{GetParent}{\void}

Returns the parent of this shape, if it is part of a composite.

\membersection{wxShape::GetPen}

\constfunc{wxPen*}{GetPen}{\void}

Returns the pen used for drawing the shape's outline.

\membersection{wxShape::GetPerimeterPoint}

\func{bool}{GetPerimeterPoint}{\param{double}{ x1}, \param{double}{ y1}, \param{double}{ x2}, \param{double}{ y2}, \param{double *}{x3}, \param{double *}{y3}}

Gets the point at which the line from (x1, y1) to (x2, y2) hits the shape. Returns TRUE if the
line hits the perimeter.

\membersection{wxShape::GetRegionId}\label{getregionid}

\func{int}{GetRegionId}{\param{const wxString\& }{name}}

Gets the region's identifier by name. This is {\it not} unique for within an entire composite, but
is unique for the image.

\membersection{wxShape::GetRegionName}\label{getregionname}

\func{wxString}{GetRegionName}{\param{int}{ regionId = 0}}

Gets the region's name. A region's name can be used to uniquely determine a region within
an entire composite image hierarchy. See also \helpref{wxShape::SetRegionName}{wxshapesetregionname}.

\membersection{wxShape::GetRegions}\label{getregions}

\func{wxList\&}{GetRegions}{\void}

Returns the list of wxShapeRegions.

\membersection{wxShape::GetRotation}

\constfunc{double}{GetRotatation}{\void}

Returns the angle of rotation in radians.

\membersection{wxShape::GetSensitivityFilter}

\constfunc{void}{GetSensitivityFilter}{\void}

Returns the sensitivity filter, a bitlist of values. See \helpref{wxShape::SetSensitivityFilter}{wxshapesetsensitivityfilter}.

\membersection{wxShape::GetShadowMode}

\constfunc{int}{SetShadowMode}{\void}

Returns the shadow mode. See \helpref{wxShape::SetShadowMode}{wxshapesetshadowmode}.

\membersection{wxShape::GetSpaceAttachments}

\constfunc{bool}{GetSpaceAttachments}{\void}

Indicates whether lines should be spaced out evenly at the point they touch the node (TRUE), or whether they
should join at a single point (FALSE).

\membersection{wxShape::GetTextColour}

\constfunc{wxString}{GetTextColour}{\param{int}{ regionId = 0}}

Gets the colour for the specified text region.

\membersection{wxShape::GetTopAncestor}

\constfunc{wxShape *}{GetTopAncestor}{\void}

Returns the top-most ancestor of this shape (the root of the composite).

\membersection{wxShape::GetX}

\constfunc{double}{GetX}{\void}

Gets the x position of the centre of the shape.

\membersection{wxShape::GetY}

\constfunc{double}{GetY}{\void}

Gets the y position of the centre of the shape.

\membersection{wxShape::HitTest}

\func{bool}{HitTest}{\param{double}{ x}, \param{double}{ y}, \param{int*}{ attachment}, \param{double*}{ distance}}

Given a point on a canvas, returns TRUE if the point was on the shape, and returns
the nearest attachment point and distance from the given point and target.

\membersection{wxShape::Insert}

\func{void}{InsertInCanvas}{\param{wxShapeCanvas*}{ canvas}}

Inserts the shape at the front of the shape list of {\it canvas}.

\membersection{wxShape::IsHighlighted}

\constfunc{bool}{IsHighlighted}{\void}

Returns TRUE if the shape is highlighted. Shape highlighting is unimplemented.

\membersection{wxShape::IsShown}

\constfunc{bool}{IsShown}{\void}

Returns TRUE if the shape is in a visible state, FALSE otherwise. Note
that this has nothing to do with whether the window is hidden or the
shape has scrolled off the canvas; it refers to the internal
visibility flag.

\membersection{wxShape::MakeControlPoints}

\func{void}{MakeControlPoints}{\void}

Make a list of control points (draggable handles) appropriate to the shape.

\membersection{wxShape::MakeMandatoryControlPoints}

\func{void}{MakeMandatoryControlPoints}{\void}

Make the mandatory control points. For example, the control point on a dividing line should
appear even if the divided rectangle shape's handles should not appear (because it is the child of
a composite, and children are not resizable).

\membersection{wxShape::Move}\label{wxshapemove}

\func{void}{Move}{\param{wxDC\&}{ dc}, \param{double}{ x1}, \param{double}{ y1}, \param{bool}{ display = TRUE}}

Move the shape to the given position, redrawing if {\it display} is TRUE.

\membersection{wxShape::MoveLineToNewAttachment}\label{wxshapemovelinetonewattachment}

\func{void}{MoveLineToNewAttachment}{\param{wxDC\&}{ dc}, \param{wxLineShape*}{ toMove}, \param{double}{ x}, \param{double}{ y}}

Move the given line (which must already be attached to the shape) to 
a different attachment point on the shape, or a different order on the same attachment.

Cals \helpref{wxShape::AttachmentSortTest}{wxshapeattachmentsorttest} and then \helpref{wxShapeEvtHandler::OnChangeAttachment}{wxshapeevthandleronchangeattachment}.

\membersection{wxShape::MoveLinks}

\func{void}{MoveLinks}{\param{wxDC\&}{ dc}}

Redraw all the lines attached to the shape.

\membersection{wxShape::NameRegions}

\func{void}{NameRegions}{\param{const wxString\& }{parentName = ``"}}

Make unique names for all the regions in a shape or composite shape.

\membersection{wxShape::Rotate}

\func{void}{Rotate}{\param{double }{x}, \param{double }{y}, \param{double }{theta}}

Rotate about the given axis by the given amount in radians (does nothing
for most shapes). But even non-rotating shapes should record their
notional rotation in case it's important (e.g. in dog-leg code).

\membersection{wxShape::ReadConstraints}

\func{void}{ReadConstraints}{\param{wxExpr *}{clause}, \param{wxExprDatabase *}{database}}

If the shape is a composite, it may have constraints that need to be read in in a separate pass.

\membersection{wxShape::ReadAttributes}

\func{void}{ReadAttributes}{\param{wxExpr*}{ clause}}

Reads the attributes (data member values) from the given expression.

\membersection{wxShape::ReadRegions}

\func{void}{ReadRegions}{\param{wxExpr *}{clause}}

Reads in the regions.

\membersection{wxShape::Recentre}

\func{void}{Recentre}{\void}

Does recentring (or other formatting) for all the text regions for this shape.

\membersection{wxShape::RemoveFromCanvas}

\func{void}{RemoveFromCanvas}{\param{wxShapeCanvas*}{ canvas}}

Removes the shape from the canvas.

\membersection{wxShape::ResetControlPoints}

\func{void}{ResetControlPoints}{\void}

Resets the positions of the control points (for instance when the
shape's shape has changed).

\membersection{wxShape::ResetMandatoryControlPoints}

\func{void}{ResetMandatoryControlPoints}{\void}

Reset the mandatory control points. For example, the control point on a dividing line should
appear even if the divided rectangle shape's handles should not appear (because it is the child of
a composite, and children are not resizable).

\membersection{wxShape::Recompute}\label{wxshaperecompute}

\func{bool}{Recompute}{\void} 

Recomputes any constraints associated with the shape (normally
applicable to wxCompositeShapes only, but harmless for other
classes of shape).

\membersection{wxShape::RemoveLine}

\func{void}{RemoveLine}{\param{wxLineShape*}{ line}}

Removes the given line from the shape's list of attached lines.

\membersection{wxShape::Select}\label{wxshapeselect}

\func{void}{Select}{\param{bool}{ select = TRUE}}

Selects or deselects the given shape, drawing or erasing control points
(handles) as necessary.

\membersection{wxShape::Selected}\label{wxshapeselected}

\constfunc{bool}{Selected}{\void}

TRUE if the shape is currently selected.

\membersection{wxShape::SetAttachmentMode}\label{wxshapesetattachmentmode}

\func{void}{SetAttachmentMode}{\param{bool}{ flag}}

Sets the attachment mode to TRUE or FALSE. If TRUE, attachment points
will be significant when drawing lines to and from this shape.
If FALSE, lines will be drawn as if to the centre of the shape.

\membersection{wxShape::SetBrush}

\func{void}{SetBrush}{\param{wxBrush *}{brush}}

Sets the brush for filling the shape's shape.

\membersection{wxShape::SetCanvas}\label{wxshapesetcanvas}

\func{void}{SetCanvas}{\param{wxShapeCanvas*}{ theCanvas}}

Identical to \helpref{wxShape::Attach}{wxshapesetcanvas}.

\membersection{wxShape::SetCentreResize}

\func{void}{SetCentreResize}{\param{bool}{ cr}}

Specify whether the shape is to be resized from the centre (the centre stands still) or from the corner or side
being dragged (the other corner or side stands still).

\membersection{wxShape::SetClientData}

\func{void}{SetClientData}{\param{wxObject *}{clientData}}

Sets the client data.

\membersection{wxShape::SetDefaultRegionSize}\label{setdefaultregionsize}

\func{void}{SetDefaultRegionSize}{\void}

Set the default region to be consistent with the shape size.

\membersection{wxShape::SetDisableLabel}

\func{void}{SetDisableLabel}{\param{bool}{ flag}}

Set {\it flag} to TRUE to stop the default region being shown, FALSE otherwise.

\membersection{wxShape::SetDraggable}

\func{void}{SetDraggable}{\param{bool}{ drag}, \param{bool}{ recursive = FALSE}}

Sets the shape to be draggable or not draggable.

\membersection{wxShape::SetDrawHandles}

\func{void}{SetDrawHandles}{\param{bool}{ drawH}}

Sets the {\it drawHandles} flag for this shape and all descendants. If {\it drawH} is TRUE (the default),
any handles (control points) will be drawn. Otherwise, the handles will not be drawn.

\membersection{wxShape::SetEventHandler}

\func{void}{GetEventHandler}{\param{wxShapeEvtHandler *}{handler}}

Sets the event handler for this shape.

\membersection{wxShape::SetFixedSize}

\func{void}{SetFixedSize}{\param{bool}{ x}, \param{bool}{ y}} 

Sets the shape to be of the given, fixed size.

\membersection{wxShape::SetFont}

\func{void}{SetFont}{\param{wxFont *}{font}, \param{int}{ regionId = 0}}

Sets the font for the specified text region.

\membersection{wxShape::SetFormatMode}\label{setformatmode}

\func{void}{SetFormatMode}{\param{int}{ mode}, \param{int}{ regionId = 0}} 

Sets the format mode of the default text region. The argument can be a bit list
of the following:

\begin{description}\itemsep=0pt
\item[FORMAT\_NONE] No formatting.
\item[FORMAT\_CENTRE\_HORIZ] Horizontal centring.
\item[FORMAT\_CENTRE\_VERT] Vertical centring.
\end{description}

\membersection{wxShape::SetHighlight}

\func{void}{SetHighlight}{\param{bool}{ hi}, \param{bool}{ recurse = FALSE}}

Sets the highlight for a shape. Shape highlighting is unimplemented.

\membersection{wxShape::SetId}

\func{void}{SetId}{\param{long}{ id}}

Set the integer identifier for this shape.

\membersection{wxShape::SetMaintainAspectRatio}\label{wxshapesetmaintainaspectratio}

\func{void}{SetMaintainAspectRatio}{\param{bool}{ flag}}

If the argument is TRUE, tells the shape that resizes should not change the aspect ratio
(width and height should be in the original proportion).

\membersection{wxShape::SetPen}

\func{void}{SetPen}{\param{wxPen *}{pen}}

Sets the pen for drawing the shape's outline.

\membersection{wxShape::SetRegionName}\label{wxshapesetregionname}

\func{void}{SetRegionName}{\param{const wxString\& }{name}, \param{int}{ regionId = 0}}

Sets the name for this region. The name for a region is unique within the scope of the whole
composite, whereas a region id is unique only for a single image.

\membersection{wxShape::SetSensitivityFilter}\label{wxshapesetsensitivityfilter}

\func{void}{SetSensitivityFilter}{\param{int}{ sens=OP\_ALL}, \param{bool}{ recursive = FALSE}}

Sets the shape to be sensitive or insensitive to specific mouse operations.

{\it sens} is a bitlist of the following:

\begin{itemize}\itemsep=0pt
\item OP\_CLICK\_LEFT
\item OP\_CLICK\_RIGHT
\item OP\_DRAG\_LEFT
\item OP\_DRAG\_RIGHT
\item OP\_ALL (equivalent to a combination of all the above).
\end{itemize}

\membersection{wxShape::SetShadowMode}\label{wxshapesetshadowmode}

\func{void}{SetShadowMode}{\param{int}{ mode}, \param{bool}{ redraw = FALSE}}

Sets the shadow mode (whether a shadow is drawn or not). {\it mode} can be one of
the following:

\begin{description}\itemsep=0pt
\item[SHADOW\_NONE] No shadow (the default).
\item[SHADOW\_LEFT] Shadow on the left side.
\item[SHADOW\_RIGHT] Shadow on the right side.
\end{description}

\membersection{wxShape::SetSize}

\func{void}{SetSize}{\param{double}{ x}, \param{double}{ y}, \param{bool}{ recursive = TRUE}}

Sets the shape's size.

\membersection{wxShape::SetSpaceAttachments}

\func{void}{SetSpaceAttachments}{\param{bool}{ sp}}

Indicate whether lines should be spaced out evenly at the point they touch the node (TRUE), or whether they
should join at a single point (FALSE).

\membersection{wxShape::SetTextColour}

\func{void}{SetTextColour}{\param{const wxString\& }{colour}, \param{int}{ regionId = 0}}

Sets the colour for the specified text region.

\membersection{wxShape::SetX}

\func{void}{SetX}{\param{double}{ x}}

Sets the {\it x} position of the shape.

\membersection{wxShape::SetX}

\func{void}{SetY}{\param{double}{ y}}

Sets the {\it y} position of the shape.

\membersection{wxShape::SpaceAttachments}

\func{void}{SpaceAttachments}{\param{bool}{ sp}} 

Sets the spacing mode: if TRUE, lines at the same attachment point will be
spaced evenly across that side of the shape. If false, all lines at the
same attachment point will emanate from the same point.

\membersection{wxShape::Show}

\func{void}{Show}{\param{bool}{ show}}

Sets a flag indicating whether the shape should be drawn.

\membersection{wxShape::Unlink}

\func{void}{Unlink}{\void}

If the shape is a line, unlinks the nodes attached to the shape, removing itself from the list of
lines for each of the `to' and `from' nodes.

\membersection{wxShape::WriteAttributes}

\func{void}{WriteAttributes}{\param{wxExpr *}{clause}}

Writes the shape's attributes (data member values) into the given expression.

\membersection{wxShape::WriteRegions}

\func{void}{WriteRegions}{\param{wxExpr *}{clause}}

Writes the regions.

\section{\class{wxShapeCanvas}}\label{wxshapecanvas}

A canvas for drawing diagrams on.

\wxheading{Derived from}

wxScrolledWindow

\wxheading{See also}

\helpref{wxDiagram}{wxdiagram}

\latexignore{\rtfignore{\wxheading{Members}}}

\membersection{wxShapeCanvas::wxShapeCanvas}

\func{}{wxShapeCanvas}{\param{wxWindow*}{ parent = NULL}, \param{wxWindowID}{ id = -1},
 \param{const wxPoint\&}{ pos = wxDefaultPosition}, \param{const wxSize\&}{ size = wxDefaultSize},
 \param{long}{ style = wxBORDER}}

Constructor.

\membersection{wxShapeCanvas::\destruct{wxShapeCanvas}}

\func{}{\destruct{wxShapeCanvas}}{\void}

Destructor.

\membersection{wxShapeCanvas::AddShape}

\func{void}{AddShape}{\param{wxShape *}{shape}, \param{wxShape *}{addAfter = NULL}}

Adds a shape to the diagram. If {\it addAfter} is non-NULL, the shape will be added after this
one.

\membersection{wxShapeCanvas::FindShape}

\func{wxShape *}{FindShape}{\param{double}{ x1}, \param{double}{ y}, \param{int *}{attachment}, \param{wxClassInfo *}{info = NULL},
 \param{wxShape *}{notImage = NULL}}

Find a shape under this mouse click. Returns the shape (or NULL), and the nearest attachment point.

If {\it info} is non-NULL, a shape whose class which is a descendant of the desired class is found.

If {\it notImage} is non-NULL, shapes which are descendants of {\it notImage} are ignored.

\membersection{wxShapeCanvas::FindFirstSensitiveShape}

\func{wxShape *}{FindFirstSensitiveShape}{\param{double}{ x1}, \param{double}{ y}, \param{int *}{attachment}, \param{int}{ op}}

Finds the first sensitive shape whose sensitivity filter matches {\it op}, working up the hierarchy of composites until
one (or none) is found.

\membersection{wxShapeCanvas::GetDiagram}

\constfunc{wxDiagram*}{GetDiagram}{\void}

Returns the canvas associated with this diagram.

\membersection{wxShapeCanvas::GetGridSpacing}

\constfunc{double}{GetGridSpacing}{\void}

Returns the grid spacing.

\membersection{wxShapeCanvas::GetMouseTolerance}

\constfunc{int}{GetMouseTolerance}{\void}

Returns the tolerance within which a mouse move is ignored.

\membersection{wxShapeCanvas::GetShapeList}

\constfunc{wxList*}{GetShapeList}{\void}

Returns a pointer to the internal shape list.

\membersection{wxShapeCanvas::GetQuickEditMode}

\constfunc{bool}{GetQuickEditMode}{\void}

Returns quick edit mode for the associated diagram.

\membersection{wxShapeCanvas::InsertShape}

\func{void}{InsertShape}{\param{wxShape*}{ shape}}

Inserts a shape at the front of the shape list.

\membersection{wxShapeCanvas::OnBeginDragLeft}\label{wxshapecanvasonbegindragleft}

\func{void}{OnBeginDragLeft}{\param{double}{ x}, \param{double}{ y}, \param{int}{ keys = 0}}

Called when the start of a left-button drag event on the canvas background is detected by OnEvent. You may override this member;
by default it does nothing.

{\it keys} is a bit list of the following:

\begin{itemize}\itemsep=0pt
\item KEY\_SHIFT
\item KEY\_CTRL
\end{itemize}

See also \helpref{wxShapeCanvas::OnDragLeft}{wxshapecanvasondragleft}, \helpref{wxShapeCanvas::OnEndDragLeft}{wxshapecanvasonenddragleft}.

\membersection{wxShapeCanvas::OnBeginDragRight}\label{wxshapecanvasonbegindragright}

\func{void}{OnBeginDragRight}{\param{double}{ x}, \param{double}{ y}, \param{int}{ keys = 0}}

Called when the start of a right-button drag event on the canvas background is detected by OnEvent. You may override this member;
by default it does nothing.

{\it keys} is a bit list of the following:

\begin{itemize}\itemsep=0pt
\item KEY\_SHIFT
\item KEY\_CTRL
\end{itemize}

See also \helpref{wxShapeCanvas::OnDragRight}{wxshapecanvasondragright}, \helpref{wxShapeCanvas::OnEndDragRight}{wxshapecanvasonenddragright}.

\membersection{wxShapeCanvas::OnEndDragLeft}\label{wxshapecanvasonenddragleft}

\func{void}{OnEndDragLeft}{\param{double}{ x}, \param{double}{ y}, \param{int}{ keys = 0}}

Called when the end of a left-button drag event on the canvas background is detected by OnEvent. You may override this member;
by default it does nothing.

{\it keys} is a bit list of the following:

\begin{itemize}\itemsep=0pt
\item KEY\_SHIFT
\item KEY\_CTRL
\end{itemize}

See also \helpref{wxShapeCanvas::OnDragLeft}{wxshapecanvasondragleft}, \helpref{wxShapeCanvas::OnBeginDragLeft}{wxshapecanvasonbegindragleft}.

\membersection{wxShapeCanvas::OnEndDragRight}\label{wxshapecanvasonenddragright}

\func{void}{OnEndDragRight}{\param{double}{ x}, \param{double}{ y}, \param{int}{ keys = 0}}

Called when the end of a right-button drag event on the canvas background is detected by OnEvent. You may override this member;
by default it does nothing.

{\it keys} is a bit list of the following:

\begin{itemize}\itemsep=0pt
\item KEY\_SHIFT
\item KEY\_CTRL
\end{itemize}

See also \helpref{wxShapeCanvas::OnDragRight}{wxshapecanvasondragright}, \helpref{wxShapeCanvas::OnBeginDragRight}{wxshapecanvasonbegindragright}.

\membersection{wxShapeCanvas::OnDragLeft}\label{wxshapecanvasondragleft}

\func{void}{OnDragLeft}{\param{bool}{ draw}, \param{double}{ x}, \param{double}{ y}, \param{int}{ keys = 0}}

Called when a left-button drag event on the canvas background is detected by OnEvent. You may override this member;
by default it does nothing.

{\it draw} is alternately TRUE and FALSE, to assist drawing and erasing.

{\it keys} is a bit list of the following:

\begin{itemize}\itemsep=0pt
\item KEY\_SHIFT
\item KEY\_CTRL
\end{itemize}

See also \helpref{wxShapeCanvas::OnBeginDragLeft}{wxshapecanvasonbegindragleft}, \helpref{wxShapeCanvas::OnEndDragLeft}{wxshapecanvasonenddragleft}.

\membersection{wxShapeCanvas::OnDragRight}\label{wxshapecanvasondragright}

\func{void}{OnDragRight}{\param{bool}{ draw}, \param{double}{ x}, \param{double}{ y}, \param{int}{ keys = 0}}

Called when a right-button drag event on the canvas background is detected by OnEvent. You may override this member;
by default it does nothing.

{\it draw} is alternately TRUE and FALSE, to assist drawing and erasing.

{\it keys} is a bit list of the following:

\begin{itemize}\itemsep=0pt
\item KEY\_SHIFT
\item KEY\_CTRL
\end{itemize}

See also \helpref{wxShapeCanvas::OnBeginDragRight}{wxshapecanvasonbegindragright}, \helpref{wxShapeCanvas::OnEndDragRight}{wxshapecanvasonenddragright}.

\membersection{wxShapeCanvas::OnLeftClick}\label{wxshapecanvasonleftclick}

\func{void}{OnLeftClick}{\param{double}{ x}, \param{double}{ y}, \param{int}{ keys = 0}}

Called when a left click event on the canvas background is detected by OnEvent. You may override this member;
by default it does nothing.

{\it keys} is a bit list of the following:

\begin{itemize}\itemsep=0pt
\item KEY\_SHIFT
\item KEY\_CTRL
\end{itemize}

\membersection{wxShapeCanvas::OnRightClick}\label{wxshapecanvasonrightclick}

\func{void}{OnRightClick}{\param{double}{ x}, \param{double}{ y}, \param{int}{ keys = 0}}

Called when a right click event on the canvas background is detected by OnEvent. You may override this member;
by default it does nothing.

{\it keys} is a bit list of the following:

\begin{itemize}\itemsep=0pt
\item KEY\_SHIFT
\item KEY\_CTRL
\end{itemize}

\membersection{wxShapeCanvas::Redraw}

\func{void}{Redraw}{\void}

Calls wxDiagram::Redraw.

\membersection{wxShapeCanvas::RemoveShape}

\func{void}{RemoveShape}{\param{wxShape *}{shape}}

Calls wxDiagram::RemoveShape.

\membersection{wxShapeCanvas::SetDiagram}

\func{void}{SetDiagram}{\param{wxDiagram *}{diagram}}

Sets the diagram associated with this diagram.

\membersection{wxShapeCanvas::Snap}

\func{void}{Snap}{\param{double *}{x}, \param{double *}{y}}

Calls wxDiagram::Snap.



\section{\class{wxShapeEvtHandler}}\label{wxshapeevthandler}

wxShapeEvtHandler is a class from which wxShape (and therefore all shape classes) are derived.
A wxShape also contains a pointer to its current wxShapeEvtHandler. Event handlers
can be swapped in and out, altering the behaviour of a shape. This allows, for example,
a range of behaviours to be redefined in one class, rather than requiring
each shape class to be subclassed.

\wxheading{Derived from}

wxObject

\latexignore{\rtfignore{\wxheading{Members}}}

\membersection{wxShapeEvtHandler::m\_handlerShape}

\member{wxShape*}{m\_handlerShape}

Pointer to the shape associated with this handler.

\membersection{wxShapeEvtHandler::m\_previousHandler}

\member{wxShapeEvtHandler*}{m\_previousHandler}

Pointer to the previous handler.

\membersection{wxShapeEvtHandler::wxShapeEvtHandler}

\func{void}{wxShapeEvtHandler}{\param{wxShapeEvtHandler *}{previous = NULL}, \param{wxShape *}{shape = NULL}}

Constructs a new event handler.

\membersection{wxShapeEvtHandler::\destruct{wxShapeEvtHandler}}

\func{void}{\destruct{wxShapeEvtHandler}}{\void}

Destructor.

\membersection{wxShapeEvtHandler::CopyData}\label{wxshapeevthandlercopydata}

\func{void}{CopyData}{\param{wxShapeEvtHandler\&}{ handler}}

A virtual function to copy the data from this object to {\it handler}. Override if you
derive from wxShapeEvtHandler and have data to copy.

\membersection{wxShapeEvtHandler::CreateNewCopy}\label{wxshapeevthandlercreatenewcopy}

\func{wxShapeEvtHandler*}{CreateNewCopy}{\void}

Creates a new event handler object of the same class as this object, and then
calls \helpref{wxShapeEvtHandler::CopyData}{wxshapeevthandlercopydata}.

\membersection{wxShapeEvtHandler::GetPreviousHandler}\label{wxshapeevthandlergetprevioushandler}

\constfunc{wxShapeEvtHandler*}{GetPreviousHandler}{\void}

Returns the previous handler.

\membersection{wxShapeEvtHandler::GetShape}\label{wxshapeevthandlergetshape}

\constfunc{wxShape*}{GetShape}{\void}

Returns the shape associated with this handler.

\membersection{wxShapeEvtHandler::OnBeginDragLeft}

\func{void}{OnBeginDragLeft}{\param{double}{ x}, \param{double}{ y}, \param{int}{ keys=0}, \param{int}{ attachment = 0}}

Called when the user is beginning to drag using the left mouse button.

\membersection{wxShapeEvtHandler::OnBeginDragRight}

\func{void}{OnBeginDragRight}{\param{double}{ x}, \param{double}{ y}, \param{int}{ keys=0}, \param{int}{ attachment = 0}}

Called when the user is beginning to drag using the right mouse button.

\membersection{wxShapeEvtHandler::OnBeginSize}

\func{void}{OnBeginSize}{\param{double}{ width}, \param{double}{ height}}

Called when a shape starts to be resized.

\membersection{wxShapeEvtHandler::OnChangeAttachment}\label{wxshapeevthandleronchangeattachment}

\func{void}{OnChangeAttachment}{\param{int}{ attachment}, \param{wxLineShape*}{ line}, \param{wxList\&}{ ordering}}

Override this to prevent or intercept line reordering. wxShape's implementation of this function
calls \helpref{wxShape::ApplyAttachmentOrdering}{wxshapeapplyattachmentordering} to apply
the new ordering.

\membersection{wxShapeEvtHandler::OnDragLeft}

\func{void}{OnDragLeft}{\param{bool}{ draw}, \param{double}{ x}, \param{double}{ y}, \param{int}{ keys=0}, \param{int}{ attachment = 0}}

Called twice when the shape is being dragged, once to allow erasing the old
image, and again to allow drawing at the new position.

\membersection{wxShapeEvtHandler::OnDragRight}

\func{void}{OnDragRight}{\param{bool}{ draw}, \param{double}{ x}, \param{double}{ y}, \param{int}{ keys=0}, \param{int}{ attachment = 0}}

Called twice when the shape is being dragged, once to allow erasing the old
image, and again to allow drawing at the new position.

\membersection{wxShapeEvtHandler::OnDraw}

\func{void}{OnDraw}{\param{wxDC\&}{ dc}}

Defined for each class to draw the main graphic, but
not the contents.

\membersection{wxShapeEvtHandler::OnDrawContents}

\func{void}{OnDrawContents}{\param{wxDC\&}{ dc}}

Defined for each class to draw the contents of the
shape, such as text.

\membersection{wxShapeEvtHandler::OnDrawControlPoints}

\func{void}{OnDrawControlPoints}{\param{wxDC\&}{ dc}}

Called when the shape's control points (handles) should
be drawn.

\membersection{wxShapeEvtHandler::OnDrawOutline}

\func{void}{OnDrawOutline}{\param{wxDC\&}{ dc}}

Called when the outline of the shape should be drawn.

\membersection{wxShapeEvtHandler::OnEndDragLeft}

\func{void}{OnEndDragLeft}{\param{double}{ x}, \param{double}{ y}, \param{int}{ keys=0}, \param{int}{ attachment = 0}}

Called when the user is stopping dragging using the left mouse button.

\membersection{wxShapeEvtHandler::OnEndDragRight}

\func{void}{OnEndDragRight}{\param{double}{ x}, \param{double}{ y}, \param{int}{ keys=0}, \param{int}{ attachment = 0}}

Called when the user is stopping dragging using the right mouse button.

\membersection{wxShapeEvtHandler::OnEndSize}

\func{void}{OnEndSize}{\param{double}{ width}, \param{double}{ height}}

Called after a shape is resized.

\membersection{wxShapeEvtHandler::OnErase}

\func{void}{OnErase}{\param{wxDC\&}{ dc}}

Called when the whole shape should be erased.

\membersection{wxShapeEvtHandler::OnEraseContents}

\func{void}{OnEraseContents}{\param{wxDC\&}{ dc}}

Called when the contents should be erased.

\membersection{wxShapeEvtHandler::OnEraseControlPoints}

\func{void}{OnEraseControlPoints}{\param{wxDC\&}{ dc}}

Called when the shape's control points (handles) should
be erased.

\membersection{wxShapeEvtHandler::OnHighlight}

\func{void}{OnHighlight}{\param{wxDC\&}{ dc}}

Called when the shape should be highlighted.

\membersection{wxShapeEvtHandler::OnLeftClick}

\func{void}{OnLeftClick}{\param{double}{ x}, \param{double}{ y}, \param{int}{ keys =0}, \param{int}{ attachment = 0}}

Called when the shape receives a left mouse click event.

\membersection{wxShapeEvtHandler::OnMoveLink}

\func{void}{OnMoveLink}{\param{wxDC\&}{ dc}, \param{bool}{ moveControlPoints=TRUE}}

Called when the line attached to an shape need to be repositioned,
because the shape has moved.

\membersection{wxShapeEvtHandler::OnMoveLinks}

\func{void}{OnMoveLinks}{\param{wxDC\&}{ dc}}

Called when the lines attached to an shape need to be repositioned,
because the shape has moved.

\membersection{wxShapeEvtHandler::OnMovePost}

\func{bool}{OnMovePost}{\param{wxDC\&}{ dc}, \param{double}{ x}, \param{double}{ y}, \param{double}{ oldX}, \param{double}{ oldY}, \param{bool}{ display = TRUE}}

Called just after the shape receives a move request.

\membersection{wxShapeEvtHandler::OnMovePre}

\func{bool}{OnMovePre}{\param{wxDC\&}{ dc}, \param{double}{ x}, \param{double}{ y}, \param{double}{ oldX}, \param{double}{ oldY}, \param{bool}{ display = TRUE}}

Called just before the shape receives a move request. Returning TRUE
allows the move to be processed; returning FALSE vetoes the move.

\membersection{wxShapeEvtHandler::OnRightClick}

\func{void}{OnRightClick}{\param{double}{ x}, \param{double}{ y}, \param{int}{ keys = 0}, \param{int}{ attachment = 0}}

Called when the shape receives a mouse mouse click event.

\membersection{wxShapeEvtHandler::OnSize}

\func{void}{OnSize}{\param{double}{ x}, \param{double}{ y}}

Called when the shape receives a resize request.

\membersection{wxShapeEvtHandler::OnSizingBeginDragLeft}

\func{void}{OnSizingBeginDragLeft}{\param{wxControlPoint*}{ pt}, \param{double}{ x}, \param{double}{ y}, \param{int}{ keys=0}, \param{int}{ attachment = 0}}

Called when a sizing drag is beginning.

\membersection{wxShapeEvtHandler::OnSizingDragLeft}

\func{void}{OnSizingDragLeft}{\param{wxControlPoint*}{ pt}, \param{bool}{ draw}, \param{double}{ x}, \param{double}{ y}, \param{int}{ keys=0}, \param{int}{ attachment = 0}}

Called when a sizing drag is occurring.

\membersection{wxShapeEvtHandler::OnSizingEndDragLeft}

\func{void}{OnSizingEndDragLeft}{\param{wxControlPoint*}{ pt}, \param{double}{ x}, \param{double}{ y}, \param{int}{ keys=0}, \param{int}{ attachment = 0}}

Called when a sizing drag is ending.

\membersection{wxShapeEvtHandler::SetPreviousHandler}\label{wxshapeevthandlersetprevioushandler}

\func{void}{SetPreviousHandler}{\param{wxShapeEvtHandler*}{ handler}}

Sets the previous handler.

\membersection{wxShapeEvtHandler::SetShape}\label{wxshapeevthandlersetshape}

\func{void}{SetShape}{\param{wxShape*}{ shape}}

Sets the shape for this handler.

\section{\class{wxTextShape}}\label{wxtextshape}

As wxRectangleShape, but only the text is displayed.

\wxheading{Derived from}

\helpref{wxRectangleShape}{wxrectangleshape}

\latexignore{\rtfignore{\wxheading{Members}}}

\membersection{wxTextShape::wxTextShape}

\func{void}{wxTextShape}{\param{double}{ width = 0.0}, \param{double}{ height = 0.0}}

Constructor.

\membersection{wxTextShape::\destruct{wxTextShape}}

\func{void}{\destruct{wxTextShape}}{\void}

Destructor.

\section{Functions}\label{functions}

These are the OGL functions.

\membersection{::wxOGLInitialize}

\func{void}{wxOGLInitialize}{\void}
 
Initializes OGL.

\membersection{::wxOGLCleanUp}

\func{void}{wxOGLCleanUp}{\void}
 
Cleans up OGL.