f93ce4dadc
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@739 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
2862 lines
85 KiB
TeX
2862 lines
85 KiB
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.
|
|
|