// 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:
// Implements the query dialog box used for asking users input on row 
// and column resize.\n
// Also implements the Grid Window which handles the user 
// inputs on the Grid Table.\n
// Copy of COEGRID.CPP except for OfferKeyEvent and HandlePointerEvent\n
// Copy of COEGRID.CPP except for OfferKeyEvent and HandlePointerEvent
// 
//

/**
 @file
 @internalComponent - Internal Symbian test code
*/

#include <coemain.h>
#include "COEGRID.H"

#define KGridPointerRepeatDelayInMicroSeconds	10000

#define KGridRectForPointerRepeats		(TRect(-1000,-1000,1000,1000))

/**
  Static function to construct the Grid Window.\n
  Grid Window is a control on which the Grid table is displayed .\n
  Invokes the second phase constructor.\n
 
  @return : Pointer to the newly constructed Grid window.\n
 
*/
CGrid2Win* CGrid2Win::NewL(CCoeControl* aWin,CGridLay *aGridLay,CGridImg *aGridImg)
	{
	CGrid2Win *self=new(ELeave) CGrid2Win(aGridLay,aGridImg);
	CleanupStack::PushL(self);
	self->ConstructL(aWin);
	CleanupStack::Pop();
	return self;
	}
/**
  Two argument Constructor.\n
  Constructs a Grid Window taking GridLay and Grid Img as arguments.\n
*/
CGrid2Win::CGrid2Win(CGridLay *aGridLay,CGridImg *aGridImg)
	: iGridLay(aGridLay),
	iGridImg(aGridImg)
	{}
/**
  Second phase constructor for the Grid Window.\n
  Creates a control's window which is the child of the application's window group.\n
  Allows pointer grabs in a window in order to receive pointer events.\n
  Sets the window as the default window.\n
*/
void CGrid2Win::ConstructL(CCoeControl* aWin)
	{
	CreateWindowL(aWin);
	Window().PointerFilter(EPointerFilterDrag,0);
	Window().SetPointerGrab(ETrue);
	iGridImg->SetWindow(&Window());
	if (iGridLay->IsIndefiniteRowBoundaries())
		iGridLay->SetUniformRowHeight(ETrue);
	}
/**
  Destructor for Grid Window.\n
*/
CGrid2Win::~CGrid2Win()
	{
	}
/**
  
  @return Pointer to the GridLay object owned by the Grid Window.\n
 
  The function is invoked in case modifications 
  need to be made to the layout of the grid.\n
*/
CGridLay* CGrid2Win::GridLay() const
	{
	return iGridLay;
	}
/**
  @return Pointer to the GridImg object owned by the Grid Window.\n
 
  The function is invoked whenever there is a need to redraw the contents of the grid.\n
*/
CGridImg* CGrid2Win::GridImg() const
	{
	return iGridImg;
	}
/**
  Draws the Grid Window.\n
  The function is invoked by the window server.\n
  This function is used for window server-initiated redrawing of controls,
  and for some application-initiated drawing.\n
  It should be implemented by each control.\n
 
*/
void CGrid2Win::Draw(const TRect& aRect) const
	{
	CWindowGc& gc=SystemGc();
	gc.DrawRect(Rect());
	TRAPD(err,iGridImg->DrawL(&gc,aRect));
	__ASSERT_ALWAYS(!err,User::Panic(_L("DrawL(&gc,aRect) 2"),err));
	}
/**
  The function provides handlers for various key events such as \n
  Ctrl+ KeyUpArrow.\n
  Ctrl+ KeyDownArrow.\n
  Ctrl+ KeyRightArrow.\n
  Ctrl+ KeyLeftArrow.\n
  Ctrl+ KeyHome.\n
  Ctrl+ KeyEnd.\n
  Ctrl+ KeyPageup.\n
  Ctrl+ KeyPageDown.\n
  KeyUpArrow.\n
  KeyDownArrow.\n 
  KeyRightArrow.\n
  KeyLeftArrow.\n
  KeyHome.\n
  KeyEnd.\n
  KeyPageup.\n
  KeyPageDown.\n
  The function differs from the corresponding function in CGridWin as the
  Resize mode is not taken into consideration while handling the key events.\n
 
  @return : TKeyResponse indicating whether the key event has been handled or not.\n
 
*/
TKeyResponse CGrid2Win::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode /*aType*/)
// Tells GridImg to do the appropriate action on a keypress.
	{
	TUint selectState=0;
	if (aKeyEvent.iModifiers&EModifierCtrl)
		{
		switch (aKeyEvent.iCode)
			{
		case EKeyUpArrow:
			iGridImg->MoveCursorL(EMovePageUp,selectState);
			break;
		case EKeyDownArrow:
			iGridImg->MoveCursorL(EMovePageDown,selectState);
			break;
		case EKeyLeftArrow:
			iGridImg->MoveCursorL(EMovePageLeft,selectState);
			break;
		case EKeyRightArrow:
			iGridImg->MoveCursorL(EMovePageRight,selectState);
			break;
		case EKeyHome:
			iGridImg->MoveCursorL(EMoveHome,selectState);
			break;
		case EKeyEnd:
			iGridImg->MoveCursorL(EMoveEnd,selectState);
			break;
		case EKeyPageUp:
			iGridImg->MoveCursorL(EMoveColumnStart,selectState);
			break;
		case EKeyPageDown:
			iGridImg->MoveCursorL(EMoveColumnEnd,selectState);
			break;
		default:
			return EKeyWasNotConsumed;
			}
		}
	else
		{
		switch (aKeyEvent.iCode)
			{
		case EKeyUpArrow:
			iGridImg->MoveCursorL(EMoveRowUp,selectState);
			break;
		case EKeyDownArrow:
			iGridImg->MoveCursorL(EMoveRowDown,selectState);
			break;
		case EKeyLeftArrow:
			iGridImg->MoveCursorL(EMoveColumnLeft,selectState);
			break;
		case EKeyRightArrow:
			iGridImg->MoveCursorL(EMoveColumnRight,selectState);
			break;
		case EKeyPageUp:
			iGridImg->MoveCursorL(EMovePageUp,selectState);
			break;
		case EKeyPageDown:
			iGridImg->MoveCursorL(EMovePageDown,selectState);
			break;
		case EKeyHome:
			iGridImg->MoveCursorL(EMoveRowStart,selectState);
			break;
		case EKeyEnd:
			iGridImg->MoveCursorL(EMoveRowEnd,selectState);
			break;
		default:
			return EKeyWasNotConsumed;
			}
		}
	return EKeyWasConsumed;
	}
/**
  The function provides handlers for Pointer events.\n
  Handles the following pointer events \n
  1. Pointer Drag.\n
  2. Double click event.\n
  3. Pointer Button Down.\n
*/
void CGrid2Win::HandlePointerEventL(const TPointerEvent& aPointerEvent)
	{
	//
	// Tells GridImg to do the appropriate action on a pointer event
	//
    if (aPointerEvent.iType==TPointerEvent::EDrag || aPointerEvent.iType==TPointerEvent::EButtonRepeat
		&& !iGridImg->MainRect().Contains(aPointerEvent.iPosition))
		{
        Window().RequestPointerRepeatEvent(KGridPointerRepeatDelayInMicroSeconds,KGridRectForPointerRepeats);
		}
	TPointerEvent event=aPointerEvent;
	if (event.iType==TPointerEvent::EButtonRepeat)
		event.iType=TPointerEvent::EDrag;
	else if (event.iModifiers&EModifierDoubleClick)
		event.iType=TPointerEvent::EButton1Down;

	if (event.iType == TPointerEvent::EButton1Up)
		iGridImg->FinishLabelDragL();
	else if (event.iType == TPointerEvent::EButton1Down)
		{
		if (!iGridImg->StartLabelDrag(event.iPosition))
			iGridImg->SetCursorWithPointerL(event.iPosition,0);
		}
	else if (event.iType == TPointerEvent::EDrag)
		{
		if (!iGridImg->UpdateLabelDrag(event.iPosition))
			iGridImg->SetCursorWithPointerL(event.iPosition,CGridImg::EIsWithDrag);
		}
	}
/**
  Shrinks the Grid. 
  The shrinking is achieved by adding value of (1,1) to the top left corner.\n
  and subtracting the same coordinates from the bottom right corner of the grid.\n
*/
void CGrid2Win::SizeChanged()
	{
	TRect rect(Size());
	rect.Shrink(1,1);
	iGridImg->SetGridRect(rect);
	iGridLay->ResetVisibleToCell();
	}
/**
  Draw the cell corresponding to the reference.\n
  Calls the DrawCellL function of the CGridImg class.\n
*/
void CGrid2Win::DrawCellL(const TCellRef& aCell) const
	{
	iGridImg->DrawCellL(aCell);
	}
/**
  Draws the rectangle corresponding to the range.\n
  Invokes the DrawRangeL function of the CGridImg class.\n
*/
void CGrid2Win::DrawRangeL(const TRangeRef& aRange) const
	{
	iGridImg->DrawRangeL(aRange);
	}
/**
  Draws the currently selected region.\n
  Invokes the corresponding function of the CGridImg class.\n
*/
void CGrid2Win::DrawSelectedL() const
	{
	iGridImg->DrawSelectedL();
	}
/**
  @return the cell reference where the cursor is located.\n
 
  Delegates the task to the corresponding function of CGridImg function.\n
*/
TCellRef CGrid2Win::CursorPos() const
	{
	return iGridImg->CursorPos();
	}
/**
  Sets the cursor position to the cell reference sent as an argument.\n
*/
void CGrid2Win::SetCursorPosL(const TCellRef& aCursorPos) const
	{
	iGridImg->SetCursorPosL(aCursorPos);
	}
/**
  Scrolls the grid by the minimum necessary to 
  allow the specified cell to become visible.\n
  The offset to the cell required to be visible is calculated and 
  a scroll operation is performed.\n
*/
void CGrid2Win::ExposeCellL(const TCellRef& aCell) const
	{
	TPoint offset=iGridLay->ExposeCell(aCell);
	iGridImg->ScrollL(offset);
	}