ITableLineType.h

//========================================================================================
// 
// $File$
// 
// Owner: Joe Shankar
// 
// $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: Data interface for table stroke type.
// 
//========================================================================================

#ifndef __ITableLineType__
#define __ITableLineType__

#include "IPMUnknown.h"
#include "TablesID.h"
#include "InstStrokeFillID.h"
#include "ScotchRulesID.h"
#include "IDataBase.h"

 class ITableLineType : public IPMUnknown
{
public:
 enum { kDefaultIID = IID_ITABLELINETYPE };

 struct SType {
 typedef object_type data_type;

 ClassID classID;
 UID uID;

 SType() {
 classID = kSolidPathStrokerBoss;
 uID = kInvalidUID;
 }

 SType(ClassID c, UID u) {
 classID = c;
 uID = u;
 }
/*
 bool16 SType::IsValid() const {
 return (IsMixed() || IsNone() ||
 ((classID != kCustomStripedPathStrokerBoss || uID != kInvalidUID)));
 }
*/
 bool16 IsMixed() const {
 return ((classID == kInvalidClass) && (uID == kInvalidUID));
 }

 bool16 IsNone() const {
 return (classID == kNonePathStrokerBoss);
 }

 bool16 IsSolid() const {
 return (classID == kSolidPathStrokerBoss);
 }

 bool16 IsStriped(IDataBase* db) const {
 return (classID == kThinThinPathStrokerBoss ||
 classID == kThickThickPathStrokerBoss ||
 classID == kThinThickPathStrokerBoss ||
 classID == kThickThinPathStrokerBoss ||
 classID == kThinThickThinPathStrokerBoss ||
 classID == kThickThinThickPathStrokerBoss ||
 classID == kTriplePathStrokerBoss || 
 (classID == kCustomPathStrokerBoss && db->GetClass(uID) == kCustomStripedPathStrokerBoss)
 );
 }

 bool16 IsDashed(IDataBase* db) const {
 return (classID == kDashedPathStrokerBoss || 
 classID == kCannedDash4x4PathStrokerBoss || 
 classID == kCannedDash3x2PathStrokerBoss || 
 (classID == kCustomPathStrokerBoss && db->GetClass(uID) == kCustomDashedPathStrokerBoss)
 );
 }

 bool16 IsDotted(IDataBase* db) const {
 return (classID == kCannedDotPathStrokerBoss ||
 classID == kJapaneseDotsPathStrokerBoss ||
 (classID == kCustomPathStrokerBoss && db->GetClass(uID) == kCustomDottedPathStrokerBoss)
 );
 }

 bool16 IsHash() const {
 return (classID == kLeftSlantHashPathStrokerBoss ||
 classID == kRightSlantHashPathStrokerBoss ||
 classID == kStraightHashPathStrokerBoss
 );
 }

 bool16 IsSpecial(IDataBase* db) const {
 return !(this->IsNone() || this->IsMixed() || 
 this->IsSolid() || this->IsStriped(db) || this->IsDashed(db));
 }

 bool16 operator==(const SType& rhs) const {
 return rhs.classID == classID &&
 rhs.uID == uID;
 }

 bool16 operator!=(const SType& rhs) const {
 return !(this->operator==(rhs));
 }
 };

 virtual SType Get() const = 0;
 virtual void Set(SType type) = 0;

 virtual int32 ConvertSTypeToEType(ITableLineType::SType type) const = 0;
 virtual ITableLineType::SType ConvertETypeToSType(int32 eType) const = 0;
};

#endif // __ITableLineType__