+
−/*
+
−+--------------------------------------------------------------------+
+
−| 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);
+
−}
+
−
+
−
+
−
+
−
+
−
+
−
+
−
+
−