/*

* 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 <resize.mbg>

#include <resize.rsg>

#include <aknutils.h> 

#include <aknglobalnote.h>

#include <ConeResLoader.h> 

#include <stringloader.h>

#include "SingleParamControl.h"

#include "SystemParameters.h"

#include "ResizeControl.h"

#include "ImageEditorResizePlugin.h"

#include "PluginInfo.h"

/// CONSTANTS

_LIT (KPgnResourceFile, "resize.rsc");

_LIT (KResourceDir, "\\resource\\apps\\");

const TInt KResizeHSTitleIndex = 0;

const TInt KMinDimension = 25;

const TInt KMaxCaptionLength = 50;

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

CResizeControl * CResizeControl::NewL (const TRect&	aRect, CCoeControl*	aParent)

{

	CResizeControl * self = new (ELeave) CResizeControl;

	CleanupStack::PushL (self);

	self->ConstructL (aRect, aParent);

	CleanupStack::Pop ();   // self

	return self;

}

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

CResizeControl::CResizeControl() 

{

	// EMPTY

}

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

CResizeControl::~CResizeControl()

{

	delete iControl;

    iControl = NULL;

    iParamArray.Reset();

//    iEditorView = NULL;

    iSysPars = NULL;

    iPluginInfo = NULL;

    iParameters = NULL;

    delete iBufBitmap;

}

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

void CResizeControl::ConstructL (

    const TRect &   aRect, 

    CCoeControl *   aParent

    )

{

	//	Set parent

	SetContainerWindowL (*aParent);

	iControl = CSingleParamControl::NewL (aRect, aParent);

    ((CSingleParamControl *)iControl)->SetParObserver ( (MSingleParControlObserver*)this );

//	aPluginControl = iControl;

	//	Activate control

    ActivateL();

}

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

void CResizeControl::SetView (CAknView * aView)

{

	((CSingleParamControl *)iControl)->SetView(aView);

//    iEditorView = aView;

}

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

void CResizeControl::SetSelectedUiItemL (CPluginInfo * aItem)

{

	iPluginInfo = aItem;

}

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

void CResizeControl::PrepareL ()

{

}

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

TKeyResponse CResizeControl::OfferKeyEventL (

    const TKeyEvent &       aKeyEvent, 

    TEventCode              aType

    )

{

    TKeyResponse response = EKeyWasNotConsumed;

    if ( Busy() )

	{

        response = EKeyWasConsumed;

    }

    else if (aType != EEventKey  )

    {

        switch (aKeyEvent.iScanCode)

		{   

		    // Just consume these keys (No EEventKey type event delivered for 

		    // these keys so this must be done here)

		    case EStdKeyRightShift:

		    case EStdKeyLeftShift:

			{

				response = EKeyWasConsumed;

                break;

			}

		}

    }

    else if (EEventKey == aType)

	{

        switch (aKeyEvent.iCode)

        {

            // Just consume the keys

		    case 0x31: // 1

		    case 0x32: // 2

		    case 0x33: // 3

            case 0x37: // 7

		    case 0x38: // 8

		    case 0x39: // 9

			case EKeyDownArrow:

			case EStdKeyDecVolume:

			case 0x30:			

			case EKeyUpArrow:

			case EStdKeyIncVolume:

            case 0x35:

            case 0x2a: // *

		    case 0x23: // #

//			case EKeyLeftArrow:

//			case EKeyRightArrow:

			{

				response = EKeyWasConsumed;

                break;

			}

		    case 0x34: // 4

			{

				TKeyEvent kevent;

				TEventCode ecode = EEventKey;

				kevent.iCode = EKeyLeftArrow;

				iControl->OfferKeyEventL(kevent, ecode);

				response = EKeyWasConsumed;

                break;

			}

            case 0x36: // 6 

			{

				TKeyEvent kevent;

				TEventCode ecode = EEventKey;

				kevent.iCode = EKeyRightArrow;

				iControl->OfferKeyEventL(kevent, ecode);

				response = EKeyWasConsumed;

                break;

			}

            default:

            {

                response = iControl->OfferKeyEventL(aKeyEvent, aType);

            }

        }

    }

	return response;

}

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

void CResizeControl::HandlePointerEventL( const TPointerEvent &aPointerEvent )

{

    return iControl->HandlePointerEventL( aPointerEvent );

}

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

TInt CResizeControl::CountComponentControls() const

{

	TInt count(0);

	if (iControl)

	{

		++count;

	}

    return count;

}

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

CCoeControl * CResizeControl::ComponentControl (TInt aIndex) const

{

	switch (aIndex) 

	{

		case 0:

			{

			return iControl;

			}

		default:

			{

			return 0;

			}

	}

}

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

void CResizeControl::HandlePluginCommandL (const TInt aCommand)

	{

	return ((CSingleParamControl *)iControl)->HandlePluginCommandL(aCommand);

/*

	switch(aCommand)

		{

		case EPgnSoftkeyIdCancel:

			{

			iEditorView->HandleCommandL (EImageEditorCancelPlugin);

			break;

			}

		case EPgnSoftkeyIdOk:

			{

				if ( iControl->Position() != iInitPosition )

				{

					((CImageEditorUIView*)iEditorView)->

						ShowConfirmationNoteL(iPluginInfo->Parameters()[KResolutionChangedTextIndex] );

					iEditorView->HandleCommandL (EImageEditorApplyPlugin);

				}

				else

				{

					iEditorView->HandleCommandL (EImageEditorCancelPlugin);

				}

            }

		}

*/

	}

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

TInt CResizeControl::GetSoftkeyIndexL ()

{

    return 0;

}

/*

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

TPtrC CResizeControl::GetNaviPaneTextL (

    TBool& aLeftNaviPaneScrollButtonVisibile, 

    TBool& aRightNaviPaneScrollButtonVisible )

{

    aLeftNaviPaneScrollButtonVisibile = EFalse;

    aRightNaviPaneScrollButtonVisible = EFalse;

    // .loc file parameter format strings

    _LIT(KParameter1, "%0N");

    _LIT(KParameter2, "%1N");

    // Getting string from resources

    TPtrC ptr = iPluginInfo->Parameters()[KStatusPaneTextIndex]; 

    // Finding format patterns

    TInt pos1 = ptr.Find(KParameter1);

    TInt pos2 = ptr.Find(KParameter2);

    if(pos1 == KErrNotFound || pos2 == KErrNotFound)

        {

        User::Leave(KSIEEInternal);

        }

    // Clear navi pane 

    iNaviPaneText.Zero();

    // Add new text and replace format strings with new resolution

    iNaviPaneText.Append(ptr.Left(pos1));

    iNaviPaneText.AppendNum (iSize.iWidth);

    iNaviPaneText.Append (ptr.Mid(pos1 + 3, pos2 - (pos1 + 3)));

    iNaviPaneText.AppendNum (iSize.iHeight);

	iNaviPaneText.Append (ptr.Mid(pos2 + 3));

    return iNaviPaneText;

	}

*/

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

TBitField CResizeControl::GetDimmedMenuItems ()

{

    return TBitField();

}

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

void CResizeControl::SetSystemParameters (CSystemParameters * aSysPars, CImageEditorResizePlugin* aParent)

{

    iSysPars = aSysPars;

	ComputeAndSetSliderParameters(aParent);

}

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

void CResizeControl::SizeChanged()

{

	iControl->SetRect(Rect());

}

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

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

{

    // Fill the background with black

    CWindowGc & gc = SystemGc();

	gc.SetPenStyle (CGraphicsContext::ESolidPen);

	gc.SetPenColor (KRgbBlack);

	gc.SetBrushStyle (CGraphicsContext::ESolidBrush);

	gc.SetBrushColor (KRgbBlack);

    if ( iPreview && iPreview->Handle() )

    {

		if ( ((CSingleParamControl *)iControl)->Position() == iInitPosition )

		{

			gc.BitBlt ( TPoint(0,0), iPreview );

		}

		else

		{

			gc.Clear (aRect);

			TReal ratio = (TReal)iSize.iHeight / (TReal)iOrigSize.iHeight;

			TInt w = (TInt)(ratio * (TReal)Rect().Width());

			TInt h = (TInt)(ratio * (TReal)Rect().Height());

			TRect target;

			target.iTl.iX = ((Rect().Width() - w) >> 1);

			target.iTl.iY = ((Rect().Height() - h) >> 1);

			target.iBr.iX = ((Rect().Width() + w) >> 1) + 1;

			target.iBr.iY = ((Rect().Height() + h) >> 1) + 1;

			TRect rect ( iPreview->SizeInPixels() );

			//rect.iBr.iX++;

			//rect.iBr.iY++;

			gc.DrawBitmap (target, iPreview, rect);

		}

    }

}

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

void CResizeControl::ComputeAndSetSliderParameters (CImageEditorResizePlugin* aParent) 

{

    //  Store image size

    TInt width = 

        (iSysPars->ViewPortRect().iBr.iX - 

        iSysPars->ViewPortRect().iTl.iX);

    TInt height = 

        (iSysPars->ViewPortRect().iBr.iY - 

        iSysPars->ViewPortRect().iTl.iY);

    iOrigSize = TSize (

        (TInt)(iSysPars->Scale() * width + 0.5), 

        (TInt)(iSysPars->Scale() * height + 0.5)

        );

	ComputeImageSizes();

    //  Set slider properties

    TInt count = iParamArray.Count();

    if ( count > 0 )

    {

		((CSingleParamControl *)iControl)->SetSliderMinimumAndMaximum(0, iParamArray.Count() - 1);

    }

    else

    {

		((CSingleParamControl *)iControl)->SetSliderMinimumAndMaximum(0, 0);

    }

    ((CSingleParamControl *)iControl)->SetSliderStep(1);

    iInitPosition = 0;

    width = (TInt)(iSysPars->Scale() * width + 0.5);

    height = (TInt)(iSysPars->Scale() * height + 0.5);

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

    {

        if ( (width == iParamArray[i]) || ((height == iParamArray[i])) )

        {

			((CSingleParamControl *)iControl)->SetSliderPosition(i);

			iInitPosition = i;

        }

    }

    ComputeSizeAndScale();

    TFileName iconFile (KResourceDir);

	TBuf<256> readbuf;

	User::LeaveIfError ( aParent->GetProperty (KCapIconName, readbuf) );

	iconFile.Append(readbuf);

    CEikImage* icon = new (ELeave) CEikImage;

	icon->CreatePictureFromFileL(iconFile,

								 EMbmResizeQgn_indi_imed_downple_super);

	((CSingleParamControl *)iControl)->SetIcon(icon);

	// Get caption from plugin properties

	User::LeaveIfError ( aParent->GetProperty (KCapPluginParamNames, readbuf) );

	TLex parser;

	parser.Assign (readbuf);

    TInt tempval = 0;

	parser.Val ( tempval );

    iParameters = (CDesCArray *)tempval;

    // Format the resolutions

    TBuf< KMaxCaptionLength > caption_temp;

    TBuf< KMaxCaptionLength > caption;

    StringLoader::Format( caption_temp, (*iParameters)[KResizeHSTitleIndex], 0, iSize.iWidth );

    StringLoader::Format( caption, caption_temp, 1, iSize.iHeight );

    ((CSingleParamControl *)iControl)->SetCaption( caption );

}

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

void CResizeControl::ComputeSizeAndScale() 

{

	//	Compute current image size and scale

	TReal ar = (TReal)iOrigSize.iWidth / (TReal)iOrigSize.iHeight;

    if ( iOrigSize.iHeight < iOrigSize.iWidth )

	{

		iSize.iHeight = iParamArray[ ((CSingleParamControl *)iControl)->Position() ];

		iSize.iWidth = (TReal)(ar * iSize.iHeight) + 0.5; 

	}

	else

	{

		iSize.iWidth = iParamArray[ ((CSingleParamControl *)iControl)->Position() ];		

		iSize.iHeight = (TReal)(iSize.iWidth / ar) + 0.5; 

	}

    iSysPars->Scale() = 

        (TReal)iSize.iHeight / 

        (TReal)((iSysPars->ViewPortRect().iBr.iY - 

        iSysPars->ViewPortRect().iTl.iY));

}

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

void CResizeControl::ComputeImageSizes()

{

	const TSize KQSXGASize(2592, 1944);

	const TSize KQXGASize(2048, 1536);

	const TSize KUXGASize(1600, 1200);

	const TSize KSXGASize(1280, 960);

	const TSize KSVGASize(800, 600);

	const TSize KVGASize(640, 480);

	const TSize KQVGASize(320, 240);

#ifdef RESIZE_CIF_SIZES_SUPPORTED

	const TSize KCIFSize(352, 288);

	const TSize KQCIFSize(176, 144);

	const TSize KSubQCIFSize(128, 96);

#endif

#ifdef RESIZE_CIF_SIZES_SUPPORTED

	PopulateParamArray(KSubQCIFSize);

	PopulateParamArray(KQCIFSize);

#endif

	PopulateParamArray(KQVGASize);

#ifdef RESIZE_CIF_SIZES_SUPPORTED

	PopulateParamArray(KCIFSize);

#endif 

	PopulateParamArray(KVGASize);

	PopulateParamArray(KSVGASize);

	PopulateParamArray(KSXGASize);

	PopulateParamArray(KUXGASize);

	PopulateParamArray(KQSXGASize);

	// Landscape

	if (iOrigSize.iHeight < iOrigSize.iWidth)

	{

		iParamArray.Append(iOrigSize.iHeight);

	}

	else

	{

		iParamArray.Append(iOrigSize.iWidth);

	}

}

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

void CResizeControl::PopulateParamArray(const TSize& aTargetSize )

{

	TReal origRatio = 0.0;

	if (iOrigSize.iWidth < iOrigSize.iHeight)

	{

		origRatio = (TReal)iOrigSize.iHeight / iOrigSize.iWidth;	

	}

	else

	{

		origRatio = (TReal)iOrigSize.iWidth / iOrigSize.iHeight;

	}

	TReal targetRatio = (TReal)aTargetSize.iWidth / aTargetSize.iHeight;

	if (aTargetSize.iWidth < iOrigSize.iWidth && aTargetSize.iHeight < iOrigSize.iHeight)

	{

		// Landscape

		if (iOrigSize.iHeight < iOrigSize.iWidth)

		{

			if (origRatio > targetRatio)

			{

				TInt h = (TReal)(aTargetSize.iWidth * iOrigSize.iHeight) / iOrigSize.iWidth + 0.5;	

				if (h > KMinDimension)

				{

					iParamArray.Append(h);							

				}