/*
* Copyright (c) 2002-2004 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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:  Implementation of CScrollBarFrame and 
*				 CScrollBarCornerWindow
*
*/

#include "ScrollBarFrame.h"
#include "ScrollBar.h"
#include "ScrollThumb.h"

#include <e32std.h>
#include <e32def.h>
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

//--------------------------------------------------------------------
// CScrollBarFrame::NewL(const CCoeControl& aParent)
//
// Two-phased construction
//--------------------------------------------------------------------
//
CScrollBarFrame* CScrollBarFrame::NewL(const CCoeControl& aParent)
	{
	CScrollBarFrame* self = new (ELeave) CScrollBarFrame();
	CleanupStack::PushL(self);
	self->ConstructL(aParent);
	CleanupStack::Pop();	// self
	return self;
	}

//--------------------------------------------------------------------
// CScrollBarFrame::CScrollBarFrame()
//
// First Phase Construction
//--------------------------------------------------------------------
//
CScrollBarFrame::CScrollBarFrame()
	{
	SetLayout(EOriginTopLeft);
	}

//--------------------------------------------------------------------
// CScrollBarFrame::ConstructL(const CCoeControl& aParent)
// 
// Second Phase Constructor
//--------------------------------------------------------------------
//
void CScrollBarFrame::ConstructL(const CCoeControl& aParent)
	{
	// Create Scroll Bars
	iVScrollBar = CScrollBar::NewL(CScrollBar::EVertical, aParent);
	iHScrollBar = CScrollBar::NewL(CScrollBar::EHorizontal, aParent);

    iCornerWindow = CScrollBarCornerWindow::NewL(aParent);
	}


//--------------------------------------------------------------------
// CScrollBarFrame::~CScrollBarFrame()
// 
// DESTRUCTOR
//--------------------------------------------------------------------
//
CScrollBarFrame::~CScrollBarFrame()
	{
	delete iCornerWindow;
	delete iVScrollBar;
	delete iHScrollBar;
	}

//--------------------------------------------------------------------
// void CScrollBarFrame::UpdateVScrollBarL()
//--------------------------------------------------------------------
//
void CScrollBarFrame::UpdateVScrollBarL()
	{
	SetScrollBar(CScrollBar::EVertical);
	}

//--------------------------------------------------------------------
// void CScrollBarFrame::UpdateHScrollBarL()
//--------------------------------------------------------------------
//
void CScrollBarFrame::UpdateHScrollBarL()
	{
	SetScrollBar(CScrollBar::EHorizontal);
	}


//-----------------------------------------------------------------------------
// void CScrollBarFrame::NotifyLayoutChange(TBrCtlLayout aLayout)
//-----------------------------------------------------------------------------
//
void CScrollBarFrame::NotifyLayoutChange(TBrCtlLayout aLayout)
	{
	iLayout = aLayout;
	}


//-----------------------------------------------------------------------------
// void CScrollBarFrame::SetScrollBar(const CScrollBar::TOrientation aOrientation)
//-----------------------------------------------------------------------------
//
void CScrollBarFrame::SetScrollBar(const CScrollBar::TOrientation aOrientation)
	{
	// scrollbar coordinates
	TInt tlX(0);
	TInt tlY(0);
	TInt brX(0);
	TInt brY(0);

	TInt height = iDisplay.Height();
	TInt width = iDisplay.Width();
	
	// Set Vertical Scroll Bar
	// Calculate size and position of Vertical Scroll Bar
	if (aOrientation == CScrollBar::EVertical)	
		{	
		switch (iLayout)
			{
			case EOriginTopLeft:
				{
				tlX = width;
				tlY = 0;
				brX = width + KBrowserVScrollBarWidth;
				brY = height;
				break;
				}
			case EOriginTopRight:
				{
				tlX = 0;
				tlY = 0;
				brX = KBrowserVScrollBarWidth;
				brY = height;
				break;
				}
			default:
				break;
			}
		iVScrollBar->SetTrackAndBackground(TRect(tlX, tlY, brX, brY));
		}

	// Set Horizontal Scroll Bar
	else
		{
		// If we need a horizontal scrollbar
		if (iDocument.Width() > iDisplay.Width())
			{
			TRect cornerWindow;
			switch (iLayout)
				{
				case EOriginTopLeft:
					{
					tlX = 0;
					tlY = height;
					brX = width;
					brY = height + KBrowserHScrollBarHeight;

					cornerWindow.SetRect(width, height,
                                         width + KBrowserVScrollBarWidth,
										 height + KBrowserHScrollBarHeight);
					iCornerWindow->SetRect(cornerWindow);
					break;				
					}
				case EOriginTopRight:
					{
					tlX = KBrowserVScrollBarWidth;
					tlY = height;
					brX = width + KBrowserVScrollBarWidth;
					brY = height + KBrowserHScrollBarHeight;
					
					cornerWindow.SetRect(0, height, KBrowserVScrollBarWidth, 
										 height + KBrowserHScrollBarHeight);
					iCornerWindow->SetRect(cornerWindow);					
					break;
					}
				default:
					break;
				}
			}
		iHScrollBar->SetTrackAndBackground(TRect(tlX, tlY, brX, brY));
		}	
	
	// Set scrollbar thumb attributes
	SetThumb(aOrientation);
	
	if (aOrientation == CScrollBar::EVertical)
		{
		iVScrollBar->DrawNow();
		}
	else
		{
		iHScrollBar->DrawNow();
		}
	iCornerWindow->DrawNow();
	}


//----------------------------------------------------------------------------
// void CScrollBarFrame::SetThumb(const CScrollBar::TOrientation aOrientation)
//----------------------------------------------------------------------------
//
void CScrollBarFrame::SetThumb(CScrollBar::TOrientation aOrientation)
	{	
	TInt display;
	TInt document;
	TInt displayPos;	
	TRect sbThumb;

	// Set Vertical THUMB
	if (aOrientation == CScrollBar::EVertical)
		{
		TInt height = 0;
		TInt posY = 0;

		display = iDisplay.Height();
		document = iDocument.Height();
		displayPos = iDisplayPos.iY;
 
		if (document)	// avoid dividing by zero
			{
			// Height of the thumb
			height = (display * display) / document;
			
			// Position of thumb
			posY = (display * displayPos) / document;
			}

		// Set thumb
		sbThumb.SetRect(iVScrollBar->Rect().iTl.iX, posY,
						iVScrollBar->Rect().iBr.iX, (posY + height));
		iVScrollBar->iThumb->SetThumbAndShadow(sbThumb);
		}
	// Set Horizontal THUMB
	else
		{
		TInt width = 0;
		TInt posX = 0;

		display = iDisplay.Width();
		document = iDocument.Width();
		displayPos = iDisplayPos.iX;

		if (document)	// avoid dividing by zero
			{
			// Width of the thumb		
			width = (display * display) / document;
			// Position of thumb
			posX = (display * displayPos) / document;
			}

		// shift thumb to the right
		if (iLayout == EOriginTopRight)
			{
			posX += KBrowserVScrollBarWidth;
			}

		// Set Thumb
		sbThumb.SetRect(posX, iHScrollBar->Rect().iTl.iY, (posX + width),
                        iHScrollBar->Rect().iBr.iY);
		iHScrollBar->iThumb->SetThumbAndShadow(sbThumb);
		}
	}


//----------------------------------------------------------------------------
// TInt CScrollBarFrame::VScrollBarNeeded(TInt aDocument, TInt aDisplay,
//										  TInt aDisplayPos)
//
//	External Function determining if Vertical Scroll Bar is needed
//	returns width of scrollbar
//----------------------------------------------------------------------------
//
/*
TInt CScrollBarFrame::VScrollBarNeeded(TInt aDocument, TInt aDisplay,
									   TInt aDisplayPos)
	{
	TInt ret = 0;

	// Set data members
	iDocument.SetHeight(aDocument);
	SetDisplayHeight(aDisplay);
	iDisplayPos.iY = aDisplayPos;
	
	// Modify Display rect to accomodate scrollbar - if not already present
	if ((iDisplay.Width() == KBrowserMaxDisplayWidth) && iDocument.Width())
		{
		ret = KBrowserVScrollBarWidth;
		}
	return ret;	
	}


//----------------------------------------------------------------------------
// TInt CScrollBarFrame::HScrollBarNeeded(TInt aDocument,
//										  TInt aDisplay,
//										  TInt aDisplayPos,
//										  TInt aDisplayHeight)
//----------------------------------------------------------------------------
//
TInt CScrollBarFrame::HScrollBarNeeded(TInt aDocument,
									   TInt aDisplay,
									   TInt aDisplayPos,
									   TInt aDisplayHeight)
	{
	TInt ret = 0;
	iDocument.SetWidth(aDocument);
	SetDisplayWidth(aDisplay);
	iDisplayPos.iX = aDisplayPos;

	// Modify Display rect to accomodate scrollbar - if not already present
	if (iDocument.Height())
		{
		// Calculate space needed for H Scrollbar
		if (iDocument.Width() > iDisplay.Width())
			{
			if (iDisplay.Height() == aDisplayHeight)	// H Scrollbar present?
				{
				ret = KBrowserHScrollBarHeight;
				}
			}
		// H Scrollbar not needed any more if doc not wider than display 
		// (with or without a V scrollbar being present)
		else if (iDocument.Width() <= iDisplay.Width() ||
				 iDisplay.Width() == KBrowserMaxDisplayWidth)
			{			
			if ((aDisplayHeight - iDisplay.Height()) == KBrowserHScrollBarHeight)
				{
				ret = KBrowserHScrollBarHeight * KConvertToNegativeValue;
				}
			// We also don't need a corner window
			iCornerWindow->SetRect(TRect(0, 0, 0, 0));
			}
		}	
	return ret;	
	}
*/
//----------------------------------------------------------------------------
// void CScrollBarFrame::SetDisplayHeight( const TInt aHeight )
//----------------------------------------------------------------------------
//
void CScrollBarFrame::SetDisplayHeight(const TInt aHeight)
	{
	iDisplay.SetHeight(aHeight);
	iScrollBarRect.SetHeight(aHeight + KBrowserHScrollBarHeight);
	}

//----------------------------------------------------------------------------
// void CScrollBarFrame::SetDisplayWidth(const TInt aWidth)
//----------------------------------------------------------------------------
//
void CScrollBarFrame::SetDisplayWidth(const TInt aWidth)
	{
	iDisplay.SetWidth(aWidth);
	iScrollBarRect.SetWidth(aWidth + KBrowserVScrollBarWidth);
	}


//----------------------------------------------------------------------------
//	CScrollBarCornerWindow Class Implementation
//----------------------------------------------------------------------------

//--------------------------------------------------------------------
// CScrollBarCornerWindow::CScrollBarCornerWindow(const CCoeControl& aParent)
//
// Second Phase Construction
//--------------------------------------------------------------------
//
CScrollBarCornerWindow* CScrollBarCornerWindow::NewL(const CCoeControl& aParent)
	{
    CScrollBarCornerWindow* self = new (ELeave)CScrollBarCornerWindow;
    CleanupStack::PushL(self);
    self->ConstructL(aParent);
    CleanupStack::Pop();
    return self;
    }

//--------------------------------------------------------------------
// CScrollBarCornerWindow::ConstructL(const CCoeControl& aParent)
//
// ConstructL
//--------------------------------------------------------------------
//
void CScrollBarCornerWindow::ConstructL(const CCoeControl& aParent)
    {
	SetContainerWindowL(aParent);
	}

//--------------------------------------------------------------------
// CScrollBarCornerWindow::~CScrollBarCornerWindow()
// 
// DESTRUCTOR
//--------------------------------------------------------------------
//
CScrollBarCornerWindow::~CScrollBarCornerWindow()
	{
	}

//----------------------------------------------------------------------------
//	void CScrollBarCornerWindow::Draw(const TRect& /*aRect*/) const
//----------------------------------------------------------------------------
//
void CScrollBarCornerWindow::Draw(const TRect& /*aRect*/) const
	{	
	const TRgb KBrowserCornerWindowColour = KRgbWhite;	// Corner Window Colour
	CWindowGc& gc = SystemGc();	 
	
	gc.SetPenStyle(CGraphicsContext::ENullPen );
    gc.SetBrushColor(KBrowserCornerWindowColour);
    gc.SetBrushStyle(CGraphicsContext::ESolidBrush);
	gc.DrawRect(Rect());
	}