IHyphenatedWord.h

//========================================================================================
// 
// $File$
// 
// Owner: Bernd Paradies
// 
// $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 __IHyphenatedWord__
#define __IHyphenatedWord__

#include "GRRefCountedObj.h"
#include "InterfacePtr.h"

#include "K2Vector.h"
#include "KeyValuePair.h"


class WideString;


struct HyphenPoint
{
 typedef base_type data_type;

 HyphenPoint(int32 pos, int32 val) : nPosition(pos), nValue(val)
 {}

 int32 nPosition; // the position of the break.
 int32 nValue; // the "quality" of the brea.
};

typedef K2Vector<KeyValuePair<int32, int32> > HyphenPoints;



class IHyphenatedWord : public grRefCountedObj
{
public:
 enum { kNoHyphenPoint = 0,
 kVeryUnpreferredHyphenPoint = 10,
 kUnpreferredHyphenPoint = 25,
 kRegularHyphenPoint = 50,
 kPreferredHyphenPoint = 75,
 kDiscretionaryHyphenPoint = 80,
 kHardHyphenPoint = 90,

 kBestHyphenPoint = 100,
 kWorstHyphenPoint = 0,
 kForcedHyphenPoint = kBestHyphenPoint,
 kRefusedHyphenPoint = kWorstHyphenPoint,

 kInvalidHyphenPoint = -1
 };


 virtual int32 GetPointCount() const = 0;

 virtual int32 GetIndexOfPoint( int32 nNthPoint ) const = 0;

 virtual int32 GetQualityOfPoint( int32 nNthPoint ) const = 0;

 virtual WideString GetWord() const = 0;

 virtual void GetPartsOfPoint( int32 nNthPoint, WideString *pFirstPart, WideString *pLastPart ) const = 0;

 virtual void GetFirstPartOfPoint( int32 nNthPoint, WideString *pPart ) const = 0;

 virtual void GetLastPartOfPoint( int32 nNthPoint, WideString *pPart ) const = 0;

 virtual void Merge( const IHyphenatedWord *pToMergeWith ) = 0;

 virtual void ValidatePointRanges(void) = 0;
};


template <>
class InterfacePtr<IHyphenatedWord>
{
public:
 InterfacePtr(IHyphenatedWord * pFace = nil) : fFace(pFace)
 {}

// template <class OtherType>
// InterfacePtr(const InterfacePtr<OtherType>& p)
// :fFace(AddRef_(p.get()))
// { /* Implementation Note: we use a template member fucntion here to do the right thing
// when an InterfacePtr<const IFoo> is constructed from an InterfacePtr<IFoo> */
// }

 InterfacePtr(const InterfacePtr<IHyphenatedWord>& p)
 :fFace(AddRef_(p.get())) { }

 template <class OtherType>
 InterfacePtr<IHyphenatedWord>& operator=(const InterfacePtr<OtherType>& p)
 {
 // Take ownership of p
 reset(AddRef_(p.get()));
 return *this;
 /* Implementation Note: we use a template member function here to do the right thing
 when an InterfacePtr<const IFoo> is constructed from an InterfacePtr<IFoo> */
 }

 InterfacePtr<IHyphenatedWord>& operator=(const InterfacePtr<IHyphenatedWord>& p)
 {
 // Take ownership of p
 reset(AddRef_(p.get()));
 return *this;
 }

 ~InterfacePtr()
 {
 Release_(fFace);
 }

 operator IHyphenatedWord*() const
 { return fFace; }

 IHyphenatedWord * operator ->() const
 {
 #ifdef DEBUG
 ASSERT_MSG(fFace != nil,"About to use nil interface ptr!");
 #endif
 return fFace;
 }

 // Null test
 bool16 operator!() const
 { return fFace == nil; }

 IHyphenatedWord* forget() // was release
 {
 IHyphenatedWord* result = fFace;
 fFace = 0;
 return result;
 }

 IHyphenatedWord* get() const
 { return fFace; }

 void reset(IHyphenatedWord* p = 0)
 {
 IHyphenatedWord* oldFace = fFace;
 fFace = p;
 Release_(oldFace);
 }

private:
 IHyphenatedWord * fFace;

 static IHyphenatedWord* AddRef_(const IHyphenatedWord* p)
 { if(p) p->AddRef(); return const_cast<IHyphenatedWord*>(p);}

 static void Release_(IHyphenatedWord* p)
 { if(p) p->Release(); }

 template <class OtherType>
 InterfacePtr<IHyphenatedWord>& operator=(OtherType* p); // intentionally unimplemented
};

#endif
 // __IHyphenatedWord__