// Copyright (c) 2005-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:

//

/**

 @file

 @internalComponent - Internal Symbian test code  

*/

#include <coeaui.h>

#include <coemain.h>

#include <coecntrl.h>

#include <coesndpy.h>

#include <e32keys.h>

#include <basched.h>

#include <bassnd.h>

#include "TMenu1Step.h"

//#include <e32test.h>

//RTest test(_L("tmenu1"));

//#define FORCE_AUT

// class CTestMenu1

/**

  Returns the number of bytes a menu item actually consists of.\n

*/

TInt TSimpleMenuItem::RealLengthOfData() const

    {

    return(sizeof(TSimpleMenuItem)-(ENominalTextLength-iText.Length())*sizeof(TText));

    }

/**

  Destructor\n

  Frees all memory allocated by the menu and fonts.\n

*/

CTestMenu1::~CTestMenu1()

    {

    FreeData();

    iCoeEnv->ReleaseScreenFont(iFont);

    }

/**

  Creates a font.\n

*/

void CTestMenu1::CreateFontL()

    {

    TFontSpec spec(_L("Arial"),240);

    iFont=iCoeEnv->CreateScreenFontL(spec);

    }

/**

  Handles pointer events.\n

  Closes the menu if pointer button has been pressed or been released

  and the pointer is outside the displayed menu.\n

  If inside, find out where and highlight the correct menu item. Report

  the event if pointer button was released.\n

*/

void CTestMenu1::HandlePointerEventL(const TPointerEvent& aPointerEvent)

    {

    TRect rect=Rect();

    if (!rect.Contains(aPointerEvent.iPosition))

        {

        switch (aPointerEvent.iType)

            {

        case TPointerEvent::EButton1Down:

        case TPointerEvent::EButton1Up:

            CloseMenu();

        default:

            break;

            }

        }

    rect.Shrink(EBorderWidth,EBorderWidth);

    if (!rect.Contains(aPointerEvent.iPosition))

        return;

    TInt n=(aPointerEvent.iPosition.iY-EBorderWidth)/iFont->HeightInPixels();

    HighlightTo(n);

    if (aPointerEvent.iType==TPointerEvent::EButton1Up)

        {

        ReportSelectionMadeL();

        CloseMenu();

        }

    }

/**

  Display the entire menu with the selected item hilighted.\n

 */

void CTestMenu1::Draw(const TRect& /*aRect*/) const

    {

    CWindowGc& gc=SystemGc();

    TRect rect=Rect();

    gc.DrawRect(rect);

    rect.Shrink(1,1);

    gc.SetPenColor(KRgbWhite);

    gc.DrawRect(rect);

    PrepareGcForDrawingItems();

    TInt count=iItemArray->Count();

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

        DrawItem(i,i==iItemSelected);

    }

/**

  Prepares the system graphical context.\n

 */

void CTestMenu1::PrepareGcForDrawingItems() const

    {

    CWindowGc& gc=SystemGc();

    gc.UseFont(iFont);

    gc.SetBrushStyle(CGraphicsContext::ESolidBrush);

    }

/**

  Display a menu item either hilighted or not.\n

 */

void CTestMenu1::DrawItem(TInt aItem,TInt aHighlight) const

    {

    TInt itemHeight=iFont->HeightInPixels();

    TPoint tl(2,2+aItem*itemHeight);

    TSize sz(iSize.iWidth-4,itemHeight);

    TRect rect(tl,sz);

    CWindowGc& gc=SystemGc();

    if (!aHighlight)

       	{

        gc.SetPenColor(KRgbBlack);

        gc.SetBrushColor(KRgbWhite);

        }

    else

       	{

        gc.SetPenColor(KRgbWhite);

        gc.SetBrushColor(KRgbBlack);

        }

    TSimpleMenuItem& tmp=(*iItemArray)[aItem];

    gc.DrawText(tmp.iText,rect,iFont->AscentInPixels());

    }

/**

  Report to the window which menu item was selected.\n

 */

void CTestMenu1::ReportSelectionMadeL()

    {

    TSimpleMenuItem& tmp=(*iItemArray)[iItemSelected];

    iObserver->MenuSelectionMadeL(tmp.iCommand);

    }

/**

  Binds hot keys to menu items.\n

 */

void CTestMenu1::InitializeHotKeyCommands()

    {

    iHotKeyCommand[CTRL('b')]=EMenuCommandBold;

    iHotKeyCommand[CTRL('i')]=EMenuCommandItalic;

    iHotKeyCommand[CTRL('u')]=EMenuCommandUnderline;

    iHotKeyCommand[CTRL('s')]=EMenuCommandStrikethrough;

    iHotKeyCommand[CTRL('a')]=EMenuCommandAddWindow;

    iHotKeyCommand[CTRL('r')]=EMenuCommandRemoveWindow;

    iHotKeyCommand[CTRL('d')]=EMenuCommandDrag;

    iHotKeyCommand[CTRL('e')]=EMenuCommandExit;

    iHotKeyCommand[CTRL('c')]=EMenuCommandColor;

    iHotKeyCommand[CTRL('p')]=EMenuCommandPlaySound;

    }

/**

  Second phase constructor for the test menu.\n

 */

void CTestMenu1::ConstructL(MTestMenu1MenuObserver* aObserver,CCoeAppUi* aStack)

    {

    iObserver=aObserver;

    iStack=aStack;

    InitializeHotKeyCommands();

	CreateFontL();

    }

/**

  Frees the memory the menu occupied.\n

 */

void CTestMenu1::FreeData()

    {

    delete(iItemArray);

    iItemArray=NULL;

    }

/**

  Closes the menu if it is displayed.\n

 */

void CTestMenu1::CloseMenu()

    {

    if (!iDisplayed)

        return;

    CloseWindow();

    iDisplayed=EFalse;

    FreeData();

    }

/**

  Constructs a single menu item.\n

 */

void CTestMenu1::AddMenuItemL(TMenuCommand aCommand,const TDesC& aText)

    {

    TSimpleMenuItem tmp;

    tmp.iCommand=aCommand;

    tmp.iText=aText;

    iItemArray->AppendL(tmp,tmp.RealLengthOfData());

    }

/**

  Adds individual menu items.\n

 */

void CTestMenu1::DoLoadDataL()

    {

    AddMenuItemL(EMenuCommandBold,_L("Toggle bold (Ctrl+B)"));

    AddMenuItemL(EMenuCommandItalic,_L("Toggle italic (Ctrl+I)"));

    AddMenuItemL(EMenuCommandUnderline,_L("Toggle underline (Ctrl+U)"));

    AddMenuItemL(EMenuCommandStrikethrough,_L("Toggle strikethrough (Ctrl+S)"));

    AddMenuItemL(EMenuCommandAddWindow,_L("Add window (Ctrl+A)"));

    AddMenuItemL(EMenuCommandRemoveWindow,_L("Remove window (Ctrl+R)"));

    AddMenuItemL(EMenuCommandDrag,_L("Toggle drag enablement (Ctrl+D)"));

    AddMenuItemL(EMenuCommandColor,_L("Override colours (Ctrl+C)"));

    AddMenuItemL(EMenuCommandPlaySound,_L("Play sounds (Ctrl+P)"));

    AddMenuItemL(EMenuCommandExit,_L("Exit (Ctrl+E)"));

    }

/**

  Constructs a menu.\n

 */

void CTestMenu1::LoadDataL()

    {

    iItemArray=new(ELeave) CArrayVarFlat<TSimpleMenuItem> (16);

    TRAPD(ret,DoLoadDataL());

    if (ret)

        {

        FreeData();

        User::Leave(ret);

        }

    }

/**

  Calculates the size of all items in the menu.\n

 */

void CTestMenu1::CalculateSize(TSize& aSize)

    {

    TInt count=iItemArray->Count();

    aSize.iHeight=count*iFont->HeightInPixels();

    aSize.iHeight+=2+2; // 2 pixels at top and 2 at bottom

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

        {

        TSimpleMenuItem& tmp=(*iItemArray)[i];

        TInt itemWidth=iFont->TextWidthInPixels(tmp.iText);

        if (itemWidth>aSize.iWidth)

            aSize.iWidth=itemWidth;

        }

    aSize.iWidth+=2+2; // 2 pixels at left and 2 at right

    }

/**

  Creates a menu in a newly created window.\n

 */

void CTestMenu1::CreateMenuL()

    {

    LoadDataL();

    TRAPD(err,CreateWindowL());

    if (err)

        {

        FreeData();

        User::Leave(err);

        }

    EnableDragEvents();

    SetPointerCapture();

    iDisplayed=ETrue;

    TSize size;

    CalculateSize(size);

    SetExtent(TPoint(5,5),size);

    ActivateL();

    }

/**

  Hilights the current menu item.\n

 */

void CTestMenu1::HighlightTo(TInt aNewItemSelected)

    {

    if (aNewItemSelected==iItemSelected)

        return;

    ActivateGc();

    PrepareGcForDrawingItems();

    DrawItem(iItemSelected,EFalse);

    iItemSelected=aNewItemSelected;

    DrawItem(iItemSelected,ETrue);

	DeactivateGc();

    }

/**

  The method is an override from CCoeControl.\n

  The function is called to handle key events.\n

  Handles the up and down arrow keys which hilights previous/next item in the menu.\n

  PageUp causes first item in menu to be hilighted and PageDown causes the last to be hilighted.\n

  The enter key executes the current menu item.\n

  The escape key closes the menu.\n

  F9 and Tab show the menu.\n

  If <Ctrl> + key is pressed it is checked if it is a hot key. If so execute the menu selection.\n

 */

TKeyResponse CTestMenu1::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)

    {

	if (aType!=EEventKey)

		return(EKeyWasNotConsumed);

    TInt modifiers=aKeyEvent.iModifiers;

    TInt code=aKeyEvent.iCode;

    if ((modifiers&EAllStdModifiers)==EModifierCtrl)

        {

        if (code<27)

            {

            TMenuCommand command=iHotKeyCommand[code];

            if (command)

                {

                iObserver->MenuSelectionMadeL(command);

                CloseMenu();

                }

            }

        return(EKeyWasConsumed);

        }

    if (!iDisplayed)

        {

        if (code==EKeyF9 || code==EKeyTab)

            {

            CreateMenuL();

            return(EKeyWasConsumed);

            }

        }

    else

        {

        TInt count=iItemArray->Count();

        switch (code)

            {

			case EKeyDownArrow:

				if (iItemSelected<count-1)

					HighlightTo(iItemSelected+1);

				break;

			case EKeyUpArrow:

				if (iItemSelected)

					HighlightTo(iItemSelected-1);

				break;

			case EKeyPageUp:

				HighlightTo(0);

				break;

			case EKeyPageDown:

				HighlightTo(count-1);

				break;

			case EKeyEnter:

				ReportSelectionMadeL();

			case EKeyEscape:

				CloseMenu();

				break;

			default:

				break;

            }

        return(EKeyWasConsumed);

        }

    return(EKeyWasNotConsumed);

    }

//

// class CMenu1MessageControl

//

void CMenu1MessageControl::ToggleDragState()

    {

    TInt filter=EPointerFilterDrag; // means to filter out drags

    if (iDragsEnabled)

        {

        iDragsEnabled=EFalse;

        SetMessage(_L8("Pointer drag events disabled"));

        }

    else

        {

        iDragsEnabled=ETrue;

        SetMessage(_L8("Pointer drag events enabled"));

        filter=0;

        }

    BackedUpWindow().PointerFilter(EPointerFilterDrag,filter);

    }

/**

  Second phase constructor for CMenu1MessageControl.\n

  Creates a control's window.\n

  The created window is the child of the application's window group.\n

  Sets a Font and display a message.\n

 */

void CMenu1MessageControl::ConstructL()

    {

    CreateBackedUpWindowL(iCoeEnv->RootWin(),EGray2);

    SetExtent(TPoint(20,20),TSize(600,200));

    TFontSpec spec(_L("Arial"),220);

    SetFontL(spec);

    SetMessage(_L8("Press Tab for Menu..."));

    ActivateL();

    }

/**

  Destructor for the CMenu1MessageControl class.\n

  Calls the ReleaseScreenFont API of CCoeEnv to free all resources used by the font.\n

 */

CMenu1MessageControl::~CMenu1MessageControl()

    {

    iCoeEnv->ReleaseScreenFont(iFont);

	//delete iPeriodic;

    }

/**

  Auxiliary Function to a set a new font.\n

 */

void CMenu1MessageControl::SetFontL(const TFontSpec& aFontSpec)

    {

    CFbsFont* font=iCoeEnv->CreateScreenFontL(aFontSpec);

    iCoeEnv->ReleaseScreenFont(iFont); // after previous line succeeds

    iFont=font;

    iFontSpec=aFontSpec;

    }

/**

  Auxiliary Function to change the font style.\n

 */

void CMenu1MessageControl::ToggleFontStyleL(TMessageControlFontStyle aStyleElement)

    {

    TFontSpec spec=iFontSpec;

    TBool doSet=EFalse;

    switch (aStyleElement)

        {

		case EStyleElementBold:

			spec.iFontStyle.SetStrokeWeight(spec.iFontStyle.StrokeWeight()? EStrokeWeightNormal: EStrokeWeightBold);

			doSet=ETrue;

			break;

		case EStyleElementItalic:

			spec.iFontStyle.SetPosture(spec.iFontStyle.Posture()? EPostureUpright: EPostureItalic);

			doSet=ETrue;

			break;

		case EStyleElementUnderline:

			iFontUnderline=(iFontUnderline? EUnderlineOff: EUnderlineOn);

			break;

		case EStyleElementStrikethrough:

			iFontStrikethrough=(iFontStrikethrough? EStrikethroughOff: EStrikethroughOn);

        }

    if (doSet)

        SetFontL(spec); // otherwise change effective at Draw time

    DrawMessageNow();

    }

/**

  Handles Pointer events.\n

  Just logs that a pointer events has happend and redraws the window.\n

 */

void CMenu1MessageControl::HandlePointerEventL(const TPointerEvent& aPointerEvent)

    {

    iMessage.Format(_L8("Pointer event %d at (%d,%d)"),aPointerEvent.iType,aPointerEvent.iPosition.iX,aPointerEvent.iPosition.iY);

    DrawMessageNow();

    }

/**

  Responds to focus change.\n

  This function is called whenever a control gains or loses focus\n

  as a result of a call to SetFocus().\n

 */

void CMenu1MessageControl::FocusChanged(TDrawNow aDrawNow)

	{

    if (aDrawNow)

        {

        ActivateGc();

        DrawBorder();

        DeactivateGc();

        }

    }

/**

  Draws a border around the window CMessageControl owns.\n

 */

void CMenu1MessageControl::DrawBorder() const

	{

    CWindowGc& gc=SystemGc();

    TRect rect=Rect();

    gc.DrawRect(rect);

    if (!IsFocused())

        gc.SetPenColor(KRgbWhite);

    rect.Shrink(1,1);

    gc.DrawRect(rect);

    rect.Shrink(1,1);

    gc.DrawRect(rect);

	}

/**

  Draws border and display a message in the window CMenu1MessageControl owns.\n

 */

void CMenu1MessageControl::Draw(const TRect& /*aRect*/) const

    {

    DrawBorder();

    DrawMessage();

    }

/**

  Displays a message stored in iMessage centered both vertically and horisontally.\n

 */

void CMenu1MessageControl::DrawMessage() const

    {

    TRect rect=Rect();

    rect.Shrink(3,3);

    TInt ascent=(rect.iBr.iY-rect.iTl.iY-iFont->HeightInPixels())/2 + iFont->AscentInPixels();

    CWindowGc& gc=SystemGc();

    gc.SetPenColor(KRgbBlack);

	gc.UseFont(iFont);

    if (iFontUnderline)

        gc.SetUnderlineStyle(iFontUnderline);

    if (iFontStrikethrough)

        gc.SetStrikethroughStyle(iFontStrikethrough);