/*
 * 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:    Provides LM compass view's container class methods.
 *
 */

// INCLUDE FILES
#include <aknlists.h>
#include <aknview.h>
#include <eikmenub.h>
#include <aknsfld.h>
#include <layoutmetadata.cdl.h> // To Check TOUCH Support
// For RD_AVKON_UNBRANCH
#include <bldvariant.hrh>
#include <AknDef.h>
#include <landmarks.rsg>
#include "CLmkAppUi.h"
#include "CLmkUiUtils.h"
#include "CLmkSender.h"
#include <csxhelp/lm.hlp.hrh>
#include "CLmkByLmView.h"
#include "CLmkByLmContainer.h"
#include "CLmkAppLmSelectorImpl.h"
#include "landmarks.hrh"
#include <lmkui.rsg>
#include "Debug.h"

// ----------- Touch feedback additions start
#ifdef RD_TACTILE_FEEDBACK
#include <touchfeedback.h>
#endif //RD_TACTILE_FEEDBACK
// ----------- Touch feedback additions end

// ================= MEMBER FUNCTIONS =======================
// ----------------------------------------------------------------------------
// CLmkByLmContainer::NewL
// ----------------------------------------------------------------------------
//
CLmkByLmContainer* CLmkByLmContainer::NewL(MLmkKeyProcessor& aKeyProcessor,
        MObjectProvider* aParent, const TRect& aRect, CAknView& aView)
    {
    CLmkByLmContainer* self = new (ELeave) CLmkByLmContainer(aKeyProcessor,
            aView);
    CleanupStack::PushL(self);
    self->SetMopParent(aParent);
    self->ConstructL(aRect);
    CleanupStack::Pop(); // self
    return self;
    }

// ----------------------------------------------------------------------------
// CLmkByLmContainer::ConstructL
// ----------------------------------------------------------------------------
//
void CLmkByLmContainer::ConstructL(const TRect& aRect)
    {
    CLmkLbWithFilterContainer::ConstructL(aRect);
    iFindBox->SetObserver(this);
    }

// ----------------------------------------------------------------------------
// CLmkByLmContainer::CLmkByLmContainer
// ----------------------------------------------------------------------------
//
CLmkByLmContainer::CLmkByLmContainer(MLmkKeyProcessor& aKeyProcessor,
        CAknView& aView) :
    CLmkLbWithFilterContainer(aKeyProcessor, KLM_HLP_LM_BY_NAME),
            iView(aView)
    {
    iIsEditorOpened = EFalse;
    iHandlePointerEvent = ETrue;
    }
// ----------------------------------------------------------------------------
// CLmkByLmContainer::~CLmkByLmContainer
// ----------------------------------------------------------------------------
//
CLmkByLmContainer::~CLmkByLmContainer()
    {
    }

// ----------------------------------------------------------------------------
// CLmkByLmContainer::SetupTitlePaneL
// ----------------------------------------------------------------------------
//
void CLmkByLmContainer::SetupTitlePaneL()
    {
    CLmkUiUtils::ChangeTitlePaneL( R_LMK_BYLM_VIEW_TITLE);
    }

// ----------------------------------------------------------------------------
// CLmkByLmContainer::SetupSelectorAndListL
// ----------------------------------------------------------------------------
//
void CLmkByLmContainer::SetupSelectorAndListL(CPosLandmarkDatabase& aDb,
        CLmkSender& aSender)
    {
    iSelector = CLmkAppLmSelectorImpl::NewL(aDb, aSender, ETrue);
    iSelector->SetMskObserver(this);
    iListBox = &(iSelector->CreateListBoxL(this, EAknCtSingleGraphicListBox,
#ifdef RD_SCALABLE_UI_V2
            EAknListBoxStylusMarkableList,
#else
            EAknListBoxMarkableList,
#endif //RD_SCALABLE_UI_V2
            R_LMK_EMPTY_NO_LANDMARKS, R_LMK_GUIDE_NEW_LANDMARK));
    }

// ----------------------------------------------------------------------------
// CLmkByLmContainer::SetupNaviPaneL
// ----------------------------------------------------------------------------
//
void CLmkByLmContainer::SetupNaviPaneL()
    {
    iNaviDeco = CreateNaviPaneL(R_LMK_TAB_GROUP);
    ActivateTabL(*iNaviDeco, ELmkByLmView);
    }

// ----------------------------------------------------------------------------
// CLmkByLmContainer::OfferKeyEventL
// ----------------------------------------------------------------------------
//
TKeyResponse CLmkByLmContainer::OfferKeyEventL(const TKeyEvent& aKeyEvent,
        TEventCode aType)
    {
    DEBUG( CLmkByLmContainer::OfferKeyEventL entered );
    DEBUG2( aKeyEvent.iCode=%d aKeyEvent.iScanCode=%d,
            aKeyEvent.iCode,
            aKeyEvent.iScanCode
    );
    DEBUG3( aKeyEvent.iModifiers=%d aKeyEvent.iRepeats=%d aType=%d,
            aKeyEvent.iModifiers,
            aKeyEvent.iRepeats,
            aType
    );

    TBool shiftKeyPressed = (aKeyEvent.iModifiers & EModifierShift)
            || (aKeyEvent.iModifiers & EModifierLeftShift)
            || (aKeyEvent.iModifiers & EModifierRightShift);

    if (aKeyEvent.iScanCode == EStdKeyUpArrow || aKeyEvent.iScanCode
            == EStdKeyDownArrow)
        {
        if (aType == EEventKey)
            {
            if (iListBox->OfferKeyEventL(aKeyEvent, aType) == EKeyWasConsumed)
                {
                if (shiftKeyPressed)
                    UpdateMskContainerL();
                return EKeyWasConsumed;
                }
            }
        return EKeyWasNotConsumed;
        }

    CLmkAppSelectorImplBase& selector = SelectorImpl();
    TInt markedCount(selector.ListMarkedItemCountL());
    TInt visibleCount(selector.ListVisibleItemCount());
    DEBUG1( CLmkByLmContainer::OfferKeyEventL markedCount=%d,markedCount );
    DEBUG1( CLmkByLmContainer::OfferKeyEventL visibleCount=%d,visibleCount );

    if (aKeyEvent.iCode == EKeyOK && !shiftKeyPressed && aType == EEventKey)
        {
        DEBUG( CLmkByLmContainer::OfferKeyEventL EKeyOK );
        if (visibleCount > 0 && markedCount < 1)
            {
            DEBUG( CLmkByLmContainer::OfferKeyEventL EKeyOK ELmkCmdOpenLm );
            // Launch landmark viewer here
            selector.ProcessCommandL(ELmkCmdOpenLm);
            iIsEditorOpened = ETrue;
            return EKeyWasConsumed;
            }
        else
            {
            DEBUG( CLmkByLmContainer::OfferKeyEventL EKeyOK show menubar );
            CEikMenuBar* menubar =
                    static_cast<CAknViewAppUi*> (iAvkonAppUi)->View(
                            TUid::Uid(ELmkByLmView))->MenuBar();
            if (menubar)
                {
                menubar->SetMenuTitleResourceId(R_LMK_OK_MENUBAR);

                menubar->StopDisplayingMenuBar();
                TRAPD(err, menubar->TryDisplayMenuBarL());
                DEBUG1( CLmkByLmContainer::OfferKeyEventL menubar->TryDisplayMenuBarL() = %d,err );
                // set ordinary menubar back even in case of error
                menubar->SetMenuTitleResourceId(R_LMK_BYLM_MENUBAR);
                User::LeaveIfError( err);
                }

            return EKeyWasConsumed;
            }
        }
    else if (shiftKeyPressed && aType == EEventKeyUp)
        {
        UpdateMskContainerL();
        }
    else
        {
        DEBUG( CLmkByLmContainer::OfferKeyEventL send event key & other keys handling );
        // 'send' eveny key processing        
        if (visibleCount > 0 && markedCount < 1)
            {
            // Check TOUCH Support
            if (aKeyEvent.iCode == EKeyPhoneSend
                    && (!Layout_Meta_Data::IsPenEnabled()))
                {
                selector.ProcessCommandL(ELmkCmdCall);
                }
            }
        if (iIsEditorOpened)
            {
            DEBUG( CLmkByLmContainer::OfferKeyEventL iIsEditorOpened entered );
            SelectorImpl().HandleListProviderEvent(ELmkEventListReady);
            }
        }
    iIsEditorOpened = EFalse;
    DEBUG( CLmkByLmContainer::OfferKeyEventL end );
    return CLmkLbWithFilterContainer::OfferKeyEventL(aKeyEvent, aType);
    }

// ----------------------------------------------------------------------------
// CLmkByLmContainer::HandleControlEventL()
// Called by framework when the view size is changed
// ----------------------------------------------------------------------------
//

void CLmkByLmContainer::HandleControlEventL(CCoeControl* aControl,
        TCoeEvent aEventType)
    {
    if (aEventType == EEventStateChanged && aControl == iFindBox)
        {
        SelectorImpl().ProcessCommandL(ELmkCmdFindBoxSearchAfresh);
        }
    }

// -----------------------------------------------------------------------------
//CLmkByLmContainer::HandleResourceChange
// -----------------------------------------------------------------------------
//
void CLmkByLmContainer::HandleResourceChange(TInt aType)
    {
    CCoeControl::HandleResourceChange(aType);
    if (aType == KEikDynamicLayoutVariantSwitch)
        {
        (static_cast<CLmkByLmView *> (&iView))->Update();
        }

    if (iListBox)
        {
        iListBox->DrawNow();
        }
    if (iFindBox && iFindBox->IsVisible())
        {
        iFindBox->DrawNow();
        }
    }

// ----------------------------------------------------------------------------
// CLmkByLmContainer::GetSelectedLandmarksL
// ----------------------------------------------------------------------------
//
TInt CLmkByLmContainer::GetSelectedLandmarksL(
        RPointerArray<CPosLandmark> &aArray)
    {
    return (static_cast<CLmkAppLmSelectorImpl*> (iSelector))->GetSelectedLandmarksL(
            aArray);
    }

// ----------------------------------------------------------------------------
// CLmkByLmContainer::IsLandmarkEmptyL
// ----------------------------------------------------------------------------
//
TBool CLmkByLmContainer::IsLandmarkDataEmptyL(CPosLandmark* aLandmark)
    {
    return (static_cast<CLmkAppLmSelectorImpl*> (iSelector))->IsLandmarkDataEmptyL(
            aLandmark);
    }

// ----------------------------------------------------------------------------
// CLmkByLmContainer::FocusChanged()
// ----------------------------------------------------------------------------
//
void CLmkByLmContainer::FocusChanged(TDrawNow aDrawNow)
    {
    if (iListBox)
        {
        iListBox->SetFocus(IsFocused(), aDrawNow);
        }
    if (iFindBox && iFindBox->IsVisible())
        {
        iFindBox->SetFocus(IsFocused(), aDrawNow);
        }
    }

// ----------------------------------------------------------------------------
// CLmkByLmContainer::IsEditorOpened()
// ----------------------------------------------------------------------------
//
TBool CLmkByLmContainer::IsEditorOpened()
    {
    return iIsEditorOpened;
    }

// ----------------------------------------------------------------------------
// CLmkByLmContainer::SetEditorOpenedBool()
// ----------------------------------------------------------------------------
//
void CLmkByLmContainer::SetEditorOpenedBool(TBool aBoolvalue)
    {
    iIsEditorOpened = aBoolvalue;
    }

// ----------------------------------------------------------------------------
// CLmkByLmContainer::UpdateMskContainerL()
// ----------------------------------------------------------------------------
//
void CLmkByLmContainer::UpdateMskContainerL()
    {
    CLmkBaseView* view = reinterpret_cast<CLmkBaseView*> (&iView);
    view->UpdateMskViewL(ResolveMskDisplayItem());
    }

// ---------------------------------------------------------
// CLmkByLmContainer::MenuBar
// ---------------------------------------------------------
//
CEikMenuBar* CLmkByLmContainer::MenuBar()
    {
    return ViewAppUi()->View(TUid::Uid(ELmkByLmView))->MenuBar();
    }

// ---------------------------------------------------------
// CLmkByLmContainer::ContextSpecificMenuBar
// ---------------------------------------------------------
//
TInt CLmkByLmContainer::ContextSpecificMenuBar()
    {
    return R_LMK_OK_MENUBAR;
    }

// ---------------------------------------------------------
// CLmkByLmContainer::SetHandlePointerEventBool
// ---------------------------------------------------------
//
void CLmkByLmContainer::SetHandlePointerEventBool(TBool aBoolValue)
    {
    iHandlePointerEvent = aBoolValue;
    }

#ifdef RD_SCALABLE_UI_V2
// ---------------------------------------------------------
// CLmkByLmContainer::HandlePoineteventL
// ---------------------------------------------------------
//
void CLmkByLmContainer::HandlePointerEventL( const TPointerEvent& aPointerEvent )
    {
    CCoeControl::HandlePointerEventL(aPointerEvent);
    }

#endif//RD_SCALABLE_UI_V2
// End of File