/*******************************************************************************

	CONDAT (UK)

********************************************************************************

 This software product is the property of Condat (UK) Ltd and may not be
 disclosed to any third party without the express permission of the owner.

********************************************************************************

 $Project name: Basic MMI
 $Project code: BMI (6349)
 $Module:   MMI
 $File:       AUICalcEditor.c
 $Revision:   1.0

 $Author:   Condat(UK)
 $Date:       22/02/01

********************************************************************************

 Description: Editor for calculator, or generic floating-point number input



********************************************************************************

 $History: AUICalcEditor.c

 	xrashmic 20 Oct, 2005 MMI-SPR-33845
	To display BACK softkey when no more character are left in the calculator editor

  14/11/02      Original Condat(UK) BMI version.
 $End

*******************************************************************************/

#define ENTITY_MFW

/* includes */
#include <string.h>
#include <stdio.h>
#include <stdlib.h>

#if defined (NEW_FRAME)

#include "typedefs.h"
#include "vsi.h"
#include "pei.h"
#include "custom.h"
#include "gsm.h"

#else

#include "STDDEFS.H"
#include "custom.h"
#include "gsm.h"
#include "vsi.h"

#endif

#include "mfw_mfw.h"
#include "mfw_win.h"
#include "mfw_kbd.h"
#include "mfw_tim.h"
#include "mfw_phb.h"
#include "mfw_sms.h"
#include "mfw_ss.h"
#include "mfw_icn.h"
#include "mfw_mnu.h"
#include "mfw_lng.h"
#include "mfw_sat.h"
#include "mfw_kbd.h"
#include "mfw_nm.h"
#include "mfw_cm.h"

#include "dspl.h"

#include "ksd.h"
#include "psa.h"

#include "MmiDummy.h"
#include "MmiMmi.h"

#include "MmiDialogs.h"
#include "MmiLists.h"
#include "MmiMenu.h"
#include "MmiSoftKeys.h"
#include "MmiIdle.h"
#include "MmiResources.h"

#include "cus_aci.h"
#include "prim.h"
#ifndef PCM_2_FFS
#include "pcm.h"
#endif

#include "mmiColours.h"

#include "ATBCommon.h"
#include "ATBDisplay.h"
#include "ATBEditor.h"
#include "AUIEditor.h"
#include "AUITextEntry.h"

#include "AUICalcEditor.h"

typedef struct
{
    T_MMI_CONTROL		mmi_control;
    T_MFW_HND			parent;				// The parent window
    T_MFW_HND			win;				// The edit window
    T_MFW_HND			kbd;				// The keyboard handler
    T_MFW_HND			kbd_long;			// The longpress keyboard handler
    T_MFW_HND			timer;				// The timer for timeouts

	T_ED_DATA			*editor;			/* The ATB editor */
	T_AUI_EDITOR_DATA	editor_data;		/* The MMI editor data, provided by caller */
    T_AUI_ENTRY_DATA	*entry_data;		/* The MMI text entry data */

	BOOL				haveTitle;			/* TRUE if a title is supplied */
    T_ATB_TEXT			title;				/* Title of editor */
    BOOL				haveResult;			/* TRUE if a result is supplied */
    T_ATB_TEXT			result;				/* Text of result */

	BOOL				doNextLongPress;	/* Flag used to notice/not notice long keypress */
	BOOL				hasDecimalPoint;	/* Ensures only one decimal point per number */
}
T_AUI_CALC_DATA;

/* LOCAL FUNCTION PROTOTYPES */
static T_MFW_HND AUI_calc_Create(T_MFW_HND parent, T_AUI_EDITOR_DATA *editor_data);
static void AUI_calc_ExecCb(T_MFW_HND win, USHORT event, SHORT value, void *parameter);
static int AUI_calc_WinCb(T_MFW_EVENT event, T_MFW_WIN *win_data);
static int AUI_calc_KbdCb(T_MFW_EVENT event, T_MFW_KBD *keyboard);
static int AUI_calc_KbdLongCb(T_MFW_EVENT event, T_MFW_KBD *keyboard);




/*******************************************************************************

 $Function:		AUI_calc_Start

 $Description:	Start the Calc editor.

 $Returns:		None.

 $Arguments:	None.

*******************************************************************************/

T_MFW_HND AUI_calc_Start(T_MFW_HND parent, T_AUI_EDITOR_DATA *editor_data)
{
    T_MFW_HND win;

    TRACE_FUNCTION ("AUI_calc_Start()");
    win = AUI_calc_Create(parent, editor_data);

    return win;
}


/*******************************************************************************

 $Function:		AUI_calc_Create

 $Description:	Create the Calc editor.

 $Returns:		Pointer to the editor's window.

 $Arguments:	parent	-	The parent window.

*******************************************************************************/

static T_MFW_HND AUI_calc_Create(T_MFW_HND parent, T_AUI_EDITOR_DATA *editor_data)
{
    T_AUI_CALC_DATA	*data = (T_AUI_CALC_DATA *)ALLOC_MEMORY(sizeof (T_AUI_CALC_DATA));
    T_MFW_WIN     		*win_data;

    TRACE_FUNCTION ("AUI_calc_Create()");

	/* Create window handler */

    data->win = win_create(parent, 0, E_WIN_VISIBLE, (T_MFW_CB)AUI_calc_WinCb);	// Create window

    if (data->win==NULL)														// Make sure window exists
    {
		return NULL;
    }

	/* Connect the dialog data to the MFW-window */

    data->mmi_control.dialog	= (T_DIALOG_FUNC)AUI_calc_ExecCb;				/* Setup the destination for events */
    data->mmi_control.data		= data;
    data->parent				= parent;
    win_data					= ((T_MFW_HDR *)data->win)->data;
    win_data->user				= (void *)data;

 	data->kbd					= kbd_create(data->win, KEY_ALL,(T_MFW_CB)AUI_calc_KbdCb);
	data->kbd_long				= kbd_create(data->win, KEY_ALL|KEY_LONG,(T_MFW_CB)AUI_calc_KbdLongCb);
	data->editor				= ATB_edit_Create(&data->editor_data.editor_attr,0);

	data->editor_data = *editor_data;
	data->entry_data = AUI_entry_Create(data->win, data->editor, E_CALC_UPDATE);

	SEND_EVENT(data->win, E_CALC_INIT, 0, 0);

    /* Return window handle */

    return data->win;
}


/*******************************************************************************

 $Function:		AUI_calc_Destroy

 $Description:	Destroy the Calc editor.

 $Returns:		None.

 $Arguments:	window	-	The editor window.

*******************************************************************************/

void AUI_calc_Destroy(T_MFW_HND win)
{
    T_MFW_WIN		*win_data	= ((T_MFW_HDR *)win)->data;
    T_AUI_CALC_DATA	*data		= (T_AUI_CALC_DATA *)win_data->user;

    if (data)
    {
		AUI_entry_Destroy(data->entry_data);

        win_delete (data->win);

		/* Free memory allocated to store result */

		if (data->haveResult)
		{
			FREE_MEMORY(data->result.data, data->result.len*sizeof(char));
		}

		/* Free editor memory */

		ATB_edit_Destroy(data->editor);
		FREE_MEMORY ((void *)data, sizeof (T_AUI_CALC_DATA));
    }

    return;
}


/*******************************************************************************

 $Function:    	AUI_calc_ExecCb

 $Description:	Dialog function for Calc editor.

 $Returns:		None.

 $Arguments:	None.

*******************************************************************************/

static void AUI_calc_ExecCb(T_MFW_HND win, USHORT event, SHORT value, void *parameter)
{
    T_MFW_WIN			*win_data	= ((T_MFW_HDR *)win)->data;
    T_AUI_CALC_DATA		*data		= (T_AUI_CALC_DATA *)win_data->user;
    T_MFW_HND			parent_win	= data->parent;
	USHORT				textIndex;
	T_ATB_TEXT			text;
	/* Store these in case editor is destroyed on callback */
    USHORT				Identifier	= data->editor_data.Identifier;
    T_AUI_EDIT_CB		Callback	= data->editor_data.Callback;
    UBYTE				destroyEditor = data->editor_data.destroyEditor;

    TRACE_FUNCTION ("AUI_calc_ExecCb()");

    switch (event)
    {
    	/* Initialise */

        case E_CALC_INIT:
        	TRACE_EVENT("E_CALC_INIT");
        	ATB_edit_Init(data->editor);

        	data->haveTitle = FALSE;
        	data->haveResult = FALSE;

			/* If we require an output line, shrink editor to fit it at bottom
			 * NB TitleString is assumed here to be a numeric string of ascii digits */

			if (data->editor_data.TitleString)
			{
				data->haveResult = TRUE;
				text.dcs = ATB_DCS_ASCII;
				text.data = data->editor_data.TitleString;
				text.len = ATB_string_Length(&text);

				data->result.data = ALLOC_MEMORY(text.len*sizeof(char));
				ATB_string_Copy(&data->result, &text);

				/* Change size of editor to fit result line in */
				data->editor_data.editor_attr.win_size.sy -= ATB_display_StringHeight(&data->result, NULL);
			}

			/* Set up title */

			if (data->editor_data.TitleId!=NULL)
			{
				data->haveTitle = TRUE;
				data->title.data = (UBYTE *)MmiRsrcGetText(data->editor_data.TitleId);
			}

			/* If title exists, get its dcs and length */

			if (data->haveTitle)
			{
				if (data->title.data[0]==0x80)
				{
					data->title.data += 2;		/* Skip over two unicode indicator bytes */
					data->title.dcs = ATB_DCS_UNICODE;
				}
#ifdef EASY_TEXT_ENABLED
				else if (Mmi_getCurrentLanguage() == CHINESE_LANGUAGE)
				{
					data->title.dcs = ATB_DCS_UNICODE;
				}
#endif
				else
				{
					data->title.dcs = ATB_DCS_ASCII;
				}

				data->title.len = ATB_string_Length(&data->title);
			}

        	/* Check to see if number already has decimal point */

			data->hasDecimalPoint = FALSE;

			for (textIndex = 0; textIndex<data->editor->attr->text.len; textIndex++)
			{
				if (ATB_string_GetChar(&data->editor->attr->text, textIndex)==UNICODE_FULLSTOP)
				{
					data->hasDecimalPoint = TRUE;
				}
			}

			/* Show the window */
			win_show(data->win);
			break;

		case E_CALC_UPDATE:
        	TRACE_EVENT("E_CALC_UPDATE");
			win_show(data->win);
			break;

		case E_CALC_DEINIT:
			TRACE_EVENT("E_CALC_DEINIT");

			if (Callback)
    	    	(Callback) (parent_win, Identifier, value);

			if (destroyEditor)
				AUI_calc_Destroy(data->win);

			break;

   	}

    return;
}

/*******************************************************************************

 $Function:		AUI_calc_WinCb

 $Description:	Calc editor window event handler.

 $Returns:		None.

 $Arguments:	event	- the event
 				win		- the editor window

*******************************************************************************/

static int AUI_calc_WinCb(T_MFW_EVENT event, T_MFW_WIN *win_data)
{
    T_AUI_CALC_DATA		*data			= (T_AUI_CALC_DATA *)win_data->user;
    T_ED_DATA			*editor			= data->editor;
    T_ATB_WIN_SIZE		*win_size		= &data->editor->attr->win_size;
    T_DS_TEXTFORMAT		format;
//    USHORT				titleLen;   // RAVI

	TRACE_EVENT("AUI_calc_WinCb");

	if (!data)
		return MFW_EVENT_CONSUMED;

    switch(event)
    {
        case E_WIN_VISIBLE: 											/* window is visible */
            if (win_data->flags & E_WIN_VISIBLE)
			{
				if (editor->update==ED_UPDATE_TRIVIAL)
				{
					TRACE_EVENT("Only updating editor.");
					ATB_edit_Show(data->editor);
				}
				else
				{
					TRACE_EVENT("Updating whole screen.");

					ATB_edit_Show(data->editor);

					/* Set the colour for drawing title */

					resources_setTitleColour(COLOUR_EDITOR);

					/* TITLE */

					dspl_Clear(0,0, SCREEN_SIZE_X-1, win_size->py-1);

					if (data->haveTitle)
					{
						ATB_display_SetFormatAttr(&format, 0, FALSE);
						ATB_display_Text(0,0,&format, &data->title);
					}

					/* RESULT */

					if (data->haveResult)
					{
						resources_setHLColour(COLOUR_EDITOR);
						ATB_display_SetFormatAttr(&format, 0, FALSE);
						dspl_Clear( win_size->px, win_size->py+win_size->sy,  win_size->px+win_size->sx,
							win_size->py+win_size->sy+ATB_display_StringHeight(&data->result, &format));

						ATB_display_Text(win_size->px+win_size->sx-ATB_display_StringWidth(&data->result, &format),
							win_size->py+win_size->sy,&format, &data->result);
					}

					/* Display Soft Keys */
					//xrashmic 20 Oct, 2005 MMI-SPR-33845
					//Need to display the alternate right softkey when the editor is does not contain any character other than 0.
					if (data->editor_data.editor_attr.text.len == data->editor_data.min_enter && (data->editor_data.editor_attr.text.data[0] == '0'))
					{
						/* entered less than the required number of chars: Alternate Softkey appears */
						displaySoftKeys(data->editor_data.LeftSoftKey,data->editor_data.AltRightSoftKey);
					}
					else
					{
						/* entered sufficient number of chars: Normal Softkey appears */
						displaySoftKeys(data->editor_data.LeftSoftKey, data->editor_data.RightSoftKey);
					}
				}
			}
            break;
    }

	data->editor->update = ED_UPDATE_DEFAULT;

	return MFW_EVENT_CONSUMED;
}


/*******************************************************************************

 $Function:		AUI_calc_KbdCb

 $Description:	Calc editor keyboard event handler

 $Returns:		None.

 $Arguments:	event		- The keyboard event
 				keyboard 	- The keypress info

*******************************************************************************/

static int AUI_calc_KbdCb(T_MFW_EVENT event, T_MFW_KBD *keyboard)
{
	T_MFW_HND			win			= mfw_parent (mfw_header());
	T_MFW_WIN			*win_data	= ((T_MFW_HDR *)win)->data;
	T_AUI_CALC_DATA		*data		= (T_AUI_CALC_DATA *)win_data->user;
	ED_RES				result;

	TRACE_FUNCTION("AUI_calc_KbdCb()");

   /* Suppress unwanted long keypresses */

	data->doNextLongPress = TRUE;         		/* next Key_long event is correct */
	data->editor->update = ED_UPDATE_DEFAULT;	/* Default behaviour is just to update text */

	switch (keyboard->code)
	{
#ifdef COLOURDISPLAY
		case KCD_MNUSELECT:
			if (data->editor_data.Callback)
    	    	(data->editor_data.Callback) (data->parent, data->editor_data.Identifier, INFO_KCD_SELECT);
			break;

#endif /* COLOURDISPLAY */

		case KCD_STAR:
			if (data->editor_data.Callback)
    	    	(data->editor_data.Callback) (data->parent, data->editor_data.Identifier, INFO_KCD_STAR);
			break;

		case KCD_HASH:
			/* Insert decimal point, if the number doesn't have one already */
			if (!data->hasDecimalPoint)
			{
				data->hasDecimalPoint = TRUE;
				AUI_entry_EditChar(data->entry_data, UNICODE_FULLSTOP, FALSE);
				win_show(data->win);
			}
			break;

		case KCD_LEFT:
			if (data->editor_data.editor_attr.text.len < data->editor_data.min_enter)
			{
				/* Entered less than the required number of chars */
				if (data->editor_data.AltLeftSoftKey!=TxtNull)
				{
					/* an alternate softkey is defined: execute it */
					SEND_EVENT (win, E_CALC_DEINIT, INFO_KCD_ALTERNATELEFT, NULL);
				}
			}
			else if (data->editor_data.LeftSoftKey!=TxtNull)
			{
				/* Left Softkey is enabled (and entered sufficient number of chars): execute it */
				SEND_EVENT (win, E_CALC_DEINIT, INFO_KCD_LEFT, NULL);
			}
			break;

		case KCD_HUP:
			SEND_EVENT(data->win, E_CALC_DEINIT, INFO_KCD_HUP, 0);
			break;

		case KCD_RIGHT:
			/* If we're deleting the decimal point... */
			if (ATB_edit_GetCursorChar(data->editor, -1)==UNICODE_FULLSTOP)
			{
				data->hasDecimalPoint = FALSE;
			}

			/* If we've just got a zero, delete it so we can exit with next call to ATB_edit_DeleteLeft() */

			if (ATB_edit_GetCursorChar(data->editor, -1)==ATB_char_Unicode('0'))
			{
				ATB_edit_DeleteLeft(data->editor, FALSE); /* SPR#2342 - SH */
			}

			/* Perform normal delete */
			result = ATB_edit_DeleteLeft(data->editor, TRUE); /* SPR#2342 - SH */

			/* If buffer is now empty, insert '0' */
			if (data->editor->attr->text.len==0 && result!=ED_DONE)
			{
				AUI_entry_EditChar(data->entry_data, ATB_char_Unicode('0'), FALSE);
			}

			/* If we've deleted on an empty buffer, exit editor */
			if (result==ED_DONE)
			{
				SEND_EVENT(data->win, E_CALC_DEINIT, INFO_KCD_RIGHT, 0);
			}
			else
			{
				win_show(data->win);
			}
			break;

		/* 0 - 9 */

		case KCD_0:
		case KCD_1:
		case KCD_2:
		case KCD_3:
		case KCD_4:
		case KCD_5:
		case KCD_6:
		case KCD_7:
		case KCD_8:
		case KCD_9:
			/* Remove leading zero */
			if (data->editor->attr->text.len==1 && ATB_edit_GetCursorChar(data->editor, -1)==ATB_char_Unicode('0'))
			{
				ATB_edit_DeleteLeft(data->editor, FALSE); /* SPR#2342 - SH */
			}

			/* Insert the digit */
			AUI_entry_EventKey(data->entry_data, event, keyboard);
			win_show(data->win);
			break;
	}

	return MFW_EVENT_CONSUMED;
}


/*******************************************************************************

 $Function:		AUI_calc_KbdLongCb

 $Description:	Calc editor long keypress event handler

 $Returns:		None.

 $Arguments:	event		- The keyboard event
 				keyboard 	- The keypress info

*******************************************************************************/

static int AUI_calc_KbdLongCb(T_MFW_EVENT event, T_MFW_KBD *keyboard)
{
	T_MFW_HND			win			= mfw_parent (mfw_header());
	T_MFW_WIN			*win_data	= ((T_MFW_HDR *)win)->data;
	T_AUI_CALC_DATA		*data		= (T_AUI_CALC_DATA *)win_data->user;
	ED_RES				result;

    /* Suppress unwanted long keypresses */

	 if ( data->doNextLongPress )
		data->doNextLongPress = FALSE;       			/* mark Key_long event as consumed but do current long press */
	else
		return MFW_EVENT_CONSUMED;      		/* don't do current long press */

	switch (keyboard->code)
	{
		case KCD_RIGHT:
			/* Long press of RSK deletes buffer */
			result = ATB_edit_ClearAll(data->editor);

			/* If buffer is now empty, insert '0' */
			if (data->editor->attr->text.len==0 && result!=ED_DONE)
			{
				AUI_entry_EditChar(data->entry_data, ATB_char_Unicode('0'), FALSE);
			}

			/* If we've deleted on an empty buffer, exit editor */
			if (result==ED_DONE)
			{
				SEND_EVENT(data->win, E_CALC_DEINIT, INFO_KCD_RIGHT, 0);
			}
			else
			{
				win_show(data->win);
			}
			break;
	}

	return MFW_EVENT_CONSUMED;
}