StrokeBoundsOutlineInfo.h

//========================================================================================
// 
// $File$
// 
// Owner: jargast
// 
// $Author$
// 
// $DateTime$
// 
// $Revision$
// 
// $Change$
// 
// Copyright 1997-2010 Adobe Systems Incorporated. All rights reserved.
// 
// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance 
// with the terms of the Adobe license agreement accompanying it. If you have received
// this file from a source other than Adobe, then your use, modification, or 
// distribution of it requires the prior written permission of Adobe.
// 
//========================================================================================

#ifndef __StrokeBoundsOutlineInfo__
#define __StrokeBoundsOutlineInfo__

#include "IOutlineInfo.h"
#include "PMPoint.h"
#include "PMRect.h"
#include "PMMatrix.h"
#include "PMBezierCurve.h"

const int32 kSegmentWindow = 3;

class IPathEndStroker;


class StrokeBoundsOutlineInfo : public IOutlineInfo
{
public:
 StrokeBoundsOutlineInfo
 (
 const PMReal& strokeWeight,
 const PMReal& miterLimit,
 int32 joinType,
 int32 lineCap,
 const PMMatrix& xForm,
 IGraphicStyleDescriptor* styleDescriptor
 );

 PMRect GetBoundingBox();

 virtual void BeginPath();

 virtual void EndPath();

 virtual void moveto(const PMReal& x, const PMReal& y);

 virtual void lineto(const PMReal& x, const PMReal& y);

 virtual void curveto(const PMReal& x1, const PMReal& y1, const PMReal& x2, const PMReal& y2, const PMReal& x3, const PMReal& y3);

 virtual void closepath();
 
private:
 StrokeBoundsOutlineInfo(); 

private:
 // Compute the bounds of the one and only segment
 void ComputeSingleSegmentBoundsWithEnds();
 
 // Compute the first segment bounds and include an end calculation
 // at the beginning
 void ComputeFirstSegmentBoundsWithEnd();
 
 // Compute the last segment bounds and include an end calculation
 // at the end. This assumes the segment to miter with is
 // fNumSegments - 1
 void ComputeLastSegmentBoundsWithEnd();
 
 // Compute the given segment bounds. Will use whichsegment - 1 as the segment
 // to miter to
 void ComputeSegmentBounds (int32 whichSegment);
 
 // Compute a single closed segment bounds. There is only one segment in this
 // case and no end calculations
 void ComputeSingleSegmentBounds();
 
 // Compute the first segment bounds assuming the path is closed. Use the last segment
 // to miter with
 void ComputeFirstSegmentBounds();
 
 // Compute the bounds of the Bezier
 void ComputeBezierBounds(PMPoint* ptList);
 
 // Compute the bounds of the line
 void ComputeLineBounds(const PMPoint& P0, const PMPoint& P1);
 
 // Compute the miter point
 void ComputeMiterBounds 
 (
 PMPoint* B,
 int32 segmentType,
 int32 previousSegment
 );
 
 // Compute the miter point
 void ComputeRoundJoinBounds 
 (
 PMPoint* B,
 int32 segmentType,
 int32 previousSegment
 );
 
 // Compute the bbox for the starting path end
 void ComputeStartPathEnd (PMPoint* ptList, int32 segType);
 
 // Compute the bbox for the ending path end
 void ComputeEndPathEnd (PMPoint* ptList, int32 segType);
 
 // Single method that both of the above call. Passes in start pt and end pt 
 void ComputePathEnd (const PMPoint& Pfrom, const PMPoint& Pto);
 
 // Compute bounds at the given param location
 void ComputeCurveBounds (const PMBezierCurve& bezCurve, const PMReal& u);
 
private:
 IGraphicStyleDescriptor* fStyleDescriptor;

 PMPoint fFirstSegmentStorage[4];
 int32 fFirstSegmentType;
 
 PMPoint fSegmentStorage[kSegmentWindow][4]; // Three segments, each having up to 4 points
 int32 fSegmentType[kSegmentWindow];
 
 int32 fNumSegments;
 
 PMReal fLastX, fLastY;
 PMReal fFirstX, fFirstY;
 
 // The following values comprise the bounds
 PMRect fBounds;
 
 bool16 fBoundsSet;

 bool16 fStartedWithMoveTo;
 bool16 fComputeBoundsForFirstSegment;
 bool16 fComputeBoundsForLastSegment;
 
 PMMatrix fXform;
 PMMatrix fStrokeMat;
 bool16 fIsMatrixIdentity;
 
 int32 fJoinType;
 int32 fLineCap;
 PMReal fMiterLimit;
 
 PMReal fStrokeWeight;
 PMReal fHalfStrokeWeight;
 PMReal fXStrokeWeight;
 PMReal fYStrokeWeight;
 
 // temp storage for line methods
 PMPoint fP0, fP1, fP2, fP3;
 
 // temp storage for curve methods
 PMBezierCurve fCurve1, fCurve2;
};


#endif