diff -r 000000000000 -r 2f259fa3e83a uifw/AvKon/inc/AknPhedModel.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/uifw/AvKon/inc/AknPhedModel.h	Tue Feb 02 01:00:49 2010 +0200
@@ -0,0 +1,371 @@
+/*
+* Copyright (c) 2002 - 2008 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 AKNPHEDMODEL_H
+#define AKNPHEDMODEL_H
+
+#include <e32base.h>
+
+#include "AknPhedDataObserver.h"
+#include "NumberGrouping.h"
+
+
+class CAknPhedBuffers;
+class CAknPhedModel;
+class TAknPhedDataMirror;
+
+
+NONSHARABLE_CLASS(CAknPhedScratchBuffer) : public CBase
+    {
+    public:
+        CAknPhedScratchBuffer();
+        ~CAknPhedScratchBuffer();
+        void ConstructL(TInt aMaxLen);
+        
+        // Writable access to the scratch area
+        inline TPtr ScratchBuffer() const;
+    protected:
+        HBufC* iBuf;
+        TPtr iPtr;
+    };
+
+
+
+
+//
+// CAknPhedModel
+//
+// The editor model combines a two way text buffer with cursor and selection logic
+//
+NONSHARABLE_CLASS(CAknPhedModel) : public CBase
+    {
+    public:
+        // construction & destruction
+        static CAknPhedModel* NewL(TInt aMaxLen);
+        ~CAknPhedModel();
+        
+        // Observer interface
+        inline MPhedDataObserver* Observer();
+        inline void SetObserver(MPhedDataObserver* aObserver);
+        
+        // Text access
+        inline TInt Length() const;
+        inline TInt MaxDisplayLength() const;
+        inline TPtrC Text(TInt aFrom=0) const;
+        inline TPtrC Text(TInt aFrom, TInt aTo) const;
+        inline TPtrC ReverseText(TInt aFrom=0) const;
+        inline TPtrC ReverseText(TInt aFrom, TInt aTo) const;
+        
+        inline TPtrC UnFormattedText(TInt aFrom=0) const;
+        inline TPtrC UnFormattedText(TInt aFrom, TInt aTo) const;
+        
+        inline TBool IsSpace(TInt aPos) const;
+        TInt Spaces(TInt aTo, TInt aFrom) const;
+        TInt Spaces( TInt aToPos ) const;
+        inline TPtr TranslationBuffer() const;
+        
+        // Text setting
+        void SetText(const TDesC& aText);
+        
+        enum TDirection{EDown, EUp};
+        
+        // Cursor/selection relative text manipulation
+        void Insert(TText aChar);
+        void DeleteLeft();
+        void DeleteLeft(TInt aIndex, TInt aCount=1);
+        void Cut(TDes& aCutText);
+        void Copy(TDes& aCopiedText) const;
+        void Paste(const TDesC& aText);
+        
+        // Cursor manipulation
+        inline TInt CursorPosition() const;
+        // The following three functions clear any selection
+        // Now return a TInt indicating the new cursor position
+        TInt SetRealCursorPosition(TInt aCursorPos);  
+        TInt SetCompensatedCursorPosition(TInt aCursorPos); 
+        TInt CursorLeft();
+        TInt CursorRight();
+        
+        // Selection manipulation
+        TPtrC           Selection() const;
+        inline TBool    SelectionExists() const;
+        inline TInt     AnchorPosition() const;
+        TInt            SetAnchorPosition(TInt aAnchorPos);
+        inline void     SelectLeft();
+        inline void     SelectRight();
+        inline TInt     LeftMark() const;
+        inline TInt     RightMark() const;
+        inline TInt     SelectionWidth() const;
+        
+        // testing support
+        inline TBool InvariantOk() const;
+        inline void ForceLanguage(TLanguage aLanguage);
+        TInt Language()  const;
+        TInt   Uncompensate( TInt aCompensatedPosition ) const;
+        friend class TAknPhedDataMirror;
+        
+    private:
+        void    ConstructL(TInt aMaxLen);
+        void    Insert(const TDesC& aText);
+        TBool   ClearAnySelection();
+        void    SelectMove(TInt aInc);
+        TBool   CursorPositionIsSpace();
+        TInt    Compensate(TInt aRealPosition) const;
+        
+        void StartEvent();
+        void ReportEvent(const MPhedDataObserver::TAknPhedDataEvent& aEvent);
+        
+    private:
+        TDirection          iCursorDirection;
+        CAknPhedScratchBuffer* iBuf;            // owned
+        CPNGNumberGrouping* iNumberGroupingBuffer;
+        TInt                iRealLength;
+        
+        TInt                iRealCursor;
+        TInt                iRealAnchor;
+        TPtrC               iSelection;
+        
+        TInt iCount;
+        
+        MPhedDataObserver* iObserver;
+        MPhedDataObserver::TAknPhedDataEvent iEvent;
+        TInt iEventDepth;
+    };
+
+
+//
+// TAknPhedDataMirror
+//
+// CAknPhedModel position indexing is from the left hand side. This class reverses
+// all the positioning functions so that they index from the right hand side.
+//
+    NONSHARABLE_CLASS(TAknPhedDataMirror) : public MPhedDataObserver
+        {
+public:
+    inline TAknPhedDataMirror();
+    inline void SetPhedModel(CAknPhedModel* aPhed);
+    
+    // Position mirror+ iBuf    0x13c42088
+    
+    inline TInt Mirror(TInt aPos) const;
+    inline TInt Compensate(TInt aMirroredPosition, TInt aRealPosition) const;
+    
+    // Text access
+    inline TPtrC Text(TInt aFrom=0) const;
+    inline TPtrC Text(TInt aFrom, TInt aTo) const;
+    inline TPtrC ReverseText(TInt aFrom=0) const;
+    inline TPtrC ReverseText(TInt aFrom, TInt aTo) const;
+    
+    // Observer interface
+    inline MPhedDataObserver* Observer();
+    inline void SetObserver(MPhedDataObserver* aObserver);
+    
+    // Cursor manipulation
+    inline TInt CursorPosition() const;
+    inline TInt SetCompensatedCursorPosition(TInt aCursorPos);
+    inline TInt SetRealCursorPosition(TInt aCursorPos);
+    
+    // Selection manipulation
+    inline TInt AnchorPosition() const;
+    inline TInt SetAnchorPosition(TInt aAnchorPos);
+    inline TInt LeftMark() const;
+    inline TInt RightMark() const;
+    
+    void HandlePhedDataEvent(const TAknPhedDataEvent& aEvent, 
+                             CAknPhedModel* aPhedData);
+
+    TInt Compensate(TInt aMirrorPosition) const;
+    
+private:
+    CAknPhedModel*      iPhed;
+    MPhedDataObserver*  iObserver;
+        };
+    
+    inline TPtr CAknPhedScratchBuffer::ScratchBuffer() const 
+        { return iPtr; }
+    // MPhedDataObserver inlines
+    inline MPhedDataObserver::TAknPhedDataEvent::TAknPhedDataEvent() 
+        : iType(0), iStart(0), iEnd(0) 
+        {}
+    
+    inline MPhedDataObserver::TAknPhedDataEvent::TAknPhedDataEvent(TInt aType) 
+        : iType(aType), iStart(0), iEnd(0) 
+        {}
+    
+    inline MPhedDataObserver::TAknPhedDataEvent::TAknPhedDataEvent( TInt aType, 
+        TInt aStart, 
+        TInt aEnd ) 
+        : iType(aType), iStart(aStart), iEnd(aEnd) 
+        {}
+    
+    inline void MPhedDataObserver::TAknPhedDataEvent::Reset() 
+        { iType = iStart = iEnd = 0; }
+    
+    inline TBool MPhedDataObserver::TAknPhedDataEvent::TextChanged() const 
+        { return iType & EText; }
+    
+    inline TBool MPhedDataObserver::TAknPhedDataEvent::CursorChanged() const 
+        { return iType & ECursor; }
+    
+    inline TBool MPhedDataObserver::TAknPhedDataEvent::SelectionChanged() const 
+        { return iType & ESelection; }
+    
+    inline void MPhedDataObserver::TAknPhedDataEvent::TextChangeRange( TInt& aStart, 
+                                                                       TInt& aEnd ) const 
+        { aStart = iStart; aEnd = iEnd; }
+    
+    inline TInt MPhedDataObserver::TAknPhedDataEvent::Type() const
+        { return iType; }
+    
+    
+    // CAknPhedModel inlines
+    inline MPhedDataObserver* CAknPhedModel::Observer()
+        { return iObserver; }
+    
+    inline void CAknPhedModel::SetObserver(MPhedDataObserver* aObserver)
+        { iObserver = aObserver; }
+    
+    inline TInt CAknPhedModel::Length() const
+        { return iNumberGroupingBuffer->Length();}
+    
+    inline TInt CAknPhedModel::MaxDisplayLength() const
+        { return iNumberGroupingBuffer->MaxDisplayLength(); }
+    
+    inline TPtr CAknPhedModel::TranslationBuffer() const
+        { return iBuf->ScratchBuffer(); }
+    
+    inline TInt CAknPhedModel::CursorPosition() const
+        { return Compensate(iRealCursor); }
+    
+    inline TBool CAknPhedModel::SelectionExists() const
+        { return CursorPosition() != AnchorPosition(); }
+    
+    inline TInt CAknPhedModel::AnchorPosition() const
+        { return Compensate(iRealAnchor); }
+    
+    inline TBool CAknPhedModel::IsSpace(TInt aPos) const
+        { return iNumberGroupingBuffer->IsSpace(aPos); }
+    
+    inline TInt CAknPhedModel::LeftMark() const
+        { return (iRealAnchor < iRealCursor) 
+        ? iRealAnchor 
+        : iRealCursor; }
+    
+    inline TInt CAknPhedModel::RightMark() const
+        { return (iRealAnchor > iRealCursor) 
+        ? iRealAnchor
+        : iRealCursor; }
+    
+    inline TInt CAknPhedModel::SelectionWidth() const
+        { return RightMark() - LeftMark(); }
+    
+    inline void CAknPhedModel::SelectLeft()
+        { SelectMove(-1); }
+    
+    inline void CAknPhedModel::SelectRight()
+        { SelectMove(+1); }
+    
+    inline TPtrC CAknPhedModel::Text(TInt aFrom) const
+        { return Text(aFrom, iNumberGroupingBuffer->Length() - 1); }
+    
+    inline TPtrC CAknPhedModel::Text(TInt aFrom, TInt aTo) const
+        { return iNumberGroupingBuffer->FormattedNumber(aFrom, aTo); }
+    
+    inline TPtrC CAknPhedModel::ReverseText(TInt aFrom) const
+        { return ReverseText(aFrom, iNumberGroupingBuffer->Length() - 1); }
+    
+    inline TPtrC CAknPhedModel::ReverseText(TInt aFrom, TInt aTo) const
+        { return iNumberGroupingBuffer->ReverseFormattedNumber(aFrom, aTo); }
+    
+    inline TPtrC CAknPhedModel::UnFormattedText(TInt aFrom) const
+        { return iNumberGroupingBuffer->UnFormattedNumber(aFrom, iNumberGroupingBuffer->UnFormattedLength() - 1); }
+    
+    inline TPtrC CAknPhedModel::UnFormattedText(TInt aFrom, TInt aTo) const
+        { return iNumberGroupingBuffer->UnFormattedNumber(aFrom, aTo); }
+    
+    inline TBool CAknPhedModel::InvariantOk() const
+    { /*return 
+      0 <= iCompensatedCursor && iCompensatedCursor <= Length() && 
+      0 <= iCompensatedAnchor && iCompensatedAnchor <= Length() &&
+    iEventDepth == 0; */
+    return ETrue; }
+    
+    void CAknPhedModel::ForceLanguage(TLanguage aLanguage)
+        { iNumberGroupingBuffer->iForceLanguage = aLanguage; }
+    
+    // TAknPhedDataMirror inlines
+    inline TAknPhedDataMirror::TAknPhedDataMirror() : iPhed(0), iObserver(0)
+        {}
+    
+    inline void TAknPhedDataMirror::SetPhedModel(CAknPhedModel* aPhed)
+        { iPhed = aPhed; }
+    
+    inline TInt TAknPhedDataMirror::Mirror(TInt aPos) const
+        { return iPhed->iNumberGroupingBuffer->Length() - aPos; }
+    
+    inline TPtrC TAknPhedDataMirror::Text(TInt aFrom) const
+        { return iPhed->ReverseText(aFrom); }
+    
+    inline TPtrC TAknPhedDataMirror::Text(TInt aFrom, TInt aTo) const
+        { return iPhed->ReverseText(aFrom, aTo); }
+    
+    inline TPtrC TAknPhedDataMirror::ReverseText(TInt aFrom) const
+        { return iPhed->Text(aFrom); }
+    
+    inline MPhedDataObserver* TAknPhedDataMirror::Observer()
+        { return iObserver; }
+    
+    inline void TAknPhedDataMirror::SetObserver(MPhedDataObserver* aObserver)
+        { iObserver = aObserver; iPhed->SetObserver(this); }
+    
+    inline TInt TAknPhedDataMirror::CursorPosition() const
+        { return Compensate(Mirror(iPhed->iRealCursor), iPhed->iRealCursor); }
+    
+    // This function is defective. It uses Mirror, 
+    // which does not work in real space see MRED-5GPJQQ
+    inline TInt TAknPhedDataMirror::SetRealCursorPosition(TInt aCursorPos)
+        { return iPhed->SetRealCursorPosition(Mirror(aCursorPos)); }
+    
+    inline TInt TAknPhedDataMirror::SetCompensatedCursorPosition(TInt aCursorPos)
+        { return iPhed->SetCompensatedCursorPosition(Mirror(aCursorPos)); }
+    
+    inline TInt TAknPhedDataMirror::AnchorPosition() const
+        { return Compensate(Mirror(iPhed->iRealAnchor), iPhed->iRealAnchor); }
+    
+    inline TInt TAknPhedDataMirror::SetAnchorPosition(TInt aAnchorPos)
+        { return iPhed->SetAnchorPosition(Mirror(aAnchorPos)); }
+    
+    inline TInt TAknPhedDataMirror::LeftMark() const
+        { return Compensate(Mirror(iPhed->LeftMark()), iPhed->LeftMark()); }
+    
+    inline TInt TAknPhedDataMirror::RightMark() const
+        { return Compensate(Mirror(iPhed->RightMark()), iPhed->RightMark()); }
+    
+    inline TInt TAknPhedDataMirror::Compensate(TInt aMirrorPosition, TInt aRealPosistion) const
+        {
+        if ( iPhed->Language() )
+        	{
+            return aMirrorPosition - iPhed->Spaces(0, aRealPosistion); 
+        	}
+        else
+        	{
+        	return aMirrorPosition; 
+        	}
+        }
+    
+#endif
+