// GuiConsAppUi.cpp

// 

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

//

#include <avkon.hrh>

#include <aknnotewrappers.h>

#include <stringloader.h>

#include <GuiCons.rsg>

#include <f32file.h>

#include <s32file.h>

#include <aknnavi.h>

#include <aknnavilabel.h>

#include <akntabgrp.h>

#include <akntitle.h>

#include <hal.h>

#include <caknmemoryselectiondialog.h>

#include <caknfileselectiondialog.h>

#include <fshell/ltkutils.h>

#include "GuiConsAppUi.h"

#include "GuiConsAppView.h"

#include "GuiCons.hrh"

#define EXPAND(L, X) L(X)

#define PANIC() User::Panic(EXPAND(_L, __FILE__), __LINE__)

#define GUICONS_ASSERT(x) __ASSERT_ALWAYS(x, PANIC())

_LIT(KServerName, "guicons");

_LIT(KNoConsole, "no console connected");

_LIT(KConsoleClosed, "console closed");

_LIT(KNewProcName, "fshell.exe");

_LIT(KNewProcArgs, "--console guicons");

_LIT(KIniFile, "\\system\\console\\guicons.ini");

_LIT(KIdfFile, "\\resource\\guicons.idf");

_LIT(KIniLongPress, "longpress");

_LIT(KIniShowNav, "shownav");

_LIT(KIniBufferSize, "buffersize");

_LIT(KIniFont, "font");

_LIT(KInvalidFontMsgFmt, "The file '%S' is not a valid font (error %d).\r\n\r\nA font file is a bitmap containing an 8x12 grid "

			L"of characters with ASCII codes 32 to 127. The width of the bitmap must be a multiple of 8, and the "

			L"height must be a multiple of 12.");

_LIT(KFontPreview, "New font:\r\nThe quick brown fox jumps over the lazy dog.");

void CGuiConsAppUi::ConstructL()

	{

	BaseConstructL(CAknAppUi::EAknEnableSkin);

	iTempState = new(ELeave) CConsoleState(NULL);

	iAppView = CGuiConsAppView::NewL( ClientRect() );

	iIniFile = LtkUtils::CIniFile::NewL(KIniFile, KIdfFile);

	iAppView->Layout();

	iAppView->ActivateL();

	CEikStatusPane* sp = StatusPane();

	iNaviPane = (CAknNavigationControlContainer*)sp->ControlL(TUid::Uid(EEikStatusPaneUidNavi));

	//iNaviDecorator = iNaviPane->CreateNavigationLabelL(_L("guicons"));

	iNaviDecorator = iNaviPane->CreateTabGroupL(this);

	iTabGroup = static_cast<CAknTabGroup*>(iNaviDecorator->DecoratedControl());

	iTabGroup->SetTabFixedWidthL(KTabWidthWithFourTabs);

	iNaviPane->PushL(*iNaviDecorator);

	SetStateL(ENoConsole);

	ConsoleTitleChangedL(NULL, KNullDesC);

	SetCapturingLongPressesL(iIniFile->GetBool(KIniLongPress));

	LtkUtils::CSetting* showNavSetting = iIniFile->GetSetting(KIniShowNav);

	if (!showNavSetting->IsSet())

		{

		TBool hasTouchScreen = EFalse;

		TInt err = HAL::Get(HAL::EPen, hasTouchScreen);

		if (!err && hasTouchScreen)

			{

			iShouldDisplayOnscreenNav = ETrue;

			}

		}

	else

		{

		iShouldDisplayOnscreenNav = showNavSetting->AsBool();

		}

	iConsoleServer = StartGuiConsServerL(KServerName, *this);	

	TRAP_IGNORE(LoadCommandsL());

	}

CGuiConsAppUi::CGuiConsAppUi()

	{

	}

void CGuiConsAppUi::SetNaviPaneTextL(const TDesC& aText)

	{

	if (iNaviDecorator->ControlType() == CAknNavigationDecorator::ENaviLabel)

		{

		CAknNaviLabel* naviLabel = (CAknNaviLabel*)iNaviDecorator->DecoratedControl();

		naviLabel->SetTextL(aText);

		iNaviPane->DrawNow();

		naviLabel->DrawNow();

		}

	}

TKeyResponse CGuiConsAppUi::HandleKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)

	{

	if (aType == EEventKey)

		{

		switch (iState)

			{

		case EEdwinActive:

			GUICONS_ASSERT(iConsole);

			// fallthrough

		case EConsoleClosed:

			switch (aKeyEvent.iCode)

				{

			case EKeyEnter:

			case EKeyDevice3:

				if (iState == EEdwinActive) 

					{

					HBufC* text = iAppView->GetEditorTextL();

					if (text)

						{

							{

							CleanupStack::PushL(text);

							iConsole->InjectKeysL(*text);

							CleanupStack::PopAndDestroy();

							}

						iConsole->InjectKeysL(_L("\r"));

						iAppView->SetEditorTextL(NULL);

						//iAppView->Editor()->DrawNow();

						}

					SetStateL(iState);

					return EKeyWasConsumed;

					}

			case EKeyUpArrow:

				iConsole->ViewScrollUp();

				return EKeyWasConsumed;

			case EKeyDownArrow:

				iConsole->ViewScrollDown();

				return EKeyWasConsumed;

			case EKeyPageDown:

				iConsole->ViewPageDown();

				return EKeyWasConsumed;

			case EKeyPageUp:

				iConsole->ViewPageUp();

				return EKeyWasConsumed;

			case EKeyHome:

				iConsole->ViewHome();

				return EKeyWasConsumed;

			case EKeyEnd:

				iConsole->ViewEnd();

				return EKeyWasConsumed;

			default:

				break;

				}

		case EConsoleActive:

		case ENoConsole:

		default:

			return EKeyWasNotConsumed;

			}

		}

	return EKeyWasNotConsumed;

	}

void CGuiConsAppUi::SetSoftkeysL()

	{

	CEikButtonGroupContainer* cba = CEikButtonGroupContainer::Current();

	TInt softkeysResourceId;

	switch (iState)

		{

	case EConsoleActive:

		softkeysResourceId = R_GUICONS_INTERACTIVE_CBA;

		break;

	case EEdwinActive:

		softkeysResourceId = R_GUICONS_LINE_CBA;

		break;

	case EConsoleClosed:

		softkeysResourceId = R_GUICONS_CLOSED_CBA;

		break;

	case ENoConsole:

	default:

		softkeysResourceId = R_AVKON_SOFTKEYS_OPTIONS_EXIT;

		break;

		}

	cba->SetCommandSetL(softkeysResourceId);

	cba->DrawNow();

	}

void CGuiConsAppUi::SetStateL(TState aNewState)

	{

	switch (aNewState)

		{

	case ENoConsole:

		GUICONS_ASSERT(!iConsole);

		CCoeEnv::Static()->RootWin().CancelTextCursor();

		iAppView->ShowLabelL(KNoConsole);

		break;

	case EConsoleActive:

		GUICONS_ASSERT(iConsole);

		iAppView->FocusEditor(EFalse);

		iAppView->RemoveEditorFromStack(this);

		RemoveFromStack(iConsole);

		AddToStackL(iConsole);

		iConsole->SetFocusing(ETrue);

		iConsole->SetFocus(ETrue);

		iAppView->ShowEditor();

		iEdwinWasLastRunningState = EFalse;

		break;

	case EEdwinActive:

		GUICONS_ASSERT(iConsole);

		iConsole->SetFocus(EFalse);

		iConsole->SetFocusing(EFalse);

		RemoveFromStack(iConsole);

		iAppView->ShowEditor();

		iAppView->FocusEditor(ETrue);

		iAppView->RemoveEditorFromStack(this);

		iAppView->AddEditorToStackL(this);

		iAppView->ShowEditor();

		iEdwinWasLastRunningState = ETrue;

		break;

	case EConsoleClosed:

		GUICONS_ASSERT(iConsole);

		iAppView->FocusEditor(EFalse);

		iAppView->RemoveEditorFromStack(this);

		RemoveFromStack(iConsole);

		iAppView->ShowLabelL(KConsoleClosed);

		CCoeEnv::Static()->RootWin().CancelTextCursor();

		break;

		}

	iState = aNewState;

	SetSoftkeysL();

	}

void CGuiConsAppUi::HandleNewConsoleL(CConsoleControl* aConsole)

	{

	CConsoleState* newState = new(ELeave) CConsoleState(aConsole);

	iTabs.AppendL(newState);

	if (aConsole == iTempState->iControl)

		{

		newState->iTitle.Copy(iTempState->iTitle);

		iTempState->iControl = NULL;

		}

	TBuf<2> text;

	text.Num(iTabs.Count());

	iTabGroup->AddTabL(reinterpret_cast<TInt>(newState), text);

	SwitchTabL(iTabs.Count()-1);

	SetStateToPreferredL();

	aConsole->ActivateL();

	}

void CGuiConsAppUi::HandleConsoleClosed(CConsoleControl* aConsole)

	{

	CConsoleState* state = StateForConsole(aConsole);

	if (state)

		{

		state->iConsoleClosed = ETrue;

		}

	if (aConsole && (aConsole == iConsole))

		{

		TRAP_IGNORE(SetStateL(EConsoleClosed));

		}

	}

void CGuiConsAppUi::ConsoleTitleChangedL(const CConsoleControl* aConsole, const TDesC& aTitle)

	{

	//SetNaviPaneTextL(aTitle);

	// Put it in the title so the navi bar is free for tabs

	if (aConsole == iConsole)

		{

		// If aConsole isn't current, we don't want to update anything

		CEikStatusPane* sp = StatusPane();

		CAknTitlePane* titlePane = NULL;

		if (sp) titlePane = (CAknTitlePane*)sp->ControlL(TUid::Uid(EEikStatusPaneUidTitle));

		if (titlePane)

			{

			if (aTitle.Length())

				{

				titlePane->SetTextL(aTitle);

				}

			else

				{

				titlePane->SetTextL(_L("GuiCons"));

				}

			}

		}

	// And update the state

	CConsoleState* state = StateForConsole(aConsole);

	if (state)

		{

		state->iTitle = aTitle.Left(state->iTitle.MaxLength());

		}

	else

		{

		iTempState->iControl = const_cast<CConsoleControl*>(aConsole);

		iTempState->iTitle = aTitle.Left(iTempState->iTitle.MaxLength());

		}

	}

TInt CGuiConsAppUi::GetConsoleBufferSize()

	{

	return iIniFile->GetInt(KIniBufferSize);

	}

const TDesC& CGuiConsAppUi::GetConsoleFont()

	{

	return iIniFile->GetString(KIniFont);

	}

CGuiConsAppUi::~CGuiConsAppUi()

	{

	CKeyCapturer::DeleteCapturer();

	iAppView->RemoveEditorFromStack(this);

	delete iConsoleServer;

	iTabs.ResetAndDestroy();

	delete iNaviDecorator;

	delete iAppView;

	delete iTempState;

	iCommands.ResetAndDestroy();

	delete iIniFile;

	}

void CGuiConsAppUi::HandleCommandL(TInt aCommand)

	{

	if (!CommandValidInCurrentState(aCommand))

		{

		_LIT(KNotAvailableNow, "Not available now");

		iEikonEnv->InfoMsg(KNotAvailableNow);

		return;

		}

	switch(aCommand)

		{

	case EEikCmdExit:

	case EAknSoftkeyExit:

		Exit();

		break;

	case EGuiConsFocusConsole:

		SetStateL(EConsoleActive);

		break;

	case EGuiConsFocusEdwin:

		SetStateL(EEdwinActive);

		break;

	case EGuiConsPageUp:

		iConsole->ViewPageUp();

		break;

	case EGuiConsPageDown:

		iConsole->ViewPageDown();

		break;

	case EGuiConsHome:

		iConsole->ViewHome();

		break;

	case EGuiConsEnd:

		iConsole->ViewEnd();

		break;

	case EGuiConsCloseConsole:

		DeleteCurrentConsoleL();

		break;

	case EGuiConsNewConsole:

		NewFshellProcessL(KNullDesC);

		break;

	case EGuiConsCtrlC:

		{

		TKeyEvent key;

		key.iCode = CTRL('c');

		key.iScanCode = 0;

		key.iRepeats = 0;

		key.iModifiers = EModifierLeftCtrl | EModifierCtrl;

		iConsole->OfferKeyEventL(key, EEventKey);

		break;

		}

	case EGuiConsShow5Way:

		{

		iShouldDisplayOnscreenNav = !iShouldDisplayOnscreenNav;

		if (iConsole) iConsole->SetDisplayFivewayNav(iShouldDisplayOnscreenNav);

		TRAP_IGNORE(iIniFile->SetL(KIniShowNav, iShouldDisplayOnscreenNav); iIniFile->WriteL());

		break;

		}

	case EGuiConsLongPressSwitchesTabs:

		{

		TBool capturing = CKeyCapturer::GetCapturerL()->IsCaptured(EKeyLeftArrow);

		SetCapturingLongPressesL(!capturing);

		TRAP_IGNORE(iIniFile->SetL(KIniLongPress, !capturing); iIniFile->WriteL());

		break;

		}

	case EGuiConsChooseFont:

		{

		// Note, we have to use the memory and file selection dialogs seperately

		// so that we can choose things from C: outside of C:\Data

		// choose drive

		// TODO see if we can do something better here, so we can also choose files from Z: and

		// other drives

		CAknMemorySelectionDialog::TMemory memory = CAknMemorySelectionDialog::EPhoneMemory;

		if (!CAknMemorySelectionDialog::RunDlgLD(memory))

			{

			break;

			}

		TChar drive = (memory == CAknMemorySelectionDialog::EPhoneMemory) ? 'C' : 'E';

		TFileName* fn = new(ELeave)TFileName;

		CleanupStack::PushL(fn);

		fn->Append(drive);

		fn->Append(_L(":\\"));

		CAknFileSelectionDialog* fileSel = CAknFileSelectionDialog::NewL(ECFDDialogTypeSelect);

		CleanupStack::PushL(fileSel);

		fileSel->SetDefaultFolderL(_L("\\"));

		if (fileSel->ExecuteL(*fn))

			{

			// verify that the file chosen is a valid font

			CConsoleFont* font = NULL;

			TRAPD(err, font = CConsoleFont::NewL(*fn));

			if (err!=KErrNone)

				{

				DisplayMessageL(KInvalidFontMsgFmt, fn, err);

				}

			else

				{

				TRAP_IGNORE(iIniFile->SetL(KIniFont, *fn); iIniFile->WriteL());

				DisplayMessageL(KFontPreview);

				}

			delete font;

			}

		CleanupStack::PopAndDestroy(2, fn); // fn, fileSel

		break;

		}

	case EGuiConsResetFont:

		iIniFile->RemoveValueL(KIniFont);

		iIniFile->WriteL();

		break;

	default:		

		break;

		}

	if (aCommand >= ETabStart)

		{

		TInt tabIdx = aCommand - ETabStart;

		SwitchTabL(tabIdx);

		}

	else if (aCommand >= ECommandStart)

		{

		TInt cmdIdx = aCommand - ECommandStart;

		InputTextL(*iCommands[cmdIdx]->iValue);

		}

	}

void CGuiConsAppUi::NewFshellProcessL(const TDesC& aArgs)

	{

	RBuf args;

	args.Create(aArgs.Length()+1+KNewProcArgs().Length());

	CleanupClosePushL(args);

	args.Append(KNewProcArgs);

	args.Append(' ');

	args.Append(aArgs);

	RProcess proc;

	User::LeaveIfError(proc.Create(KNewProcName, args));

	proc.Resume();

	proc.Close();

	CleanupStack::PopAndDestroy(&args);

	}

void CGuiConsAppUi::HandleStatusPaneSizeChange()

	{

	iAppView->SetRect( ClientRect() );

	}

void CGuiConsAppUi::SetMenuItemDimmed(TInt aCommandId, CEikMenuPane* aMenuPane)

	{

	aMenuPane->SetItemDimmed(aCommandId, !CommandValidInCurrentState(aCommandId));

	}

void CGuiConsAppUi::DynInitMenuPaneL(TInt aMenuId, CEikMenuPane* aMenuPane)

	{

	if (aMenuId == R_GUICONS_MENU)

		{

		SetMenuItemDimmed(EAknSoftkeyExit, aMenuPane);

		for (TInt i = EGuiConsCommandFirst; i<EGuiConsCommandLast; ++i)

			{

			SetMenuItemDimmed(i, aMenuPane);

			}

		}

	else if (aMenuId == R_GUICONS_TABS_SUBMENU)

		{

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

			{

			CConsoleState* state = iTabs[i];

			CEikMenuPaneItem::SData menu;

			menu.iCommandId = ETabStart + i;

			menu.iCascadeId = 0;

			menu.iFlags = 0;

			menu.iText = state->iTitle;

			aMenuPane->AddMenuItemL(menu);

			}

		}

	else if (aMenuId == R_GUICONS_SETTINGS_SUBMENU)

		{

		TBool capturing = CKeyCapturer::GetCapturerL()->IsCaptured(EKeyLeftArrow);

		aMenuPane->SetItemButtonState(EGuiConsLongPressSwitchesTabs, capturing ? EEikMenuItemSymbolOn : 0);

		aMenuPane->SetItemButtonState(EGuiConsShow5Way, iShouldDisplayOnscreenNav ? EEikMenuItemSymbolOn : 0);

		SetMenuItemDimmed(EGuiConsResetFont, aMenuPane);

		}

	else if (aMenuId == R_GUICONS_COMMANDS_SUBMENU)

		{