TransformUtils.h

//========================================================================================
// 
// $File$
// 
// Owner: ?
// 
// $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.
// 
// 
// Purpose:
// Some often used tranformation calculations shelled with easy to use functions
// 
//========================================================================================

#ifndef __TransformUtils__
#define __TransformUtils__

#include "PMMatrix.h"
#include "PMPoint.h"
#include "ITransform.h"

class IPMUnknown;
class PMRect;
class PMPolygon4;
class IHierarchy;
class PMPathPoint;
class IGraphicsPort;


//
// Inner <--> Pasteboard
//


 void TransformPasteboardPointToInner(const IPMUnknown * pUnknown, PMPoint * pt);

 void TransformInnerPointToPasteboard(const IPMUnknown * pUnknown, PMPoint * pt);


 void InnerToPasteboardDelta(const IPMUnknown * pUnknown, PMPoint * delta);


 void TransformPasteboardPathToInner(const IPMUnknown * pUnknown, PMPathPoint * pt);

 void TransformInnerPathToPasteboard(const IPMUnknown * pUnknown, PMPathPoint * pt);


 void TransformPasteboardRectToInner(const IPMUnknown * pUnknown, PMRect * r);

 void TransformInnerRectToPasteboard(const IPMUnknown * pUnknown, PMRect * r);

// These are useful for rotating a rectangle and then rebounding the points to find
// the bounding box of the transformed object

 void TransformPasteboardPolyToInner(const IPMUnknown * pUnknown, PMPolygon4 * poly);

 void TransformInnerPolyToPasteboard(const IPMUnknown * pUnknown, PMPolygon4 * poly);


//
// Parent <--> Pasteboard
//


 void TransformPasteboardPointToParent(const IPMUnknown * pUnknown, PMPoint * pt);

 void TransformParentPointToPasteboard(const IPMUnknown * pUnknown, PMPoint * pt);


 void PasteboardToParentDelta(const IPMUnknown * pUnknown, PMPoint * delta);


 void TransformPasteboardPathToParent(const IPMUnknown * pUnknown, PMPathPoint * pt);

 void TransformParentPathToPasteboard(const IPMUnknown * pUnknown, PMPathPoint * pt);


 void TransformPasteboardRectToParent(const IPMUnknown * pUnknown, PMRect * r);

 void TransformParentRectToPasteboard(const IPMUnknown * pUnknown, PMRect * r);

// These are useful for rotating a rectangle and then rebounding the points to find
// the bounding box of the transformed object

 void TransformPasteboardPolyToParent(const IPMUnknown * pUnknown, PMPolygon4 * poly);

 void TransformParentPolyToPasteboard(const IPMUnknown * pUnknown, PMPolygon4 * poly);

//
// Inner <--> Spread
//


 void TransformSpreadPointToInner(const IPMUnknown * pUnknown, PMPoint * pt);

 void TransformInnerPointToSpread(const IPMUnknown * pUnknown, PMPoint * pt);


 void TransformSpreadPathToInner(const IPMUnknown * pUnknown, PMPathPoint * pt);

 void TransformInnerPathToSpread(const IPMUnknown * pUnknown, PMPathPoint * pt);


 void TransformSpreadRectToInner(const IPMUnknown * pUnknown, PMRect * r);

 void TransformInnerRectToSpread(const IPMUnknown * pUnknown, PMRect * r);

// These are useful for rotating a rectangle and then rebounding the points to find
// the bounding box of the transformed object

 void TransformSpreadPolyToInner(const IPMUnknown * pUnknown, PMPolygon4 * poly);

 void TransformInnerPolyToSpread(const IPMUnknown * pUnknown, PMPolygon4 * poly);


//
// Parent <--> Spread
//


 void TransformSpreadPointToParent(const IPMUnknown * pUnknown, PMPoint * pt);

 void TransformParentPointToSpread(const IPMUnknown * pUnknown, PMPoint * pt);



 void TransformSpreadPathToParent(const IPMUnknown * pUnknown, PMPathPoint * pt);

 void TransformParentPathToSpread(const IPMUnknown * pUnknown, PMPathPoint * pt);


 void TransformSpreadRectToParent(const IPMUnknown * pUnknown, PMRect * r);

 void TransformParentRectToSpread(const IPMUnknown * pUnknown, PMRect * r);

// These are useful for rotating a rectangle and then rebounding the points to find
// the bounding box of the transformed object

 void TransformSpreadPolyToParent(const IPMUnknown * pUnknown, PMPolygon4 * poly);

 void TransformParentPolyToSpread(const IPMUnknown * pUnknown, PMPolygon4 * poly);


//
// Inner <--> Parent
//




 void TransformInnerPointToParent( const IPMUnknown* pUnknown, PMPoint * pt); //t_TransformPoint
 void TransformParentPointToInner( const IPMUnknown* pUnknown, PMPoint * pt); //t_InverseTransformPoint
 void TransformInnerRectToParent( const IPMUnknown* pUnknown, PMRect * r); //t_TransformRect
 void TransformParentRectToInner( const IPMUnknown* pUnknown, PMRect * r); //t_InverseTransformRect
 void TransformInnerPolyToParent( const IPMUnknown* pUnknown, PMPolygon4 * poly); //t_TransformPolygon4
 void TransformParentPolyToInner( const IPMUnknown* pUnknown, PMPolygon4 * poly); //t_InverseTransformPolygon4

//
// Query matrix functions
//

 PMMatrix InnerToOuterMatrix( const Transform::CoordinateSpace& coordinateSpace, const IPMUnknown * pUnknown );


 PMMatrix InnerToPasteboardMatrix(const IPMUnknown * pUnknown);
 

 PMMatrix ParentToPasteboardMatrix( const IPMUnknown* pUnknown);


 PMMatrix InnerToSpreadMatrix(const IPMUnknown * pUnknown);

 PMMatrix ParentToSpreadMatrix( const IPMUnknown* pUnknown);




 PMMatrix InnerToParentMatrix(const IPMUnknown * pUnknown);


 void InnerToArbitraryParentMatrix( PMMatrix* resultMat, const IPMUnknown* pUnknown, const IHierarchy* pParent);
 


 void ResolveLocation( const UIDList* pageItems, const Transform::CoordinateSpace& coordinateSpace,
 const Transform::TransformOrigin& location, K2Vector<PMPoint>* resolvedLocation);




#endif