/*

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

*  Support for transparent camera setting pages

*

*

*/

#include "AknTransparentCameraSettingPage.h"

// For icon support

#include <barsread.h>

#include <gulicon.h>

#include <AknIconArray.h>

// lists

#include <aknlists.h>

#include <AknTasHook.h>

// Used for setting  1 in the radio button 

_LIT(KOneSlashT, "1\t");

enum TAknTransparentCameraSettingPagePanicCodes

    {

    EAknPanicTransparentCameraSettingPageIndexOutOfRange

    };

GLDEF_C void Panic(TAknTransparentCameraSettingPagePanicCodes aPanic)

    {

    _LIT(KPanicCat,"AknTransparentCameraSettingPage");

    User::Panic(KPanicCat, aPanic);

    }

NONSHARABLE_CLASS(CAknTransparentCameraSettingPageExtension) : public CBase

    {

    friend class CAknTransparentCameraSettingPage;

public:

    static CAknTransparentCameraSettingPageExtension* NewL(

        CCoeControl& aOwner );

    ~CAknTransparentCameraSettingPageExtension();

private:

    CAknTransparentCameraSettingPageExtension( CCoeControl& aOwner );

    void ConstructL();

public: //data

    CFbsBitmap* iBackground;

    // Background bitmap's top left corner.

    TPoint iBitmapPosition;

    // Background bitmap will be drawn inside this rect (ie. it will be cropped 

    // if the rect is smaller than the actual bitmap)

    TRect iBitmapClipRect;

    TBool iDrawFullBackground;

    TBool iDrawBackgroundBitmap;

    TBool iFullScreenMode;

    TBool iReplaceNaviPane; //replace navi pane with empty contents?

    TBool iReturn; //user select okay or cancel?

    TInt iUpdateMode;

    CActiveSchedulerWait iWait; //owned

    /**

     * Extension flags definition.

     */

    enum TFlags

        {

        ESingleClickEnabled

        };

    /**

     * Extension flags.

     */

    TBitFlags iFlags;

    };

CAknTransparentCameraSettingPageExtension* CAknTransparentCameraSettingPageExtension::NewL(

    CCoeControl& aOwner )

    {

    CAknTransparentCameraSettingPageExtension* self =

        new (ELeave) CAknTransparentCameraSettingPageExtension( aOwner );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

CAknTransparentCameraSettingPageExtension::~CAknTransparentCameraSettingPageExtension()

    {

    if(iWait.IsStarted())

        {

        CAknEnv::StopSchedulerWaitWithBusyMessage(iWait);

        }

    }

CAknTransparentCameraSettingPageExtension::CAknTransparentCameraSettingPageExtension(

    CCoeControl& aOwner )

    : iDrawFullBackground(ETrue), iDrawBackgroundBitmap(ETrue),

      iReplaceNaviPane(ETrue),

      iUpdateMode(CAknSettingPage::EUpdateWhenAccepted)

    {

    if ( static_cast<CAknAppUi*>(

            aOwner.ControlEnv()->AppUi() )->IsSingleClickCompatible() )

        {

        iFlags.Set( ESingleClickEnabled );

        }

    }

void CAknTransparentCameraSettingPageExtension::ConstructL()

    {

    }

//////////////////////////////////////////////////////////////////////

// Construction/Destruction

//////////////////////////////////////////////////////////////////////

EXPORT_C CAknTransparentCameraSettingPage::CAknTransparentCameraSettingPage( TInt aResourceId, TInt& aCurrentSelectionItem, const MDesCArray* aItemArray):

    CAknListBoxSettingPage(aResourceId), iOldSelectionIndex(aCurrentSelectionItem), iCurrentSelectionIndex(aCurrentSelectionItem), iItemArray(aItemArray)

    {

    AKNTASHOOK_ADD( this, "CAknTransparentCameraSettingPage" );

    }

EXPORT_C CAknTransparentCameraSettingPage::CAknTransparentCameraSettingPage(    

            const TDesC* aSettingText, 

            TInt aSettingNumber, 

            TInt aControlType,

            TInt aEditorResourceId, 

            TInt aSettingPageResourceId, 

            TInt& aCurrentSelectionIndex, 

            const MDesCArray* aItemArray )

            :   CAknListBoxSettingPage( 

                aSettingText, 

                aSettingNumber, 

                aControlType, 

                aEditorResourceId, 

                aSettingPageResourceId ), 

                iOldSelectionIndex(aCurrentSelectionIndex), 

                iCurrentSelectionIndex(aCurrentSelectionIndex), 

                iItemArray(aItemArray)

    {

    AKNTASHOOK_ADD( this, "CAknTransparentCameraSettingPage" );

    }

/**

 * Destructor

 *

 */

EXPORT_C CAknTransparentCameraSettingPage::~CAknTransparentCameraSettingPage()

    {   

    AKNTASHOOK_REMOVE();

    delete(iInternalItemArray);

    if (iExtension)

        delete iExtension;

    }

EXPORT_C void CAknTransparentCameraSettingPage::ConstructL()

    {

    BaseConstructL( KAknSettingPageNoEmbeddedSoftKeys );

    SetDrawBackground(EFalse);  // Enable transparent drawing

    if( CAknEnv::Static()->TransparencyEnabled() )

        {

        // try to enable window transparency

        if ( Window().SetTransparencyAlphaChannel() == KErrNone )

            {

            Window().SetRequiredDisplayMode( EColor16MA );

            Window().SetBackgroundColor( ~0 );

            }

        }

    GenerateInternalArrayAndGiveToListBoxL();

    iExtension = CAknTransparentCameraSettingPageExtension::NewL( *this );

    // This updates the CBA 

    CheckAndSetDataValidity();

    UpdateCbaL();

    // Only a reference to the CBase object; not owned

    CAknSetStyleListBox* listBox = ListBoxControl();

    CreateBitmapArrayAndGiveToListBoxL();

    listBox->ItemDrawer()->FormattedCellData()->SetDrawBackground( EFalse );

    listBox->ItemDrawer()->FormattedCellData()->ToggleDropShadows( ETrue );

    // Range should be within the valid indices, or -1:

    // So valid range is >= -1 and also < Count.

    __ASSERT_ALWAYS( iCurrentSelectionIndex >= -1, Panic(   EAknPanicTransparentCameraSettingPageIndexOutOfRange) );

    __ASSERT_ALWAYS( iCurrentSelectionIndex < iInternalItemArray->Count(), Panic(   EAknPanicTransparentCameraSettingPageIndexOutOfRange) );

    listBox->View()->CalcBottomItemIndex();

    // Set initial highlight to the top element

    if (FocusToFirstItem())

        {// Set initial highlight to the top element

        if ( iInternalItemArray->Count() > 0 )

            listBox->SetCurrentItemIndex( 0 );

        }

    if (FocusToSelectedItem())

        {// Set initial highlight to the current element.

        if ( iInternalItemArray->Count() > 0 )

            {

            if (iCurrentSelectionIndex != -1)

                listBox->SetCurrentItemIndex( iCurrentSelectionIndex );

            else

                listBox->SetCurrentItemIndex( 0 ); // Set at the top if selected is -1

            }

        }

    listBox->SetListBoxObserver(this);

    // Set the current "pushed in" indication

    if ( iCurrentSelectionIndex != -1 )

    // Set the scroller indication off

    listBox->CreateScrollBarFrameL(ETrue);

    listBox->ScrollBarFrame()->SetScrollBarVisibilityL(CEikScrollBarFrame::EOff,CEikScrollBarFrame::EOff);

    // Need to do this to set up the scroll bar model

    listBox->UpdateScrollBarsL();

    if(!IsBackgroundDrawingEnabled())

    // Force a size changed

    SizeChanged();

    // Construct an appropriate control context for the contained editor areas.

    // Context produced is owned by CAknSettingPage. 

    SetEditedItemFrameIID( KAknsIIDQsnFrSetOpt, KAknsIIDQsnFrSetOptCenter );

}

//---------------------------------------------------------------------------------------------

// Note: please call CAknSettingPage::ConstructL() before call this function!

//---------------------------------------------------------------------------------------------

//

EXPORT_C TBool CAknTransparentCameraSettingPage::ExecuteLD( 

        enum CAknSettingPage::TAknSettingPageUpdateMode aMode, 

        TBool aReplaceNaviPane )

    {

    iExtension->iReplaceNaviPane = aReplaceNaviPane;

    if(aReplaceNaviPane)

        {

        return CAknSettingPage::ExecuteLD( aMode );

        }

    CleanupStack::PushL( this ); // Matching Pop is in AttemptExitL

    iExtension->iUpdateMode = aMode;

    DynamicInitL();

    ActivateL();

    DrawNow();

    EditorControl()->SetObserver( this );

    iEikonEnv->EikAppUi()->AddToStackL(this,ECoeStackPriorityDialog);

    if ( PostDisplayCheckL() )

        {

        if (!iExtension->iWait.IsStarted())

            {

            iExtension->iWait.Start();

            }

        }

    else

        AttemptExitL(EFalse);

    iEikonEnv->EikAppUi()->RemoveFromStack(this);

    CleanupStack::Pop(); // this

    TBool res=iExtension->iReturn;

    delete (this);

    return res;

    }

//---------------------------------------------------------------------------------------------

// Set the flags in extension to indicate user accept settings or cancel it.

//---------------------------------------------------------------------------------------------

//

void CAknTransparentCameraSettingPage::AttemptExitL(TBool aAccept)

    {

    if ( OkToExitL( aAccept ) )

        {

        DismissL( aAccept );

        iExtension->iReturn = aAccept;

        if ( iExtension->iWait.IsStarted() )

            {

            CAknEnv::StopSchedulerWaitWithBusyMessage( iExtension->iWait );

            }

        else

            {

            StopActiveScheduler();

            }

        }

    }

//---------------------------------------------------------------------------------------------

// Update settings according to update mode

//---------------------------------------------------------------------------------------------

//

EXPORT_C void CAknTransparentCameraSettingPage::HandleControlEventL(

    CCoeControl* /*aControl*/,TCoeEvent aEventType)

    {

    if ( aEventType == EEventStateChanged && iExtension &&

         iExtension->iUpdateMode == EUpdateWhenChanged )

        {

        UpdateSettingL();

        }

    }

//---------------------------------------------------------------------------------------------

// Process user command by modifying flags in extension

//---------------------------------------------------------------------------------------------

//

EXPORT_C void CAknTransparentCameraSettingPage::ProcessCommandL(TInt aCommandId)

    {

    if(iExtension->iReplaceNaviPane)

        {

        CAknSettingPage::ProcessCommandL(aCommandId);

        return;

        }

    if(!IsEditable() && !(aCommandId == EAknSoftkeyBack || aCommandId == EAknSoftkeyCancel))

        {

        return;

        }

    HideMenu();

    // Respond to softkey events

    switch (aCommandId)

        {

        case EAknSoftkeySelect:

            {

            if ( EnableSingleClickHighlight( aCommandId ) )

                {

                break;                           

                } 

            // no single click mode was enabled, fall through

            }

        case EAknSoftkeyOk:

        case EAknSoftkeyDone:                    

            SelectCurrentItemL(); // has non-trivial implemenations in listbox type 

                                        // controls to put the selection on the current item

            AttemptExitL(ETrue);

            break;

        case EAknSoftkeyBack:

        case EAknSoftkeyCancel:

            AttemptExitL(EFalse);

            break;

        case EAknSoftkeyOptions:

            DisplayMenuL();

            break;

        default:

            break;

        }

    }

EXPORT_C void CAknTransparentCameraSettingPage::HandleListBoxEventL(CEikListBox* /*aListBox*/, 

        MEikListBoxObserver::TListBoxEvent aEventType)

    {

    switch ( aEventType )

        {

        case MEikListBoxObserver::EEventItemSingleClicked:

        case MEikListBoxObserver::EEventEnterKeyPressed:

        case MEikListBoxObserver::EEventItemDoubleClicked:

        case MEikListBoxObserver::EEventItemActioned:

            {

            SelectCurrentItemL();

            AttemptExitL( ETrue );

            break;

            }

        case MEikListBoxObserver::EEventFlickStopped:   // fallthrough

        case MEikListBoxObserver::EEventPanningStopped:

            {

            // The current item index (highlighted item) of the listbox control

            // has been changed when starting the dragging / flicking, so

            // it must be reverted back to represent the same item as

            // the current selection in the setting page.

            // Only in single click enabled applications.

            if ( iExtension &&

                 iExtension->iFlags.IsSet(

                     CAknTransparentCameraSettingPageExtension::ESingleClickEnabled ) &&

                 iCurrentSelectionIndex >= 0 &&

                 iCurrentSelectionIndex < ListBoxControl()->Model()->NumberOfItems() )

                {

                ListBoxControl()->View()->SetCurrentItemIndex(

                    iCurrentSelectionIndex );

                }

            break;

            }

        default:

            break;

        }

    }

EXPORT_C void CAknTransparentCameraSettingPage::UpdateSettingL()

    {

    }

EXPORT_C CAknSetStyleListBox* CAknTransparentCameraSettingPage::ListBoxControl() const

    {

    return STATIC_CAST( CAknSetStyleListBox*, EditorControl());

    }

EXPORT_C void CAknTransparentCameraSettingPage::DynamicInitL()

    {

    }

void CAknTransparentCameraSettingPage::SetRadioButtonSelectionL( TInt aPushed )

    {

    // reference listbox's view; not owned here

    CListBoxView* view = ListBoxControl()->View();

    view->SelectItemL( aPushed );

    if ( aPushed != iOldSelectionIndex )

        {

        view->DeselectItem( iOldSelectionIndex );

        iOldSelectionIndex = aPushed;

        }

    } 

EXPORT_C void CAknTransparentCameraSettingPage::SelectCurrentItemL()

    {

    iCurrentSelectionIndex = ListBoxControl()->CurrentItemIndex();

    SetRadioButtonSelectionL( iCurrentSelectionIndex );

    UpdateSettingL();

    if( iSettingPageObserver )

        iSettingPageObserver->HandleSettingPageEventL(this, MAknSettingPageObserver::EEventSettingChanged);

    } 

EXPORT_C void CAknTransparentCameraSettingPage::SetItemArrayAndSelectionL( const MDesCArray* aItemArray, TInt aPushed )

    {

    SetRadioButtonSelectionL(0);  // Put the selection into a known state

    iItemArray = aItemArray;

    GenerateInternalArrayAndGiveToListBoxL();

    // This updates the CBA 

    CheckAndSetDataValidity();

    UpdateCbaL();

    SizeChanged();

    SetRadioButtonSelectionL(aPushed);

    DrawDeferred();

    }

void CAknTransparentCameraSettingPage::GenerateInternalArrayAndGiveToListBoxL()

    {

    delete iInternalItemArray;

    iInternalItemArray = 0;

    // Make a new owned text array from the input one with the "Pushed in" icon index:

    iInternalItemArray = new(ELeave)CDesCArrayFlat(1);

    TInt nItems = iItemArray->MdcaCount();

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

        {

        // Fill up the control-owned space for the modified buffers:

        TInt newLen = (iItemArray->MdcaPoint(ii)).Length() + KOneSlashT().Length();

        HBufC* newText = HBufC::NewMaxLC( newLen ); 

        TPtr newTPtr = newText->Des();

        newTPtr.Copy( KOneSlashT );

        newTPtr.Append( iItemArray->MdcaPoint(ii) );

        // A copy of the new buffer goes to the internal itemarray:

        iInternalItemArray->AppendL(newTPtr); 

        CleanupStack::PopAndDestroy(); // newText

        }

    // Only a reference to the CBase object; not owned

    CAknSetStyleListBox* listBox = ListBoxControl();

    // Set the text data

    CTextListBoxModel* model=listBox->Model();

    model->SetItemTextArray(iInternalItemArray);

    model->SetOwnershipType(ELbmDoesNotOwnItemArray);

    }

/**

 * Writes the internal state of the control and its components to aStream.

 * Does nothing in release mode.

 * Designed to be overidden and base called by subclasses.

 */

#ifndef _DEBUG

EXPORT_C void CAknTransparentCameraSettingPage::WriteInternalStateL(RWriteStream& /*aWriteStream*/) const

    {}

#else

EXPORT_C void CAknTransparentCameraSettingPage::WriteInternalStateL(RWriteStream& aWriteStream) const

    {

    CAknSettingPage::WriteInternalStateL(aWriteStream);

    }

#endif