/*

* Copyright (c) 2010 Ixonos Plc.

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the "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:

* Ixonos Plc

*

* Description:  

 *

*/

//  INCLUDES

#include <fbs.h>

#include <aknview.h>

#include <aknutils.h>

#include <AknIconUtils.h>

#include <ImageEditorUi.mbg>

#include <AknLayoutScalable_Avkon.cdl.h>

#include <AknLayoutScalable_Apps.cdl.h>

#include <eiklabel.h>

#ifdef RD_TACTILE_FEEDBACK 

#include <touchfeedback.h>

#endif /* RD_TACTILE_FEEDBACK  */

#include "ImageEditorUI.hrh"

#include "ImageEditorUiDefs.h"

#include "SingleParamControl.h"

#include "PreviewControlBase.h"

#include "SingleParamControlObserver.h"

#include "PluginInfo.h"

#include "CustomControlPanics.h"

// constants

const TReal KTouchSensitivity = 0.5;

const TInt KBorderPartsNum = 9;

const TInt KSliderPartsNum = 4;

const TInt KTouchSliderPartsNum = 7;

const TInt KSliderWidth = 20;

const TInt KScrollRepeatTimeout = 250000; // 0.25 seconds

//=============================================================================

EXPORT_C CSingleParamControl * CSingleParamControl::NewL (

		const TRect & aRect,

		CCoeControl * aParent,

		TBool aActionOnButtonRelease

)

	{

	CSingleParamControl * self = new (ELeave) CSingleParamControl;

	CleanupStack::PushL (self);

	self->ConstructL (aRect, aParent, aActionOnButtonRelease);

	CleanupStack::Pop (); // self

	return self;

	}

//=============================================================================

EXPORT_C CSingleParamControl::CSingleParamControl()

: iDragging( EFalse ),

iActionOnButtonRelease( EFalse ),

iTouchRect(0,0,0,0),

iMinimumValue(0),

iMaximumValue(1),

iStep(0),

iStepInPixels(0),

iNumberOfSteps(0),

iPosition(0),

iMarkerPressed( EFalse )

	{

	}

//=============================================================================

EXPORT_C void CSingleParamControl::ConstructL (

		const TRect & /*aRect*/,

		CCoeControl * aParent,

		TBool aActionOnButtonRelease

)

	{

	//	Set parent

	SetContainerWindowL (*aParent);

	TFileName iconFile (KImageEditorUiMifFile);

	// create popup and slider graphics

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

		{

		CEikImage* image = new (ELeave) CEikImage;

		image->CreatePictureFromFileL(iconFile,

				EMbmImageeditoruiQgn_graf_popup_trans_center + 2*i,

				EMbmImageeditoruiQgn_graf_popup_trans_center_mask + 2*i);

		CleanupStack::PushL( image );

		image->SetContainerWindowL( *this );

		iBorders.AppendL( image );

		CleanupStack::Pop( image );

		}

	if( AknLayoutUtils::PenEnabled() )

		{

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

			{

			CEikImage* image = new (ELeave) CEikImage;

			image->CreatePictureFromFileL(iconFile,

					EMbmImageeditoruiQgn_graf_nslider_end_left + 2*i,

					EMbmImageeditoruiQgn_graf_nslider_end_left_mask + 2*i);

			CleanupStack::PushL( image );

			image->SetContainerWindowL( *this );

			iScrollBar.AppendL( image );

			CleanupStack::Pop( image );

			}

		}

	else

		{

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

			{

			CEikImage* image = new (ELeave) CEikImage;

			image->CreatePictureFromFileL(iconFile,

					EMbmImageeditoruiQgn_graf_nslider_imed_end_left + 2*i,

					EMbmImageeditoruiQgn_graf_nslider_imed_end_left_mask + 2*i);

			CleanupStack::PushL( image );

			image->SetContainerWindowL( *this );

			iScrollBar.AppendL( image );

			CleanupStack::Pop( image );

			}

		}

	iText = new (ELeave) CEikLabel;

	iText->SetContainerWindowL( *this );

	iActionOnButtonRelease = aActionOnButtonRelease;

#ifdef RD_TACTILE_FEEDBACK 

    iTouchFeedBack = MTouchFeedback::Instance();

#endif /* RD_TACTILE_FEEDBACK  */

	EnableDragEvents();

	//	Activate control

	ActivateL();

	}

//=============================================================================

EXPORT_C CSingleParamControl::~CSingleParamControl()

	{

	iBorders.ResetAndDestroy();

	iScrollBar.ResetAndDestroy();

	if (iIcon)

		{

		delete iIcon;

		}

	delete iText;

	iParObserver = NULL;

	iItem = NULL;

	iEditorView = NULL;

	}

//=============================================================================

EXPORT_C void CSingleParamControl::SetView (CAknView * aView)

	{

	iEditorView = aView;

	}

EXPORT_C void CSingleParamControl::SetIcon(CEikImage* aIcon)

	{

	iIcon = aIcon;

	}

EXPORT_C void CSingleParamControl::SetCaption(const TDesC& aText)

	{

	iText->SetTextL( aText );

	}

//=============================================================================

EXPORT_C void CSingleParamControl::SetSelectedUiItemL (CPluginInfo * aItem)

	{

	iItem = aItem;

	}

//=============================================================================

EXPORT_C TKeyResponse CSingleParamControl::OfferKeyEventL (

		const TKeyEvent & aKeyEvent,

		TEventCode aType

)

	{

	if ( Busy() )

		{

		return EKeyWasConsumed;

		}

	else

		{

		if (EEventKey == aType)

			{

			switch (aKeyEvent.iCode)

				{

				case EKeyRightArrow:

					{

					if ( iPosition == iMaximumValue )

						{

						return EKeyWasConsumed;

						}

					MoveSlider(1);

					if( iActionOnButtonRelease )

						{

						iEditorView->HandleCommandL (EImageEditorCmdRender);

						DrawDeferred();

						}				

					return EKeyWasConsumed;

					}

				case EKeyLeftArrow:

					{

					if ( iPosition == iMinimumValue )

						{

						return EKeyWasConsumed;

						}

					MoveSlider(-1);

					if( iActionOnButtonRelease )

						{

						iEditorView->HandleCommandL (EImageEditorCmdRender);

						DrawDeferred();

						}	

					return EKeyWasConsumed;

					}

				case EKeyOK:

				case EKeyEnter:

					{

					// Cancel plug-in if no changes made

					iEditorView->HandleCommandL (EImageEditorApplyPlugin);

					return EKeyWasConsumed;

					}

				case EKeyDownArrow:

				case EKeyUpArrow:

					{

					return EKeyWasConsumed;

					}

				default:

					{

					break;

					}

				}

			}

		return EKeyWasNotConsumed;

		}

	}

//=============================================================================

EXPORT_C void CSingleParamControl::HandlePointerEventL(const TPointerEvent &aPointerEvent)

	{

	if( AknLayoutUtils::PenEnabled() )

		{

		if( iTouchRect.Contains( aPointerEvent.iPosition ) )

			{

			TRect markerRect = iScrollBar[KSliderPartsNum - 1]->Rect();

			markerRect.iTl.iX -= KSliderWidth / 2;

			markerRect.iBr.iX += KSliderWidth / 2;

			// marker pressed?

			if( markerRect.Contains( aPointerEvent.iPosition ) )

				{

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

					{

					iDragging = ETrue;

					iMarkerPressed = ETrue;

#ifdef RD_TACTILE_FEEDBACK

					if ( iTouchFeedBack )

						{

						iTouchFeedBack->InstantFeedback( ETouchFeedbackBasic );

						RDebug::Printf( "ImageEditor::SingleParamControl: ETouchFeedback" );

						}

#endif /* RD_TACTILE_FEEDBACK  */

					DrawDeferred();

					return;

					}

				}

			// marker dragged?

			if (iDragging)

				{

				if( aPointerEvent.iType == TPointerEvent::EButton1Up

						|| aPointerEvent.iType == TPointerEvent::EDrag )

					{

					TInt markerCenter = iScrollBar[KSliderPartsNum - 1]->Rect().iTl.iX

					+ (iScrollBar[KSliderPartsNum - 1]->Rect().iBr.iX

							- iScrollBar[KSliderPartsNum - 1]->Rect().iTl.iX) / 2;

					if(aPointerEvent.iPosition.iX> iScrollBar[KSliderPartsNum - 1]->Rect().iBr.iX)

						{

						MoveSlider((((TReal) (aPointerEvent.iPosition.iX

														- markerCenter))

										/ iStepInPixels) + KTouchSensitivity);

						}

					else if(aPointerEvent.iPosition.iX < iScrollBar[KSliderPartsNum - 1]->Rect().iTl.iX)

						{

						MoveSlider((((TReal) (aPointerEvent.iPosition.iX

														- markerCenter))

										/ iStepInPixels) - KTouchSensitivity);

						}

					}

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

					{

					if( iActionOnButtonRelease )

						{

						iEditorView->HandleCommandL (EImageEditorCmdRender);

						}

					iDragging = EFalse;

					iMarkerPressed = EFalse;

					DrawDeferred();

					}

				if( iActionOnButtonRelease )

					{

					DrawDeferred();

					}

				return;

				}

			// normal moving

			if( aPointerEvent.iType == TPointerEvent::EButton1Down

					|| aPointerEvent.iType == TPointerEvent::EButtonRepeat )

				{

				iMarkerPressed = ETrue;

				if(aPointerEvent.iPosition.iX> iScrollBar[KSliderPartsNum - 1]->Rect().iBr.iX)

					{

					MoveSlider(1);

					if( iActionOnButtonRelease )

						{

						iEditorView->HandleCommandL (EImageEditorCmdRender);

						DrawDeferred();

						}	

					}

				else if(aPointerEvent.iPosition.iX < iScrollBar[KSliderPartsNum - 1]->Rect().iTl.iX)

					{

					MoveSlider(-1);

					if( iActionOnButtonRelease )

						{

						iEditorView->HandleCommandL (EImageEditorCmdRender);

						DrawDeferred();

						}

					}

				Window().RequestPointerRepeatEvent( KScrollRepeatTimeout, iTouchRect );

#ifdef RD_TACTILE_FEEDBACK

					if ( iTouchFeedBack &&

							((aPointerEvent.iPosition.iX < markerRect.iTl.iX) ||

							(aPointerEvent.iPosition.iX > markerRect.iBr.iX)) )

						{

						iTouchFeedBack->InstantFeedback( ETouchFeedbackBasic );

						RDebug::Printf( "ImageEditor::SingleParamControl: ETouchFeedback" );

						}

#endif /* RD_TACTILE_FEEDBACK  */

				return;

				}

			}

		if (iDragging && iMarkerPressed)

			{

			iEditorView->HandleCommandL (EImageEditorCmdRender);

			}

		iDragging = EFalse;

		iMarkerPressed = EFalse;

		DrawDeferred();

		return;

		}

	}

//=============================================================================

EXPORT_C void CSingleParamControl::HandlePluginCommandL (const TInt aCommand)

	{

	//  If soft key 1 pressed

	if (aCommand == EAknSoftkeyOk)

		{

		// Cancel plug-in if no changes made

		iEditorView->HandleCommandL (EImageEditorApplyPlugin);

		}

	//  If soft key 2 pressed

	else if (aCommand == EAknSoftkeyCancel)

		{

		iEditorView->HandleCommandL (EImageEditorCancelPlugin);

		}

	//  Default functionality

	else

		{

		CImageEditorControlBase::HandlePluginCommandL (aCommand);

		}

	}

//=============================================================================

EXPORT_C TInt CSingleParamControl::GetSoftkeyIndexL()

	{

	return 0;

	}

//=============================================================================

EXPORT_C TPtrC CSingleParamControl::GetNaviPaneTextL (

		TBool& aLeftNaviPaneScrollButtonVisibile,

		TBool& aRightNaviPaneScrollButtonVisible )

	{

	aLeftNaviPaneScrollButtonVisibile = EFalse;

	aRightNaviPaneScrollButtonVisible = EFalse;

	// Don't show any text in navi pane

	// The whole if-branch should probably be removed for good

	TBool showNaviPaneText ( EFalse );

	if ( iItem && showNaviPaneText )

		{

		return iItem->PluginName()->Des();

		}

	else

		{

		return TPtrC();

		}

	}

//=============================================================================

EXPORT_C void CSingleParamControl::SetParObserver (MSingleParControlObserver * aObserver)

	{

	iParObserver = aObserver;

	}

//=============================================================================

EXPORT_C void CSingleParamControl::Draw (const TRect & aRect) const

	{

	TInt variety = 0;

	if( AknLayoutUtils::PenEnabled() )

		{

		variety = 1;

		}

	TAknLayoutRect layoutRect;

	layoutRect.LayoutRect( Rect(), AknLayoutScalable_Apps::popup_imed_adjust2_window(variety) );

	TRect parentRect = layoutRect.Rect();

	// centralize the slider

	TPoint topLeft = parentRect.iTl;

	topLeft.iX = (Rect().Width() - parentRect.Width()) / 2;

	parentRect.SetRect(topLeft, parentRect.Size());

	TAknWindowComponentLayout l = AknLayoutScalable_Apps::slider_imed_adjust_pane(variety);

	TAknWindowLineLayout lineLayout = l.LayoutLine();

	layoutRect.LayoutRect(parentRect, lineLayout);

	TRect markerRect = layoutRect.Rect();

	TUint sliderTabWidth = KSliderWidth;

	TUint sliderBitmapWidth = layoutRect.Rect().Width() - sliderTabWidth;

	if ( iMinimumValue < iMaximumValue )

		{

		if(AknLayoutUtils::LayoutMirrored())

			{

        	markerRect.iTl.iX += (iPosition - iMinimumValue)

			* sliderBitmapWidth

			/ (iMaximumValue - iMinimumValue);

			}

		else

			{

			markerRect.iTl.iX += (iPosition - iMinimumValue)

			* sliderBitmapWidth

			/ (iMaximumValue - iMinimumValue);

			}

		iScrollBar[KSliderPartsNum - 1]->SetPosition(markerRect.iTl);

		if( AknLayoutUtils::PenEnabled() )

			{

			iScrollBar[KTouchSliderPartsNum - 1]->SetPosition(markerRect.iTl);

			}

		}

	if (iPreview)

		{

		CPreviewControlBase::DrawPreviewImage (aRect);

		}

	}

//=============================================================================

EXPORT_C TInt CSingleParamControl::CountComponentControls() const

	{

	TInt count = iBorders.Count();

	count += iScrollBar.Count();

	if( AknLayoutUtils::PenEnabled() )

		{

		count--;

		}

	if (iIcon)

		{

		count++;

		}

	count++;

	return count;

	}

//=============================================================================

EXPORT_C CCoeControl* CSingleParamControl::ComponentControl(TInt aIndex) const

	{

	if ( aIndex < iBorders.Count() )

		{

		return iBorders[aIndex];

		}

	TInt touchSelected = 0;

	if( AknLayoutUtils::PenEnabled() )

		{

		touchSelected++;

		}

	if ( aIndex < iBorders.Count() + iScrollBar.Count() - touchSelected )

		{

		if ( iMarkerPressed && (aIndex - iBorders.Count() == 3) )