/*
+--------------------------------------------------------------------+
| PROJECT: MMI-Framework (8417)         $Workfile:: mfw_edt.c       $|
| $Author:: Es  $ CONDAT GmbH           $Revision:: 15              $|
| CREATED: 21.09.98                     $Modtime:: 23.03.00 8:57    $|
| STATE  : code                                                      |
+--------------------------------------------------------------------+

   MODULE  : MFW_EDT

   PURPOSE : edit handling functions

   EXPORT  :

   TO DO   :

   $History:: mfw_edt.c    
   
	Aug 16, 2004    REF: CRR 24323   Deepa M.D
	Bug:Clenup of sprintf used for tracing
	Fix:Replace the char buf[]; sprintf (buf, "...", ...); TRACE_EVENT (buf); statements by TRACE_EVENT_PX                                     $
 * 
 * *****************  Version 15  *****************
 * User: Es           Date: 23.03.00   Time: 14:40
 * Updated in $/GSM/Condat/MS/SRC/MFW
 * added edtUnhide()
 * 
 * *****************  Version 14  *****************
 * User: Kk           Date: 21.02.00   Time: 9:36
 * Updated in $/GSM/Condat/MS/SRC/MFW
 * changes from es inserted
 *
 * *****************  Version 13  *****************
 * User: Es           Date: 18.02.00   Time: 15:45
 * Updated in $/GSM/Condat/MS/SRC/MFW
 * added edit controls: ecTop, ecBottom
|
| *****************  Version 12  *****************
| User: Le           Date: 6.01.00    Time: 9:23
| Updated in $/GSM/Condat/MS/SRC/MFW
| Alignment of MFW versions
 *
 * *****************  Version 3  *****************
 * User: Kk           Date: 13.12.99   Time: 17:30
 * Updated in $/GSM/Condat/SND-MMI/MFW
 *
 * *****************  Version 2  *****************
 * User: Es           Date: 22.11.99   Time: 10:29
 * Updated in $/GSM/Condat/SND-MMI/MFW
 *
 * *****************  Version 1  *****************
 * User: Es           Date: 18.11.99   Time: 16:35
 * Created in $/GSM/Condat/SND-MMI/MFW
 * Initial
 *
 * *****************  Version 11  *****************
 * User: Es           Date: 6.07.99    Time: 12:18
 * Updated in $/GSM/DEV/MS/SRC/MFW
 *
 * *****************  Version 10  *****************
 * User: Es           Date: 14.04.99   Time: 17:34
 * Updated in $/GSM/DEV/MS/SRC/MFW
 * moved to CST
|
| *****************  Version 9  *****************
| User: Le           Date: 14.04.99   Time: 9:51
| Updated in $/GSM/DEV/MS/SRC/MFW
 *
 * *****************  Version 8  *****************
 * User: Es           Date: 1.04.99    Time: 17:07
 * Updated in $/GSM/DEV/MS/SRC/MFW
 * removed lots of traces
 *
 * *****************  Version 7  *****************
 * User: Es           Date: 18.02.99   Time: 17:01
 * Updated in $/GSM/DEV/MS/SRC/MFW
 *
 * *****************  Version 6  *****************
 * User: Es           Date: 17.02.99   Time: 19:10
 * Updated in $/GSM/DEV/MS/SRC/MFW
 *
 * *****************  Version 5  *****************
 * User: Es           Date: 8.02.99    Time: 19:06
 * Updated in $/GSM/DEV/MS/SRC/MFW
 * Cursor auf 0 !
 *
 * *****************  Version 4  *****************
 * User: Es           Date: 27.01.99   Time: 15:06
 * Updated in $/GSM/DEV/MS/SRC/MFW
 *
 * *****************  Version 3  *****************
 * User: Es           Date: 14.01.99   Time: 17:19
 * Updated in $/GSM/DEV/MS/SRC/MFW
 *
 * *****************  Version 2  *****************
 * User: Es           Date: 23.12.98   Time: 16:19
 * Updated in $/GSM/DEV/MS/SRC/MFW
*/


#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 <stdio.h>
#include <string.h>

#include "mfw_mfw.h"
#include "mfw_sys.h"
#include "gdi.h"
#include "dspl.h"
#include "mfw_edt.h"
#include "font_bitmaps.h"

#include "mfw_mmi.h"

#define TIME_TRACE_EVENT TRACE_EVENT
#ifndef TIME_TRACE_EVENT 
#define TIME_TRACE_EVENT
#endif

static int edtInsert (int c, char *b, int s, U8 curMode, U16 curCP);
static int edtCommand (U32 cmd, void *h);
void moveLeft (char * str, int ofs);

static void edtUnicodeSplitLine (int px, int py, int ls, int ly, U16 *tp);

static void moveLeftUnicode(U16 *unicodeStr, int nChars);
static int  edtInsertUnicode (MfwEdt *e, int c, U16 *b, int s);

U16 strlenUnicode(U16* str);

static void edtOutTextLines (int px, int py, int ls, int ly, U16 *tpUnicode, unsigned char* tpAscii,
							 int fontHeight, int display);
MfwRes updateWindow (MfwEdt *e, int  dy	);

int isAWordChar( char chr);

//Define the chars that correspond to the end of a word.
#define STR_WORDBREAK " .?!"

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EDT            |
| STATE   : code                        ROUTINE : edtInit            |
+--------------------------------------------------------------------+

  PURPOSE : initialize edit handler

*/

MfwRes edtInit (void)
{
    mfwCommand[MfwTypEdt] = (MfwCb) edtCommand;

    return MfwResOk;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EDT            |
| STATE   : code                        ROUTINE : edtExit            |
+--------------------------------------------------------------------+

  PURPOSE : finalize edit handler

*/

MfwRes edtExit (void)
{
    mfwCommand[MfwTypEdt] = 0;

    return MfwResOk;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EDT            |
| STATE   : code                        ROUTINE : edtCreate          |
+--------------------------------------------------------------------+

  PURPOSE : create editor control

*/

MfwHnd edtCreate (MfwHnd w, MfwEdtAttr *a, MfwEvt e, MfwCb f)
{
    MfwHdr *hdr = (MfwHdr *) mfwAlloc(sizeof(MfwHdr));
    MfwEdt *edt = (MfwEdt *) mfwAlloc(sizeof(MfwEdt));
	MfwHdr *insert_status =0;
	TRACE_FUNCTION("edtCreate");
	
    if (!hdr || !edt)
    {
    	TRACE_ERROR("ERROR: edtCreate() Mem Alloc Failed.");
			
	   	if(hdr)
   			mfwFree((U8*)hdr,sizeof(MfwHdr));

   		if(edt)
   			mfwFree((U8*)edt,sizeof(MfwEdt));
	   	return 0;
  	}

    edt->mask = e;
    edt->flags = 0;
    edt->handler = f;
    edt->attr = a;
    edt->cp = 0;                        /* cursor position          */
    edt->curOffs = 0;

    hdr->data = edt;
    hdr->type = MfwTypEdt;

    edtUpdate(edt);

    insert_status = mfwInsert(w,hdr);
    
    if(!insert_status)
	{
  		TRACE_ERROR("ERROR: edtCreate() Failed to Install Handler. ");
   		mfwFree((U8*)hdr,sizeof(MfwHdr));
   		mfwFree((U8*)edt,sizeof(MfwEdt));
		return 0;
  	}
    return insert_status;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EDT            |
| STATE   : code                        ROUTINE : edtDelete          |
+--------------------------------------------------------------------+

  PURPOSE : delete editor control

*/

MfwRes edtDelete (MfwHnd e)
{
    MfwRes res;

    if (!e)
        return MfwResIllHnd;

    edtHide(e);                         /* hide editor contents     */
    res = (mfwRemove(e)) ? MfwResOk : MfwResIllHnd;

    mfwFree(((MfwHdr *) e)->data,sizeof(MfwEdt));
    mfwFree(e,sizeof(MfwHdr));

    return res;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EDT            |
| STATE   : code                        ROUTINE : edtReset           |
+--------------------------------------------------------------------+

  PURPOSE : reset editor control

*/

MfwRes edtReset (MfwHnd w)
{
    MfwEdt *e;


	TRACE_FUNCTION("edtReset()");
    if (!w)
        return MfwResIllHnd;            /* editor does not exist    */

    e = ((MfwHdr *) w)->data;

    if (!e)
        return MfwResIllHnd;            /* editor does not exist    */

    e->cp = 0;                          /* cursor position          */
    e->curOffs = 0;

    return MfwResOk;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EDT            |
| STATE   : code                        ROUTINE : edtShow            |
+--------------------------------------------------------------------+

  PURPOSE : show editor

*/

MfwRes edtShow (MfwHnd e)
{
    MfwEdt *edt;

	TRACE_FUNCTION("edtShow()");

    if (!e)
        return MfwResIllHnd;            /* editor does not exist    */

    edt = ((MfwHdr *) e)->data;         /* get control block        */

    edt->flags |= MfwEdtVisible;        /* editor is visible        */
    if (edt->handler)                   /* call event handler       */
        if (edt->mask & MfwEdtVisible)
            edt->handler(MfwEdtVisible,edt);
    edt->display = 1;                        /* really show it           */
    edtUpdate(edt);                     /* draw editor elements     */

    return MfwResOk;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EDT            |
| STATE   : code                        ROUTINE : edtHide            |
+--------------------------------------------------------------------+

  PURPOSE : hide editor

*/

MfwRes edtHide (MfwHnd e)
{
    MfwEdt *edt;

	TRACE_FUNCTION("edtHide()");
    if (!e)
        return MfwResIllHnd;            /* element does not exist   */

    edt = ((MfwHdr *) e)->data;         /* get edit control block   */
    edt->flags &= ~MfwEdtVisible;       /* editor is not visible    */
    if (edt->handler)                   /* call event handler       */
        if (edt->mask & MfwEdtVisible)
            edt->handler(MfwEdtVisible,edt);

    return MfwResOk;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EDT            |
| STATE   : code                        ROUTINE : edtUnhide          |
+--------------------------------------------------------------------+

  PURPOSE : unhide editor (without drawing)

*/

MfwRes edtUnhide (MfwHnd e)
{
    MfwEdt *edt;
    
	TRACE_FUNCTION("edtunhide()");
	
    if (!e)
        return MfwResIllHnd;            /* element does not exist   */

    edt = ((MfwHdr *) e)->data;         /* get edit control block   */
    edt->flags |= MfwEdtVisible;        /* editor is visible        */
    if (edt->handler)                   /* call event handler       */
        if (edt->mask & MfwEdtVisible)
            edt->handler(MfwEdtVisible,edt);

    return MfwResOk;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EDT            |
| STATE   : code                        ROUTINE : edtClear           |
+--------------------------------------------------------------------+

  PURPOSE : clear editor

*/

MfwRes edtClear (MfwHnd e)
{
    MfwEdt *edt;

    TRACE_FUNCTION("edtClear()");

    if (!e)
        return MfwResIllHnd;            /* element does not exist   */

    edt = ((MfwHdr *) e)->data;         /* get edit control block   */
    if (edtReset(e) && edt->attr->text)
    {
        *(edt->attr->text) = 0;         /* clear buffer             */
        edtUpdate(edt);                 /* clear edit area          */
    }

    return MfwResOk;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EDT            |
| STATE   : code                        ROUTINE : edtUpdate          |
+--------------------------------------------------------------------+

  PURPOSE : draw editor
GW 06/09/01 - Call chinese update if first char is 0x80,0x81 or 0x82.
GW 06/09/01 - Added extra parameters to displ_setCursorPos for the size of cursor.
*/

//Return non-zero result if chr is in the string str.
int chrInString(char chr,char* str)
{
	int i;
	i=0;

	TRACE_FUNCTION("chrInString()");
	
	while (str[i] != 0x00)
	{
		if (str[i]== chr)
			return (i+1);
		else
			i++;
	}
	//Not found -
	return (0);
}

//GW 18/09/01 Use 'isAWordChar' procedure instead of 'chrInString' 
void findWordBounds(MfwEdt *e, int *opStChr, int *opEndChr)
{
	int found;
	int stChr,endChr;

	TRACE_FUNCTION("findWordBounds()");
	
	//Find char before start of the word.
	stChr = e->cp-1;
	found = FALSE;
	while ((stChr >0) && (!found))
	{
		if (isAWordChar(e->attr->text[stChr])==0)
			found = TRUE;
		else
			stChr--;
	}
	//find char after end of the word.
	endChr = e->cp;
	found = FALSE;
	while ((e->attr->text[endChr]!=0x00 ) && (!found))
	{
		if (isAWordChar(e->attr->text[endChr])==0)
			found = TRUE;
		else
			endChr++;
	}
	*opStChr  = stChr;
	*opEndChr = endChr;
}

//GW 18/09/01 Commented out debug code. 
MfwRes edtUpdate (MfwEdt *e)
{
	UBYTE temp;

    char *tp;
    S16 px, py;                         /* top left corner of edit  */
    S16 ls;                             /* width of edit window     */
    S16 ly;                             /* bottom of edit window    */
    U8 oldFont = -1;                    /* store previous font      */
	char* endChar;

    unsigned char *tb;

	//Data used to add word highlight 
	char saveChr[2];
	char startHtext[2] = {0x01,0x00};
	char endHtext[2]   = {0x02,0x00};
	int stChr,endChr;

	U16* tmp;

	TRACE_FUNCTION("edtUpdate()");

    if (!e)
        return MfwResIllHnd;

    if (!e->attr->text)
        return MfwResErr;               /* no text to display       */

	//Have we still got keys in the buffer to process? - process them first!
    if (mfwKey_skipDisplay())
		return (MfwResOk);
    
	tb = (unsigned char*)e->attr->text;

	if ((tb[0] == 0x80) || (tb[0] == 0x81) || (tb[0] == 0x82))
	{
		return( edtUpdateUnicode (e ) );
	}

	temp = dspl_get_char_type();		
	dspl_set_char_type(DSPL_TYPE_ASCII);

	//TRACE_EVENT_P1("flags: %d", e->flags);
    if (!(e->flags & MfwEdtVisible))
        e->display = 0;                    /* invisible editor         */

	resources_setColour(e->attr->edtCol);	
    tp = e->attr->text + e->curOffs;    /* start of display buffer  */
    px = e->attr->win.px;               /* left of edit window      */
    py = e->attr->win.py;               /* top of edit window       */
    ls = e->attr->win.sx;               /* width of edit window     */
    ly = (S16) (py+e->attr->win.sy);	/* bottom of edit window    */
    if (e->attr->font != (U8) -1)
        oldFont = dspl_SelectFontbyID(e->attr->font); /* setup font */
    e->fontHeight = dspl_GetFontHeight();  /* get height of curr font  */
    e->curMode = e->attr->mode;            /* setup edi mode           */
    if (e->display)
	{
		dspl_TextOut (e->attr->win.px, e->attr->win.py, 0, endHtext);
        dspl_Clear(e->attr->win.px,e->attr->win.py,(U16)(ls+e->attr->win.px-1),(U16)(ly-1));
	}

    dspl_SetCursor(0,(U8)(e->curMode&edtCurMask));

	//Add a space to the end of the line
	endChar = &tp[strlen(tp)];
	if ((endChar[0] == 0x00) &&
		(endChar[1] == 0x00))
	{
		endChar[0] = ' ';
		endChar[1] = 0x00;
		//For some editors, we want to highlight a complete word
		if (e->curMode & edtModWordSkip)
		{

			//find char at the start of the word
			findWordBounds(e,&stChr,&endChr);
			saveChr[0] = e->attr->text[stChr];
			saveChr[1] = e->attr->text[endChr];
			if (endChr == e->cp) // do not highlight if at the start of a word
			{
				if (stChr > e->curOffs)
					e->attr->text[stChr] = 0x01;
				else
					dspl_TextOut (e->attr->win.px, e->attr->win.py, 0, startHtext);
				e->attr->text[endChr] = 0x02;
			}

		}
		edtOutTextLines(e->attr->win.px, e->attr->win.py, ls, ly, NULL, (unsigned char*)tp,
						e->fontHeight, e->display); //* show it     * /
		if (e->curMode & edtModWordSkip)
		{
			e->attr->text[stChr] = saveChr[0];
			e->attr->text[endChr]= saveChr[1];
		}
		//and remove space again.
		endChar[0] = 0x00;
	}
	else
	{	//Cannot add space
		edtOutTextLines(e->attr->win.px, e->attr->win.py, ls, ly, NULL, (unsigned char*)tp,
						e->fontHeight, e->display); //* show it     * /
	}
	//GW 18/09/01 - Display predicted word.
    if (e->display)
	{
		if ((e->attr->predText[0] != '\0') && (e->attr->win.py >=e->fontHeight))
        {
			dspl_TextOut(0,e->attr->win.py-e->fontHeight,0,"             " );
			dspl_TextOut(0,e->attr->win.py-e->fontHeight,1,e->attr->predText );
        }
	}

    if (e->display && (e->curMode & edtCurMask))
    	{
        dspl_SetCursorPos(e->curCX+e->attr->win.px,e->curCY,e->curCSize,(S16)e->fontHeight); // sbh 19/02/02, position cursor correctly
    	}
    if (oldFont != (U8) -1)
        dspl_SelectFontbyID(oldFont);   /* restore previous font    */

#ifdef MFW_DEBUG_DISPLAY_SIZE
	{
		USHORT ax,ay,aw,ah;
		ax = e->attr->win.px;
		ay = e->attr->win.py;
		aw = e->attr->win.sx;
		ah = e->attr->win.sy;
    	dspl_DrawRect(ax,ay,(ax+aw-1),(ay+ah-1));
	    {
			/***************************Go-lite Optimization changes Start***********************/
	    	//	Aug 16, 2004    REF: CRR 24323   Deepa M.D
	    	TRACE_EVENT_P4(" ax:%d ay:%d aw:%d ah:%d",ax,ay,aw,ah);
			/***************************Go-lite Optimization changes end***********************/
	    } 	
    }
#endif
	dspl_set_char_type(temp);
	resources_restoreColour();
TIME_TRACE_EVENT("edtUpdate-end");
    return MfwResOk;
}



//GW 18/09/01 - Corrected linefeed definition and added carriage return definition.
#define UNICODE_SPACE			0x2000
#define UNICODE_LINEFEED		0x0A00
#define UNICODE_CR				0x0D00
#define UNICODE_EOLN			0x0000
#define UNICODE_NONASCII		0x00FF
#define UNICODE_STARTHIGHLIGHT	0x0100 
#define UNICODE_ENDHIGHLIGHT	0x0200


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EDT            |
| STATE   : code                        ROUTINE : edtChar            |
+--------------------------------------------------------------------+

  PURPOSE : handle editing char
//GW 06/09/01 - Call chinese procedure if first char is 0x80,0x81 or 0x82 or display type is not ascii.

*/
char getCursorChar(MfwHnd e, int offset )
{
    MfwEdt *edit; 
	int chPos;

	TRACE_FUNCTION("getCursorChar()");

	if (!e)
        return (0xFF);

    if (((MfwHdr *)e)->type != MfwTypEdt)
        return (0xFF);            /* not an editor            */

	edit = ((MfwHdr *) e)->data;


	chPos = offset + edit->cp;
	if ((chPos < 0) || (chPos > strlen(edit->attr->text)))
		return (0x00);
	else
		return (edit->attr->text[chPos]);
}
int isAWordChar( char chr)
{	TRACE_FUNCTION("isAWordChar()");



	if ( ((chr >='A') && (chr <='Z')) || 
		 ((chr >='a') && (chr <='z')) )
		return (TRUE);
	else
		return(FALSE);
}
MfwRes edtChar (MfwHnd e, int c)
{
	int warn99;
    MfwEdt *edit; 
    U16 bs; 
	int dy;	//Change in cursor y position when moving up/down lines.
    char *tbString; 
	int found;

	TRACE_FUNCTION("edtChar()");

   if (!e)
        return MfwResIllHnd;

    if (((MfwHdr *)e)->type != MfwTypEdt)
        return MfwResIllHnd;            /* not an editor            */

	edit = ((MfwHdr *) e)->data;
 	tbString = &edit->attr->text[0];

	if (tbString[0] & 0x80)
	{
		return(edtCharUnicode(e,c));
	}
	bs = edit->attr->size;
	dy = 0;
    switch (c)
    {
		
        case ecEscape:                  //* quit editor              
            return MfwResDone;
        case ecLeft:					//* cursor left              
			if (edit->attr->mode & edtModWordSkip) 
			{
				edit->cp = edit->cp-1;
				if (isAWordChar(edit->attr->text[edit->cp]))
				{	//pointing to a letter in a word. Move left until next char is not a word char
					found = FALSE;
					while (!found)
					{
				        if (edit->cp == 0)
							found = TRUE;
						else if (isAWordChar(edit->attr->text[edit->cp-1]))
							edit->cp = edit->cp-1;
						else
							found = TRUE;
					}
				}
			}
			else
				edit->cp = edit->cp-1;
	        if (edit->cp <= 0)
				edit->cp = 0;
            break;
        case ecRight:                   //* cursor right 
			if (edit->attr->mode & edtModWordSkip) 
			{
				if (!isAWordChar(edit->attr->text[edit->cp]))
					edit->cp = edit->cp+1;//current char is not a word - move to next and stop.
				else 
				{
					found = FALSE;
					while (!found)
					{
						edit->cp = edit->cp+1;
				        if (!isAWordChar(edit->attr->text[edit->cp]))
							found = TRUE;//found a non-word char (could be the end of the string
					}
				}
			}
			else
				edit->cp = edit->cp+1;
            break;
        case ecUp:                      //* cursor up      
  			dy =  -1;
            break;
        case ecDown:                    //* cursor down           
  			dy = 1;
            break;
        case ecTop:                     //* cursor to start of text  
            edit->cp = 0;
            edit->curOffs = 0;
            break;
        case ecBottom:                  //* cursor to end of text   
            edit->cp = strlen(tbString);
            edit->curOffs = 0;
            break;
        case ecBack:                    //* backspace                *
            if ((edit->cp != 0) && (strlen(tbString)+1 > edit->cp))
			{
				moveLeft(&tbString[edit->cp-1],1);
			}
			edit->cp = edit->cp-1;
	        if (edit->cp <= 0)
				edit->cp = 0;
            break;
        case ecDel:                     //* delete                   *
			if (strlen(tbString) > edit->cp)
			{
				moveLeft(&tbString[edit->cp],1);
			}
            break;
        case ecEnter:                   //* cr/lf                    
            c = UNICODE_LINEFEED;
            edtInsert(c,tbString,bs, edit->curMode, edit->cp);
			return (edtChar(e,ecRight));
            break;
        default:                        //* normal char              
            edtInsert(c,tbString,bs, edit->curMode, edit->cp);

			if (edit->attr->alphaMode NEQ TRUE)
				return (edtChar(e,ecRight));
			/*NM, p003 end*/	
            break;
    }
    edit->display = 1;                        //* really show it           
  	updateWindow( edit, dy);
    edtUpdate(edit);

    return MfwResOk;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EDT            |
| STATE   : code                        ROUTINE : edtCharUnicode     |
+--------------------------------------------------------------------+

  PURPOSE : 

  GW 06/09/01 - Created
*/
MfwRes edtCharUnicode (MfwHnd e, int c)
{
    MfwEdt *edit; 
    U16 bs; 
	int dy;
    U16 *tbUnicode; 

 	TRACE_FUNCTION("edtCharUnicode()");
 	
    if (!e)
        return MfwResIllHnd;

    if (((MfwHdr *)e)->type != MfwTypEdt)
        return MfwResIllHnd;            //* not an editor            

	edit = ((MfwHdr *) e)->data;
	bs = edit->attr->size;
	tbUnicode = (U16*) &edit->attr->text[2];

	dy = 0;
    switch (c)
    {
        case ecEscape:                  //* quit editor              
            return MfwResDone;
        case ecLeft:                    //* cursor left              
            if (edit->cp <= 0)
				edit->cp = 0;
			else
	            edit->cp = edit->cp-1;
            break;
        case ecRight:                   //* cursor right             
			if (tbUnicode[edit->cp]!=UNICODE_EOLN)
	            edit->cp = edit->cp +1;
            break;
        case ecUp:                      //* cursor up                
  			dy = -1;
            break;
        case ecDown:                    //* cursor down              
  			dy = 1;
            break;
        case ecTop:                     //* cursor to start of text  
            edit->cp = 0;
            edit->curOffs = 0;
  			dy = 0;
            break;
        case ecBottom:                  //* cursor to end of text    
			while (tbUnicode[edit->cp]!=UNICODE_EOLN)
			{
	            edit->cp = edit->cp +1;
			}
            break;
        case ecBack:                    //* backspace                
            if (edit->cp != 0)
	            moveLeftUnicode(tbUnicode+edit->cp-1,1);
            return edtCharUnicode(e,ecLeft);
        case ecDel:                     //* delete                   
            moveLeftUnicode(tbUnicode+edit->cp,1);
            break;
        case ecEnter:                   //* cr/lf                    
            c = UNICODE_LINEFEED;
            edtInsertUnicode(edit,c,tbUnicode,bs);
            return edtCharUnicode(e,ecRight);
        default:                        //* normal char  
            edtInsertUnicode(edit,c,tbUnicode,bs);

			if (edit->attr->alphaMode NEQ TRUE)
				return (edtCharUnicode(e,ecRight));
			/*MC end*/	
            break;

    }
    edit->display = 1;                        // really show it           
  	updateWindow( edit, dy);
    edtUpdateUnicode(edit);


    return MfwResOk;
}




/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EDT            |
| STATE   : code                        ROUTINE :        |
+--------------------------------------------------------------------+

  PURPOSE : Return no of chinese chars in a string

  GW 06/09/01 - Created
  GW 25/09/01 - Corrected length - now skips first two chars.
*/

U16 strlenUnicode(U16* str)
{
	U16 len = 2; //First char is 0x80, second char is 0x00

	TRACE_FUNCTION("strlenUnicode()");
	
	while (*str!=UNICODE_EOLN)
	{
		//treat ascii chars as half size chinese chars.
		len = len + 2;
		str++;
	}
	return (len);
}


//Assumptions :-
//str is a null-terminated string 
//edit->cp is the cursor position of the char 
//The string is inserted before the cursor char
//The cursor is moved strlen(str) chars forward.
MfwRes edtInsertString (MfwHnd e, char* insWord)
{
    MfwEdt *edit;
    char *textBfr;

	int lenText;
	int lenInsWord;
    int maxTextBfrLen;
	int i;


TRACE_FUNCTION("edtInsertString()");

    if (!e)
        return MfwResIllHnd;

    if (((MfwHdr *)e)->type != MfwTypEdt)
        return MfwResIllHnd;            /* not an editor            */

	edit = ((MfwHdr *) e)->data;
	if (insWord == NULL)
		return (MfwResOk);	//no string to insert - trivial operation.
	if (insWord[0] == 0x00)
		return (MfwResOk);	//no string to insert - trivial operation.
	textBfr			= edit->attr->text;
	if ((textBfr[0] == 0x80) || (textBfr[1] == 0x81) || (textBfr[2] == 0x82))
	{//String is unicode
		return (edtInsertUnicodeString (e, insWord));
	}
	maxTextBfrLen	= edit->attr->size;
	lenText		= strlen(textBfr);
	lenInsWord	= strlen(insWord);
	if ((lenText+lenInsWord) >= maxTextBfrLen)
		return (MfwResErr); //String too long 

	//move text up by 'lemnInsWord' words
	for (i=lenText;i>=edit->cp;i--)
	{
		textBfr[i+lenInsWord]=textBfr[i];
	}
	//and copy string into buffer.
	for (i=0;i<lenInsWord;i++)
		textBfr[edit->cp+i] = insWord[i];
	edit->cp = edit->cp+lenInsWord;
	//Update cursor position
	//<TBD>
	//And output updated text
	edit->display = 1;
	updateWindow( edit, 0);
    edtUpdate(edit);

    return MfwResOk;
}
#define MAXWORD_ARRAY 32
//Assumptions :-
//'removeWord' is char array of MAXWORD chars 
//edit->cp is the cursor position of the char 
//The word removed is at or just before the cursor char
//The cursor is placed before the previous word.
//a space char (start or end) will be removed if there is one.
//GW 18/09/01 - Use 'isAWordChar' procedure
MfwRes edtRemoveString (MfwHnd e, char* removeWord)
{
    MfwEdt *edit;
    char *textBfr;

	int i,j;
	int stChr,endChr;

	TRACE_FUNCTION("edtRemoveString");
	
	if (dspl_get_char_type() != DSPL_TYPE_ASCII)
	{	//String is unicode - can't remove word (could remove a char but...)
		return(MfwResIllHnd);
	}

    if (!e)
        return MfwResIllHnd;

    if (((MfwHdr *)e)->type != MfwTypEdt)
        return MfwResIllHnd;            //* not an editor            *

	edit = ((MfwHdr *) e)->data;
	textBfr			= edit->attr->text;
	if ((textBfr[0] == 0x80) || (textBfr[1] == 0x81) || (textBfr[2] == 0x82))
	{//String is unicode - can't remove word (could remove a char but...)
		return(MfwResIllHnd);
	}

	findWordBounds(edit, &stChr, &endChr);
	//Copy word out
	j = 0;
	for (i=stChr;i<endChr;i++)
	{
		if (j<MAXWORD_ARRAY-1)
		{
			removeWord[j] = textBfr[i];
			if (isAWordChar(removeWord[j]))
				j++;//not punctuation .
			else if (removeWord[j] == ' ') //but do include last space (if it is a space)
				j++;
		}
	}
	removeWord[j] = 0x00;

	//and now move text up by 'j' chars.
	i=stChr;
	j=endChr; 
	//skip one space at start/end.
	if (textBfr[i] != ' ')
	{
		i++;
		if (textBfr[j] == ' ')
			j++;
	}
	//else overwrite first space
	edit->cp = i;

	while((textBfr[i] != 0x00) && (i < j))
	{
		textBfr[i] = textBfr[j];
		i++;
		j++;
	}

	edit->display = 1;
	updateWindow( edit, 0);
    edtUpdate(edit);

    return MfwResOk;
}


//Create a copy of the current word.
//GW 18/09/01 - Use 'isAWordChar' procedure
MfwRes edtCopyString (MfwHnd e, char* removeWord)
{
    MfwEdt *edit;
    char *textBfr;

	int i,j;
	int stChr,endChr;
	
	TRACE_FUNCTION("edtCopyString");
	
	if (dspl_get_char_type() != DSPL_TYPE_ASCII)
	{	//String is unicode - can't remove word (could remove a char but...)
		return(MfwResIllHnd);
	}

    if (!e)
        return MfwResIllHnd;

    if (((MfwHdr *)e)->type != MfwTypEdt)
        return MfwResIllHnd;            //* not an editor            *

	edit = ((MfwHdr *) e)->data;
	textBfr			= edit->attr->text;
	if ((textBfr[0] == 0x80) || (textBfr[0] == 0x81) || (textBfr[0] == 0x82))
	{//String is unicode - can't remove word (could remove a char but...)
		return(MfwResIllHnd);
	}

	findWordBounds(edit, &stChr, &endChr);
	//Copy word out
	j = 0;
	for (i=stChr;i<endChr;i++)
	{
		if (j<MAXWORD_ARRAY-1)
		{
			removeWord[j] = textBfr[i];
			if (isAWordChar(removeWord[j]))
				j++;//not punctuation.
			else if (removeWord[j] == ' ') //but do include last space (if it is a space)
				j++;
		}
	}
	removeWord[j] = 0x00;

	edit->display = 1;
	updateWindow( edit, 0);
    edtUpdate(edit);

    return MfwResOk;
}




MfwRes edtInsertUnicodeString (MfwHnd e, char* insWordChar)
{
    MfwEdt *edit;
    U16 *unicodeBfr;

	int lenText;
	int lenInsWord;
    int maxTextBfrLen;
	int i;
	U16* insWordUnicode;
	insWordUnicode = (U16*) insWordChar;


	TRACE_FUNCTION("edtInsertUnicodeString");
    if (!e)
        return MfwResIllHnd;

    if (((MfwHdr *)e)->type != MfwTypEdt)
        return MfwResIllHnd;            //* not an editor 

	edit = ((MfwHdr *) e)->data;
	if (insWordUnicode == NULL)
		return (MfwResOk);	//no string to insert - trivial operation.
	if (insWordUnicode[0] == 0x0000)
		return (MfwResOk);	//no string to insert - trivial operation.
	unicodeBfr	= (U16*) &edit->attr->text[2];
	if ((edit->attr->text[0] != (char)0x80) && 
		(edit->attr->text[0] != (char)0x81) && 
		(edit->attr->text[0] != (char)0x82))
	{//String is unicode
		return (edtInsertString (e, insWordChar));
	}

	maxTextBfrLen	= edit->attr->size;
	lenText		= strlenUnicode(unicodeBfr);
	lenInsWord	= strlenUnicode(insWordUnicode);
	if ((lenText+lenInsWord) >= maxTextBfrLen)
		return (MfwResErr); //String too long 

	//move text up by 'lemnInsWord' chars
	for (i=lenText/2;i>=edit->cp;i--)
	{
		unicodeBfr[i+lenInsWord]=unicodeBfr[i];
	}
	//and copy string into buffer.
	for (i=0;i<lenInsWord/2;i++)
		unicodeBfr[edit->cp+i] = insWordUnicode[i];
	edit->cp = edit->cp+lenInsWord/2;
	//Update cursor position
	//<TBD>
	//And output updated text
	edit->display = 1;
	updateWindow( edit, 0);
    edtUpdateUnicode(edit);

    return MfwResOk;
}




/*

  
	
	  
		
		  
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EDT            |
| STATE   : code                        ROUTINE : edtInsert          |
+--------------------------------------------------------------------+

  PURPOSE : insert editing char
  SPR1017 - NH  - Added "curMode" and "curCP" parameters.

*/

static int edtInsert (int c, char *b, int s, U8 curMode, U16 curCP)
{
    int size = (c > 0x80) ? 2 : 1;

	TRACE_FUNCTION("edtInsert");
    if (!curMode)
        return 0;

	if (!(curMode & edtModOverWr))
		{
		if ((int) strlen(b) >= s - size)          /* no more space in buffer  */
        	return 0;
    	
        moveRight(b+curCP,strlen(b+curCP),size);
		}
	else
		{
		if (curCP > s-size )				/* SH - for overwrite mode, only stop input */
			return 0;						/* when the cursor is at the maximum string size */
		}

    if (size == 2)
        *((U16 *) (b+curCP)) = (U16) c;
    else
    	{
    	*(b+strlen(b)+1) = (char) 0;		// SH - make sure string is null terminated
        *(b+curCP) = (char) c;
    	}
    return 1;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EDT            |
| STATE   : code                        ROUTINE : moveRight          |
+--------------------------------------------------------------------+

  PURPOSE : move right memory
  s = no of chars to move 
  d = size (no of chars to be inserted in string) 
  b = current position
*/
void moveRight (char *b, int s, int d)
{
    char *p;
    
	TRACE_FUNCTION("edtInsert");
	
    b += s++;                           /* start with trailing zero */
    p = b + d;                          /* new = old + distance     */
    while (s--)
    {
        *p = *b;
        p--;
        b--;
    }
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EDT            |
| STATE   : code                        ROUTINE : moveLeft           |
+--------------------------------------------------------------------+

  PURPOSE : move left memory
  s = no of chars to move 
  d = size (no of chars to be inserted in string) 
  b = current position
  str - string
*/
void moveLeft (char * str, int ofs)
{

	
	while (*str)
	{
		str[0] = str[ofs];
		if (*str)
			str++;
	}
	
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EDT            |
| STATE   : code                        ROUTINE : edtCommand         |
+--------------------------------------------------------------------+

  PURPOSE : handle mfw windows command

*/

static int edtCommand (U32 cmd, void *h)
{
	TRACE_FUNCTION("edtCommand");

    switch (cmd)
    {
        case MfwCmdDelete:              /* delete me                */
            if (!h)
                return 0;
            edtDelete(h);
            return 1;
        case MfwCmdUpdate:              /* repaint                  */
            if (!h || ((MfwHdr *) h)->type != MfwTypEdt)
                return 0;
            edtUpdate(((MfwHdr *) h)->data);
            return 1;
        default:
            break;
    }

    return 0;
}




/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EDT            |
| STATE   : code                        ROUTINE :        |
+--------------------------------------------------------------------+

  PURPOSE : 

  GW 06/09/01 - Created
*/
  //Move part of string right (delete char)
void moveLeftUnicode(U16* unicodeStr, int nChars)
{
	TRACE_FUNCTION("moveLeftUnicode");
	//Copy until end of line char reached - do not overwrite existing EOLN char 
	while (unicodeStr[0] != UNICODE_EOLN)
	{
		unicodeStr[0] = unicodeStr[nChars];
		if (unicodeStr[0] != UNICODE_EOLN)
			unicodeStr++;
		//else we have copied end of line char - stop.
	}

}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EDT            |
| STATE   : code                        ROUTINE :        |
+--------------------------------------------------------------------+

  PURPOSE : 

  GW 06/09/01 - Created
*/
U16 strlenUnicodePixels(U16* str)
{
	U16 len = 0;

	TRACE_FUNCTION("strlenUnicodePixels");
	
	while (*str!=UNICODE_EOLN)
	{	//Is next char an ascii char ? 
		if ((*str & UNICODE_NONASCII) != 0)
			len = len+12;
		else
			len = len+6;
		str++;
	}
	return (len);
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EDT            |
| STATE   : code                        ROUTINE :        |
+--------------------------------------------------------------------+

  PURPOSE : 

  GW 06/09/01 - Created
*/
U16* strchrUnicode(U16* str,U16 chr)
{
	TRACE_FUNCTION("strchrUnicode");
	
	while (*str!=UNICODE_EOLN)
	{
		if (*str==chr)
			return (str);
		else
			str++;
	}
	return (NULL);
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EDT            |
| STATE   : code                        ROUTINE :        |
+--------------------------------------------------------------------+

  PURPOSE : 

  GW 06/09/01 - Created
*/
//Return pointer to end of unicode string.
U16* strendUnicode(U16* tp)
{	TRACE_FUNCTION("strendUnicode");
	while (*tp!=UNICODE_EOLN)
	{
		tp++;
	}
	return (tp);

}
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EDT            |
| STATE   : code                        ROUTINE :        |
+--------------------------------------------------------------------+

  PURPOSE : 

  GW 06/09/01 - Created
*/
//Move string right by 'nChars' (insert char)
static void moveRightUnicode(U16 *unicodeStr, int nChars)
{
	U16* strEndPtr;

	TRACE_FUNCTION("moveRightUnicode");
	
	strEndPtr = strendUnicode( unicodeStr);
	while (strEndPtr >= unicodeStr)
	{
		strEndPtr[nChars] = strEndPtr[0];
		strEndPtr--;
	}
}

static int edtInsertUnicode (MfwEdt *edit, int c, U16 *b, int s)
{	//Unicode chars are always 2 bytes.
	U16* bCursor;

	TRACE_FUNCTION("edtInsertUnicode");

    if (!edit->curMode)
        return 0;

    if ( strlenUnicode(b) >= s/* -2 MC SPR 1319, allow last 2 bytes to be used*/ )          //* no more space in buffer  *
        return 0;

	bCursor = b+edit->cp;

    if (!(edit->curMode & edtModOverWr))
        moveRightUnicode(bCursor,1);

	*((U16 *) (b+edit->cp )) = (U16) c;

    return 1;

}

int wArray[20]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

int getCharWidth(int nextChar)
{
	int w;
	if ((nextChar == UNICODE_LINEFEED) || (nextChar == UNICODE_CR))
		w = 6;
	else
		w = font_getCharWidth( ((nextChar & 0x00FF) <<8) | ((nextChar & 0xFF00) >>8) );
	return (w);
}

static void edtOutTextLines (int px, int py, int ls, int ly, U16 *tpUnicode, unsigned char* tpAscii,
							 int fontHeight, int display)
{
    U16 ctWord;
	unsigned char ctByte;
    unsigned int fitChars;			//No of chars that fit on this line.
	U16 nextChar;					//next char to display
	int lineWidth;					//Width (so far) of the current line of text.
	int dispEnd = 0;
	int spaceChar;
	int charWidth;
	int punctuation;
	char chr;
	if ((tpAscii==NULL) && (tpUnicode == NULL))
		return;

         
	fitChars = 0;
	if (tpAscii)
	{
		nextChar = (tpAscii[fitChars] << 8) & 0xFF00;
		if ((nextChar == UNICODE_LINEFEED) || (nextChar == UNICODE_CR))
		{
			fitChars++;
			nextChar = (tpAscii[fitChars] << 8) & 0xFF00;
		}
	}
	else
	{
		 nextChar = tpUnicode[fitChars];
		if ((nextChar == UNICODE_LINEFEED) || (nextChar == UNICODE_CR))
		{
			fitChars++;
			nextChar = tpUnicode[fitChars];
		}
	}

    while ((nextChar != UNICODE_EOLN) && (!dispEnd))                /* any more to display      */
    {
		fitChars = 0;
		if (tpAscii)
		{
			charWidth = getCharWidth(nextChar);
			nextChar = (tpAscii[fitChars] << 8) & 0xFF00;
			if ((nextChar == UNICODE_LINEFEED) || (nextChar == UNICODE_CR))
			{	//linefeed - always start a new-line.
				charWidth = ls+1;
			}
		}
		else
		{
			nextChar = tpUnicode[fitChars];
			charWidth = getCharWidth(nextChar);
			if ((nextChar == UNICODE_LINEFEED) || (nextChar == UNICODE_CR))
				{	//linefeed - always start a new-line.
					charWidth = ls+1;
				}
		}
		lineWidth = 0;
		spaceChar = -1;

		while ((lineWidth <= ls) && (nextChar != UNICODE_EOLN))
		{
			lineWidth = lineWidth + charWidth;

			//If the last char added still fits on the line
			if (lineWidth <= ls)
			{	//move on to the next character.
				fitChars++;
				//if the previous char was a space, we can cut the line on the next char.
				punctuation = FALSE;
				if ((nextChar & UNICODE_NONASCII) == 0)
				{
					chr = (nextChar >> 8) & 0x00FF;
					if (chr==' ')			// sbh - only space is punctuation now.
						punctuation = TRUE;
				}
				//Remember when we find a space if it is not the first char of a new line
				if ((fitChars > 1) &&
					((punctuation) || 
					 (nextChar == UNICODE_STARTHIGHLIGHT)|| 
					 (nextChar == UNICODE_ENDHIGHLIGHT)))
				{	//save char after space.
					spaceChar = fitChars;
				}
				if (tpAscii)
				{
					charWidth = getCharWidth(nextChar);
					nextChar = (tpAscii[fitChars] << 8) & 0xFF00;
				}
				else
				{
					 nextChar = tpUnicode[fitChars];
					charWidth = getCharWidth(nextChar);
				}
				if ((nextChar == UNICODE_LINEFEED) || (nextChar == UNICODE_CR))
				{	//linefeed - always start a new-line.
					charWidth = ls+1;
				}

			}
		}
        if (nextChar == UNICODE_EOLN)
        {                               /* all fits fine ...        */
			dispEnd = TRUE;
		}
		else if ((nextChar == UNICODE_LINEFEED) || (nextChar == UNICODE_CR))
		{	//Break line on this linefeed char
		}
		else if (spaceChar != -1) // we have a space in the line
		{	
			fitChars = spaceChar;
		}
		if (tpAscii)
		{
	        ctByte = tpAscii[fitChars];			/* save not fitting char    */		
	        tpAscii[fitChars] = 0x00;//UNICODE_EOLN;	/* cut the line             */
			if (display)
				dspl_TextOut((U16)px,(U16)py, 0, (char*)tpAscii); /* display line         */
			tpAscii[fitChars] = ctByte;			/* restore                  */
	        tpAscii = &tpAscii[fitChars];				/* and go ahead             */
			//For linefeed char - move to next char.
			if (((ctByte <<8) == UNICODE_LINEFEED) || ((ctByte <<8) == UNICODE_CR))
				tpAscii++;

		}
		else
		{
	        ctWord = tpUnicode[fitChars];			/* save not fitting char    */
	        tpUnicode[fitChars] = UNICODE_EOLN;	/* cut the line             */
			if (display)
				dspl_TextOut((U16)px,(U16)py, DSPL_TXTATTR_UNICODE, (char*)tpUnicode); /* display line         */
			tpUnicode[fitChars] = ctWord;			/* restore                  */
	        tpUnicode = &tpUnicode[fitChars];				/* and go ahead             */
			if ((ctWord == UNICODE_LINEFEED) || (ctWord == UNICODE_CR))
				tpUnicode++;
		}        
        py = py + fontHeight;			/* move to next screen line */
        if (py > ly - fontHeight)		/* past end of screen ?     */
            dispEnd = TRUE;             /* clip the rest            */
    }
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EDT            |
| STATE   : code                        ROUTINE :        |
+--------------------------------------------------------------------+

  PURPOSE : 

  GW 06/09/01 - Created
*/
MfwRes edtUpdateUnicode (MfwEdt *e)
{
	int warn;
	UBYTE temp;

    S16 ls;                             /* width of edit window     */
    S16 ly;                             /* bottom of edit window    */
    U8 oldFont = -1;                    /* store previous font      */
	/* NM p004
	U8 uMode;
	*/
    U16 *tpWord;	
	U16 *endChar;	
	static char bmp[5];

	TRACE_FUNCTION("edtUpdateUnicode");
	
    if (!e)
        return MfwResIllHnd;

    if (!e->attr->text)
        return MfwResErr;               /* no text to display       */

	if (((unsigned char)e->attr->text[0] < 0x80) || ((unsigned char)e->attr->text[0] > 0x83))
        return MfwResErr;               /* text is not unicode      */
		
	temp = dspl_get_char_type();		
	dspl_set_char_type(DSPL_TYPE_UNICODE);

    if (!(e->flags & MfwEdtVisible))
        e->display = 0;                    /* invisible editor         */

	tpWord = ((U16*)&e->attr->text[2]) + e->curOffs;
    ls = e->attr->win.sx;               /* width of edit window     */
    ly = (S16) (e->attr->win.py+e->attr->win.sy);  /* bottom of edit window    */
    if (e->attr->font != (U8) -1)
        oldFont = dspl_SelectFontbyID(e->attr->font); /* setup font */
    e->fontHeight = dspl_GetFontHeight();  /* get height of curr font  */
    e->curMode = e->attr->mode;            /* setup edi mode           */
    if (e->display)
        dspl_Clear(e->attr->win.px,e->attr->win.py,(U16)(ls+e->attr->win.px-1),(U16)(ly-1));
    dspl_SetCursor(0,(U8)(e->curMode&edtCurMask));

	//Add a space to the end of the line
	endChar = strendUnicode(tpWord);
	if ((endChar[0] == UNICODE_EOLN) &&
		(endChar[1] == UNICODE_EOLN))
	{

		endChar[0] = UNICODE_SPACE;
		endChar[1] = UNICODE_EOLN;

		edtOutTextLines(e->attr->win.px, e->attr->win.py, ls, ly, tpWord, NULL,
						e->fontHeight, e->display); //* show it     * /

		//and remove space again.
		endChar[0] = UNICODE_EOLN;
	}
	else
	{	//Cannot add space
		edtOutTextLines(e->attr->win.px, e->attr->win.py, ls, ly, tpWord, NULL,
						e->fontHeight, e->display); //* show it     * /
	}
	
	
    if (e->display && (e->curMode & edtCurMask))
        dspl_SetCursorPos(e->curCX,e->curCY,e->curCSize,(S16)e->fontHeight); /* display cursor           */
    if (oldFont != (U8) -1)
        dspl_SelectFontbyID(oldFont);   /* restore previous font    */


		
	dspl_set_char_type(temp);

    return MfwResOk;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EDT            |
| STATE   : code                        ROUTINE :        |
+--------------------------------------------------------------------+

  PURPOSE : 

  GW 06/09/01 - Created
*/

//Incodmation relating to last 'space' char found.
typedef struct {
	int charWidth;
	int lineCharPos;
} T_SPACE_EDITINFO;

//Information about current editor
typedef struct  {
	int txtWidth;
	int charWidth;
	int endOfLine;		//TRUE indicates end of a text line
	int endOfText;		//TRUE indicates no more chars in line.
	int lineXpos;		//Current x-pos (in pixels) of cursor.
	int lineCharPos;	//Current char/word position in array
	int lastChar;		//index of last char on cursor line
	BOOL precedingEOL;	// sbh - preceding character was a CR/LF
	T_SPACE_EDITINFO space;
} T_EDITINFO;


//Calculate width of chars on screen so far.
//GW 18/09/01 - Corrected code dealing with linefeeds and also deal with carriage returns.
void getTotalWidth(U16 txtChar, int scrSxPixels, T_EDITINFO *editInfo )
{
	char chr;
	int punctuation;
	
	TRACE_FUNCTION("getTotalWidth");
	
	editInfo->endOfLine = FALSE;

	if (editInfo->precedingEOL)				// Previous character was CR/LF
		{
		editInfo->precedingEOL = FALSE;
		editInfo->endOfLine = TRUE;
		}
		
	if (txtChar == UNICODE_EOLN)
	{
		editInfo->endOfText = TRUE;		
		editInfo->charWidth = getCharWidth(txtChar);//6;	// sbh - Has width, so it can be wrapped if necessary
	}
	else if ((txtChar == UNICODE_LINEFEED) || (txtChar == UNICODE_CR))
	{
		editInfo->precedingEOL = TRUE;
		editInfo->charWidth = getCharWidth(txtChar);//6;
	}
	else //GW-Get actual width for proportional fonts.
		editInfo->charWidth = getCharWidth(txtChar);
	
	if (editInfo->txtWidth+editInfo->charWidth >  scrSxPixels)
	{	//newline
		editInfo->txtWidth = 0;
		editInfo->endOfLine = TRUE;

		//update start of window.
		if ((txtChar == UNICODE_LINEFEED)||(txtChar == UNICODE_CR))
		{
			editInfo->lineCharPos	= editInfo->space.lineCharPos+1;

		}
		else if (editInfo->space.lineCharPos > 0) 
		{	//reset editor position back to here
			editInfo->lineCharPos	= editInfo->space.lineCharPos+1;
			editInfo->charWidth     = editInfo->space.charWidth;
			editInfo->endOfText = FALSE;
		}

		editInfo->space.lineCharPos = 0;
	}
	else
	{	
		punctuation = FALSE;
		if (txtChar==UNICODE_SPACE)						// sbh - will only wrap on a space
			punctuation = TRUE;

		if ((punctuation) && (editInfo->txtWidth > 0)) 
		{	//A space is a good point for a soft break - remember enough info so that this
			//point can be restored
			editInfo->space.lineCharPos = editInfo->lineCharPos;		
			if ((txtChar == UNICODE_LINEFEED) || (txtChar == UNICODE_CR))
				editInfo->space.charWidth   = getCharWidth(txtChar);
			else
				editInfo->space.charWidth   = editInfo->charWidth;
			}
	}

}
//Update the cursor position
// SPR920 - NH (SH) - provide editor handle e, as cursor vars are now in structure

void updateCursorPos(MfwEdt *e, T_EDITINFO *editInfo)
{
	TRACE_FUNCTION("updateCursorPos");
	e->curCSize	= editInfo->charWidth;
	if (e->curCSize < 3)
		e->curCSize = 3;
	e->curCX	= editInfo->txtWidth;
}

//dy - move cursor up/down screen by dy lines
MfwRes updateWindow (MfwEdt *e, int  dy	)
{
T_EDITINFO editInfo;

	int winCharPos;		//char position  in string of the first text line in current window
	int winLineNo;		//line no of the first text line to be displayed

	int ipCursorCharPos;	
	int opCursorCharPos;	
	int cursorLineNo;	//line no the cursor is on

	int linePos;		//char pos in string of current line.
	int lineNo;			//overall displayed line (from start of text)

	int editComplete;	//flag indicating cursor position found/updated or end of line reached.

	int scrSxPixels;
	int scrSyLines;

	char* textStartAscii;
	U16* textStartUnicode;
	U16  charUnicode;	//current unicode char.

	int textStrType;

	TRACE_FUNCTION("UpdateWindow()");

	//Set up screen size - the width in pixels and no of lines displayed.
	if (e->fontHeight > 5)
		scrSyLines = e->attr->win.sy / e->fontHeight;
	else
		scrSyLines = e->attr->win.sy / 6;
	scrSxPixels = e->attr->win.sx;

	ipCursorCharPos = e->cp;
	if ((ipCursorCharPos < 0) || (ipCursorCharPos > 32767))
		ipCursorCharPos = 0;
	opCursorCharPos = ipCursorCharPos;
	lineNo = 0;
	winLineNo = 0;
	winCharPos = 0;
	editComplete = FALSE;
	editInfo.endOfText = FALSE;
	editInfo.lineCharPos = 0;
	editInfo.lastChar = 9999;
	editInfo.space.lineCharPos = 0;
	editInfo.precedingEOL = FALSE;
	linePos = 0;

	editInfo.txtWidth = 0;
	cursorLineNo = 0;

	if ((e->attr->text[0] == (char)0x80) || 
		(e->attr->text[0] == (char)0x81) || 
		(e->attr->text[0] == (char)0x82))
	{
		textStrType = DSPL_TYPE_UNICODE;
		textStartUnicode = (U16*) &e->attr->text[2];    /* start of edit text - 16 bits/char      */
	}
	else
	{
		textStrType = DSPL_TYPE_ASCII;
		textStartAscii = &e->attr->text[0];				/* start of edit text - 8 bits/char       */
	}

	//Go through editor and work out 
	// (1) current x-pixel position for cursor 
	// (2) line number of the start of the display.
	while( (!editInfo.endOfText) && (!editComplete) )
	{
		if (textStrType == DSPL_TYPE_UNICODE)
		{
			charUnicode = textStartUnicode[editInfo.lineCharPos];
			getTotalWidth(charUnicode,scrSxPixels,&editInfo);
		}
		else
		{
			charUnicode = (textStartAscii[editInfo.lineCharPos] << 8) & 0xFF00;
			getTotalWidth(charUnicode,scrSxPixels,&editInfo);
		}

		if (editInfo.endOfLine)
		{
			//newline or current char will not fit on previous line.
			lineNo++;
			linePos = editInfo.lineCharPos;
			editInfo.txtWidth = 0;
			//Is this the first line to be displayed in the editor?
			if (editInfo.lineCharPos <= e->curOffs)
			{
				winLineNo = lineNo;
				winCharPos= editInfo.lineCharPos;
			}
		}

		if (editInfo.endOfText)
		{
			//Cursor is past end of line - move to char before end of line.
			if (ipCursorCharPos > editInfo.lineCharPos)
			{
				ipCursorCharPos = editInfo.lineCharPos;
				opCursorCharPos = editInfo.lineCharPos;
			}
		}
		
		if (editInfo.lineCharPos == ipCursorCharPos)
		{	//found the cursor position - either 
			//		the new pos if dy=0 or 
			//		the old pos if we have moved up/down a line.
			updateCursorPos(e, &editInfo);
			editInfo.lineXpos  = editInfo.txtWidth;
			cursorLineNo   = lineNo;
		}
		else if ((editInfo.lineCharPos > ipCursorCharPos) &&
		  		 (lineNo      > cursorLineNo      ) &&
				 (lineNo      > cursorLineNo + dy))
		{
			//we have moved far enough down to store all required information
			editComplete   = TRUE;
		}
		editInfo.txtWidth = editInfo.txtWidth + editInfo.charWidth;
		editInfo.lineCharPos++;
	}	//end while
	
	//We now know either (a) the line the cursor is on and the char offset of the cursor or (b) the
	//original line the cursor was on and the x-pixel position of the cursor (for dy != 0)  
	
	if (dy)
	{	//update line with the cursor on it
		if (cursorLineNo+dy >lineNo )
			cursorLineNo = lineNo; //last line of editor.
		else if (cursorLineNo+dy < 0)
			cursorLineNo = 0;
		else
			cursorLineNo = cursorLineNo+dy;

		//Now we need to calculate cursor char pos. 'opCursorCharPos'

	}
	else
	{	
		//Cursor line no is already set up.

		//the new cursor position was passed into the procedure.
		opCursorCharPos = ipCursorCharPos;
	}

	editInfo.lineCharPos = 0;
	lineNo    = 0;
	editInfo.txtWidth  = 0;
	editComplete = FALSE;
	editInfo.endOfText = FALSE;
	editInfo.space.lineCharPos = 0;

	//Update start of windows position
	if (cursorLineNo < winLineNo || !(e->attr->mode & edtCurMask)) 
	{//cursor is on a line before current window screen - search from the start
	// sbh - or we're in read-only mode, no cursor, scroll with every up/down press
		winLineNo = cursorLineNo;
		winCharPos = 0;
	}
	else if (cursorLineNo >= winLineNo+scrSyLines) 
	{	//cursor is below the bottom of the screen
		winLineNo = cursorLineNo-(scrSyLines-1);
		winCharPos = 0;
	}
	else if (dy != 0)
	{	//windows line no is unchanged - start search at win char pos.
		editInfo.lineCharPos = winCharPos;
		lineNo = winLineNo;
	}
	else
	{	//we do not need to calculate new window position - it is unchanged.
		//and we have already calculated the new cursor position.
		editComplete = TRUE;
	}

	//Calculate last char on cursor line and winCharPos
	if (!editComplete)
	{
		while( (!editInfo.endOfText) && (!editComplete) )
		{
			if (textStrType == DSPL_TYPE_UNICODE)
			{
				charUnicode = textStartUnicode[editInfo.lineCharPos];
				getTotalWidth(charUnicode,scrSxPixels,&editInfo);
			}
			else
			{
				charUnicode = (textStartAscii[editInfo.lineCharPos] << 8) & 0xFF00;
				getTotalWidth(charUnicode,scrSxPixels,&editInfo);
			}
			if (editInfo.endOfLine)
			{	//newline
				editInfo.txtWidth = 0;
				//update start of window.
				linePos = editInfo.lineCharPos;

				//Remember char before first char on next line.
				if (lineNo == cursorLineNo)
				{
					if (ipCursorCharPos >=  editInfo.lineCharPos) 
						ipCursorCharPos = editInfo.lineCharPos-1;
				}
				lineNo++;
				if (winLineNo == lineNo)
					winCharPos = editInfo.lineCharPos;
			}
			if (dy!=0)
			{	//line number has changed
				//Once we have found the correct line, look for the char at the same x-pixel pos
				//as before (or the last char before we pass the position).
				if (lineNo == cursorLineNo)
				{	
					if (editInfo.txtWidth <= editInfo.lineXpos)
					{	//Update cursor char pos...
						ipCursorCharPos = editInfo.lineCharPos;
					}
				}
			}
			else if (lineNo > cursorLineNo) //...or we start a new line
			{
				editComplete = TRUE;
			}
		
			editInfo.txtWidth = editInfo.txtWidth + editInfo.charWidth;
			editInfo.lineCharPos++;
		}	//end while

		editComplete = FALSE;
	}
	
	editInfo.lineCharPos = winCharPos;
	lineNo    = winLineNo;
	editInfo.txtWidth  = 0;
	editInfo.endOfText = FALSE;
	editInfo.space.lineCharPos = 0;

	//Calculate where the window is to start from
	while( (!editInfo.endOfText) && (!editComplete) )
	{
		if (textStrType == DSPL_TYPE_UNICODE)
		{
			charUnicode = textStartUnicode[editInfo.lineCharPos];
			getTotalWidth(charUnicode,scrSxPixels,&editInfo);
		}
		else
		{
			charUnicode = (textStartAscii[editInfo.lineCharPos] << 8) & 0xFF00;
			getTotalWidth(charUnicode,scrSxPixels,&editInfo);
		}
		if (editInfo.endOfLine)
		{	//newline
			editInfo.txtWidth = 0;
			//update start of window.
			linePos = editInfo.lineCharPos;
			lineNo++;
		}

		if ((lineNo == cursorLineNo) &&
			(ipCursorCharPos == editInfo.lineCharPos))
		{	//we have reached desired char.
			opCursorCharPos = editInfo.lineCharPos;
			updateCursorPos(e, &editInfo);
			cursorLineNo   = lineNo;
			editComplete = TRUE;
		}
	
		editInfo.txtWidth = editInfo.txtWidth + editInfo.charWidth;
		editInfo.lineCharPos++;
	}	//end while

	//Calculate y position of cursor
	//GW 17/09/01 Place cursor for windows that have blank lines at the top of the screen
	e->curCY = (cursorLineNo - winLineNo)*e->fontHeight+e->attr->win.py; 

	//Output updated window start position
	e->curOffs = winCharPos;
	e->cp = opCursorCharPos;

    return (MfwResOk);
}