/*

* Copyright (c) 1997-2009 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:

*

*/

#include <barsread.h>

#include <coemain.h>

#include <eikenv.h>

#include <eikcapc.h>

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <eikfctry.h>

#else

#include <eikfctry.h>

#include <uikon/eikctrlstatus.h>

#endif

#include <eikcapca.h>

#include <eikedwin.h>

#include <eikappui.h>

#include <eikdpage.h>

#include <eikdpsel.h>

#include <eikdialg.pan>

#include <eikform.pan>

#include <eikon.hrh>

#include <eikdialogext.h>

#include <eikseced.h>

#include <eikmfne.h>

#include <eikfpne.h> 

#include <avkon.hrh>

#include <avkon.rsg>

#include <AknUtils.h> 

#include <eikscrlb.h>

#include <AknsDrawUtils.h>

#include <AknsUtils.h>

#include <skinlayout.cdl.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include "EIKFANIM.H"

#include <touchfeedback.h>

#include <AknTasHook.h> // for testability hooks

#include "aknformphysics.h"

#include "aknrecordinggc.h"

#include <aknphysics.h>

#include <aknappui.h>

#include <aknPriv.hrh>

//

// Global constants.

//

const TInt KSpaceFromTitle=0 ; 

const TInt KSpaceFromBottom=0 ;

const TInt KPageArrayGranularity=4;

const TInt KLineArrayGranularity=4;

/*

 *  The following set of static functions return value which have been hard coded from the Series 60 Skins LAF v2.0

 *  If a layout DLL becomes available the hard-coded values may be replaced with equivalent Macros.

 *  NOTE THAT THESE ARE COPIES OF FUNCTIONS IN EIKCAPC.CPP

 */

LOCAL_D TRect EditFrameTopLeftRect( const TRect& aParentRect )

    {// Skins LAF table 5.24 Line 2

    TAknLayoutRect topLeft ;

    topLeft.LayoutRect( aParentRect, SkinLayout::Input_field_skin_placing__general__Line_2() ); 

    return topLeft.Rect() ;

    }

LOCAL_D TRect EditFrameBottomRightRect( const TRect& aParentRect )

    {// Skins LAF table 5.24 Line 5

    TAknWindowLineLayout l( SkinLayout::Input_field_skin_placing__general__Line_5() );

    TAknLayoutRect layoutRect;

    layoutRect.LayoutRect( aParentRect, l );

    TRect rectInputField( layoutRect.Rect() );

    return rectInputField;

    }

NONSHARABLE_CLASS(CDialogPageExtension) : public CBase

    {

public:

    enum TFlags

        {

        ELineHandlerCalled

        };

    static CDialogPageExtension* NewL();

    ~CDialogPageExtension();

    void Feedback( CEikDialogPage* aControl, TTouchLogicalFeedback aFeedback ) const;

    /**

     * Produces vibra-only feedback. Event filtering by pointer event is used..

     */

    void SilentFeedback( CEikDialogPage* aDPage, 

                         TTouchLogicalFeedback aFeedback, 

                         const TPointerEvent& aPointerEvent ) const;

    void HandleFormFeedback( CEikDialogPage* aControl, const TPointerEvent& aPointerEvent, TInt aTouchedLineIndex, TInt aCurrentLine );

protected:  

    void ConstructL();

private:

    CDialogPageExtension();

    CDialogPageExtension(const CDialogPageExtension& aExtension);

public: 

    TInt iPopFieldEvents;    

    TBool iExternalScrollbar;

    TBool iIsDoubleQuery;

    TBool iFocusedClicked;

    TInt iPreviousThumbPosition;

    TBool iPreviousThumbDirection;

    MTouchFeedback* iFeedback;

    TBitFlags iFlags;

    /**

    * @c iDestroyedPtr is used for the object destruction check.

    * If it has non-null value, the destruction check is turned on, and

    * the value points to a local boolean variable that keeps the destroyed state.

    */

    TBool* iDestroyedPtr;

    TPoint iDragStartPosition;

    TPoint iLastPointerPos;

    TTime iStartTime;

    CAknRecordingGc* iRecordingGc;

    TBool iHandlingScrollEvent;

    CPeriodic* iHighlightTimer;

    TInt iLastTouchedLine;

    TPoint iSynchronizedPosition;

    TBool iScrolling;

    TBool iScrolled;

    TBool iInitialLayoutDone;

    TBool iSetInitialFocusDone;

    TBool iHandlingResourceChange;

    TInt iCapturingItem;

    // record the center point Y value of current view when touch down an item

    TInt iOldCenterY;

    // top item in current view, -1 if item's Y is negative

    TInt iTopItem;

    // bottom item in current view, fields count when Y is larger than

    // the last item's Y

    TInt iBottomItem; 

    /**

     * Boolean used to check if application is single touch compatible.

     */

    TBool iUsesSingleClick;

    // It is used to distinguish if the focus item has changed.

    TBool iFocusItemChanged;

    };

CDialogPageExtension::CDialogPageExtension()

    {

    }

CDialogPageExtension* CDialogPageExtension::NewL()

    {

    CDialogPageExtension* extension = new (ELeave) CDialogPageExtension();

    CleanupStack::PushL(extension);

    extension->ConstructL();

    CleanupStack::Pop(extension); //extension

    return extension;

    }

CDialogPageExtension::~CDialogPageExtension()

    {

    delete iHighlightTimer;

    delete iRecordingGc;

    if( iDestroyedPtr )

        {

        // Mark the object as destroyed.

        *iDestroyedPtr = ETrue;

        iDestroyedPtr = NULL;

        }

    }

CDialogPageExtension::CDialogPageExtension(const CDialogPageExtension& /*aExtension*/)

    {

    }

void CDialogPageExtension::ConstructL()

    {

    iFeedback = MTouchFeedback::Instance();

    iHighlightTimer = CPeriodic::NewL( CActive::EPriorityStandard );

    iCapturingItem = KErrNotFound;

    }

void CDialogPageExtension::HandleFormFeedback(

    CEikDialogPage* aDPage,

    const TPointerEvent& aPointerEvent,

    TInt aTouchedLineIndex,

    TInt aCurrentLine )

    {

    // note, that iFormControl is checked in Feedback()

    if ( aPointerEvent.iType == TPointerEvent::EButton1Down &&

        aCurrentLine != aTouchedLineIndex && aDPage->LineOnPageOrNull( 0 ) ) 

        {

        // feedback for edit/view mode form, when non-focused line is clicked

        // feedback for focused item is responsibility of the item

        // no feedback with focus change when single click is enabled

        if ( !iUsesSingleClick )

            {

            Feedback( aDPage, ETouchFeedbackSensitiveList );

            }

        iFocusItemChanged = ETrue;

        }

    else if ( aPointerEvent.iType == TPointerEvent::EButton1Down &&

        aTouchedLineIndex == aCurrentLine && aDPage->LineOnPageOrNull( 0 ) )

        {

        // Feedback for view mode form, when focused item is

        // clicked. Basically same case as for msk simulation later on

        // the function, but on pointer

        // down. iExtension->iFocusedClicked is not valid here, since

        // it can't be known in this phase whether user drags pointer

        // away.

        Feedback( aDPage, ETouchFeedbackList );

        iFocusItemChanged = EFalse;

        }

    else if ( aPointerEvent.iType == TPointerEvent::EButton1Up &&

            aDPage->LineOnPageOrNull( 0 ) )

        {// when focus changed, it should not send feedback on up event.

        //when up event comes, aTouchedLineIndex always equal to aCurrentLine

        if ( !iFocusItemChanged )

            {

            SilentFeedback( aDPage, ETouchFeedbackList, aPointerEvent );

            }

        }

    }

void CDialogPageExtension::Feedback( CEikDialogPage* aDPage, 

                                     TTouchLogicalFeedback aFeedback ) const

    {

    if ( aDPage

        && aDPage->IsForm()

        && iFeedback

        && !aDPage->IsDimmed()

        && aDPage->IsVisible() )

        {

        iFeedback->InstantFeedback( aFeedback );

        }

    }

void CDialogPageExtension::SilentFeedback( CEikDialogPage* aDPage, 

                                           TTouchLogicalFeedback aFeedback, 

                                           const TPointerEvent& aPointerEvent ) const

    {

    if ( aDPage

        && aDPage->IsForm()

        && iFeedback

        && !aDPage->IsDimmed()

        && aDPage->IsVisible() )

        {

        iFeedback->InstantFeedback( aDPage, aFeedback, ETouchFeedbackVibra, aPointerEvent );

        }

    }

class CAknPaneScroll : public CBase

{

public:

    enum TScrollChangeType

        {

        ENoChange = 0,

        ETopChanged = 1,

        EBottomChanged = 2,

        ESizeChanged = 4,

        EFocusChanged = 8

        };

    CAknPaneScroll(CCoeControl* /*ctrl*/) : iTop(0), iMiddle(-1), iBottom(-1) { }

    void SetLines(CEikCapCArray *aLines) { iLines = aLines; }

    void SetOutsideRect(TRect aRect); // this is list_form_gen_pane

    TScrollChangeType ExposeLine(TInt aLine, TBool aShowWholeLine=ETrue);

    TInt Top() const {return iTop; }

    TInt Middle() const {return iMiddle; }

    TInt Bottom() const {return iBottom; }

private:

    TRect iOutsideRect;

    CEikCapCArray *iLines;

    TInt iTop, iMiddle, iBottom;

    TInt iOldTop, iOldMiddle, iOldBottom;

    TInt iOldFocus;

};

CAknPaneScroll::TScrollChangeType CAknPaneScroll::ExposeLine(TInt aLine, TBool /*aShowWholeLine*/)

{

    if (aLine < 0 || aLine >= iLines->Count()) return ENoChange;

    TInt top = iTop;

    TInt middle = iMiddle;

    TInt bottom = iBottom;

    TBool switchDir = iLines->CalcItemIndexes(top, middle, bottom, iOutsideRect.Size());

    if (switchDir && iTop == -1) { iTop = top; iMiddle = -1; iBottom = -1; }

    if (switchDir && iBottom == -1) { iTop = -1; iMiddle = -1; iBottom = bottom; }

    if (aLine < top) { iTop = aLine; iMiddle = -1; iBottom=-1; }

    else if (aLine >= iLines->Count() - bottom) { iBottom = iLines->Count() - 1 - aLine; iMiddle = -1; iTop=-1; }

    TScrollChangeType change = ENoChange;

    if (iOldTop != top) { change = TScrollChangeType(change | ETopChanged); }

    if (iOldBottom != bottom) { change = TScrollChangeType(change | EBottomChanged); }

    if (iOldMiddle != middle) { change = TScrollChangeType(change | ESizeChanged); }

    if (iOldFocus != aLine) {change = TScrollChangeType(change | EFocusChanged); }

    iOldTop = top;

    iOldMiddle = middle;

    iOldBottom = bottom;

    iOldFocus = aLine;

    return change;

}

void CAknPaneScroll::SetOutsideRect(TRect aRect) { iOutsideRect = aRect; }

//

// CEikDialogPage.

//

CEikDialogPage::~CEikDialogPage()

    {

    AKNTASHOOK_REMOVE();

    // Page observer needs to be nulled or an already deleted instance is

    // called when pointer up event is handled. This is valid only for dialogs

    // that have embedded virtual inputs.

    iPageObserver = NULL;

    delete iPhysics;

    delete iLines;

    delete iScroll;    

    delete iExtension;

    }

CEikDialogPage* CEikDialogPage::NewL(TInt aPageId,RWindow& aViewWin,CEikScrollBarFrame& aSBFrame,const CEikDialogPageContainer& aParent,MEikDialogPageObserver* aPageObserver)

    {

    CEikDialogPage* self=CEikDialogPage::NewLC(aPageId,aViewWin,aSBFrame,aParent,aPageObserver);

    CleanupStack::Pop();

    return self;

    }

void CEikDialogPage::CommonConstructCodeBetweenNewL(CEikDialogPage& aDialogPage, const CEikDialogPageContainer& aParent)

    {

/* 

Added the next line as normal window heirarchy does not hold for dialogs, so the 

container window mechanism cannot be used to find the menu / CBA, which is used

in the MOP system for scrollers.

*/

    aDialogPage.SetPageContainer(&aParent);

    aDialogPage.ConstructL();

    aDialogPage.CopyControlContextFrom(&aParent);

    };

CEikDialogPage* CEikDialogPage::NewLC(TInt aPageId,RWindow& aViewWin,CEikScrollBarFrame& aSBFrame,const CEikDialogPageContainer& aParent,MEikDialogPageObserver* aPageObserver)

    {

    CEikDialogPage* self=new(ELeave) CEikDialogPage(aPageId,aViewWin,aSBFrame,aPageObserver);

    CleanupStack::PushL(self);

    CommonConstructCodeBetweenNewL(*self,aParent); 

    AKNTASHOOK_ADDL( self, "CEikDialogPage" );

    return self;

    }

CEikDialogPage* CEikDialogPage::NewL(TInt aPageId,RWindow& aViewWin,CEikScrollBarFrame& aSBFrame,const CEikDialogPageContainer& aParent,MEikDialogPageObserver* aPageObserver,TResourceReader& aReader)

    {

    CEikDialogPage* self=CEikDialogPage::NewLC(aPageId,aViewWin,aSBFrame,aParent,aPageObserver,aReader);

    CleanupStack::Pop();

    return self;

    }

CEikDialogPage* CEikDialogPage::NewLC(TInt aPageId,RWindow& aViewWin,CEikScrollBarFrame& aSBFrame,const CEikDialogPageContainer& aParent,MEikDialogPageObserver* aPageObserver,TResourceReader& aReader)

    {

    CEikDialogPage* self=new(ELeave) CEikDialogPage(aPageId,aViewWin,aSBFrame,aPageObserver);

    CleanupStack::PushL(self);

    CommonConstructCodeBetweenNewL(*self,aParent);

    self->ConstructFromResourceL(aReader);

    AKNTASHOOK_ADDL( self, "CEikDialogPage" );

    return self;

    }

CEikDialogPage::CEikDialogPage(TInt aPageId,RWindow& /*aViewWin*/,

    CEikScrollBarFrame& /*aSBFrame*/,MEikDialogPageObserver* aPageObserver)

    : iPageObserver(aPageObserver),

        iPageId(aPageId),iCurrentLine(-1)

    {

    SetBlank();

    SetComponentsToInheritVisibility();

    }

void CEikDialogPage::ConstructL()

    {

    iLines=new(ELeave)CEikCapCArray(KLineArrayGranularity);

    SetContainerWindowL( *iPageContainer );

    Window().SetPointerGrab(ETrue); 

    Window().SetShadowDisabled(ETrue);

    Window().SetBackgroundColor(iEikonEnv->ControlColor(EColorDialogBackground,*this));

    iScroll = new(ELeave)CAknPaneScroll(this);

    iScroll->SetLines(iLines);

    iExtension = CDialogPageExtension::NewL();

    }

void CEikDialogPage::ConstructFromResourceL(TResourceReader& aReader, TBool aFormControl )

    {

    iFormControl = aFormControl ;

    if ( IsForm() )

        {

        if ( iAvkonAppUi )

            {

            iExtension->iUsesSingleClick = 

                iAvkonAppUi->IsSingleClickCompatible();

            }

        iPhysics = CAknFormPhysics::NewL( *this, *iExtension->iRecordingGc );

        iExtension->iRecordingGc = new ( ELeave ) CAknRecordingGc( &SystemGc() );

        }

    const TInt lineCount=aReader.ReadInt16();

    if (lineCount==EEikDlgMainPageIndirect)

        {

        TInt indirectRid=aReader.ReadInt32();

        if (!indirectRid)

            return;

        TResourceReader indirectReader;

        iCoeEnv->CreateResourceReaderLC(indirectReader,indirectRid);

        ConstructFromResourceL(indirectReader);

        CleanupStack::PopAndDestroy();

        return;

        }

    // This section modified to handle FORM structure (which contains DIALOG_LINE structs )

    // There might be lines on the page already

    for (TInt ii=0;ii<lineCount;ii++)

        {

        CEikCaptionedControl* thisLine=ConstructLineL(aReader); 

/* 

Second argument used to be used to set previous line.  This has been moved into a 

AfterAddingNewLinesL, in an attempt to group code which has to be executed together

*/

        CleanupStack::PushL(thisLine);

        iLines->AppendL(thisLine);

        CleanupStack::Pop(); // thisLine

        thisLine->iIsFormControl = aFormControl ;

        if ( aFormControl )

            {

            thisLine->GetAknLayoutValuesL() ;   // should cause the control to have size.

            if ( iFormFlags )

            thisLine->SetFormFlags( iFormFlags ) ;

            }       

// allow the caption to know the one above itself

        AfterAddingNewLinesL(iLines->LineIndexFromId(thisLine->iId));

        }

    SetDensePacking( !iFormControl ) ;

    if (!iScroll)

        {

        iScroll = new(ELeave)CAknPaneScroll(this);

        }

    iScroll->SetLines(iLines);

    }

void CEikDialogPage::ConstructFormFromResourceL( TResourceReader& aReader ) 

    {

    iFormFlags = TInt16(aReader.ReadInt16()) ;

    iFormLayout = (iFormFlags&EEikFormUseDoubleSpacedFormat) ? EDouble : ESingle;

    ConstructFromResourceL( aReader, ETrue ) ;

    }

CCoeControl* CEikDialogPage::CreateLineByTypeL(const TDesC& aCaption,TInt aLineId,TInt aControlType,TAny* aReturnValue)

    {

    ShowFocus( EFalse, EFalse ) ;  // Turn the focus off the current line.  

    CEikCaptionedControl* line=new(ELeave) CEikCaptionedControl;

    CleanupStack::PushL(line);

    line->SetComponentsToInheritVisibility();

    // Try to insert line above the currently selected line.  If no line is currently selected then append (TimW 22/5/00)

    // INSERTION SHOULD BE BELOW!

    TInt oldLine = iCurrentLine;

    if ( (iCurrentLine != -1) && (iCurrentLine < iLines->Count()) )

        {

        iLines->InsertL( iCurrentLine+1, line ) ;

        ++iCurrentLine;

        }

    else

        {

        iLines->AppendL( line ) ;

        iCurrentLine = iLines->Count() - 1 ;

        }

// used to update CaptionedControlAfter field upon adding new lines.

    CleanupStack::Pop(); // "line" is now owned by iLines.

    ConstructByTypeL(aControlType,line,this); // line owns control, dialog owns line - no need for cleanup stack.

    line->SetCaptionL(aCaption);

    line->iId=aLineId;

    __ASSERT_DEBUG(line->IsNonFocusing() || aLineId!=0, Panic(EEikDialogPanicFocusableLineWithIdZero));

    line->iReturnValue=aReturnValue;

    AfterAddingNewLinesL(iCurrentLine); 

    TInt targetLine = iCurrentLine;

    iCurrentLine = oldLine;

    ChangeFocusTo( targetLine );

    // physics engine needs to be updated when lines are added after the initial layout

    UpdatePhysics();

    return line->iControl;

    }

CEikCaptionedControl* CEikDialogPage::ConstructLineL(TInt aResourceId)

    {

    TResourceReader resourceReader;

    iCoeEnv->CreateResourceReaderLC(resourceReader,aResourceId);

    CEikCaptionedControl* line=ConstructLineL(resourceReader);

    CleanupStack::PopAndDestroy(); // resourceReader

    return line;