Camelot: ProcessPathToTrapezoids Class Reference

01118 {
01119     // Process any join we've just gone past. We have to delay processing of joins
01120     // until we know which way the curve headed off after the join, which is why
01121     // we are processing it now. If the new point is a MOVETO, then there is no join
01122     if (PointFollowsJoin && Verb == PT_LINETO)
01123     {
01124         // Find the last edge in the current edge list. If we can't find one, there is
01125         // nothing to "join to"
01126         TrapEdgeList *pEdgeList = pTraps->GetLastTrapEdgeList();
01127         TrapEdge *pEdge = NULL;
01128         if (pEdgeList != NULL)
01129             pEdge = pEdgeList->GetLastTrapEdge();
01130 
01131         if (pEdge != NULL)
01132         {
01133             switch(JoinType)
01134             {
01135                 case MitreJoin:
01136                     // A mitred join involves extending the previous and next segments of the outline
01137                     // to their intersection. If there is no intersection, or if the intersection
01138                     // is beyond the "MitreLimit", then we revert to a simple Bevelled join.
01139                     // Otherwise, we need to add 2 line segments (3 trapezoid edges) joining the
01140                     // end of the last segment to the intersection, and then from the intersection
01141                     // to the start of this new segment.
01142                     // These new segments are marked as being part of a join so that they will be
01143                     // stroked as straight line segments rather than interpolating normals to make
01144                     // a smoothed/curved join.
01145 
01146                     {
01147                         ERROR3IF(pEdgeList->GetNumEdges() < 2, "Not enough traps for mitred join");
01148                         TrapEdge *pPrevEdge = pEdgeList->GetTrapEdge(pEdgeList->GetNumEdges() - 2);
01149 
01150                         BOOL Mitred;
01151                         if (pCoord != NULL)
01152                         {
01153                             Mitred = CalculateMitreIntersection(&pPrevEdge->Centre, &pEdge->Centre, pCoord);
01154                         }
01155                         else
01156                         {
01157                             // No pCoord passed in, so this is the join at the end. Use the 1st point
01158                             // in the subpath as the "next point". (Well, the 2nd in the array, because point
01159                             // 1 is coincident! We use point 2 which is the end of the 1st line)
01160                             DocCoord NextCoord = pEdgeList->GetTrapEdge(1)->Centre;
01161                             Mitred = CalculateMitreIntersection(&pPrevEdge->Centre, &pEdge->Centre, &NextCoord);
01162                         }
01163 
01164                         //BLOCK
01165                         {
01166                             // Nasty bodge - Because AddEdge can re-alloc the array, we CANNOT keep pointers
01167                             // to array entries around over calls to AddEdge. We thus copy the edge point
01168                             // into a temporary variable which we can safely use over the 2 calls the AddEdge
01169                             DocCoord Temp = pEdge->Centre;
01170 
01171                             // Add a single point for this join - by default this gives a Bevelled join
01172                             pEdgeList->AddEdge(&Temp, TrapJoin_MitredOrBevelled);
01173 
01174                             // And if it's Mitred, then add another point for this join
01175                             if (Mitred)
01176                                 pEdgeList->AddEdge(&Temp, TrapJoin_MitredOrBevelled);
01177                         }
01178                     }
01179                     break;
01180 
01181                 case RoundJoin:
01182                     // To make a rounded join, you might think we need to output a number of trapezoids,
01183                     // but in fact the recursive flattened-mapping algorithm employed by the path
01184                     // stroker will "smooth" a single trapezoid into a proper round join!
01185                     // Thus, we simply insert another trapezoid on the join point (but do NOT mark
01186                     // it as "part of a join") so that it will be mapped as a round join.
01187                     pEdgeList->AddEdge(&pEdge->Centre, TrapJoin_Round);
01188                     break;
01189 
01190                 case BevelledJoin:
01191                     // To make a bevelled join, we simply add another TrapEdge on the join point for
01192                     // the start of the next segment, which will be joined with a straight line. 
01193                     // However, the stroking mechanism will actually output that "line" as a round
01194                     // join (due to its recursive flattened-mapping algorithm), so we have to
01195                     // mark this point as "part of a join" so that it simply plonks down the
01196                     // straight segment we want! (Hence the TRUE)
01197                     pEdgeList->AddEdge(&pEdge->Centre, TrapJoin_MitredOrBevelled);
01198                     break;
01199 
01200                 default:
01201                     ERROR3("Unsupported join type in ProcessPathToTrapezoids");
01202                     break;
01203             }           
01204         }
01205     }
01206 
01207     // Clear the join flag, as any pending join has been processed
01208     PointFollowsJoin = FALSE;
01209 
01210     // If the provided coordinate was NULL, then they only wanted to add the join
01211     // information, so we exit now
01212     if (pCoord == NULL)
01213         return(TRUE);
01214 
01215     // Add the new point to the current trapezoid list
01216     switch(Verb)
01217     {
01218         case PT_MOVETO:
01219             {
01220                 // A MoveTo signifies the start of a new (sub)path, so we start a new TrapList
01221                 TrapEdgeList *pEdgeList = pTraps->AddEdgeList();
01222                 if (pEdgeList == NULL)
01223                     return(FALSE);
01224 
01225                 pEdgeList->AddEdge(pCoord);
01226                 LastPoint = *pCoord;
01227             }
01228             break;
01229 
01230 
01231         case PT_LINETO:
01232             {
01233                 // Append each new point as a new trapezoid edge in the current TrapList
01234                 // Find the last TrapEdgeList
01235                 TrapEdgeList *pEdgeList = pTraps->GetLastTrapEdgeList();
01236 
01237                 if (pEdgeList == NULL)
01238                 {
01239                     // We have started a path with a LineTo!
01240                     // Create a new Trapezoid List (imply that this point is really a MOVETO)
01241                     ERROR3("LINETO added to traplist with no preceding MOVETO");
01242 
01243                     LastPoint = DocCoord(0,0);
01244                     pEdgeList = pTraps->AddEdgeList();
01245                     if (pEdgeList == NULL)
01246                         return(FALSE);
01247                 }
01248 
01249                 // Append the new point to the current trap list. Check first to eliminate
01250                 // coincident points (places where the source path has coincident points),
01251                 // as we only want coincident points to occur in the special case of joins.
01252                 if (pEdgeList->GetNumEdges() < 1 || LastPoint != *pCoord)
01253                 {
01254                     pEdgeList->AddEdge(pCoord);
01255                     LastPoint = *pCoord;
01256                 }
01257             }
01258             break;
01259 
01260         default:
01261             ERROR3("ProcessPathToTrapezoids only handles MOVETO and LINETO!");
01262             break;
01263     }
01264 
01265     return(TRUE);
01266 }


Public Member Functions
	ProcessPathToTrapezoids (const double flat)
	The One True Constructor. Don't call any other graven constructors.
virtual BOOL	Init (Path pSource, TrapsList pOutputList)
	Initialises the PathProcessor in preparation for processing.
virtual BOOL	Process (const ProcessFlags &PFlags, TrapTravelType TravelType, JointType JoinStyle=RoundJoin)
	Processes the path given in Init() to produce a trapezoid list in the TrapsList given to Init().
virtual BOOL	NewPoint (PathVerb Verb, DocCoord *pCoord)
	Constructor.
virtual BOOL	CloseElement (BOOL done, PathVerb Verb, INT32 Index)
	Processes the close of LINETO and BEZIERTO elements to allow us to correctly handle joins in the path.
virtual void	CloseFigure (void)
	Derived-class interface. Called after closing a LINETO or BEZIERTO element which constitutes the end of this figure (subpath) (as indicated by this element having the PT_CLOSEFIGURE flag set).
Protected Member Functions
BOOL	CalculateMitreIntersection (DocCoord p1, DocCoord p2, DocCoord p3, double pMitreRatio=NULL)
	Mitred joins revert to bevelled joins when are so tight that the mitre exceeds the "mitre limit". This function determines and returns whether a given join should be rendered mitred or bevelled. In the former case, it also provides an output, which is based upon the distance from the center of the join (point 2, below) to the mitre outline intersection ("*" below). The distance is not an absolute length, but rather, the ratio of that length to the line width.
Private Attributes
TrapsList *	pTraps
BOOL	PointFollowsJoin
JointType	JoinType
INT32	RepeatLength
DocCoord	LastPoint
Friends
class	TrapEdgeList

ProcessPathToTrapezoids Class Reference

Public Member Functions

Protected Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation