MouldPerspective Class Reference

The perspective mould class. This mould implements a rectangular transform with true perspective. More...

#include <moldpers.h>

Inheritance diagram for MouldPerspective:

List of all members.

Public Member Functions
	MouldPerspective ()
	Perspective mould constructor.
	~MouldPerspective ()
	Perspective mould destructor.
virtual BOOL	Validate (Path *const pPath, UINT32 &errorID)
	This function checks whether the path given is suitabile for use as an perspective manifold. Valid paths at present are any set of 5 path elements starting with a moveto followed by 4 lineto elements which form a closed loop without crossings.
virtual BOOL	Define (Path *const pPath, DocRect *const pRect)
	This function sets the low level perspective state ready for calls to various perspective path generation functions. It serves simply as a way of informing the low level perspectiviser of the shape of the current manifold.
virtual MouldSpace	Describe ()
virtual BOOL	MouldPathToPath (Path *pSourcePath, Path *PDestinPath)
	Using the defined Perspective, mould one path into another.
virtual BOOL	MouldBitmapToTile (KernelBitmap *pSourceBlit, KernelBitmap *pDestinBlit)
	Create an Perspectived version of a bitmap, ready to be rendered to a device.
virtual BOOL	MouldPoint (DocCoord p, DocCoord &q)
	Using the defined perspective, this function takes the input coordinate and calculates its transformed version.
virtual void	MouldPathRender (Path *pPath, RenderRegion *pRegion)
	Render a given path using the current perspective settings, to the output region.
virtual void	MouldBitmapRender (KernelBitmap *pBlit, DocCoord *pParallel, RenderRegion *pRegion)
virtual void	RenderControlBlobs (RenderRegion *pRegion)
	Draw on the perspective grid points on if they are supposed to be shown.
virtual void	RenderDragBlobs (Spread *pSpread)
	Draw on the perspective grid points on if they are supposed to be shown.
virtual void	DisableControlBlobs ()
virtual void	EnableControlBlobs ()
	Used when an perspective is undergoing a drag, we disable normal blob rendering.
virtual void	ToggleControlBlobs (Spread *pSpread)
virtual DocRect	GetBlobBoundingRect ()
	This calculates the bounding box of the mould and adds in the influence of the selection blobs. It does not consider if the blobs are visible or not, it just gives the bounding box that they would occupy if they were visible.
virtual DocRect	GetSourceRect ()
	Return the current definition of the mould perspective source rectangle.
virtual UINT32	GetByteSize () const
virtual BOOL	OnClick (DocCoord, ClickType, ClickModifiers, Spread *, NodeMould *)
	Checks to see if any of the perspective vanishing points have been clicked on. If not return FALSE.
virtual BOOL	OnMouseMove (DocCoord Coord, Spread *pSpread, ClickModifiers Mods, INT32 *ctype, INT32 *msgres)
virtual void	Transform (Path *const pPath, DocRect *const pRect, TransformBase &Trans)
	As the actual perspective mould shape is a nodepath inside the mould parent which this mouldperspecitive object is associated with, the path is passed into this function whenever the mould parent receives a transform call. The path has already been transformed so all we need to do here is update the low level perspective bits.
virtual MouldGeometry *	MakeCopy ()
	Make a copy of this mould perspective object and return it.
virtual ChangeCode	RecordContext (UndoableOperation *)
	Record our context on the undo. In this overridden function we simply create an action to perform the undo/redo of our perspective shape.
virtual ChangeCode	RecordBlobs (UndoableOperation *pOp, Spread *pSpread)
	Record our blobs on the undo. In this overridden function we simply store our blob rectangles so that they will redraw correctly during undo and redo.
void	GetVanishingPoints (DocCoord &p0, DocCoord &p1)
	Reads the values of this defined perspectives vanishing points.
void	MoveVanishingPoints (DocCoord p0, DocCoord p1)
void	CopyShape (DocCoord *pCoords)
	Make a copy of the current perspective shape, placing the output coords in pCoords, most likely a path coordinate array. Note, the routine expects pCoords to point to an array of at least five coordinates.
BOOL	MoveVanishingPoint (DocCoord OldPoint, DocCoord &NewPoint)
	Moves a vanishing point from OldPoint to NewPoint and redefines the perspective shape to suit. If the perspective moves into an invalid position the routine will return FALSE and leave the stored perspective as was.
DocRect	CalcBlobClipRect (const DocCoord &p0)
	Constructs a rectangle that surrounds the given point.
Static Public Member Functions
static BOOL	WillBeValid (POINT *P)
	Check whether the point array has any crossing and is thus unsuited for use as a manifold.
Protected Member Functions
BOOL	CopyContents (MouldPerspective *)
	Make a copy of this mould perspective class private data.
RECT	BuildRectangle (DocRect *const pOrigBBox)
	Build a RECT structure to pass to the low level perspective code.
Private Member Functions
	CC_DECLARE_DYNAMIC (MouldPerspective)
void	RenderGrid (Spread *pSpread)
	Draw on the perspective grid points on if they are supposed to be shown.
void	RenderGrid (RenderRegion *pRegion)
	Draw on the perspective vanishing points if they intersect the current region.
void	RenderGridPoints (RenderRegion *pRegion)
	Draw all the prespective grid points on if they are supposed to be shown.
void	RenderVanishingPoints (Spread *pSpread)
	Draw on the perspective vanishing points on.
void	RenderVanishingPoints (RenderRegion *pRegion)
	Draws the prespective vanishing points on.
void	RenderVanishingPoint (Spread *pSpread, const DocCoord &dcPos)
	Draws a particular prespective vanishing point on.
BOOL	BuildShape (POINT *pPoints, DocRect *const pOrigBBox)
void	ShowVPoints ()
PerspectiveClick	DetermineClickEffect (DocCoord PointerPos, Spread *pSpread)
	Used when single clicking. This routine determines what effect a click will have. The perspective mould provides draggable vanishing point blobs so we need to check whether someones trying to click and drag one of these.
Private Attributes
INT32	GridState
GPerspective	Perspective
Friends
class	RecordPerspectiveAction

---

Detailed Description

The perspective mould class. This mould implements a rectangular transform with true perspective.

Author:

Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>

Date:

3/12/94

Definition at line 182 of file moldpers.h.

---

Constructor & Destructor Documentation

MouldPerspective::MouldPerspective (   )

Perspective mould constructor. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/12/94 Parameters: [INPUTS]  Definition at line 144 of file moldpers.cpp. { GridState = 0; // 0 = Grid off // 1 = Grid on // 2 = Grid on but temporarily disabled }

MouldPerspective::~MouldPerspective (   )

Perspective mould destructor. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/12/94 Parameters: [INPUTS]  Definition at line 164 of file moldpers.cpp. { }

---

Member Function Documentation

RECT MouldPerspective::BuildRectangle (  DocRect *const   pOrigBBox  )  [protected]

Build a RECT structure to pass to the low level perspective code. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 11/01/95 Parameters: pOrigBBox  = a pointer to the bounding box of the objects to be perspectivised [INPUTS] = NULL then the old bounding box will be assumed. Returns: a RECT structure. Definition at line 391 of file moldpers.cpp. { RECT ObjRect; if (pOrigBBox!=NULL) { ObjRect.left = pOrigBBox->lo.x; ObjRect.bottom = pOrigBBox->lo.y; ObjRect.right = pOrigBBox->hi.x; ObjRect.top = pOrigBBox->hi.y; } else ObjRect = Perspective.GetSourceBBox(); return ObjRect; }

BOOL MouldPerspective::BuildShape (  POINT *  pPoints, DocRect *const   pOrigBBox )  [private]

RECT MouldPerspective::BuildShape(POINT* pPoints, DocRect* const pOrigBBox) Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 11/01/95 Parameters: pPoints  = a pointer to a array of INT32 coordinates [INPUTS] pOrigBBox = a pointer to the bounding box of the objects to be moulded = NULL then the old bounding box will be assumed. Returns: TRUE - then BuildShape has succeded FALSE - then BuildShape has failed to create the mould shape Definition at line 365 of file moldpers.cpp. { ERROR2IF(pPoints==NULL,FALSE,"MouldPerspective::BuildShape() called with NULL point list"); RECT ObjRect = BuildRectangle(pOrigBBox); Perspective.Define(pPoints,&ObjRect,MouldThreshold); return TRUE; }

DocRect MouldPerspective::CalcBlobClipRect (  const DocCoord &  dcPos  )

Constructs a rectangle that surrounds the given point. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 25/01/95 Parameters: dcPos  the centre of the blob that the clipping rectangle will surround [INPUTS] -  [OUTPUTS] Returns: A clipping rectangle for use by RenderDragBlobs. Errors: - Definition at line 962 of file moldpers.cpp. { #if !defined(EXCLUDE_FROM_RALPH) BlobManager* pBlobManager = GetApplication()->GetBlobManager(); INT32 nSize = pBlobManager->GetBlobSize() + 2; return DocRect(DocCoord(dcPos.x - nSize, dcPos.y - nSize), DocCoord(dcPos.x + nSize, dcPos.y + nSize)); #else return DocRect(0,0,0,0); #endif }

MouldPerspective::CC_DECLARE_DYNAMIC (  MouldPerspective   )  [private]

BOOL MouldPerspective::CopyContents (  MouldPerspective *  pPerspective  )  [protected]

Make a copy of this mould perspective class private data. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 17/01/95 Parameters: pPerspective  = a pointer to a copy of a perspective object. [INPUTS] [OUTPUTS]  Returns: TRUE if the data has been copied correctly FALSE if failed Definition at line 1177 of file moldpers.cpp. { ERROR3IF(pPerspective==NULL, "MouldPerspective::CopyContents() passed a null pointer"); // ask the base class to copy its bits first if (!MouldGeometry::CopyContents(pPerspective)) return FALSE; // now lets copy data about ourselves POINT TempArray[PER_NUMCOORDS]; RECT TempRect = Perspective.GetSourceBBox(); DocRect Rect = ConvRectToDocRect(TempRect); Perspective.CopyShape(TempArray); // define this shape with the details return (pPerspective->BuildShape(TempArray, &Rect)); }

void MouldPerspective::CopyShape (  DocCoord *  pCoords  )

Make a copy of the current perspective shape, placing the output coords in pCoords, most likely a path coordinate array. Note, the routine expects pCoords to point to an array of at least five coordinates. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 30/01/95 Parameters: pCoords  = A pointer to an array of doc coords [INPUTS] pCoords  contains the five coordinates of the perspective shape [OUTPUTS] Definition at line 1114 of file moldpers.cpp. { POINT TempArray[PER_NUMCOORDS]; Perspective.CopyShape(TempArray); INT32 i; for( i = 0; i < PER_NUMCOORDS; i++ ) { pCoords[i].x = TempArray[i].x; pCoords[i].y = TempArray[i].y; } // copy the last coordinate in to. pCoords[i].x=TempArray[0].x; pCoords[i].y=TempArray[0].y; }

BOOL MouldPerspective::Define (  Path *const   pPath, DocRect *const   pOrigBBox )  [virtual]

This function sets the low level perspective state ready for calls to various perspective path generation functions. It serves simply as a way of informing the low level perspectiviser of the shape of the current manifold. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 2/12/94 Parameters: pPath  = the path to use for moulding [INPUTS] pOrigBBox = a pointer to the bounding box of the objects to be moulded = NULL then the old bounding box will be assumed. returns: TRUE - then Define has succeded FALSE - then Define has failed to initialise the perspective mould Reimplemented from MouldGeometry. Definition at line 318 of file moldpers.cpp. { ERROR2IF(pPath==NULL && pOrigBBox==NULL, FALSE,"MouldPerspective::Define() called with NULL parameters"); RECT ObjRect = BuildRectangle(pOrigBBox); // Save the current state incase we fail POINT TempArray[PER_NUMCOORDS]; RECT TempRect=Perspective.GetSourceBBox(); Perspective.CopyShape(TempArray); // if we're defining a new path then point at it POINT* pPoints = TempArray; if (pPath!=NULL) pPoints=(POINT*)pPath->GetCoordArray(); // Define the new shape Perspective.Define(pPoints,&ObjRect,MouldThreshold); // now check it for validity if (!Perspective.Valid()) { // if not valid replace the old data Perspective.Define(TempArray,&TempRect,MouldThreshold); return FALSE; } return TRUE; }

virtual MouldSpace MouldPerspective::Describe (   )  [inline, virtual]

Reimplemented from MouldGeometry. Definition at line 195 of file moldpers.h. {return MOULDSPACE_PERSPECTIVE;}

PerspectiveClick MouldPerspective::DetermineClickEffect (  DocCoord  PointerPos, Spread *  pSpread )  [private]

Used when single clicking. This routine determines what effect a click will have. The perspective mould provides draggable vanishing point blobs so we need to check whether someones trying to click and drag one of these. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 30/1/95 Parameters: PointerPos  is the mouse position [INPUTS] pSpread is a pointer to the spread containing the mouse position -  [OUTPUTS] Returns: A click type, which defines what edit action should be taken. Definition at line 1356 of file moldpers.cpp. { #if !defined(EXCLUDE_FROM_RALPH) DocRect Rect; DocCoord v0,v1; GetVanishingPoints(v0,v1); if (v0.x!=PER_UNDEFINED) { Rect=CalcBlobClipRect(v0); if (Rect.ContainsCoord(PointerPos)) return PClick_EditVPoint0; } if (v1.x!=PER_UNDEFINED) { Rect=CalcBlobClipRect(v1); if (Rect.ContainsCoord(PointerPos)) return PClick_EditVPoint1; } #endif return PClick_DoNothing; }

void MouldPerspective::DisableControlBlobs (   )  [virtual]

Reimplemented from MouldGeometry. Definition at line 690 of file moldpers.cpp. { if (GridState>0) GridState++; }

void MouldPerspective::EnableControlBlobs (   )  [virtual]

Used when an perspective is undergoing a drag, we disable normal blob rendering. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 2/12/94 Parameters: -  [INPUTS] Reimplemented from MouldGeometry. Definition at line 685 of file moldpers.cpp. { if (GridState>1) GridState--; }

DocRect MouldPerspective::GetBlobBoundingRect (   )  [virtual]

This calculates the bounding box of the mould and adds in the influence of the selection blobs. It does not consider if the blobs are visible or not, it just gives the bounding box that they would occupy if they were visible. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 20/12/94 Returns: DocRect - Returns the bounding rect of the path and its blobs Reimplemented from MouldGeometry. Definition at line 988 of file moldpers.cpp. { #if !defined(EXCLUDE_FROM_RALPH) DocCoord v0,v1; GetVanishingPoints(v0,v1); DocRect Rect; if (v0.x!=PER_UNDEFINED) Rect=Rect.Union(CalcBlobClipRect(v0)); if (v1.x!=PER_UNDEFINED) Rect=Rect.Union(CalcBlobClipRect(v1)); return Rect; #else return DocRect(0,0,0,0); #endif }

virtual UINT32 MouldPerspective::GetByteSize (   )  const [inline, virtual]

Reimplemented from MouldGeometry. Definition at line 213 of file moldpers.h. { return sizeof(MouldPerspective); };

DocRect MouldPerspective::GetSourceRect (   )  [virtual]

Return the current definition of the mould perspective source rectangle. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 17/01/95 Parameters: [INPUTS]  Returns: a doc rect. Reimplemented from MouldGeometry. Definition at line 1207 of file moldpers.cpp. { RECT Rect = Perspective.GetSourceBBox(); return ConvRectToDocRect(Rect); }

void MouldPerspective::GetVanishingPoints (  DocCoord &  p0, DocCoord &  p1 )

Reads the values of this defined perspectives vanishing points. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 25/01/95 Parameters: [INPUTS]  p0  = the first vanishing point position (0x80000000 if none existant) [OUTPUTS] p1 = the second vanishing point position (0x80000000 if none existant) Returns: Definition at line 1023 of file moldpers.cpp. { POINT v0,v1; Perspective.VanishingPoints(v0,v1); p0.x=v0.x; p0.y=v0.y; p1.x=v1.x; p1.y=v1.y; }

MouldGeometry * MouldPerspective::MakeCopy (   )  [virtual]

Make a copy of this mould perspective object and return it. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 11/12/94 Parameters: [INPUTS]  a  pointer to a new mould perspective object [OUTPUTS] NULL if unable to create the object. Reimplemented from MouldGeometry. Definition at line 1145 of file moldpers.cpp. { // create a new shape MouldPerspective* pShape = new MouldPerspective; if (pShape == NULL) return NULL; BOOL ok = CopyContents(pShape); if (!ok) { delete pShape; return NULL; } return (pShape); }

void MouldPerspective::MouldBitmapRender (  KernelBitmap *  pBlit, DocCoord *  Parallel, RenderRegion *  pRegion )  [virtual]

Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 2/12/94 Parameters: pBlit  = pointer to a kernel bitmap [INPUTS] pParallel = pointer to a four point parallelogram pRegion = pointer to a region to render into Reimplemented from MouldGeometry. Definition at line 641 of file moldpers.cpp. { pRegion->SaveContext(); // No lines on the rectangle pRegion->SetLineColour(COLOUR_TRANS); pRegion->RestoreContext(); }

BOOL MouldPerspective::MouldBitmapToTile (  KernelBitmap *  pSourceBlit, KernelBitmap *  pDestinBlit )  [virtual]

Create an Perspectived version of a bitmap, ready to be rendered to a device. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 2/12/94 Parameters: pSourceBlit  = pointer to a bitmap to Perspective [INPUTS] pDestinBlit = pointer to an output tile to mould into pDestinBlit  = Perspectived version of the bitmap [OUTPUTS] Returns: TRUE - if the mould was successfull FALSE - if no room to create the mould Reimplemented from MouldGeometry. Definition at line 599 of file moldpers.cpp. { // currently not implemented return FALSE; }

void MouldPerspective::MouldPathRender (  Path *  pPath, RenderRegion *  pRegion )  [virtual]

Render a given path using the current perspective settings, to the output region. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 2/12/94 Parameters: pPath  = pointer to a path to perspectivise [INPUTS] pRegion = pointer to a region to render into Reimplemented from MouldGeometry. Definition at line 619 of file moldpers.cpp. { }

BOOL MouldPerspective::MouldPathToPath (  Path *  pSourcePath, Path *  pDestinPath )  [virtual]

Using the defined Perspective, mould one path into another. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 2/12/94 Parameters: pSourcePath  = pointer to a path object to mould [INPUTS] pDestinPath = pointer to a path buffer to put the resulting moulded path in pDestinPath  contains the moulded version of the path [OUTPUTS] Returns: TRUE - if the mould was successfull FALSE - if no room to create the mould Reimplemented from MouldGeometry. Definition at line 427 of file moldpers.cpp. { ERROR2IF(pSourcePath==NULL, FALSE, "MouldPerspective::MouldPathToPath() passed a NULL source pointer"); ERROR2IF(pDestinPath==NULL, FALSE, "MouldPerspective::MouldPathToPath() passed a NULL destin pointer"); // get the source path data length DWORD ilength = (DWORD)pSourcePath->GetNumCoords(); // if there's no input path, then there's no output path, and all is well. if (ilength<1) return TRUE; INT32 freespace = ilength*4; INT32 maxspace = ilength*16; BOOL ok; INT32 added; Path TempPath; if (!TempPath.Initialise(freespace,24)) return FALSE; do { // get the source object and destin object path data POINT* icoords = (POINT*)pSourcePath->GetCoordArray(); BYTE* iverbs = (BYTE*)pSourcePath->GetVerbArray(); POINT* ocoords = (POINT*)TempPath.GetCoordArray(); BYTE* overbs = (BYTE*)TempPath.GetVerbArray(); // try to create an enveloped path added = Perspective.FitPath(icoords,iverbs,ilength,ocoords,overbs,freespace); if (added==-1) { freespace*=2; // create what we think will be enough space for the output path ok = TempPath.EnsureVolume(freespace); if (!ok) return FALSE; } } while ((added==-1) && freespace<=maxspace); // if we've failed to create the perspectivised object then tidy up if (added<=1) return FALSE; // now lets set up the new flags array ok = TempPath.ExternalArraysReplaced(added); if (ok) TempPath.InitialiseFlags(0,added); if (ok) { /* Path trimming, temporarily removed as doesn't fix the showstopper. // Ok check for rampant null elements in this path DocCoord* Coords; PathVerb* Verbs; PathFlags* Flags; PathVerb CurVerb; INT32 i,lmi; DocCoord lm; TempPath.GetPathArrays(&Verbs,&Coords,&Flags); for (i=0; i<added; i++) { CurVerb = Verbs[i] & ~PT_CLOSEFIGURE; if (CurVerb==PT_MOVETO) { lm=Coords[i]; lmi=i; } if (CurVerb==PT_BEZIERTO) { if (Verbs[i+2] & PT_CLOSEFIGURE) { DocCoord p0,p1,p2; p0 = Coords[i]; p1 = Coords[i+1]; p2 = Coords[i+2]; if ((p0.x==p1.x) && (p1.x==p2.x) && (p2.x==lm.x) && (p0.y==p1.y) && (p1.y==p2.y) && (p2.y==lm.y) && (i-lmi)>1) { // We can delete this element! Verbs[i-1] |= PT_CLOSEFIGURE; if (TempPath.DeleteSection(i,3)) { added-=3; i-=3; } else i=added; } } i+=2; } } */ ok = pDestinPath->CloneFrom(TempPath); } return ok; }

BOOL MouldPerspective::MouldPoint (  DocCoord  p, DocCoord &  q )  [virtual]

Using the defined perspective, this function takes the input coordinate and calculates its transformed version. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 2/12/94 Parameters: p  = the coordinate to be transformed [INPUTS] q  = the transformed version of the coordinate [OUTPUTS] Returns: TRUE if the point has been transformed FALSE if q==p Reimplemented from MouldGeometry. Definition at line 553 of file moldpers.cpp. { // I aught to check that the point as contained within the source rectangle // bbox and do something about it if not. But what to do? // It turns out that perspective transforms behave sensibly for points // outside the source bbox so we can remove the following checks. /* RECT rect = Perspective.GetSourceBBox(); if ((p.x<rect.left) || (p.x>rect.right) || (p.y<rect.bottom) || (p.y>rect.top)) { q=p; return; } */ POINT r,s; r.x = p.x; r.y = p.y; Perspective.FitPoint(r,s); q.x = s.x; q.y = s.y; return TRUE; }

BOOL MouldPerspective::MoveVanishingPoint (  DocCoord  OldPoint, DocCoord &  NewPoint )

Moves a vanishing point from OldPoint to NewPoint and redefines the perspective shape to suit. If the perspective moves into an invalid position the routine will return FALSE and leave the stored perspective as was. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 25/01/95 Parameters: OldPoint  = A last known vanishing point position [INPUTS] NewPoint = What should hopefully become a new position NewPoint  = The new point will be updated to hold the actual position of [OUTPUTS] the vanishing point. It may be slightly different from NewPoint due to rounding error. Returns: TRUE if the mould vanishing point has been altered, FALSE if no change has occured, due to either (1) the old vanishing point could not be located (2) the new vanishing point causes the perspective map to become invalid Definition at line 1054 of file moldpers.cpp. { #if !defined(EXCLUDE_FROM_RALPH) BOOL Flag; if (OldPoint.x==PER_UNDEFINED || OldPoint.y==PER_UNDEFINED) return FALSE; POINT p; p.x=OldPoint.x; p.y=OldPoint.y; if (!Perspective.WhichVanishingPoint(p, Flag)) return FALSE; // Save the current state incase we fail POINT TempArray[PER_NUMCOORDS]; Perspective.CopyShape(TempArray); POINT TempArray1[PER_NUMCOORDS]; Perspective.CopyShape(TempArray1); INT32 SCode = Perspective.GetVPointState(); p.x=NewPoint.x; p.y=NewPoint.y; Perspective.DragVanishingPoints(p,Flag,TempArray1); BuildShape(TempArray1,NULL); INT32 ECode = Perspective.GetVPointState(); // now check it for validity if ((!Perspective.Valid()) || (SCode!=ECode)) { // if not valid replace the old data BuildShape(TempArray,NULL); return FALSE; } DocCoord v0,v1; GetVanishingPoints(v0,v1); Flag ? (NewPoint=v1) : (NewPoint=v0); #endif return TRUE; }

void MouldPerspective::MoveVanishingPoints (  DocCoord  p0, DocCoord  p1 )

BOOL MouldPerspective::OnClick (  DocCoord  PointerPos, ClickType  CType, ClickModifiers  Mods, Spread *  pSpread, NodeMould *  pNodeMould )  [virtual]

Checks to see if any of the perspective vanishing points have been clicked on. If not return FALSE. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 2/12/94 Parameters: Coord  = coordinate of mouse [INPUTS] CType = the type of click (single, double, drag) Mods = the click modifiers pSpread = a pointer to the spread the click occured over Returns TRUE if we processed the click FALSE if none of the vanishing points were under the click position Reimplemented from MouldGeometry. Definition at line 1236 of file moldpers.cpp. { BOOL Claimed=FALSE; #ifndef STANDALONE // we only handle the click if we can confirm that object blobs are being displayed. BlobManager* pBlobMgr = GetApplication()->GetBlobManager(); if (pBlobMgr == NULL) return FALSE; if (!pBlobMgr->GetCurrentInterest().Object) return FALSE; PerspectiveClick WhatToDo = DetermineClickEffect(PointerPos,pSpread); switch (CType) { case CLICKTYPE_SINGLE: switch (WhatToDo) { case PClick_EditVPoint0: { Claimed=TRUE; OpDragOrigin* pOpDragOrigin = new OpDragOrigin; if (pOpDragOrigin!=NULL) pOpDragOrigin->DoDragVanishPoint(pSpread,PointerPos,Mods,pNodeMould,FALSE); } break; case PClick_EditVPoint1: { Claimed=TRUE; OpDragOrigin* pOpDragOrigin = new OpDragOrigin; if (pOpDragOrigin!=NULL) pOpDragOrigin->DoDragVanishPoint(pSpread,PointerPos,Mods,pNodeMould,TRUE); } break; default: break; } break; case CLICKTYPE_DOUBLE: break; case CLICKTYPE_DRAG: break; default: break; } #endif return Claimed; }

BOOL MouldPerspective::OnMouseMove (  DocCoord  Coord, Spread *  pSpread, ClickModifiers  Mods, INT32 *  ctype, INT32 *  msgres )  [virtual]

Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 2/12/94 Parameters: Coord  = coordinate of mouse [INPUTS] Mods = the click modifiers pSpread = a pointer to the spread the click occured over Returns: ctype = the tool cursor type to use over this point msgres = the message resource type to use over this point Reimplemented from MouldGeometry. Definition at line 1312 of file moldpers.cpp. { #ifndef STANDALONE ERROR2IF(ctype==NULL,FALSE,"MouldPerspective::OnMouseMove passed a null cursor type ptr"); ERROR2IF(msgres==NULL,FALSE,"MouldPerspective::OnMouseMove passed a null msg res ptr"); PerspectiveClick Click = DetermineClickEffect(Coord, pSpread); switch (Click) { case PClick_EditVPoint0: case PClick_EditVPoint1: *ctype = 2; *msgres = 2; return TRUE; break; default: break; } #endif return FALSE; }

ChangeCode MouldPerspective::RecordBlobs (  UndoableOperation *  pOp, Spread *  pSpread )  [virtual]

Record our blobs on the undo. In this overridden function we simply store our blob rectangles so that they will redraw correctly during undo and redo. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 26/01/95 Parameters: pOp  = pointer to a running undoable operation [INPUTS] -  [OUTPUTS] Reimplemented from MouldGeometry. Definition at line 1459 of file moldpers.cpp. { #ifndef STANDALONE if (pOp!=NULL) { ActionCode Act; DocCoord v0,v1; DocRect Rect; GetVanishingPoints(v0,v1); if (v0.x!=PER_UNDEFINED) { Rect=CalcBlobClipRect(v0); Act=InvalidateRectAction::DoRecord(pOp,Rect,pSpread); if (Act == AC_FAIL) return CC_FAIL; if (Act == AC_NORECORD) return CC_NORECORD; } if (v1.x!=PER_UNDEFINED) { Rect=CalcBlobClipRect(v1); Act=InvalidateRectAction::DoRecord(pOp,Rect,pSpread); if (Act == AC_FAIL) return CC_FAIL; if (Act == AC_NORECORD) return CC_NORECORD; } } #endif return CC_OK; }

ChangeCode MouldPerspective::RecordContext (  UndoableOperation *  pOp  )  [virtual]

Record our context on the undo. In this overridden function we simply create an action to perform the undo/redo of our perspective shape. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 16/01/95 Parameters: pOp  = pointer to a running undoable operation [INPUTS] -  [OUTPUTS] Reimplemented from MouldGeometry. Definition at line 1426 of file moldpers.cpp. { if (pOp!=NULL) { RecordPerspectiveAction* PerAction; ActionCode Act; // call the actions static init function to get the action going. Act = RecordPerspectiveAction::Init(pOp, pOp->GetUndoActionList(), this, (Action**)(&PerAction)); if (Act == AC_FAIL) return CC_FAIL; if (Act == AC_NORECORD) return CC_NORECORD; } return CC_OK; }

void MouldPerspective::RenderControlBlobs (  RenderRegion *  pRegion  )  [virtual]

Draw on the perspective grid points on if they are supposed to be shown. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 2/12/94 Parameters: pRegion  = pointer to a region to render into [INPUTS] Reimplemented from MouldGeometry. Definition at line 707 of file moldpers.cpp. { #if !defined(EXCLUDE_FROM_RALPH) ERROR3IF(pRegion==NULL,"MouldPerspective::RenderControlBlobs passed a NULL region"); if (pRegion==NULL) return; if (GridState==1) RenderGrid(pRegion); RenderVanishingPoints(pRegion); #endif }

void MouldPerspective::RenderDragBlobs (  Spread *  pSpread  )  [virtual]

Draw on the perspective grid points on if they are supposed to be shown. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 2/12/94 Parameters: pRegion  = pointer to a region to render into [INPUTS] Reimplemented from MouldGeometry. Definition at line 732 of file moldpers.cpp. { #if !defined(EXCLUDE_FROM_RALPH) ERROR3IF(pSpread==NULL,"MouldPerspective::RenderControlBlobs passed a NULL spread"); if (pSpread==NULL) return; if (GridState>0) RenderGrid(pSpread); RenderVanishingPoints(pSpread); #endif }

void MouldPerspective::RenderGrid (  RenderRegion *  pRegion  )  [private]

Draw on the perspective vanishing points if they intersect the current region. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 2/12/94 Parameters: pRegion  = pointer to a region to render into [INPUTS] Definition at line 783 of file moldpers.cpp. { #if !defined(EXCLUDE_FROM_RALPH) ERROR3IF(pRegion==NULL,"MouldPerspective::RenderBlobs() passed a NULL region"); if (pRegion==NULL) return; // get the base class to render MouldGeometry::RenderControlBlobs(pRegion); // Now render any vanishing points pRegion->SetLineWidth(0); // Means single-pixel lines pRegion->SetLineColour(GREEN); pRegion->SetFillColour(GREEN); // now render the grid RenderGridPoints(pRegion); #endif }

void MouldPerspective::RenderGrid (  Spread *  pSpread  )  [private]

Draw on the perspective grid points on if they are supposed to be shown. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 2/12/94 Parameters: pSpread  = pointer to a spread to render into [INPUTS] Definition at line 756 of file moldpers.cpp. { #if !defined(EXCLUDE_FROM_RALPH) ERROR3IF(pSpread==NULL,"MouldPerspective::RenderGrid() passed a NULL spread"); DocRect Rect = Perspective.GetBoundingRect(); RenderRegion* pRegion = DocView::RenderOnTop( &Rect, pSpread, ClippedEOR ); while ( pRegion ) { RenderGrid(pRegion); pRegion = DocView::GetNextOnTop(NULL); } #endif }

void MouldPerspective::RenderGridPoints (  RenderRegion *  pRegion  )  [private]

Draw all the prespective grid points on if they are supposed to be shown. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 04/01/95 Parameters: pRegion  = pointer to a region to render into [INPUTS] Definition at line 813 of file moldpers.cpp. { #if !defined(EXCLUDE_FROM_RALPH) // We need to scan through the origin bounding rectangle, calculating // an MxN rectangle of points, transforming them all and rendering them to the region INT32 p0 = 8; INT32 p1 = 4*p0; INT32 a,b,x,y; POINT sU,dU; DocCoord pU; RECT Bounds = Perspective.GetSourceBBox(); INT32 dX = Bounds.right - Bounds.left; INT32 dY = Bounds.top - Bounds.bottom; for (a=1; a<p0; a++) { x = Bounds.left + a*dX/p0; y = Bounds.bottom + a*dY/p0; for (b=1; b<p1; b++) { if (b % (p1/p0)) { sU.x = Bounds.left + b*dX/p1; sU.y = y; Perspective.FitPoint(sU,dU); pU.x = dU.x; pU.y = dU.y; pRegion->DrawPixel(pU); } sU.x = x; sU.y = Bounds.bottom + b*dY/p1; Perspective.FitPoint(sU,dU); pU.x = dU.x; pU.y = dU.y; pRegion->DrawPixel(pU); } } #endif }

void MouldPerspective::RenderVanishingPoint (  Spread *  pSpread, const DocCoord &  dcPos )  [private]

Draws a particular prespective vanishing point on. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 25/01/95 Parameters: dcPos  = a doc coord at which to display the vanish point [INPUTS] Definition at line 891 of file moldpers.cpp. { #if !defined(EXCLUDE_FROM_RALPH) DocRect Rect; if (dcPos.x!=PER_UNDEFINED) { Rect=CalcBlobClipRect(dcPos); RenderRegion* pRegion = DocView::RenderOnTop(&Rect, pSpread, ClippedEOR ); while ( pRegion ) { pRegion->SetLineColour(COLOUR_XORSELECT); PORTNOTE("other", "DrawBitmapBlob removed"); // pRegion->DrawBitmapBlob(dcPos, _R(IDBMP_HANDLE_CENTRE)); pRegion = DocView::GetNextOnTop(NULL); } } #endif }

void MouldPerspective::RenderVanishingPoints (  RenderRegion *  pRegion  )  [private]

Draws the prespective vanishing points on. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 25/01/95 Parameters: pRegion  = pointer to a region to render into [INPUTS] Definition at line 921 of file moldpers.cpp. { #if !defined(EXCLUDE_FROM_RALPH) pRegion->SetLineColour(COLOUR_XORSELECT); // first read the vanishing point positions DocCoord v0,v1; GetVanishingPoints(v0,v1); PORTNOTE("other", "DrawBitmapBlob removed"); // if (v0.x!=PER_UNDEFINED) // pRegion->DrawBitmapBlob(v0, _R(IDBMP_HANDLE_CENTRE)); // if (v1.x!=PER_UNDEFINED) // pRegion->DrawBitmapBlob(v1, _R(IDBMP_HANDLE_CENTRE)); #endif }

void MouldPerspective::RenderVanishingPoints (  Spread *  pSpread  )  [private]

Draw on the perspective vanishing points on. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 25/01/95 Parameters: pSpread  = pointer to a spread to render into [INPUTS] Definition at line 868 of file moldpers.cpp. { #if !defined(EXCLUDE_FROM_RALPH) ERROR3IF(pSpread==NULL,"MouldPerspective::RenderVanishingPoints() passed a NULL spread"); DocCoord v0,v1; GetVanishingPoints(v0,v1); RenderVanishingPoint(pSpread,v0); RenderVanishingPoint(pSpread,v1); #endif }

void MouldPerspective::ShowVPoints (   )  [private]

Definition at line 939 of file moldpers.cpp. { DocCoord v0,v1; GetVanishingPoints(v0,v1); // TRACEUSER( "Mike", _T("V0=(%d,%d)\n"),v0.x,v0.y); // TRACEUSER( "Mike", _T("V1=(%d,%d)\n"),v1.x,v1.y); }

void MouldPerspective::ToggleControlBlobs (  Spread *  pSpread  )  [virtual]

Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 2/12/94 Parameters: pSpread  = pointer to a spread to render into [INPUTS] Reimplemented from MouldGeometry. Definition at line 664 of file moldpers.cpp. { // if we're in a suspended state do nothing! if (GridState>1) return; // toggle the grid state. GridState ^= 1; if (pSpread!=NULL) RenderGrid(pSpread); }

void MouldPerspective::Transform (  Path *const   pNewGeom, DocRect *const   pRect, TransformBase &  Trans )  [virtual]

As the actual perspective mould shape is a nodepath inside the mould parent which this mouldperspecitive object is associated with, the path is passed into this function whenever the mould parent receives a transform call. The path has already been transformed so all we need to do here is update the low level perspective bits. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 2/12/94 Parameters: pNewGeom  = a new mould shape to use. [INPUTS] Trans = The transform to be applied. Reimplemented from MouldGeometry. Definition at line 1403 of file moldpers.cpp. { // transform the blob origins, vanishing points etc Define(pNewGeom,pRect); }

BOOL MouldPerspective::Validate (  Path *const   pPath, UINT32 &  errorID )  [virtual]

This function checks whether the path given is suitabile for use as an perspective manifold. Valid paths at present are any set of 5 path elements starting with a moveto followed by 4 lineto elements which form a closed loop without crossings. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 11/02/95 Parameters: pPath  = the path to use for perspectivising [INPUTS] errorID  = an id of an error string reporting the problem when failed. [OUTPUTS] Returns: TRUE - then the path can be used as an perspective manifold FALSE - then the path is not suitable for use as an perspective manifold Reimplemented from MouldGeometry. Definition at line 185 of file moldpers.cpp. { // check for a reasonable number of coordinates INT32 numc=pPath->GetNumCoords(); if ((numc!=PER_NUMCOORDS+1)) { errorID = _R(IDE_PERS_NUMCOORDERR); return FALSE; } // now we need a more complex check DocCoord* Coords = pPath->GetCoordArray(); PathVerb* Verbs = pPath->GetVerbArray(); // we need the first element to be a move to if (Verbs[0]!=PT_MOVETO) { errorID = _R(IDE_PERS_BADELEMENT); return FALSE; } // And the last coordinate must close the loop if (Coords[0]!=Coords[numc-1]) { errorID = _R(IDE_PERS_NOTCLOSED); return FALSE; } INT32 i,j; // followed by all linetos for (i=1; i<numc; i++) { if ( (Verbs[i] & (~PT_CLOSEFIGURE))!=PT_LINETO ) { errorID = _R(IDE_PERS_NOTALLLINES); return FALSE; } } // check no coordinates are the same for (i=1; i<numc; i++) { for (j=i+1; j<numc; j++) { if (Coords[i] == Coords[j]) { errorID = _R(IDE_PERS_COINCIDENT); return FALSE; } } } // Make sure there's no folds either POINT* p = (POINT*)(Coords); if (!WillBeValid(p)) { errorID = _R(IDE_PERS_CROSSING); return FALSE; } // All is well return TRUE; }

BOOL MouldPerspective::WillBeValid (  POINT *  P  )  [static]

Check whether the point array has any crossing and is thus unsuited for use as a manifold. BOOL MouldPerspective::WillBeValid(POINT* P) Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/12/94 Parameters: P  a pointer to a POINT array of coordinates [INPUTS] Returns: TRUE if the point set is valid Definition at line 263 of file moldpers.cpp. { INT32 MinX, MaxX, MinY, MaxY, Width, Depth ; DPOINT V0,V1,V2,V3; MinX = MaxX = P[0].x ; MinY = MaxY = P[0].y ; MinX = min( MinX, INT32(P[1].x) ) ; MaxX = max( MaxX, INT32(P[1].x) ) ; MinY = min( MinY, INT32(P[1].y) ) ; MaxY = max( MaxY, INT32(P[1].y) ) ; MinX = min( MinX, INT32(P[2].x) ) ; MaxX = max( MaxX, INT32(P[2].x) ) ; MinY = min( MinY, INT32(P[2].y) ) ; MaxY = max( MaxY, INT32(P[2].y) ) ; MinX = min( MinX, INT32(P[3].x) ) ; MaxX = max( MaxX, INT32(P[3].x) ) ; MinY = min( MinY, INT32(P[3].y) ) ; MaxY = max( MaxY, INT32(P[3].y) ) ; Width = MaxX-MinX ; Depth = MaxY-MinY ; if (Width==0 || Depth==0) return FALSE; V0.x = (double)(P[0].x-MinX)/Width ; V0.y = (double)(P[0].y-MinY)/Depth ; V1.x = (double)(P[1].x-MinX)/Width ; V1.y = (double)(P[1].y-MinY)/Depth ; V2.x = (double)(P[2].x-MinX)/Width ; V2.y = (double)(P[2].y-MinY)/Depth ; V3.x = (double)(P[3].x-MinX)/Width ; V3.y = (double)(P[3].y-MinY)/Depth ; BOOL F = (V1.x-V0.x)*(V3.y-V0.y) > (V1.y-V0.y)*(V3.x-V0.x) ; if ( F != ((V2.x-V1.x)*(V0.y-V1.y) > (V2.y-V1.y)*(V0.x-V1.x)) ) return FALSE ; if ( F != ((V3.x-V2.x)*(V1.y-V2.y) > (V3.y-V2.y)*(V1.x-V2.x)) ) return FALSE ; if ( F != ((V0.x-V3.x)*(V2.y-V3.y) > (V0.y-V3.y)*(V2.x-V3.x)) ) return FALSE ; return TRUE; }

---

Friends And Related Function Documentation

friend class RecordPerspectiveAction [friend]

Definition at line 184 of file moldpers.h.

---

Member Data Documentation

INT32 MouldPerspective::GridState [private]

Definition at line 248 of file moldpers.h.

GPerspective MouldPerspective::Perspective [private]

Definition at line 249 of file moldpers.h.

---

The documentation for this class was generated from the following files:

• Kernel/moldpers.h (r1785/r751)
• Kernel/moldpers.cpp (r1785/r1282)

---