/*

* Copyright (c) 2007-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:  Compatibility mode keyboard UI component

*

*/

#include <e32base.h>

#include <AknsUtils.h> 

#include <AknsSkinInstance.h>

#include <AknsDrawUtils.h>

#include <AknsBasicBackgroundControlContext.h>

#include <centralrepository.h>

#include <AvkonInternalCRKeys.h>

#include <pslninternalcrkeys.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include "akncompakb.h"

#include "akncompaside.h"

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

//

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

CAknCompaKb* CAknCompaKb::NewL(TInt aCompaScreenMode, TBool aMakeVisible)

    {

    CAknCompaKb* self = new (ELeave) CAknCompaKb(aCompaScreenMode);

    CleanupStack::PushL(self);

    self->ConstructL(aMakeVisible);

    CleanupStack::Pop(self);

    return self;

    }

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

//

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

void CAknCompaKb::ConstructL(TBool aMakeVisible)

    {

    // Connect to key server is not delayed until buttons are pressed

    // as we don't want application to fail while it's executing due

    // to a key press.

    // Optimization: akncapserver/aknnfysrv/eiksrv have compakeyboard

    // always instantiated. akncapserver/aknnfysrv simulate raw events

    // without compakeysrv. Eikon server doesn't have capability to

    // simulate raw events directly. In this case connection to the key

    // server press is delayed until a key is pressed. This way key server

    // is not running all the time.

    RProcess process;

    TSecureId secureId = process.SecureId();

    iFlags.iInEikSrv = AknCompaUtils::IsEikSrv(secureId);

    iFlags.iInAknCapSrv = AknCompaUtils::IsAknCapSrv(secureId);

    iFlags.iInGlobalUiSrv = AknCompaUtils::IsGlobalUiSrv(secureId);

    if (!iFlags.iInGlobalUiSrv)

        {

        User::LeaveIfError(iCompaSrvSession.Connect());

        iThemesCenRep = CRepository::NewL(KCRUidThemes);

        }

    // Transition effects do not work in compa-mode (centered window). They

    // are disabled when screen mode is compa-mode. In case device was

    // powered off while effects were disabled, restore transition effects

    // state.

    if (iFlags.iInAknCapSrv)

        {

        // Enable transition effects if device was powered off while

        // we had them disabled.

        if (iCompaSrvSession.Connect() == KErrNone)

            {

            iCompaSrvSession.RestoreTransEffects();

            iCompaSrvSession.Close();

            }

        }

    CreateWindowL();

    RWindow& window = Window();

    // Prevent fading when application displays a dialog

    window.SetNonFading(ETrue);

    // Ordinal priority is not usually set for application windows

    // (only for window groups). Compa keyboard is set to high ordinary

    // priority. This keeps it always at front and prevents other windows

    // (eg. menus, dialogs) capturing pointer events.

    // If an application would set one it's own windows to higher

    // priority, it could capture pointer events but menus and dialogs

    // wouldn't work either in that case.

    const TInt KOrdinalPriority = ECoeWinPriorityAlwaysAtFront + 1;

    window.SetOrdinalPosition(window.OrdinalPosition(), KOrdinalPriority);

    // Request pointer up event event if stylus is dragged out of this window

    window.SetPointerGrab(ETrue);

    // Capture pointer events from this window group. This prevents

    // touch working in application window even when the application

    // doesn't observe layout's PenEnabled.

    window.SetPointerCapture(RWindowBase::TCaptureEnabled);

    iBgContext = CAknsBasicBackgroundControlContext::NewL(

        KAknsIIDQsnBgScreen, Rect(), ETrue);

    // Get skin background, this method is used to update it also

    SkinChanged();

    // Construct buttons

    AknCompaUtils::ReadButtonsL(iButtons, iPenButtonIndex, *iCoeEnv);

    for(TInt i = 0; i < iButtons.Count(); i++)

        {

        CAknCompaButton* button = iButtons[i];

        button->SetContainerWindowL(*this);

        button->SetObserver(button);

        }

    iLeftSide = CAknCompaSide::NewL();

    iRightSide = CAknCompaSide::NewL();

    // Set constrol and buttons size and position. If control is left

    // invisible, screen mode is not compa-mode and layout is postponed

    // until screen mode is compa-mode.

    if (aMakeVisible)

        {

        LayoutControl();

        }

    // Add to control stack to receive KEikDynamicLayoutVariantSwitch

    // events

    iCoeEnv->AppUi()->AddToStackL(this, ECoeStackPriorityDefault,

        ECoeStackFlagRefusesAllKeys);

    iCoeEnv->AddForegroundObserverL(*this);

    // Compa-mode keyboard is made visible in the case of a normal

    // applications. Compa-keyboard is also created for servers

    // that display global/notes notifications but left invisible.

    // Visibility of the keyboard is controlled according to current

    // screen mode. It's visible only in compa screen mode. Note:

    // It's also possible for a screen mode to change (e.g. due to

    // some application exiting) while a global note is on display.

    if (aMakeVisible)

        {

        ActivateL();

        }

    }

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

// Constructor

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

CAknCompaKb::CAknCompaKb(TInt aCompaScreenMode):

    iButtons(EButtonsGranularity)

    {

    iCompaScreenMode = aCompaScreenMode;

    }

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

// Destructor

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

CAknCompaKb::~CAknCompaKb()

    {

    iCoeEnv->AppUi()->RemoveFromStack(this);

    iCoeEnv->RemoveForegroundObserver(*this);

    iButtons.ResetAndDestroy();

    delete iLeftSide;

    delete iRightSide;

    delete iBgContext;

    // Keyserver sends up events if client has any keys in down state

    // when session is closed

    iCompaSrvSession.Close();

    delete iThemesCenRep;

    }

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

// Simulate a key press to application

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

void CAknCompaKb::SimulateKeyPressL(TInt aScanCode, TBool aDown)

    {

    if (!iFlags.iInGlobalUiSrv)

        {

        // Key press is simulated via a server as SwEvent capability

        // is needed

        iCompaSrvSession.SimulateKeyEventL(aScanCode, aDown);

        }

    else if (iFlags.iInEikSrv)

        {

        // Eikon server. Connect to key server only when needed.

        // Connection to key server should succeed as it is already

        // started by an application that set screen mode to compa.

        if (iCompaSrvSession.Handle() == KNullHandle)

            {

	        User::LeaveIfError( iCompaSrvSession.Connect() );

            }

        if (iCompaSrvSession.Handle() != KNullHandle)

            {

            iCompaSrvSession.SimulateKeyEventL(aScanCode, aDown);

            }

        }

    else

        {

        // akncapserver and aknnfysrv don't use compakeysrv

        TRawEvent rawEvent;        

        rawEvent.Set(

            aDown ? TRawEvent::EKeyDown:TRawEvent::EKeyUp, aScanCode);

        RWsSession& wsSession = iCoeEnv->WsSession();

        wsSession.SimulateRawEvent(rawEvent);

        wsSession.Flush();

        }

    }

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

// Set "pen" button to up state

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

void CAknCompaKb::SetPenButtonUpL()

    {

    if (iPenButtonIndex != KErrNotFound)

        {

        CAknCompaButton* compaButton = iButtons[iPenButtonIndex];

        if (compaButton->IsPressed())

            {

            compaButton->SetButtonUpL();

            }

        }

    }

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

// Set buttons to up state

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

void CAknCompaKb::SetButtonsUpL()

    {

    TInt cnt = iButtons.Count();

    for(TInt i = 0; i < cnt; i++)

        {

        CAknCompaButton* compaButton = iButtons[i];

        if (compaButton->IsPressed())

            {

            compaButton->SetButtonUpL();            

            }

        }

    }

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

// Check is compa-mode application is on foreground

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

TBool CAknCompaKb::IsForeground()

    {

    // Voice command application is launched on top of foreground application

    // in QHD mode. If it is launched on top of compa-mode application

    // the screen gets messed up. Compa-mode app is showing behind voice

    // dialer but wserv right shifting is lost. Workaround for this is to

    // switch idle screen to foreground before voice commander is launched.

    // Switch to idle screen if this is a regular application or if global

    // note is showing on top of compa-mode application.

    return !iFlags.iInGlobalUiSrv || InCompaScreenMode();

    }

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

// Disable transition effects in compa-mode

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

void CAknCompaKb::DisaTransEffects(bool aDisable)

    {

    // Transition effects cannot be disabled per application. They can be

    // disabled globally from central repository. Transition effects are

    // disabled whenever screen mode changes to compa-mode by AknCapServer.

    if (iFlags.iInAknCapSrv && iFlags.iEffectsDisa != aDisable)

        {

        if (iCompaSrvSession.Handle() == KNullHandle)

            {

            }

            {

            if (aDisable)

                {

                iCompaSrvSession.DisaTransEffects();

                }

            else

                {

                iCompaSrvSession.RestoreTransEffects();

                iCompaSrvSession.Close();

                }

            iFlags.iEffectsDisa = aDisable;

            }

        }

    }

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

// Return wanted layout rectangle

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

TRect CAknCompaKb::RectFromLayout( const TRect& aParent,

    const TAknWindowComponentLayout& aComponentLayout )

    {

    TAknLayoutRect layoutRect;

    layoutRect.LayoutRect(aParent, aComponentLayout.LayoutLine());

    return layoutRect.Rect();

    }

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

// Layout compamode controls

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

void CAknCompaKb::LayoutControl()

    {   

    TPoint origin =

        iCoeEnv->ScreenDevice()->GetScreenModeOrigin(iCompaScreenMode);

    TRect screenRect;

    AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EScreen, screenRect);

    // parent rect for all compamode components      

    iCompaRect = RectFromLayout(screenRect,

        AknLayoutScalable_Avkon::compa_mode_pane());

    TRect compaKbRect = RectFromLayout(iCompaRect,

        AknLayoutScalable_Avkon::compa_mode_pane_g3());

    AknCompaUtils::ScaleRect(compaKbRect, -origin.iX, 0);    

    SetRect(compaKbRect);    

    // side controls

    TRect leftSide = RectFromLayout(iCompaRect,

        AknLayoutScalable_Avkon::compa_mode_pane_g1());

    TRect rightSide = RectFromLayout(iCompaRect,

        AknLayoutScalable_Avkon::compa_mode_pane_g2());

    AknCompaUtils::ScaleRect(rightSide, -origin.iX, 0); 

    iRightSide->SetRect(rightSide);

    // Support for not centered compa window.

    // Left side control has to be moved to other side if not centered

    if(origin.iX == 0)

        {

        origin.iX -= screenRect.Width();

        }

    AknCompaUtils::ScaleRect(leftSide, -origin.iX, 0);   

    iLeftSide->SetRect(leftSide);

    LayoutButtonControls();   

    SetSkinBackground();

    iFlags.iLayoutDone = ETrue;

    }

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

// Layout button controls

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

void CAknCompaKb::LayoutButtonControls()

    {                  

    TRect rockerRect = RectFromLayout(iCompaRect,

        AknLayoutScalable_Avkon::main_comp_mode_rocker_pane_cp());

    TRect ituRect = RectFromLayout(iCompaRect,

        AknLayoutScalable_Avkon::main_comp_mode_itu_pane_cp());

    if (iButtons.Count() > 0)

        {

        TAknLayoutScalableParameterLimits buttonLimits =

            AknLayoutScalable_Avkon::cell_cmode_rocker_pane_cp_ParamLimits();

        // Calculating number of rocker pane buttons

        iRockerGridSize = ((buttonLimits.LastRow() + 1) *

            (buttonLimits.LastColumn() + 1));

        TInt buttonCount = 0;

        LayoutButtonGrid(rockerRect, buttonCount, buttonLimits.LastRow(),

            buttonLimits.LastColumn());

        buttonLimits =

            AknLayoutScalable_Avkon::cell_cmode_itu_pane_cp_ParamLimits();

        LayoutButtonGrid(ituRect, buttonCount, buttonLimits.LastRow(),

            buttonLimits.LastColumn());

        for(TInt i = 0; i < iButtons.Count(); i++)

            {

            CAknCompaButton* button = iButtons[i];        

            TRect rect = button->Rect();    

            AknCompaUtils::ScaleRect(rect, 0, -iCompaRect.Height());

            button->SetRect(rect);    

            button->UpdateColors();

            button->LayoutIconAndText();

            }

        }

    }

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

// Layout grid of buttons

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

void CAknCompaKb::LayoutButtonGrid(TRect aParentRect, TInt& aButtonCount,

    TInt aRows, TInt aColumns)

    {

    for(TInt row = 0; row <= aRows; row++)

        {

        for(TInt col = 0; col <= aColumns; col++)

            {

            if(aButtonCount < iRockerGridSize)

                {

                AknLayoutUtils::LayoutControl(iButtons[aButtonCount],

                    aParentRect, AknLayoutScalable_Avkon::

                    cell_cmode_rocker_pane_cp(0,col,row));

                }

            else

                {

                AknLayoutUtils::LayoutControl(iButtons[aButtonCount],

                    aParentRect, AknLayoutScalable_Avkon::

                    cell_cmode_itu_pane_cp(0,col,row));

                }

            aButtonCount++;

            }

        }

    }

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

// 

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

void CAknCompaKb::SetSkinBackground()

    {

    TPoint origin =

        iCoeEnv->ScreenDevice()->GetScreenModeOrigin(iCompaScreenMode);

    TPoint origo(0, 0);

    // Skin background context

    iBgContext->SetParentPos(origo);

    AknCompaUtils::ScaleRect(iCompaRect, -origin.iX, 0);

    iBgContext->SetRect(iCompaRect);

    iLeftSide->SetBackground(origin);

    iRightSide->SetBackground(origin);

    }

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

// Check if current screen mode is compa-mode

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

TBool CAknCompaKb::InCompaScreenMode()

    {

    return iCoeEnv->ScreenDevice()->CurrentScreenMode() ==

        iCompaScreenMode;

    }

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

//

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

TInt CAknCompaKb::CountComponentControls() const

    {

    return iButtons.Count();

    }

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

//

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

CCoeControl* CAknCompaKb::ComponentControl(TInt aIndex) const

    {

    return iButtons[aIndex];

    }

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

//

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

void CAknCompaKb::Draw(const TRect& aRect) const

    {

    CWindowGc& gc = SystemGc();

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    // If skin background draw fails, flat color will be used

    if(!AknsDrawUtils::Background(skin, iBgContext, this, gc, aRect))

        {

        gc.SetBrushStyle(CGraphicsContext::ESolidBrush);

        gc.SetPenColor(iSkinColor);

        gc.SetBrushColor(iSkinColor);     

        gc.DrawRect(Rect());

        }

    gc.SetBrushStyle(CGraphicsContext::ESolidBrush);

    gc.SetPenColor(iSkinColor);

    gc.SetBrushColor(iSkinColor);

    // Draw background rects for rocker buttons.

    // These are drawn under the buttons to achieve transparency effect.    

    for(TInt i = 0; i < iButtons.Count(); i++)

        {

        CAknCompaButton* button = iButtons[i];

        if (button->IsRocker())

            {

            gc.DrawRect(button->Rect());

            }

        }  

    }

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

//

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

void CAknCompaKb::HandleResourceChange(TInt aType)

    {

    switch(aType)

        {

        // Compa-mode application is fixed to QVGA layout and cannot change.

        // When Avkon notify server is displaying a global note, it's

        // possible for layout to change. Compa-keyboard is hidden if

        // screen mode changes out of compa-mode.

        case KEikDynamicLayoutVariantSwitch:

            {

            TBool isScreenModeCompa = InCompaScreenMode();

            if (isScreenModeCompa && !iFlags.iLayoutDone)

                {

                // In global UI-servers, buttons size and position is set

                // only when compa-mode is entered first time.

                if (!iFlags.iLayoutDone)

                    {

                    LayoutControl();

                    // In practise ActivateL() will not leave as it allocates

                    // no resources

                    TRAP_IGNORE(ActivateL());

                    }

                }

            else