--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fontservices/textbase/sgdi/LineBreakImp.h	Mon Jul 12 14:38:26 2010 +0800
@@ -0,0 +1,181 @@
+// Copyright (c) 2002-2010 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#ifndef LINEBREAKIMP_H_
+#define LINEBREAKIMP_H_
+
+#include <e32def.h>
+
+const TText KZeroWidthSpace = 0x200B;
+const TText KWhiteSpace = 0x0020;
+
+// Forward delcarations.
+GLREF_C void Panic(TInt aError);
+class MLineBreaker;
+
+/**
+ Rule for which classes may be broken before.
+@internalComponent
+ */
+struct TLineBreakRule
+	{
+	/** Classes that breaks are illegal before, even after spaces. */
+	TUint iForbid;
+	/** Classes that breaks are legal before, even without spaces. */
+	TUint iAllow;
+	};
+
+/**
+ Range of characters which have a particular line breaking class.
+@internalComponent
+ */
+struct TLineBreakRange
+	{
+	TUint iStart;
+	TUint iEnd;
+	TUint iClass;
+	};
+
+/**
+ Single-entry line break cache. Saves asking the MLineBreaker for the classes
+ of multiple characters in the same run.
+@internalComponent
+ */
+class TLineBreakClassCache
+	{
+public:
+	TLineBreakClassCache(const MLineBreaker& aBreaker): iBreaker(aBreaker), iStart(0), iEnd(0), iClass(0) { }
+	TUint LineBreakClass(TUint aChar);
+	const MLineBreaker& Breaker() const { return iBreaker; }
+
+private:
+	const MLineBreaker& iBreaker;
+	TUint iStart;
+	TUint iEnd;
+	TUint iClass;
+	};
+
+/**
+@internalComponent
+ */
+void TestLineBreakTables(void);
+
+/**
+@internalComponent
+ */
+class TLineBreakClassIterator
+	{
+public:
+	void Set(const TText* aFirst, const TText* aText, TLineBreakClassCache& aBreaker);
+	void SetNull();
+	/** Returns the pointer to the character that has the class returned by
+	Class(). */
+	const TText* Ptr() const { return iCurrent; }
+	/** Returns the class of the current character. */
+	TInt Class() const { return iClass; }
+	// Will not go beyond maximum of aLimit
+	// Should not be called with aLimit == Ptr()
+	// Will return EFalse if the limit has been exceeded
+	// aOffset must be 1 or -1
+	TBool Move(const TText* aLimit, const TText* aLimitAfterSpaces,
+		TInt aOffset, TBool& aHasSpaces, TLineBreakClassCache& aBreaker);
+private:
+    /** Addres of first character in the string to iterator through */
+    const TText* iFirst;
+	/** Current position within the iteration. */
+	const TText* iCurrent;
+	/** Class of the character at the currrent position. */
+	TInt iClass;
+	};
+
+
+/**
+@internalComponent
+ */
+TInt MoveTextPtr(const TText*& aPtr, const TText* aLimit, TInt aOffset);
+
+/**
+ Class for implementing the Unicode line breaking algorithm
+@internalComponent
+ */
+class TLineBreakIterator
+	{
+public:
+	TLineBreakIterator(TLineBreakClassCache& aBreaker,
+		const TText* aText, TInt aLength, TBool aForwards,
+		TInt aMinBreakPos, TInt aMaxBreakPos);
+	TBool IsBreak(TBool aForwards);
+	// Is one side of the potential line break CB class?
+	TBool HasContingentBreak() const;
+	// Get class before the break: useful for CB
+	TInt PreviousClass() const;
+	// Get class after the break: useful for CB
+	TInt NextClass() const;
+	// Are there spaces between the classes: useful for CB
+	TInt HasSpaces() const;
+	// go backwards
+	TBool Decrement();
+	// go forwards
+	TBool Increment();
+	// position of iterator at the break
+	TInt BreakPos() const;
+	// position of iterator after the break
+	TInt AfterBreakPos() const;
+	// position of iterator before the break
+	TInt BeforeBreakPos() const;
+private:
+	TLineBreakClassCache iBreaker;
+	const TText* iText;
+	TInt iTextLength;
+	const TText* iLimit;
+	/** The limit that we are allowed to search beyond space characters. For
+	forwards this will be up to the end of the text, for backwards we may not
+	search beyond the minimum break position because that would mean that the
+	break position returned would be below the minimum. */
+	const TText* iLimitAfterSpaces;
+	TLineBreakClassIterator iBeforeBreak;
+	TLineBreakClassIterator iAfterBreak;
+	TBool iHasSpaces;
+	/** Holds the address of the lowest point allowed to break at */
+	const TText* iMinBreakPos;
+	/** Holds the address of the highest point allowed to break at */
+	const TText* iMaxBreakPos;
+	};
+
+/** 
+@internalComponent 
+*/
+TBool HasContingentBreak(TLineBreakIterator& aIterator, TBool aForwards,
+	MContingentLineBreaker& aCbDelegate);
+
+/** 
+@internalComponent 
+*/
+TBool HasContingentBreakL(TLineBreakIterator& aIterator, TBool aForwards,
+	MContingentLineBreakerL& aCbDelegate);
+
+/** 
+@internalComponent 
+*/
+TBool FindBreak(TLineBreakIterator& aIterator, TBool aForwards,
+	MContingentLineBreaker* aCbDelegate);
+
+/** 
+@internalComponent 
+*/
+TBool FindBreakL(TLineBreakIterator& aIterator, TBool aForwards,
+	MContingentLineBreakerL* aCbDelegate);
+
+#endif