/*
* 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