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

// INCLUDE FILES

#include "HgVgScrollBar.h"
#include "HgVgDrawBuffer.h"
#include "HgVgHelper.h"
#include "HgScrollbar.h"
#include <VG/vgu.h>
#include <gulicon.h>



// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CHgVgScrollBar::NewL()
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CHgVgScrollBar* CHgVgScrollBar::NewL( MHgScrollbarObserver& aObserver, 
        TRect aScrollbarRect,
                    TSize aTotalSize,
                    TSize aViewSize,
                    TBool aLandscapeScrolling,
                    CHgScroller::THgScrollBarType aScrollBarType )
    {
    CHgVgScrollBar* self = new ( ELeave ) CHgVgScrollBar( ); 
    CleanupStack::PushL (self );
    self->ConstructL( aObserver, aScrollbarRect, aTotalSize, aViewSize, aLandscapeScrolling, aScrollBarType );
    CleanupStack::Pop ( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CHgVgScrollBar::ConstructL()
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CHgVgScrollBar::ConstructL ( MHgScrollbarObserver& aObserver, TRect aScrollbarRect,
        TSize aTotalSize,
        TSize aViewSize,
        TBool aLandscapeScrolling,
        CHgScroller::THgScrollBarType aScrollBarType )
    {
    ResizeL(aObserver, aScrollbarRect, aTotalSize, aViewSize, aLandscapeScrolling, 
            aScrollBarType);
    
    CreateImagesL();
    }


// -----------------------------------------------------------------------------
// CHgVgScrollBar::CreateImagesL()
// -----------------------------------------------------------------------------
//
void CHgVgScrollBar::CreateImagesL()
    {
    if(!iScrollbar->IsStatic())
        {
        iScrollbarBg = HgVgHelper::CreateVgImageFromIconL(*iScrollbar->ScrollbarBg());
        iScrollbarBgSelected = HgVgHelper::CreateVgImageFromIconL(*iScrollbar->ScrollbarBgSelected());
        iScrollbarHandle = HgVgHelper::CreateVgImageFromIconL(*iScrollbar->ScrollbarHandle());
        iScrollbarHandleSelected = HgVgHelper::CreateVgImageFromIconL(*iScrollbar->ScrollbarHandleSelected());
        //iScrollbarHandleBg = HgVgHelper::CreateVgImageFromIconL(iScrollbar->ScrollbarHandleBg());
        }
    }


// -----------------------------------------------------------------------------
// CHgVgScrollBar::CHgVgMediaWall()
// C++ default constructor can NOT contain any code, that might leave.
// -----------------------------------------------------------------------------
//
CHgVgScrollBar::CHgVgScrollBar(  ) : 
iEnabled(ETrue)
    {
    }
        
// -----------------------------------------------------------------------------
// CHgVgScrollBar::~CHgVgScrollBar()
// Destructor.
// -----------------------------------------------------------------------------
//
CHgVgScrollBar::~CHgVgScrollBar ( )
    {

    vgDestroyImage(iScrollbarBg);
    vgDestroyImage(iScrollbarBgSelected);
    vgDestroyImage(iScrollbarHandle);
    vgDestroyImage(iScrollbarHandleSelected);
    //vgDestroyImage(iScrollbarHandleBg);
    
    delete iScrollbar;
    
    }


void CHgVgScrollBar::SetViewPosition( TPoint aPosition )
    {
    iScrollbar->SetViewPosition(aPosition);
    }

TBool CHgVgScrollBar::HandlePointerEventL( const TPointerEvent& aEvent )
    {
    if (!iEnabled)
        return EFalse;
    
    return iScrollbar->HandlePointerEventL(aEvent);
    }

void CHgVgScrollBar::Draw(const TRect& aWindowRect, TReal aAlpha) const
    {
    if (!iEnabled || iScrollbar->IsStatic())
        return;
    
    TRect scrollbarRect = iScrollbar->ScrollbarRect();
    TPoint handlePosition = iScrollbar->HandlePosition();
    const CGulIcon* scrollbarBg = iScrollbar->ScrollbarBg();
    const CGulIcon* scrollbarBgSelected = iScrollbar->ScrollbarBgSelected();
    const CGulIcon* scrollbarHandle = iScrollbar->ScrollbarHandle();
    const CGulIcon* scrollbarHandleSelected = iScrollbar->ScrollbarHandleSelected();
    const CGulIcon* scrollbarHandleBg = iScrollbar->ScrollbarHandleBg();
    
    if(scrollbarBg && scrollbarHandle && scrollbarHandleBg)
        {
        if(iScrollbar->Handler() && !iScrollbar->IsStatic())
            {
            DrawImage(scrollbarRect.iTl,
                    iScrollbarBgSelected, 
                    scrollbarBgSelected->Bitmap()->SizeInPixels(), aWindowRect, aAlpha);
            
            DrawImage(scrollbarRect.iTl + handlePosition, 
                    iScrollbarHandleSelected,
                    scrollbarHandleSelected->Bitmap()->SizeInPixels(), aWindowRect, aAlpha);
            }
        else
            {
            DrawImage(scrollbarRect.iTl, 
                    iScrollbarBg,
                    scrollbarBg->Bitmap()->SizeInPixels(), aWindowRect, aAlpha);
            
            DrawImage(scrollbarRect.iTl + handlePosition,
                    iScrollbarHandleBg,
                    scrollbarHandleBg->Bitmap()->SizeInPixels(), aWindowRect, aAlpha);

            DrawImage(scrollbarRect.iTl + handlePosition, 
                    iScrollbarHandle,
                    scrollbarHandle->Bitmap()->SizeInPixels(), aWindowRect, aAlpha);
            }
        }    
    }

void CHgVgScrollBar::DrawImage(const TPoint& aPosition, VGImage aImage, 
        const TSize& /*aSize*/, const TRect& aWindowRect, TReal aAlpha) const
    {
    TRgb color(255, 255, 255, aAlpha * 255.0f);
    HgVgHelper::DrawImageColorized(aImage, color, aPosition, aWindowRect, EFalse, iLandscape);
    }

TBool CHgVgScrollBar::IsEnabled() const
    {
    return iEnabled;
    }

void CHgVgScrollBar::SetEnabled(TBool aEnabled)
    {
    iEnabled = aEnabled;
    }

void CHgVgScrollBar::ResizeL(
        MHgScrollbarObserver& aObserver, 
        TRect aScrollbarRect,
        TSize aTotalSize,
        TSize aViewSize,
        TBool aLandscapeScrolling,
        CHgScroller::THgScrollBarType /*aScrollBarType */)
    {
    iScrollbar = CHgScrollbar::NewL(aObserver);

    iScrollbar->InitScrollBarL(aScrollbarRect, aTotalSize, aViewSize, aLandscapeScrolling);    
    }

void CHgVgScrollBar::EnableLandscapeRendering(TBool aEnabled)
{
    iLandscape = aEnabled;
}


// End of File