IParcelContainer.h

//========================================================================================
// 
// $File$
// 
// Owner: dwaterfa
// 
// $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 __IParcelContainer__
#define __IParcelContainer__

#include "IPMUnknown.h"
#include "ICompositionStyle.h"
#include "ITextColumnSizer.h"

#include "ShuksanID.h"
#include "ParcelKey.h"

class IParcelList;


class IParcelContainer : public IPMUnknown
{
 public:
 enum { kDefaultIID = IID_IPARCELCONTAINER };

 virtual IParcelList * QueryParcelList() const = 0;

 virtual PMRect GetBounds() const = 0;

 virtual bool16 GetIsRectangular(bool16 checkCornerRadius = kFalse) const = 0;

 virtual uint32 GetColumnCount() const = 0;

 virtual PMRect GetNthColumnBBox(uint32 n) const = 0;

 virtual uint32 GetParcelCount() const = 0;

 virtual ParcelKey GetNthParcelKey(uint32 containerIndex) const = 0;

 virtual int32 GetParcelIndex(ParcelKey key) const = 0;

 virtual ParcelKey GetFirstParcelKey() const = 0;

 virtual ParcelKey GetLastParcelKey() const = 0;

 class ParcelSpanData
 {
 public:
 ParcelSpanData();

 ParcelSpanData(uint32 columnIndexStart) :
 fSpanType(ICompositionStyle::kSingleColumn),
 fPColIndexStart(columnIndexStart),
 fPColIndexEnd(columnIndexStart + 1),
 fDesiredSpan(1),
 fSplitIndex(0),
 fSplitCount(0),
 fSplitInsideGutter(0.0),
 fSplitOutsideGutter(0.0)
 { }

 ParcelSpanData(uint32 columnIndexStart,
 uint32 columnIndexEnd,
 uint32 desiredSpan) :
 fSpanType(ICompositionStyle::kSpanColumn),
 fPColIndexStart(columnIndexStart),
 fPColIndexEnd(columnIndexEnd),
 fDesiredSpan(desiredSpan),
 fSplitIndex(0),
 fSplitCount(0),
 fSplitInsideGutter(0.0),
 fSplitOutsideGutter(0.0)
 { }

 ParcelSpanData(uint32 columnIndexStart,
 uint32 splitIndex,
 uint32 splitCount,
 PMReal splitInsideGutter,
 PMReal splitOutsideGutter) :
 fSpanType(ICompositionStyle::kSplitColumn),
 fPColIndexStart(columnIndexStart),
 fPColIndexEnd(columnIndexStart + 1),
 fDesiredSpan(1),
 fSplitIndex(splitIndex),
 fSplitCount(splitCount),
 fSplitInsideGutter(splitInsideGutter),
 fSplitOutsideGutter(splitOutsideGutter)
 { }

 ParcelSpanData(const ParcelSpanData& other) :
 fSpanType(other.fSpanType),
 fPColIndexStart(other.fPColIndexStart),
 fPColIndexEnd(other.fPColIndexEnd),
 fDesiredSpan(other.fDesiredSpan),
 fSplitIndex(other.fSplitIndex),
 fSplitCount(other.fSplitCount),
 fSplitInsideGutter(other.fSplitInsideGutter),
 fSplitOutsideGutter(other.fSplitOutsideGutter)
 { }

 bool operator==(const ParcelSpanData& other) const
 {
 //
 // Non conforming bit is NOT part of the comparison.
 //
 if (fSpanType == ICompositionStyle::kSingleColumn)
 {
 return (other.fSpanType == fSpanType);
 }
 else if (fSpanType == ICompositionStyle::kSpanColumn)
 {
 return ((other.fSpanType == fSpanType) &&
 (other.GetDesiredColumnSpan() == GetDesiredColumnSpan()));
 }
 else // kSplitColumn
 {
 return ((other.fSpanType == fSpanType) &&
 (other.fSplitCount == fSplitCount) &&
 (other.fSplitInsideGutter == fSplitInsideGutter) &&
 (other.fSplitOutsideGutter == fSplitOutsideGutter));
 }
 }

 bool operator!=(const ParcelSpanData& other) const
 { return !(*this == other); }
 
 ICompositionStyle::SpanColumnsTypeOptions GetColumnType() const
 { return fSpanType; }

 bool16 GetIsSingleColumn() const
 { return (fSpanType == ICompositionStyle::kSingleColumn); }

 bool16 GetSpansColumns() const
 { return (fSpanType == ICompositionStyle::kSpanColumn); }

 bool16 GetSplitsColumn() const
 { return (fSpanType == ICompositionStyle::kSplitColumn); }

 uint32 GetColumnIndexStart() const
 { return fPColIndexStart; }

 uint32 GetColumnIndexEnd() const
 { return fPColIndexEnd; }

 uint32 GetPhysicalColumnSpan() const
 { return (fPColIndexEnd - fPColIndexStart); }

 uint32 GetDesiredColumnSpan() const
 { return fDesiredSpan; }

 uint32 GetSplitIndex() const
 {
 if (fSpanType == ICompositionStyle::kSplitColumn)
 return fSplitIndex;

 ASSERT_FAIL("Not a split");
 return 0;
 }

 uint32 GetSplitCount() const
 {
 if (fSpanType == ICompositionStyle::kSplitColumn)
 return fSplitCount;

 ASSERT_FAIL("Not a split");
 return 0;
 }

 PMReal GetSplitInsideGutter() const
 {
 if (fSpanType == ICompositionStyle::kSplitColumn)
 return fSplitInsideGutter;

 ASSERT_FAIL("Not a split");
 return 0.0;
 }

 PMReal GetSplitOutsideGutter() const
 {
 if (fSpanType == ICompositionStyle::kSplitColumn)
 return fSplitOutsideGutter;

 ASSERT_FAIL("Not a split");
 return 0.0;
 }

 ICompositionStyle::SpanColumnsTypeOptions fSpanType;
 uint32 fPColIndexStart;
 uint32 fPColIndexEnd;
 uint32 fDesiredSpan;
 uint32 fSplitIndex;
 uint32 fSplitCount;
 PMReal fSplitInsideGutter;
 PMReal fSplitOutsideGutter;

 };

 virtual ParcelSpanData GetNthParcelSpanData(uint32 n) const = 0;

 virtual PMReal GetNthParcelEffectiveTopAdj(uint32 containerParcelIndex) const = 0;

 virtual void SetNthParcelEffectiveTopAdj(uint32 containerParcelIndex,
 PMReal effectiveTopAdj) = 0;

 virtual PMReal GetNthParcelEffectiveBottomAdj(uint32 containerParcelIndex,
 PMReal* pBalanceOffset) const = 0;

 virtual void SetNthParcelEffectiveBottomAdj(uint32 containerParcelIndex,
 PMReal effectiveBottomAdj,
 PMReal balanceOffset) = 0;

 virtual bool16 GetNthParcelIsNonConforming(int32 n) const = 0;

 struct ParcelAllData
 {
 typedef base_type data_type;

 ParcelAllData(); // does nothing

 ParcelAllData(ParcelKey key,
 const ParcelSpanData& spanData,
 PMReal effectiveTopAdj,
 PMReal effectiveBottomAdj,
 PMReal effectiveBottomAdjBalanceOffset) :
 fKey(key), fSpanData(spanData),
 fEffectiveTopAdj(effectiveTopAdj),
 fEffectiveBottomAdj(effectiveBottomAdj),
 fEffectiveBottomAdjBalanceOffset(effectiveBottomAdjBalanceOffset)
 { }

 ParcelKey fKey;
 ParcelSpanData fSpanData;
 PMReal fEffectiveTopAdj;
 PMReal fEffectiveBottomAdj;
 PMReal fEffectiveBottomAdjBalanceOffset;
 
 };

 virtual void GetAllParcelData(std::vector<ParcelAllData>& list) const = 0;

 virtual ParcelKey AppendParcel(const ParcelSpanData& spanData) = 0;

 virtual bool16 ChangeNthParcelTo(uint32 containerParcelIndex,
 const ParcelSpanData& spanData) = 0;

 virtual void RemoveLastParcel() = 0;

};

#endif // __IParcelContainer__