// guicons.h
// 
// Copyright (c) 2010 Accenture. 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:
// Accenture - Initial contribution
//

#ifndef __GUICONS_H__
#define __GUICONS_H__

#include <coecntrl.h>
#include <e32cons.h>
#include <fshell/consoleproxy.h>
#include <fshell/consoleextensions.h>

static const TInt KFontBitmapWidthChars = 8;
static const TInt KFontBitmapHeightChars = 12;
static const TInt KFontBitmapFirstCharCode = ' ';
static const TInt KNumGlyphs = KFontBitmapWidthChars * KFontBitmapHeightChars;
static const TInt KFontBitmapLastCharCode = KFontBitmapFirstCharCode + KNumGlyphs - 1;
static const TInt KDefaultCursorHeightPercentage = 20;
static const TInt KTabSize = 4;
static const TInt KNumColors = 16;

class CConsoleControl;
class CConsoleLine;
class CConsoleFont;
class MGuiConsoleReader;
class MConsoleUi;
class TBufferPosition;
class TConsCursorPosition;
class TViewPosition;
class CImageDecoder;
class RImageDecodeThreadParams;

IMPORT_C CServer2* StartGuiConsServerL(const TDesC& aServerName, MConsoleUi& aConsoleUi);

class MConsoleUi
	{
public:
	virtual void HandleNewConsoleL(CConsoleControl* aConsole) = 0;
	virtual void HandleConsoleClosed(CConsoleControl* aConsole) = 0;
	virtual void ConsoleTitleChangedL(const CConsoleControl*, const TDesC&){};
	virtual TInt GetConsoleBufferSize() = 0;
	virtual const TDesC& GetConsoleFont() = 0;
	};

/**
Position relative to the text buffer. The cursor window and view window will be somewhere within this.
*/
class TBufferPosition
	{
public:
	TBufferPosition(const CConsoleControl& aConsole, TPoint aPosition);
	TBufferPosition(const CConsoleControl& aConsole, TInt aX, TInt aY);
	TBufferPosition(const TConsCursorPosition& aCursorPosition);
	TBufferPosition(const TViewPosition& aViewPosition);
public:
	const CConsoleControl& iConsole;
	TPoint iPoint;
	};

/**
Position relative to the cursor window - i.e. the area that the cursor can move around in
*/
class TConsCursorPosition
	{
public:
	TConsCursorPosition(const CConsoleControl& aConsole, TPoint aPosition);
	TConsCursorPosition(const CConsoleControl& aConsole, TInt aX, TInt aY);
	TConsCursorPosition(const TBufferPosition& aBufferPosition);
	TConsCursorPosition(const TViewPosition& aViewPosition);
public:
	const CConsoleControl& iConsole;
	TPoint iPoint;
	};

/**
Position relative to the view window - i.e. the area of the console seen on the screen
*/
class TViewPosition
	{
public:
	TViewPosition(const CConsoleControl& aConsole, TPoint aPosition);
	TViewPosition(const CConsoleControl& aConsole, TInt aX, TInt aY);
	TViewPosition(const TConsCursorPosition& aCursorPosition);
	TViewPosition(const TBufferPosition& aBufferPosition);
public:
	const CConsoleControl& iConsole;
	TPoint iPoint;
	};

/**
Position in pixels relative to CConsoleControl's rectangle.
*/
class TScreenPosition
	{
public:
	TScreenPosition(const CConsoleControl& aConsole, TPoint aPosition);
	TScreenPosition(const CConsoleControl& aConsole, TInt aX, TInt aY);
	TScreenPosition(const TViewPosition& aViewPosition);
public:
	const CConsoleControl& iConsole;
	TPoint iPoint;
	};

class TConsoleCursor
	{
public:
	TConsoleCursor(CConsoleControl& aOwner);
	void SetFont(const CConsoleFont& aFont);
	TConsCursorPosition Position() const;
	void SetPosAbs(TConsCursorPosition aPos);
	void SetPosRel(TConsCursorPosition aPos);
	void SetHeight(TInt aPercentage);
	
	void Hide();

	void operator++(int);
	void operator--(int);
	void operator+=(TUint aHowMuch);
	void operator-=(TUint aHowMuch);
	void Down();
	void Up();
	
	void Update();
private:
	void BoundsCheck();
private:
	CConsoleControl& iOwner;
	TSize iGlyphSize;
	TPoint iPosition;
	TTextCursor iTextCursor;
	TInt iTextCursorOffset;
	};

class MGuiConsoleReader
	{
public:
	virtual void ReadComplete(TInt aStatus) = 0;
	};
	
class CGuiConsole	: public CConsoleBase
					, public MGuiConsoleReader
					, public MProxiedConsole
	{
public:
	IMPORT_C CGuiConsole(CConsoleControl& aControl);
	
	IMPORT_C CConsoleControl& Control();
	
	// from CConsoleBase
	IMPORT_C virtual TInt Create(const TDesC &aTitle,TSize aSize);
	IMPORT_C virtual void Read(TRequestStatus& aStatus);
	IMPORT_C virtual void ReadCancel();
	IMPORT_C virtual void Write(const TDesC &aDes);
	IMPORT_C virtual TPoint CursorPos() const;
	IMPORT_C virtual void SetCursorPosAbs(const TPoint &aPoint);
	IMPORT_C virtual void SetCursorPosRel(const TPoint &aPoint);
	IMPORT_C virtual void SetCursorHeight(TInt aPercentage);
	IMPORT_C virtual void SetTitle(const TDesC &aTitle);
	IMPORT_C virtual void ClearScreen();
	IMPORT_C virtual void ClearToEndOfLine();
	IMPORT_C virtual TSize ScreenSize() const;
	IMPORT_C virtual TKeyCode KeyCode() const;
	IMPORT_C virtual TUint KeyModifiers() const;
	IMPORT_C virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
	
	// from MGuiConsoleReader
	virtual void ReadComplete(TInt aStatus);
	// from MProxiedConsole:
	virtual void Open();
	virtual void Close();
	virtual CConsoleBase* Console();
	virtual void Read(CConsoleProxySession& aSession);
private:
	~CGuiConsole();
private:
	CConsoleControl& iControl;
	TInt iRefCount;
	TRequestStatus* iReadStatus;
	CConsoleProxySession* iReader;
	};

class CConsoleControl : public CCoeControl
	{
public:
	IMPORT_C static CConsoleControl* NewL(TInt aBufferSize, MConsoleUi* aUi = NULL);
	IMPORT_C static CConsoleControl* NewL(TInt aBufferSize, const TDesC& aFontFile, MConsoleUi* aUi = NULL);
	IMPORT_C virtual ~CConsoleControl();
	IMPORT_C void Closed();
	
	IMPORT_C void InjectKeysL(const TDesC& aKeys);
	IMPORT_C TBool FivewayNavIsDisplaying() const;
	IMPORT_C void SetDisplayFivewayNav(TBool aShow);
	
	// from CCoeControl:
	IMPORT_C virtual void Draw(const TRect& aRect) const;
	IMPORT_C virtual void SizeChanged();
	IMPORT_C virtual TKeyResponse OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType);
	IMPORT_C virtual TCoeInputCapabilities InputCapabilities() const;
	IMPORT_C virtual void FocusChanged(TDrawNow aDrawNow);
	IMPORT_C virtual void HandlePointerEventL(const TPointerEvent& aPointerEvent);
	
	// CConsoleBase API
	IMPORT_C void Read(MGuiConsoleReader &aStatus);
	IMPORT_C void ReadCancel();
	IMPORT_C void Write(const TDesC &aDes);
	IMPORT_C TPoint CursorPos() const;
	IMPORT_C void SetCursorPosAbs(const TPoint &aPoint);
	IMPORT_C void SetCursorPosRel(const TPoint &aPoint);
	IMPORT_C void SetCursorHeight(TInt aPercentage);
	IMPORT_C void SetTitle(const TDesC &aTitle);
	IMPORT_C void ClearScreen();
	IMPORT_C void ClearToEndOfLine();
	IMPORT_C TSize ScreenSize() const;
	IMPORT_C TKeyCode KeyCode() const;
	IMPORT_C TUint KeyModifiers() const;
	
	IMPORT_C void ViewScrollUp();
	IMPORT_C void ViewScrollDown();
	IMPORT_C void ViewPageUp();
	IMPORT_C void ViewPageDown();
	IMPORT_C void ViewHome();
	IMPORT_C void ViewEnd();
	IMPORT_C TInt SetAttributes(TUint aAttributes, ConsoleAttributes::TColor aForegroundColor, ConsoleAttributes::TColor aBackgroundColor);
	
	// calls from CConsoleCursor:
	void CursorWindowScrollDown();
	
	TPoint ViewPosition() const;
	TPoint CursorWindowPosition() const;
	TSize GlyphSize() const;
	void ActivateL();
	void StartBlinking();
	
private:
	CConsoleControl(MConsoleUi* aUi, TInt aBufferSize);
	void ConstructL(CConsoleFont* aFont);
	void SizeChangedL();
	
	void DrawLine(TViewPosition aLine, CBitmapContext& aDrawTo) const;
	TRect LineRect(TViewPosition aLine) const;
	
	TBool IsSpecialChar(TChar aChar) const;
	void HandleSpecialChar(TChar aChar);
	
	void SendKey();
	
	CConsoleLine* GetLine(TBufferPosition aLine) const;
	void ViewMoved();
	void Invalidate5Way();
	enum TButton { EUp, EDown, ELeft, ERight, ECenter, ENumButtons };
	void SimulateKeyL(TButton aButton);
	void WriteL(const TDesC &aDes);

	static TInt BlinkCallback(TAny* aPtr);
	
private:
	MConsoleUi* iUi;
	CConsoleFont* iFont;
	RPointerArray<CConsoleLine> iBuffer;
	CPeriodic* iBlinkTimer;
	TSize iSizeChars;
	TConsoleCursor iCursor;
	TPoint iCursorWindow;
	TPoint iViewWindow;

	MGuiConsoleReader* iReader;
	RArray<TKeyEvent> iKeyQueue;
	TKeyEvent iCurrentKey; 
	
	TPoint iDragStart;
	TBool iIgnoringDrags;

	TRect iButtonRects[ENumButtons];
	TBool iDrawNavigator;
	ConsoleAttributes::TAttributes iCurrentAttributes;
	
	TInt iBufferSize;
	TBool iBlinkOn;
	};
	
class CConsoleFont : public CBase
	{
public:
	IMPORT_C static CConsoleFont* NewL(const TDesC& aFontFile);
	IMPORT_C static CConsoleFont* NewL(const TDesC8& aEncodedFontImage);
	IMPORT_C ~CConsoleFont();
	IMPORT_C TSize GlyphSize() const;
	IMPORT_C void DrawChar(TChar aChar, CBitmapContext& aDrawTo, TPoint aPosPixels, TRgb aColor);
	void PrepareForegroundColorL(TRgb aColor);
private:
	CConsoleFont();
	void ConstructL(const TDesC& aFontFile);
	void ConstructL(const TDesC8& aEncodedFontImage);
	void ConstructL(RImageDecodeThreadParams& aThreadParams);
	CFbsBitmap* ForegroundBitmap(TRgb aColor);
private:
	TFixedArray<CFbsBitmap*, KNumGlyphs> iChars;
	TFixedArray<CFbsBitmap*, KNumColors> iColors;
	TRect iGlyphRect;
	};

class RAttributeMap
	{
public:
	RAttributeMap();
	void Close();
	void Reset();
	void AddL(TInt aPosition, TInt aLineWidth, const ConsoleAttributes::TAttributes& aAttributes);
	void RemoveFrom(TInt aPosition);
	TInt NumberOfBlocks() const;
	void GetBlock(TInt aIndex, TInt aLineWidth, TInt& aStartPosition, TInt& aEndPosition, ConsoleAttributes::TAttributes& aAttributes) const;
private:
	class TAttributes
		{
	public:
		TAttributes(TInt aPosition, const ConsoleAttributes::TAttributes& aAttributes);
		TBool operator==(const TAttributes& aAttributes) const;
	public:
		TInt iPosition;
		ConsoleAttributes::TAttributes iAttributes;
		};
private:
	RArray<TAttributes> iAttributes;
	};
	
NONSHARABLE_CLASS(CConsoleLine) : public CBase
	{
public:
	static CConsoleLine* NewL(CConsoleControl& aControl, const CConsoleFont& aFont, TInt aWidth);
	~CConsoleLine();
	
	void SetWidthL(TInt aNewWidth);
	
	void SetL(TInt aIndex, TUint8 aChar, const ConsoleAttributes::TAttributes& aAttributes);
	void Clear();
	void ClearFrom(TBufferPosition aPosition);
	
	void Draw(CBitmapContext& aDrawTo, TViewPosition aViewPosition) const;
	TBool NeedToBlink(TBool aBlinkOn);
private:
	CConsoleLine(CConsoleControl& aControl, const CConsoleFont& aFont);
	void ConstructL(TInt aWidth);
	TUint16 At(TInt aPos) const;
private:
	CConsoleControl& iControl;
	const CConsoleFont& iFont;
	RBuf8 iText;
	RAttributeMap iAttributeMap;
	TInt iWidth;
	TBool iBlinkOn;
	};


#endif //__GUICONS_H__