/*

* Copyright (c) 2003-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:  Implementation of the CMIDDisplayable class

*

*/

#include <bldvariant.hrh>

#include <memory>

#include <apgwgnam.h>

#include <eikenv.h>

#include <coecntrl.h>

#include <uikon.hrh>

// using BaflUtils::CopyWithTruncation in PopulateMenuItemsWithListL function

#include <bautils.h>

// using MMIDImage and MMIDBitmapImage

#include <lcdgr.h>

// macros definitions for resources

#include <lcdui.rsg>

// using TMifLcdui enumeration

#include <lcdui.mbg>

// Used for Avkon toolbar disabling

#include <akntoolbar.h>

// Layout data

#include <layoutmetadata.cdl.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <e32property.h>

//#include <SysStartup.h>

#include <aknappui.h>

// using CAknTitlePane in ShowTitleL() function

#include <akntitle.h>

// using CAknContextPane in SetMIDletIconL() function to show midlet icon

#include <akncontext.h>

// used for label converting for commands (in PopulateMenuItemsWithListL function)

#include <AknBidiTextUtils.h>

#include <avkon.hrh>

#include <avkon.rsg>

#include <AvkonInternalCRKeys.h>

#include <aknstyluspopupmenu.h>

#include <eiklabel.h>

#ifdef RD_SCALABLE_UI_V2

// For requiring available keyboards in the device

#include <PtiEngine.h>

#include <PtiDefs.h>

#endif // RD_SCALABLE_UI_V2

// OMJ storage

#include <applicationinfo.h>

#include <javastorageentry.h>

#include <javastorage.h>

#include <javastoragenames.h>

#include <javauid.h>

#include <javasymbianoslayer.h>

#include "CMIDDisplayable.h"

// API used in several places (iAppUi is member)

#include "CMIDAppUi.h"

#include "CMIDCanvas.h"

// used in SetComponentL function

#include "CMIDDefaultBackground.h"

// API for ticker on displayable

#include "CMIDTicker.h"

#include "CMIDComponentFactory.h"

// used for setting iMenuHandler from iUIManager (MenuHandler)

#include "CMIDUIManager.h"

#include "CMIDCommand.h"

#include "CMIDForm.h"

// using CMIDUtils::CopyBitmapL in SetMIDletIconL() function

#include "CMIDUtils.h"

// used in SetComponentL function

// and used in several place for actions specific for Alert (SetTitleL, ContentSize, HandleCurrentL)

#include "CMIDAlert.h"

#include "CMIDAlertDialog.h"

#include "CMIDEdwin.h"

// used in SetComponentL function

// used in HandleCurrentL function

#include "CMIDTextBoxControl.h"

#include "CMIDTextBoxDialogControl.h"

// used in SetComponentL function

#include "CMIDList.h"

// using API for softkeys and their commands

#include "CMIDSoftKey.h"

#include "CMIDCanvasKeypad.h"

#include "CMIDTicker.h"

#include "coreuiavkonlcdui.h"

#include "coreuiappui.h"

#include <j2me/jdebug.h>

/** This macro is executed each time a trapped call returns an error code different than KErrNone */

#undef  TRAP_INSTRUMENTATION_LEAVE

#define TRAP_INSTRUMENTATION_LEAVE(aResult) DEBUG_INT2("In CMIDDisplayable.cpp, trapped method was called at line %D and got exception %D", __LINE__, aResult);

const TGulBorder::TBorderType KMIDLetBorder = TGulBorder::EThickDeepRaisedWithOutline;

const TInt KCommandIdNotFound = -10000;

const TInt KCommandIdBase = 7000;

const TInt KItemCommandIdBase = 8000; // must be greater than KCommandIdBase

// Special ID for built-in MSK commands. Handling of them is different because

// built-in commands are not visible in menus, only in MSK. Built-in MSK commands

// are commands that are set using SetMSKCommand method, but are not found in

// command lists.

const TInt KBuiltInMSKCommandId = 9000;

// Index of the MSK in CBA, to be used when adding MSK command to CBA

const TInt KMSKPositionInCBA = 3;

/** The maximum number of softkeys on the device.

*/

const TInt KMaxNumberOfSoftKeys = 2;

const TInt KListLongTapAnimationDelay = 400000;

const TInt KListLongTapDelay = 800000;

/*

 * The allowed command types for softkeys,

 *   -1 means we have run out of allowed types.

 * More restrictive sks, eg the right sk, should come

 * before more permissive sks. This array is used to

 * initialise iSoftkeys.

 */

const TInt KAllowedCommandTypesForSoftkeys[KMaxNumberOfSoftKeys][9] =

{

    // Right softkey

    {

        MMIDCommand::EStop,

        MMIDCommand::ECancel,

        MMIDCommand::EBack,

        MMIDCommand::EExit,

        -1,

        -1,

        -1,

        -1,

        -1

    },

    // Left softkey

    {

        MMIDCommand::EStop,

        MMIDCommand::EOk,

        MMIDCommand::ECancel,

        MMIDCommand::EItem,

        MMIDCommand::EScreen,

        MMIDCommand::EBack,

        MMIDCommand::EHelp,

        MMIDCommand::EExit,

        -1

    }

};

/**

  The CBA that can have an options menu if commands are available.

  This is used as a zero-based index in iSoftkeys and must be

  less than KMaxNumberOfSoftKeys.

*/

const TInt KOptionsMenuCBAIndex = 1; //left sk

/**

  The sk position in the CBA. Must use the same ordering as

  KAllowedCommandTypesForSoftkeys and is used to initialise

  iSoftkeys.

*/

const TInt KPositionsInCBAForSoftkeys[KMaxNumberOfSoftKeys] =

{

    2, //Right softkey

    0 //Left softkey

};

// One ticker can be added more than one displayable. So keep track of all of them

const TInt KAddDisplayable = 1; // add the displable to the list in ticker

const TInt KRemoveDisplayable = 0; // Remove the displable from the list in ticker

const TInt KSoftKeyLabelPropertyPositionsMSKIndex = 2;

const TInt KSoftKeyLabelPropertyPositionsInCBA[ KSoftKeyLabelPropertyNumberOfSoftKeys ] =

{

    0,  //LSK

    2,  //RSK

    3   //MSK

};

// class CMIDDisplayable

CMIDDisplayable* CMIDDisplayable::NewL(MMIDEnv& aEnv,CMIDUIManager& aUIManager)

{

    CMIDDisplayable* displayable = new(ELeave)CMIDDisplayable(aEnv,aUIManager);

    CleanupStack::PushL(displayable);

    displayable->ConstructL();

    CleanupStack::Pop(displayable);

    return displayable;

}

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

//

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

//

void CMIDDisplayable::ConstructL()

{

    DEBUG("+ CMIDDisplayable::ConstructL");

    // Menu/commands

    // NOTE: Menu handler member variable has to be valid before

    // the <code>CCoeContol::MakeVisible</code> method is called

    // because the <code>CMIDDisplayable::MopSupplyObject</code> method

    // might be called because of that.

    iMenuHandler = iUIManager->OpenMenuHandlerL();

    iCommandList = new(ELeave) CMIDCommandList();

    iCommandList->SetCommandOffset(KCommandIdBase);

    iMSKCommand = NULL;

    iDisplayableBehindPopup = NULL;

    iEnv.AddObserverL(*this);

    CreateWindowL(&iEikonEnv->RootWin());

    SetMopParent(java::ui::CoreUiAvkonLcdui::getInstance().getJavaAknAppUi());

    //All windows are created invisible and then made visible

    //in SetComponentL(), except for Alerts (dialogs)

    MakeVisible(EFalse);

    Window().SetOrdinalPosition(-1);

    Window().EnableOnEvents(EEventControlOnlyWhenVisible);

    EnableDragEvents();

    // Long tap detection

    iLongTapDetector = CAknLongTapDetector::NewL(this);

    // SoftKeys

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

    {

        CMIDSoftKey* softKey = CMIDSoftKey::NewLC(i, &(KAllowedCommandTypesForSoftkeys[i][0]),

                               KPositionsInCBAForSoftkeys[i]);

        User::LeaveIfError(iSoftKeys.Append(softKey));

        CleanupStack::Pop(softKey);

    }

    // CBA

    iCba = iMenuHandler->Cba();

    UpdateDisplayableRect();

    SetRect(iDisplayableRect);

    iBorder = TGulBorder::ENone;

    SetComponentsToInheritVisibility();

    // for Skin Support, Create background control context:

    iBackGroundControlContext = CAknsBasicBackgroundControlContext::NewL(

                                    KAknsIIDQsnBgAreaMain,  // Default mainpane skinning

                                    Rect(),                 // Layout to the entire client rect

                                    EFalse);

    iAppUi->Displayables().AppendL(this);

    iAppUi->SetEnv(iEnv);

    ActivateL();

    //Read JAD attribute value for On-Screen Keypad softkeys visual appearence with HW QWERTY keypad

    if (iEnv.MidletAttributeIsSetToVal(

                LcduiMidletAttributes::KAttribOskSoftkeysInQwerty,

                LcduiMidletAttributeValues::KPositionBottom))

    {

        iSKPositionWithQwerty = ESoftkeysBottom;

    }

    else

    {

        //default value

        iSKPositionWithQwerty = ESoftkeysRight;

    }

    // initialization of keypad information

    ReadOnScreenKeypadTypeFromSuiteSettings();

    DEBUG("- CMIDDisplayable::ConstructL");

}

CMIDDisplayable::CMIDDisplayable(MMIDEnv& aEnv,CMIDUIManager& aUIManager)

#ifdef RD_TACTILE_FEEDBACK

#endif //RD_TACTILE_FEEDBACK

{

#ifdef RD_JAVA_S60_RELEASE_9_2

    iSplitScreenKeyboard = EFalse;

#endif // RD_JAVA_S60_RELEASE_9_2

    iAppUi = (CMIDAppUi*)java::ui::CoreUiAvkonLcdui::getInstance().getJavaUiAppUi()->getLcduiChild();

}

CMIDDisplayable::~CMIDDisplayable()

{

    DEBUG("+ CMIDDisplayable::CMIDDisplayable");

    // iPropertyWatch is CPropertyWatch object,

    // delete member call desctructor of CPropertyWatch

    // and remove active object form active scheduler

    if (iPropertyWatch)

    {

        delete iPropertyWatch;

        iPropertyWatch = NULL;

    }

    // Informing iEnv about deleting this

    iEnv.DisplayableIsDestructed(this);

    // Remove this from iEnv observer

    iEnv.RemoveObserver(*this);

    if (iAppUi)

    {

        iAppUi->RemoveFromStack(iContentControl);

        TInt index = iAppUi->Displayables().Find(this);

        if (index != KErrNotFound)

        {

            iAppUi->Displayables().Remove(index);

        }

    }

    delete iLongTapDetector;

    delete iStylusPopupMenu;

    delete iTitle;

#ifdef RD_SCALABLE_UI_V2

    iUIManager->CloseCanvasKeypad(iCanvasKeypad);

    iCanvasKeypad = NULL;

#endif //RD_SCALABLE_UI_V2

#ifdef RD_TACTILE_FEEDBACK

    if (iPenInputServerConnected)

    {

        iPenInputServer.Close();

        iPenInputServerConnected = EFalse;

    }

#endif //RD_TACTILE_FEEDBACK

    // if ticker is present in this displayable and displayable is

    // deleted but ticker is not, tell the ticker that displayable is

    // garbage collected.

    if (iTicker)

    {

        TRAP_IGNORE(iTicker->SetDisplayableL(this, KRemoveDisplayable));

    }

    delete iBackGroundControlContext;

    iBackGroundControlContext = NULL;

    iSoftKeys.ResetAndDestroy();

    delete iCommandList;

    if (iMenuHandler->GetDisplayable() == this)

    {

        //this may happen when the application is exiting

        iMenuHandler->SetDisplayable(NULL);

    }

    DEBUG("- CMIDDisplayable::CMIDDisplayable");

}

/**

 * This means we are being deleted java side. We delete ourselves.

 * However before doing this we call ReplaceBehindAlertIfNeeded().

 **/

void CMIDDisplayable::Dispose()

{

    ReplaceBehindAlertIfNeeded();

    delete this;

}

/**

 * This method is called when we are deleted java side, from Dispose().

 * This code should only execute when java side they decide to delete the

 * displayable immeditately behind a showing alert. We check if we are a

 * displayable behind an alert. If so we find another displayable (the

 * one with lowest ordinal position, ie the top most displayable except us

 * and the alert). If we find one we make it visible so that the alert will

 * not end up with a white background.

 **/

void CMIDDisplayable::ReplaceBehindAlertIfNeeded()

{

    if ((this != iUIManager->GetDefaultDisplayable())

            && IsVisible()

            && (iMenuHandler->GetDisplayable())

            && (iMenuHandler->GetDisplayable()->Component()->Type() == EAlert))

    {

        // In this case we are a faded displayable behind a dialog

        TInt numDisplayables = iAppUi->Displayables().Count();

        TInt index = -1;

        TInt currentPosition = 999;

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

        {

            CMIDDisplayable* disp = iAppUi->Displayables()[i];

            if ((disp != this) && (disp->DrawableWindow()->OrdinalPosition() < currentPosition)

                    && (disp->Component()->Type() != EAlert))

            {

                currentPosition = disp->DrawableWindow()->OrdinalPosition();

                index = i;

            }

        }

        if (index != -1)

        {

            CMIDDisplayable* disp = iAppUi->Displayables()[index];

            disp->MakeVisible(ETrue);

        }

    }

}

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

{

    CWindowGc& gc = SystemGc();

    if (!iDirectContentsRegion.IsEmpty())

    {

        gc.CancelClippingRect();

        iUpdateRegion.Clear();

        iUpdateRegion.AddRect(aRect);

        // Remove occupied areas out from update region

        iUpdateRegion.SubRegion(iDirectContentsRegion);

        // Set the update region for the context

        gc.SetClippingRegion(iUpdateRegion);

    }

    if (iContent->Type() != ECanvas)

    {

        // Draw background

        MAknsSkinInstance* skin = AknsUtils::SkinInstance();

        AknsDrawUtils::Background(skin, iBackGroundControlContext, this, gc, aRect);

    }

    iBorder.Draw(gc, Rect());

}

TInt CMIDDisplayable::CountComponentControls() const

{

    TInt count=0;

    if (iContentControl)

    {

        ++count;

    }

    return count;

}

CCoeControl* CMIDDisplayable::ComponentControl(TInt aIndex) const

{

    switch (aIndex)

    {

    case 0:

        return iContentControl ? iContentControl: 0;

    default:

        return 0;

    }

}

void CMIDDisplayable::SizeChanged()

{

    if (iBackGroundControlContext)

    {

        iBackGroundControlContext->SetRect(Rect());

    }

    Layout();

}

/**

 * Use the commands in aCommandList to create menu items and add them to aItems.

 */

void CMIDDisplayable::PopulateMenuItemsWithListL

(

    const CMIDMenuHandler::TMenuType& aMenuType, //The type of menu

    RArray<CEikMenuPaneItem::SData>& aItems, //The items that will be added to the menu

    CMIDCommandList* aCommandList, //The list of commands to be examined

    TBool aSeparator

)

{

    if (!aCommandList)

    {

        return;

    }

    const TBool isItemCommands = (aCommandList == iItemCommandList);

    CMIDCommandList* list = aCommandList;

    CEikMenuPaneItem::SData item;

#ifdef RD_JAVA_S60_RELEASE_9_2

    // implicitList is used when creating options menu content.

    TBool implicitList = EFalse;

    if (iContent && iContent->Type() == EList && iContentControl)

    {

        CMIDList* list = static_cast<CMIDList*>(iContentControl);

        implicitList = list->ListChoiceType() == MMIDChoiceGroup::EImplicit;

    }

#endif // RD_JAVA_S60_RELEASE_9_2

    const TInt count = list->Count();

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

    {