// Copyright (c) 1995-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:
// The text cursor
// 
//

#include <e32std.h>
#include "server.h"
#include "tcursor.h"
#include "windowgroup.h"
#include "wstop.h"
#include "panics.h"
#include "offscreenbitmap.h"
#include "EVENT.H"
#include "graphics/windowserverconstants.h"

void RWsTextCursor::ConstructL(CWsWindowGroup *aGroupWin)
	{
	iInternalFlags = 0;
	iGroupWin=aGroupWin;
	iCustomTextCursor = NULL;
	}

void RWsTextCursor::Close()
	{
	iDrawRegion.Close();
	Cancel();
	}

void RWsTextCursor::SetL(const TWsWinCmdSetTextCursor &aSet, TBool aClipped)
	{
	if (aSet.cursor.iType < TTextCursor::ETypeFirst ||
        (aSet.cursor.iType > TTextCursor::ETypeLast &&        
         aSet.cursor.iType <= TTextCursor::ETypeLastBasic) ||
		(aSet.cursor.iFlags&static_cast<TUint>(ETextCursorPrivateFlags)))
		{
		Cancel();
		iGroupWin->OwnerPanic(EWservPanicInvalidTextCursor);
		}
	else
		{
		CWsClientWindow* win = NULL;
		iGroupWin->WsOwner()->HandleToClientWindow(aSet.window, &win);

		// Check window is a child of the group window
		CWsWindowBase* searchWin = NULL;
		for(searchWin=win; searchWin->WinType()!=EWinTypeGroup; searchWin=searchWin->BaseParent())
			{}
		if (iGroupWin != searchWin)
			{
			Cancel();
			iGroupWin->OwnerPanic(EWservPanicWindow);
			}

		TPoint pos(aSet.pos.iX, aSet.pos.iY-aSet.cursor.iAscent);
		TSize size(aSet.cursor.iWidth, aSet.cursor.iHeight);
		TUint flags = aSet.cursor.iFlags;
		TInt type = aSet.cursor.iType;
		TRect clipRect = iClipRect;
		TRgb color = aSet.cursor.iColor;
		CWsCustomTextCursor* customTextCursor = iCustomTextCursor;
		TBool changed = EFalse;

		TPoint clipOrigo;
		TSize clipSize;

		if (type > TTextCursor::ETypeLastBasic)
			{
			changed = ETrue;

			customTextCursor = CWsClient::FindCustomTextCursor(type);
			if (!customTextCursor)
				{
				Cancel();
				iGroupWin->OwnerPanic(EWservPanicNoCustomTextCursor);
				return;
				}
			
			if( !customTextCursor->HasSpriteMember() )
				{
				iGroupWin->OwnerPanic(EWservPanicNoSpriteMember);
				return;
				}
			
			TInt yAdjust=0;
			switch (customTextCursor->Alignment())
				{
				case RWsSession::ECustomTextCursorAlignTop:
					break;
				case RWsSession::ECustomTextCursorAlignBaseline:
					yAdjust = aSet.cursor.iAscent-1;
					break;
				case RWsSession::ECustomTextCursorAlignBottom:
					yAdjust = aSet.cursor.iHeight-1;
					break;
				default:
					Cancel();
					iGroupWin->OwnerPanic(EWservPanicCustomTextCursorAlign);
					return;
				}
			pos.iY += yAdjust;
			// Start with a clipping rect to be the whole window
			// relative cursor pos and shrink down to what we want
			clipOrigo = -pos;
			clipSize = win->Size();
			if (flags & TTextCursor::EFlagClipHorizontal)
				{
				clipOrigo.iX = 0;
				clipSize.iWidth = size.iWidth;
				}
			if (flags & TTextCursor::EFlagClipVertical)
				{
				clipOrigo.iY = -yAdjust;
				clipSize.iHeight = aSet.cursor.iHeight;
				}
			}
		else
			{
			customTextCursor = NULL;
			}

		if (aClipped)
			{
			flags|=ETextCursorFlagClipped;
			clipRect=aSet.rect;
			}

		if (pos != iPos || size != iSize || iType != type ||
			flags != iFlags || clipRect != iClipRect || color != iColor ||
			customTextCursor != iCustomTextCursor || win != iWin)
			{
			// There is a change in the cursor.
			changed = ETrue;
			}

		if (iInternalFlags&EHasFocus && changed)
			{
			TCursorSprite::Hide();
			}

		iPos = pos;
		iSize = size;
		iType = type;
		iFlags= flags;
		iClipRect = clipRect;
		iColor = color;
		iCustomTextCursor = customTextCursor;
		iWin = win;
		if (customTextCursor && iInternalFlags&EHasFocus)
			{
			customTextCursor->CompleteL(win, !(flags&TTextCursor::EFlagNoFlash), flags & (TTextCursor::EFlagClipHorizontal | TTextCursor::EFlagClipVertical), clipOrigo, clipSize);
			customTextCursor->SetPositionNoRedraw(pos);
			}

		if (iInternalFlags&EHasFocus && changed)
			{
			TCursorSprite::SetCurrentCursor(this, win);
			}
		}
	}

void RWsTextCursor::Cancel()
	{
	if (iType!=TTextCursor::ETypeNone)
		{
		if (iInternalFlags&EHasFocus)
			TCursorSprite::SetFocus(NULL);
		iType=TTextCursor::ETypeNone;
		iWin=NULL;
		}
	}

void RWsTextCursor::Disable()
	{
	if (iWin)
		{
		TCursorSprite::Hide();
		}
	}

void RWsTextCursor::Enable()
	{
	if (iWin)
		{
		TCursorSprite::Reveal();
		}
	}

void RWsTextCursor::LostFocus()
	{
	TCursorSprite::SetFocus(NULL);
	iInternalFlags &= ~EHasFocus;
	}

void RWsTextCursor::ReceivedFocus()
	{
	iInternalFlags |= EHasFocus;
	if (iType!=TTextCursor::ETypeNone && iWin)
		{
		TCursorSprite::SetFocus(this,iWin);
		if (iCustomTextCursor)
			{
			iCustomTextCursor->SetPositionNoRedraw(iPos);
			}
		}
	}

TRect RWsTextCursor::RectRelativeToScreen() const
	{
	TRect rect;
	rect.iTl=iPos+iWin->Origin();
	rect.iBr=rect.iTl+iSize;
	return(rect);
	}

void RWsTextCursor::doDraw(CFbsBitGc* aGc, const TRegion& aRegion)
	{
	TRegionFix<1> justInCase;
	const TRegion *pr= &aRegion;
	if (aRegion.CheckError())
		{
		justInCase.AddRect(iWin->AbsRect());
		pr= &justInCase;
		}
	if (!pr->IsEmpty())
		{
		aGc->SetUserDisplayMode(iWin->DisplayMode());
		aGc->SetDitherOrigin(iWin->Origin());
		aGc->SetDrawMode(CGraphicsContext::EDrawModeXOR);
		switch (iType)
			{
			case TTextCursor::ETypeRectangle:
				{
				aGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
				aGc->SetPenStyle(CGraphicsContext::ENullPen);
				aGc->SetBrushColor(iColor);
				}
				break;
			case TTextCursor::ETypeHollowRectangle:
				{
				aGc->SetBrushStyle(CGraphicsContext::ENullBrush);
				aGc->SetPenStyle(CGraphicsContext::ESolidPen);
				aGc->SetPenColor(iColor);
				}
				break;
			default:
				WS_PANIC_ALWAYS(EWsPanicInvalidCursorType);
			}
		aGc->SetClippingRegion(pr);
		aGc->DrawRect(RectRelativeToScreen());
		aGc->SetUserDisplayMode(ENone);

		TWindowServerEvent::NotifyScreenDrawingEvent(pr);
		}
	}

void RWsTextCursor::Draw(CFbsBitGc* aGc, const TRegion& aRegion)
	{
	iDrawRegion.Copy(iWin->VisibleRegion());
	if (iFlags&ETextCursorFlagClipped)
		{
		TRect rect(iClipRect);
		rect.Move(iWin->Origin());
		iDrawRegion.ClipRect(rect);
		}

	// Need to clip against a possible recent screen size change.
	iDrawRegion.ClipRect(iWin->Screen()->DrawDevice()->SizeInPixels());


	RWsRegion tmpRegion;
	tmpRegion.Intersection(iDrawRegion, aRegion);
	if (tmpRegion.CheckError())
		doDraw(aGc, iDrawRegion);
	else
		{
		if (!tmpRegion.IsEmpty())
			{
			doDraw(aGc, tmpRegion);
			}
		}
	tmpRegion.Close();
	}

void RWsTextCursor::WindowDisconnected(CWsWindow *aWindow)
	{
	if (iWin==aWindow)
		Cancel();
	}

TBool RWsTextCursor::IsStandardCursorActive()
	{
	return TCursorSprite::IsStandardCursorActive();
	}

TBool RWsTextCursor::IsFlashing() const
	{
	return !(iFlags&TTextCursor::EFlagNoFlash);
	}

void RWsTextCursor::ScheduleReDrawNow()
	{
	iGroupWin->Screen()->ScheduleAnimation(RectRelativeToScreen(), 0, 0, 0);
	}


// Cursor sprite handling

TBool TCursorSprite::iHidden=ETrue;
RWsTextCursor *TCursorSprite::iCurrentCursor=NULL;

//

// Hide / Reveal text cursors.
void TCursorSprite::Hide()
	{
	if (!iHidden && iCurrentCursor)
		{
		iHidden=ETrue;
		if (iCurrentCursor->iCustomTextCursor)
			{
			iCurrentCursor->iCustomTextCursor->Deactivate();
			}
		else
			{
			iCurrentCursor->ScheduleReDrawNow();
			}
		}
	}
	
void TCursorSprite::Reveal()
	{
	if(iHidden && iCurrentCursor)
		{
		iHidden=EFalse;
		if (iCurrentCursor->iCustomTextCursor)
			{
			iCurrentCursor->iCustomTextCursor->Activate();
			}
		else
			{
			iCurrentCursor->ScheduleReDrawNow();
			}
		}
	}

void TCursorSprite::SetFocus(RWsTextCursor* aFocus,CWsClientWindow* aWin/*=NULL*/)
	{
	if (iCurrentCursor!=aFocus)
		{
		Hide();
		SetCurrentCursor(aFocus, aWin);
		}
	}

void TCursorSprite::SetCurrentCursor(RWsTextCursor* aFocus, CWsClientWindow* aWin)
	{
	iCurrentCursor = aFocus;
	if (aWin && iCurrentCursor && iCurrentCursor->iCustomTextCursor)
		{
		iCurrentCursor->iCustomTextCursor->SetWindow(aWin);
		}
	Reveal();
	}

TBool TCursorSprite::IsStandardCursorActive()
	{
	return iCurrentCursor && !iCurrentCursor->iCustomTextCursor && !iHidden;
	}