--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/g23m/condat/ms/src/mfw/mfw_win.c	Mon Jun 01 03:24:05 2015 +0000
@@ -0,0 +1,1182 @@
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         $Workfile:: mfw_win.c       $|
+| $Author:: Es  $ CONDAT GmbH           $Revision:: 21              $|
+| CREATED: 21.09.98                     $Modtime:: 23.03.00 9:08    $|
+| STATE  : code                                                      |
++--------------------------------------------------------------------+
+
+   MODULE  : MFW_WIN
+
+   PURPOSE : window handling functions
+
+   EXPORT  :
+
+   TO DO   :
+
+   $History:: mfw_win.c                                             $
+
+	Mar 30, 2005	REF: CRR 29986	xpradipg
+	Description: Optimisation 1: Removal of unused variables and dynamically
+	allocate/ deallocate mbndata
+	Solution: removed the unused varialbe mfw_twh_strlen
+  
+ * textMessage
+ * *****************  Version 21  *****************
+ * User: Es           Date: 23.03.00   Time: 14:42
+ * Updated in $/GSM/Condat/MS/SRC/MFW
+ * Added 'winUnhide()': no update(), no event.
+ *
+ * *****************  Version 20  *****************
+ * User: Kk           Date: 14.03.00   Time: 15:52
+ * Updated in $/GSM/Condat/MS/SRC/MFW
+ * changed update sequence
+ *
+ * *****************  Version 19  *****************
+ * User: Es           Date: 3.03.00    Time: 12:04
+ * Updated in $/GSM/Condat/MS/SRC/MFW
+ * winUpdate(): first update windows children, then! call event
+ * handler
+ *
+ * *****************  Version 18  *****************
+ * User: Es           Date: 18.02.00   Time: 17:46
+ * Updated in $/GSM/Condat/MS/SRC/MFW
+ * danger in winUpdate
+ *
+ * *****************  Version 17  *****************
+ * User: Nm           Date: 17.02.00   Time: 9:23
+ * Updated in $/GSM/Condat/MS/SRC/MFW
+ * updated winIsFocussed
+ *
+ * *****************  Version 16  *****************
+ * User: Kk           Date: 17.01.00   Time: 8:56
+ * Updated in $/GSM/Condat/MS/SRC/MFW
+ * added simple check functions for easy checking if win is visible,
+ * focussed, closed
+ *
+ * *****************  Version 15  *****************
+ * User: Kk           Date: 10.01.00   Time: 13:46
+ * Updated in $/GSM/Condat/MS/SRC/MFW
+ * some changes done by ES
+ *
+ * *****************  Version 3  *****************
+ * User: Rm           Date: 12/22/99   Time: 4:34p
+ * Updated in $/GSM/Condat/SND-MMI/MFW
+ *
+ * *****************  Version 2  *****************
+ * User: Es           Date: 22.11.99   Time: 10:30
+ * 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 13  *****************
+ * User: Es           Date: 6.07.99    Time: 12:37
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ *
+ * *****************  Version 11  *****************
+ * User: Es           Date: 14.04.99   Time: 17:34
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ * moved to CST
+|
+| *****************  Version 10  *****************
+| User: Le           Date: 14.04.99   Time: 9:51
+| Updated in $/GSM/DEV/MS/SRC/MFW
+ *
+ * *****************  Version 9  *****************
+ * User: Es           Date: 1.04.99    Time: 17:07
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ * removed lots of traces
+ *
+ * *****************  Version 8  *****************
+ * User: Es           Date: 20.02.99   Time: 19:24
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ *
+ * *****************  Version 7  *****************
+ * User: Es           Date: 20.02.99   Time: 18:22
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ *
+ * *****************  Version 6  *****************
+ * User: Es           Date: 20.02.99   Time: 15:37
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ *
+ * *****************  Version 5  *****************
+ * User: Es           Date: 18.02.99   Time: 17:01
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ *
+ * *****************  Version 4  *****************
+ * User: Es           Date: 17.02.99   Time: 19:11
+ * 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
+*/
+
+
+#define ENTITY_MFW
+
+#if defined (NEW_FRAME)
+
+#include "typedefs.h"
+#include "vsi.h"
+#include "custom.h"
+#include "gsm.h"
+
+#else
+
+#include "STDDEFS.H"
+#include "custom.h"
+#include "gsm.h"
+#include "vsi.h"
+
+#endif
+
+#include "mfw_mfw.h"
+#include "mfw_sys.h"
+#include "gdi.h"
+#include "dspl.h"
+#include "mfw_win.h"
+
+static MfwHdr *autoFocus;               /* focus of toplevel window */
+static U8 winUseAutoFocus = 0;          /* automatic focussing flag */
+static int winCommand (U32 cmd, void *h);
+
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_WIN            |
+| STATE   : code                        ROUTINE : winInit            |
++--------------------------------------------------------------------+
+
+  PURPOSE : initialize window handler
+
+*/
+
+MfwRes winInit (U16 *sx, U16 *sy)
+{
+    dspl_DevCaps displayData;
+
+    dspl_Init();                        /* init display driver      */
+
+    displayData.DisplayType = DSPL_TYPE_GRAPHIC;
+    dspl_SetDeviceCaps(&displayData);
+    dspl_GetDeviceCaps(&displayData);
+    *sx = displayData.Width;
+    *sy = displayData.Height;
+    winUseAutoFocus = 0;
+
+    mfwCommand[MfwTypWin] = (MfwCb) winCommand;
+
+    return MfwResOk;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_WIN            |
+| STATE   : code                        ROUTINE : winExit            |
++--------------------------------------------------------------------+
+
+  PURPOSE : finalize window handler
+
+*/
+
+MfwRes winExit (void)
+{
+    mfwCommand[MfwTypWin] = 0;
+    dspl_Exit();                        /* finit display driver     */
+
+    return MfwResOk;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_WIN            |
+| STATE   : code                        ROUTINE : winCreate          |
++--------------------------------------------------------------------+
+
+  PURPOSE : create window control
+
+*/
+
+MfwHnd winCreate (MfwHnd w, MfwWinAttr *a, MfwEvt e, MfwCb f)
+{
+
+
+    MfwHdr *hdr = (MfwHdr *) mfwAlloc(sizeof(MfwHdr));
+    MfwWin *win = (MfwWin *) mfwAlloc(sizeof(MfwWin));
+    MfwHdr *eoc = (MfwHdr *) mfwAlloc(sizeof(MfwHdr));
+    MfwHdr *insert_status =0;
+
+    /* xreddymn Aug-09-2004, MMI-SPR-23964 (TII_MMS33) 
+     * Implemented suspend and resume functionality for MFW windows
+     * The following code posts MfwWinSuspend event
+     */
+#if 1
+    MfwWin *ee;
+    MfwHnd window;
+    window = mfwParent(mfwFocus);
+    if(window)
+    {
+    	ee = (MfwWin*) ((MfwHdr *) window)->data;
+    	if(ee && (((MfwHdr *) window)->type == MfwTypWin))
+    	{
+    		if (ee->handler && ee->mask & MfwWinSuspend)
+    		{
+    			ee->handler(MfwWinSuspend,ee);
+    		}
+    	}
+    }
+#endif
+
+
+
+
+    if (!hdr || !win || !eoc)
+    	{
+    	TRACE_ERROR("ERROR: winCreate() Mem Alloc Failed.");
+			
+	   	if(hdr)
+   			mfwFree((U8*)hdr,sizeof(MfwHdr));
+
+   		if(win)
+   			mfwFree((U8*)win,sizeof(MfwWin));
+
+   		if(eoc)
+   			mfwFree((U8*)eoc,sizeof(MfwHdr));
+   		
+	   	return 0;
+    }
+
+    eoc->next = hdr;                    /* setup eoc element        */
+    eoc->type = MfwTypMax;
+    eoc->data = 0;
+
+    win->mask = e;                      /* setup window control     */
+    win->flags = 0;
+    win->handler = f;
+    win->attr = a;
+    win->elems = eoc;
+    win->user = 0;
+
+    hdr->data = win;                    /* setup header element     */
+    hdr->type = MfwTypWin;
+
+    if (mfwSignallingMethod == 0)
+        insert_status = mfwInsert(w,hdr);
+    else
+	{
+        insert_status = mfwInsert(mfwParent(mfwFocus),hdr);
+        mfwSetFocus(eoc);
+	}
+
+	/* Release memory if handler installation failed. */
+	if(!insert_status)
+	{
+  		TRACE_ERROR("ERROR: winCreate() Failed to Install Handler. ");
+   		mfwFree((U8*)hdr,sizeof(MfwHdr));
+   		mfwFree((U8*)win,sizeof(MfwWin));
+   		mfwFree((U8*)eoc,sizeof(MfwHdr)); 
+		return 0;
+  	}
+  	
+  	return insert_status;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_WIN            |
+| STATE   : code                        ROUTINE : winDelete          |
++--------------------------------------------------------------------+
+
+  PURPOSE : delete window control
+
+*/
+
+MfwRes winDelete (MfwHnd w)
+{
+    MfwCb f;
+    MfwHdr *e, *t, *r;
+    MfwRes res;
+
+    /*NM, p012a*/
+    MfwWin *parent_controlBlock;
+    MfwHdr  *parent_win;
+	/*    U8 uMode;
+	 p012a end*/
+
+	TRACE_FUNCTION("win_delete()");
+
+    if (!w)
+        return MfwResIllHnd;
+    if (((MfwHdr *) w)->type != MfwTypWin)
+        return MfwResIllHnd;            /* element is not a window  */
+
+    e = ((MfwHdr *) w)->data;
+    if (!e)
+        return MfwResErr;
+
+    ((MfwWin *) e)->flags |= MfwWinDelete;
+    if (((MfwWin *) e)->handler)
+        if (((MfwWin *) e)->mask & MfwWinDelete)
+            ((MfwWin *) e)->handler(MfwWinDelete,e);
+
+    e = ((MfwWin *) e)->elems;
+    if (!e)
+        return MfwResErr;
+
+    if (mfwFocus == e)                  /* was focus window         */
+        mfwSetFocus(0);                   /* no focus anymore         */
+
+
+
+    while (e && e->type != MfwTypMax)   /* try to delete all elems  */
+    {
+        t = e->next;
+        if (e->data)
+        {
+            if (mfwSignallingMethod != 0 && e->type == MfwTypWin)
+            {
+                r = (MfwHdr*) mfwParent(w);
+                mfwRemove(e);           /* move up child window     */
+                mfwAppend(&(((MfwWin*)(r->data))->elems),e);
+            }
+            else
+            {
+                f = mfwCommand[e->type];
+                if (f)
+                    f(MfwCmdDelete,e);
+            }
+        }
+        e = t;
+    }
+    res = (mfwRemove(w)) ? MfwResOk : MfwResIllHnd;
+
+
+	/*NM, p012d 
+ 	old: after deleting the focus-win start from root to top
+   	new: after deleting the focus-win just give the new focus to 
+   	      his parent-win (faster)
+   	*/
+   if (mfwSignallingMethod != 0 && mfwRoot && (!mfwFocus))
+    {
+	   parent_win = (MfwHdr*) mfwParent(w);
+
+   		if (((MfwHdr *) parent_win)->type == MfwTypWin)
+		{
+		    parent_controlBlock = ((MfwHdr *) parent_win)->data;      
+
+    /* xreddymn Aug-09-2004, MMI-SPR-23964 (TII_MMS33)
+     * Implemented suspend and resume functionality for MFW windows
+     * The following code posts MfwWinResume event
+     */
+#if 1
+    		if (parent_controlBlock->handler && parent_controlBlock->mask & MfwWinResume)
+    		{
+    			parent_controlBlock->handler(MfwWinResume,parent_controlBlock);
+    		}
+#endif
+
+
+
+	        winUpdate(parent_controlBlock);
+	        mfwSetFocus(autoFocus);
+		}
+
+	}
+
+
+
+    mfwFree((MfwHnd) e,sizeof(MfwHdr));
+    mfwFree(((MfwHdr *) w)->data,sizeof(MfwWin));
+    mfwFree(w,sizeof(MfwHdr));
+
+    return res;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_WIN            |
+| STATE   : code                        ROUTINE : winShow            |
++--------------------------------------------------------------------+
+
+  PURPOSE : show window (put in front of visibles)
+
+*/
+
+MfwRes winShow (MfwHnd w)
+{
+    MfwWin *win;
+
+
+	TRACE_FUNCTION("winShow()");
+
+    if (!w)
+        return MfwResIllHnd;            /* window does not exist    */
+	
+    if (((MfwHdr *) w)->type != MfwTypWin)
+        return MfwResIllHnd;            /* element is not a window  */
+	
+    win = ((MfwHdr *) w)->data;         /* get control block        */
+
+    mfwAppend(mfwRemove(w),w);          /* to front (draw at last)  */
+    win->flags |= MfwWinVisible;        /* window is visible        */
+
+    winUpdate(win);                     /* draw window elements     */
+    if (winUseAutoFocus)                /* automatic focussing      */
+        mfwSetFocus(autoFocus);           /* determined by update()   */
+
+    return MfwResOk;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_WIN            |
+| STATE   : code                        ROUTINE : winHide            |
++--------------------------------------------------------------------+
+
+  PURPOSE : hide window (and redraw remaining)
+
+*/
+
+MfwRes winHide (MfwHnd w)
+{
+    MfwHdr *r;
+    MfwWin *win;
+
+    if (!w)
+        return MfwResIllHnd;            /* element does not exist   */
+    if (((MfwHdr *) w)->type != MfwTypWin)
+        return MfwResIllHnd;            /* element is not a window  */
+
+    win = ((MfwHdr *) w)->data;
+    win->flags &= ~MfwWinVisible;       /* window is not visible    */
+    if (win->handler)                   /* call event handler       */
+        if (win->mask & MfwWinVisible)
+            win->handler(MfwWinVisible,win);
+    r = mfwRoot;                        /* the beginning            */
+    autoFocus = 0;                      /* reset focus              */
+    while (r->type != MfwTypMax)        /* more links in chain      */
+    {
+        if (r->type == MfwTypWin)       /* link is a window         */
+            winUpdate(r->data);
+        r = r->next;
+    }
+    if (winUseAutoFocus)                /* automatic focussing      */
+        mfwSetFocus(autoFocus);           /* determined by update()   */
+
+    return MfwResOk;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_WIN            |
+| STATE   : code                        ROUTINE : winUnhide          |
++--------------------------------------------------------------------+
+
+  PURPOSE : unhide window (without redrawing, no event)
+
+*/
+
+MfwRes winUnhide (MfwHnd w)
+{
+    MfwWin *win;
+
+    if (!w)
+        return MfwResIllHnd;            /* element does not exist   */
+    if (((MfwHdr *) w)->type != MfwTypWin)
+        return MfwResIllHnd;            /* element is not a window  */
+
+    win = ((MfwHdr *) w)->data;
+    win->flags |= MfwWinVisible;        /* window will be visible   */
+
+    return MfwResOk;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_WIN            |
+| STATE   : code                        ROUTINE : winFocus           |
++--------------------------------------------------------------------+
+
+  PURPOSE : assign input/event focus to window
+
+*/
+
+MfwHnd winFocus (MfwHnd w)
+{
+    MfwWin *wNew, *wOld = 0;
+
+    if (winUseAutoFocus)                /* automatic focussing      */
+        return 0;                       /* ES!! only for testing !! */
+    if (!w)
+    {
+        w = mfwFocus;
+        mfwSetFocus(0);                   /* delete focus             */
+        return w;                       /* return old focus         */
+    }
+
+    if (((MfwHdr *) w)->type != MfwTypWin)
+        return 0;                       /* element is not a window  */
+
+    if (mfwFocus)
+    {
+        while (mfwFocus->type != MfwTypMax)
+            mfwSetFocus(mfwFocus->next);  /* search focus root        */
+        mfwSetFocus(mfwFocus->next);      /* the focus window         */
+        if (mfwFocus->type != MfwTypWin)
+        {
+            mfwSetFocus(0);               /* serious error:           */
+            return 0;                   /* element is not a window  */
+        }
+        wOld = mfwFocus->data;          /* window control block     */
+        wOld->flags &= ~MfwWinFocussed; /* input focus / deselected */
+    }
+
+    wNew = ((MfwHdr *) w)->data;
+    w = mfwFocus;                       /* save old focus           */
+    mfwSetFocus(wNew->elems);             /* focus on window elements */
+    wNew->flags |= MfwWinFocussed;      /* input focus / selected   */
+
+    if (wNew->handler)                  /* call new event handler   */
+        if (wNew->mask & MfwWinFocussed)
+            wNew->handler(MfwWinFocussed,wNew);
+    if (wOld && wOld->handler)          /* call old event handler   */
+        if (wOld->mask & MfwWinFocussed)
+            wOld->handler(MfwWinFocussed,wOld);
+
+    return w;                           /* return old focus         */
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_WIN            |
+| STATE   : code                        ROUTINE : winAutoFocus       |
++--------------------------------------------------------------------+
+
+  PURPOSE : set auto focus mode
+
+*/
+
+U8 winAutoFocus (U8 useit)
+{
+    U8 winUseAutoFocusOld = winUseAutoFocus; /* save previous state */
+
+    winUseAutoFocus = useit;
+
+    return winUseAutoFocusOld;          /* return previous state    */
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_WIN            |
+| STATE   : code                        ROUTINE : winClear           |
++--------------------------------------------------------------------+
+
+  PURPOSE : clear window
+
+*/
+
+MfwRes winClear (MfwHnd w)
+{
+    MfwWin *win;
+
+    if (!w)
+    {
+        dspl_ClearAll();                /* clear screen             */
+        return MfwResOk;
+    }
+
+    win = ((MfwHdr *) w)->data;         /* clear window area        */
+    dspl_Clear(win->attr->win.px,win->attr->win.py,
+               (U16) (win->attr->win.sx+win->attr->win.px-2),
+               (U16) (win->attr->win.sy+win->attr->win.py-2));
+
+    return MfwResOk;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_WIN            |
+| STATE   : code                        ROUTINE : winUpdate          |
++--------------------------------------------------------------------+
+
+  PURPOSE : draw all visible windows
+
+*/
+
+MfwRes winUpdate (MfwWin *w)
+{
+    MfwCb f = 0;                        /* modules command handler  */
+    MfwHdr *e;                          /* windows elements         */
+
+//	TRACE_FUNCTION("winUpdate()");
+
+    if (!w)
+        return MfwResIllHnd;
+
+    if (mfwSignallingMethod == 0)
+    {
+        if (!(w->flags & MfwWinVisible))
+            return MfwResOk;                /* hidden window            */
+
+        if (w->handler)                     /* THEN: call event handler */
+            if (w->mask & MfwWinVisible)
+                w->handler(MfwWinVisible,w);
+        e = w->elems;                       /* FIRST: update children   */
+        autoFocus = e;                      /* gets focus of top window */
+        while (e->type != MfwTypMax)        /* window has elements      */
+        {
+            if (e->type > MfwTypNone && e->type < MfwTypMax)
+            {
+                f = mfwCommand[e->type];
+                if (f)                      /* cmd function implemented */
+                    f(MfwCmdUpdate,e);
+            }
+            e = e->next;
+        }
+    }
+    else
+    {
+        if (w->handler && (w->flags & MfwWinVisible))
+            if (w->mask & MfwWinVisible){
+                w->handler(MfwWinVisible,w);
+            }
+
+        e = w->elems;                       /* FIRST: update children   */
+        autoFocus = e;                      /* gets focus of top window */
+        while (e->type != MfwTypMax)        /* window has elements      */
+        {
+            if (e->type > MfwTypNone && e->type < MfwTypMax)
+            {
+                f = mfwCommand[e->type];
+                if (f && ((w->flags & MfwWinVisible)
+                                || (e->type == MfwTypWin)))
+                    f(MfwCmdUpdate,e);
+            }
+            e = e->next;
+        }
+    }
+
+    return MfwResOk;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_WIN            |
+| STATE   : code                        ROUTINE : winNext            |
++--------------------------------------------------------------------+
+
+  PURPOSE : show next window (for testing purposes only)
+
+*/
+
+MfwHnd winNext (MfwHnd winCur)
+{
+    MfwHdr *cw;                         /* current window pointer   */
+
+    if (!winCur)
+        return 0;
+
+    cw = ((MfwWin *) (((MfwHdr *) winCur)->data))->elems;
+    while (cw->type != MfwTypWin)
+    {
+        if (cw->type == MfwTypMax)
+        {
+            cw = cw->next;
+            if (!cw)
+                cw = mfwRoot;
+            else
+                cw = cw->next;          /* windows successor        */
+        }
+        else
+            cw = cw->next;
+    }
+
+    return cw;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_WIN            |
+| STATE   : code                        ROUTINE : winPrev            |
++--------------------------------------------------------------------+
+
+  PURPOSE : show previous window (for testing purposes only)
+
+*/
+
+MfwHnd winPrev (MfwHnd winCur)
+{
+    MfwHnd wo, wc;
+
+    wo = wc = winNext(winCur);
+    while (wc != winCur)
+    {
+        wo = wc;
+        wc = winNext(wc);
+    }
+
+    return wo;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_WIN            |
+| STATE   : code                        ROUTINE : winCommand         |
++--------------------------------------------------------------------+
+
+  PURPOSE : handle mfw windows command
+
+*/
+
+static int winCommand (U32 cmd, void *h)
+{
+    switch (cmd)
+    {
+        case MfwCmdDelete:              /* delete me                */
+            if (!h)
+                return 0;
+            winDelete(h);
+            return 1;
+        case MfwCmdUpdate:              /* repaint                  */
+            if (!h || ((MfwHdr *) h)->type != MfwTypWin)
+                return 0;
+            winUpdate(((MfwHdr *) h)->data);
+            return 1;
+        default:
+            break;
+    }
+
+    return 0;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_WIN            |
+| STATE   : code                        ROUTINE : winIsVisible       |
++--------------------------------------------------------------------+
+
+  PURPOSE : check if window is visible
+
+*/
+int winIsVisible(MfwHnd w)
+{
+    MfwWin *win;
+
+    if (!w)
+        return 0;                       /* no handle                */
+
+    if (((MfwHdr *) w)->type != MfwTypWin)
+        return 0;                       /* element is not a window  */
+
+    win = ((MfwHdr *) w)->data;
+
+    return (win->flags & MfwWinVisible);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_WIN            |
+| STATE   : code                        ROUTINE : winIsFocussed      |
++--------------------------------------------------------------------+
+
+  PURPOSE : check if window is focussed
+
+*/
+int winIsFocussed(MfwHnd w)
+{
+    MfwWin *win;
+
+    if (!w)
+        return 0;                       /* no handle                */
+
+    if (((MfwHdr *) w)->type != MfwTypWin)
+        return 0;                       /* element is not a window  */
+
+    win = ((MfwHdr *) w)->data;
+
+    return (win->elems == mfwFocus);
+
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_WIN            |
+| STATE   : code                        ROUTINE : winIcClosed        |
++--------------------------------------------------------------------+
+
+  PURPOSE : check if window is closed
+
+*/
+int winIsClosed(MfwHnd w)
+{
+    MfwWin *win;
+
+    if (!w)
+        return 0;                       /* no handle                */
+
+    if (((MfwHdr *) w)->type != MfwTypWin)
+        return 0;                       /* element is not a window  */
+
+    win = ((MfwHdr *) w)->data;
+
+    return (win->flags & MfwWinClosed);
+}
+
+MfwHdr* getHdr( MfwHnd win)
+{
+	return((MfwHdr *) win);
+}
+MfwWin* getWinData( MfwHnd win)
+{
+	MfwHdr* winHdr;
+	winHdr = getHdr(win);
+	return (winHdr->data);
+}
+
+#define TWH_MAX_STR_LEN 90
+#define TWH_MAX_SINGLE_SIZE	21		// This is the length of the Level, Address, Type and Callback in hex plus a zero terminator
+
+static unsigned char trc_lvl;
+static char mfw_twh_str[TWH_MAX_STR_LEN];
+
+//	Mar 30, 2005	REF: CRR 29986	xpradipg
+//	remove the definition since its not used
+#ifndef FF_MMI_OPTIM
+static unsigned int mfw_twh_strlen;
+#endif
+
+static void mfw_twhNext(MfwHdr *next);
+static char *mfw_twhType(MfwTyp type);
+static void mfw_twhOut(void *ptr, MfwTyp typ);
+static void mfw_twhCb(void *ptr);
+static void mfw_twh_str_purge(void);
+
+#include <string.h>
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_WIN            |
+| STATE   : code                        ROUTINE : mfw_traceWinHdrs   |
++--------------------------------------------------------------------+
+
+  PURPOSE	: This function will trace out the entire window tree.
+  			: EXTREME care should be taken using this function as it will cause a
+  			: massive overhead on the CPU and processing WILL be affected!!!!
+
+*/
+void mfw_traceWinHdrs(void)
+{
+	TRACE_FUNCTION(">>>>> mfw_traceWinHdrs");
+
+	trc_lvl = 0;
+
+	TRACE_EVENT("mfwRoot");
+
+	if (mfwRoot)
+		mfw_twhNext(mfwRoot);
+
+	/*
+	** Trace out the last remaining line (there will always be one)
+	*/
+	mfw_twh_str_purge();
+
+	TRACE_FUNCTION("<<<<< mfw_traceWinHdrs");
+	return;
+}
+
+static void mfw_twhNext(MfwHdr *next)
+{
+	while (next)
+	{
+		if (next->type != MfwTypMax)
+		{
+			/*
+			** Trace out this address, and its Type
+			*/
+			mfw_twhOut(next, next->type);
+
+			/*
+			** If this type is a Window, then it may have sub-elements
+			** Trace them out before continuing the tree on this level
+			*/
+			if (next->type == MfwTypWin)
+			{
+				MfwWin *win_ptr = (MfwWin *)next->data;
+
+				if (win_ptr)
+				{
+					MfwHdr *win_elems = win_ptr->elems;
+
+					/*
+					** Add the Callback Address before doing the sub-elements
+					*/
+					mfw_twhCb((void *)win_ptr->handler);
+					trc_lvl++;
+					mfw_twhNext(win_elems);
+					trc_lvl--;
+				}
+			}
+
+			if (next->next == NULL)
+			{
+				mfw_twhOut(0, 0);
+			}
+
+			next = next->next;
+		}
+		else
+		{
+			/*
+			** Trace out this address, and its Type
+			*/
+			mfw_twhOut(next, next->type);
+
+			next = NULL;
+		}
+	}
+		
+	return;
+}
+
+static char *mfw_twhType(MfwTyp type)
+{
+	switch (type)
+	{
+    	case MfwTypNone:                         /* no element (first !!)    */
+    		return("MfwTypNone");
+//    		break;  // RAVI
+
+    	case MfwTypWin:                          /* window                   */
+    		return("MfwTypWin");
+//    		break;  // RAVI
+
+		case MfwTypEdt:                          /* editor                   */
+			return("MfwTypEdt");
+//			break;  // RAVI
+
+    	case MfwTypMnu:                          /* menu handler             */
+    		return("MfwTypMnu");
+//    		break;  // RAVI
+
+		case MfwTypIcn:                          /* icon handler             */
+			return("MfwTypIcn");
+//			break;   // RAVI
+
+		case MfwTypKbd:                          /* keyboard                 */
+			return("MfwTypKbd");
+//			break;   // RAVI
+
+		case MfwTypTim:                          /* timer                    */
+			return("MfwTypTim");
+//			break;  // RAVI
+
+		case MfwTypMme:                          /* misc. mobile equipment   */
+			return("MfwTypMme");
+//			break;   //RAVI
+
+		case MfwTypVmm:                          /* MDL virtual machine      */
+			return("MfwTypVmm");
+//			break;  // RAVI
+
+		case MfwTypNm:                           /* network                  */
+			return("MfwTypNm");
+//			break;  // RAVI
+
+		case MfwTypSim:                          /* SIM card                 */
+			return("MfwTypSim");
+//			break;  // RAVI
+
+		case MfwTypCm:                           /* call handling            */
+			return("MfwTypCm");
+//			break;  // RAVI
+
+		case MfwTypPhb:                          /* phonebook handling       */
+			return("MfwTypPhb");
+//			break;  // RAVI
+
+		case MfwTypSms:                          /* short message handling   */
+			return("MfwTypSms");
+//			break;   // RAVI
+
+		case MfwTypSs:                           /* supl. services handling  */
+			return("MfwTypSs");
+//			break;   // RAVI
+
+		case MfwTypSat:                          /* SIM Toolkit handling     */
+			return("MfwTypSat");
+//			break;   // RAVI
+
+		case MfwTypLng:                          /* language handling        */
+			return("MfwTypLng");
+//			break;  // RAVI
+
+		case MfwTypInp:                          /* input handling           */
+			return("MfwTypInp");
+//			break; // RAVI
+
+		case MfwTypNode:                         /* node element             */
+			return("MfwTypNode");
+//			break; // RAVI
+
+		case MfwTypCphs:                         /* CPHS element             */
+			return("MfwTypCphs");
+//			break; // RAVI
+
+		case MfwTypGprs:                         /* GPRS handling            */
+			return("MfwTypGprs");
+//			break;  // RAVI
+
+		case MfwTypEm:							/*MC, SPR 1209 Eng Mode handling*/
+			return("MfwTypEm");
+//			break; // RAVI
+
+#ifdef BT_INTERFACE
+		case MfwTypBt:                           /* bluetooth handling       */
+			return("MfwTypBt");
+//			break;  // RAVI
+#endif
+
+#ifdef BTE_MOBILE
+		case MfwTypBte:                           /* bluetooth handling       */
+			return("MfwTypBte");
+//			break;		// RAVI
+#endif
+
+		case MfwTypMax:                          /* end of types (last !!)   */
+			return("MfwTypMax");
+//			break;  // RAVI
+
+		default:
+			return("Not Known");
+	}
+}
+
+static void mfw_twhOut(void *ptr, MfwTyp typ)
+{
+	unsigned char i;
+	char	fmt_str[30];
+
+	memset(fmt_str, 0, 30);
+	
+#if 0
+	/* The code here will output the information in hex format which will need
+    ** more decoding, but which may be necessary if the amount of information
+    ** being output causes problems in the BMI. Change the above #if to be '#if 1'
+    ** to use this format
+    */
+	sprintf(fmt_str,"%02x%08lx%02x", trc_lvl, ptr, typ);
+
+	/*
+	** Determine whether a new string is required
+	*/
+	if (mfw_twh_strlen > (TWH_MAX_STR_LEN - TWH_MAX_SINGLE_SIZE))
+	{
+		/*
+		** Need to output the previous trace and start a new line
+		*/
+		mfw_twh_str_purge();
+	}
+		
+	strcat(mfw_twh_str, fmt_str);
+
+	mfw_twh_strlen += 12;
+#else
+
+	memset(mfw_twh_str, 0, TWH_MAX_STR_LEN);
+	
+	for (i=0; i<trc_lvl; i++)
+	{
+		strcat(mfw_twh_str, "   ");
+	}
+
+	strcat(mfw_twh_str, "-> ");
+	
+	sprintf(fmt_str,"N:%08lx T:%s", ptr, mfw_twhType(typ));
+
+	strcat(mfw_twh_str, fmt_str);
+
+	if (typ != MfwTypWin)
+	{
+		/*
+		** Trace out the details - There will be no callback
+		*/
+		TRACE_EVENT(mfw_twh_str);
+	}
+#endif
+	return;
+}
+
+static void mfw_twhCb(void *ptr)
+{
+	char	fmt_str[20];
+
+	memset(fmt_str, 0, 20);
+#if 0
+	/* The code here will output the information in hex format which will need
+    ** more decoding, but which may be necessary if the amount of information
+    ** being output causes problems in the BMI. Change the above #if to be '#if 1'
+    ** to use this format
+    */
+	/*
+	** No Need to test whether there is enough space for the callback ...already checked in mfw_twhOut()
+	*/
+	sprintf(fmt_str,"%08lx", ptr);
+		
+	strcat(mfw_twh_str, fmt_str);
+
+	mfw_twh_strlen += 8;
+#else
+	/*
+	** No Need to test whether there is enough space for the callback ...already checked in mfw_twhOut()
+	*/
+	sprintf(fmt_str," Cb:%08lx", ptr);
+		
+	strcat(mfw_twh_str, fmt_str);
+
+	TRACE_EVENT(mfw_twh_str);
+#endif
+	return;
+}
+
+static void mfw_twh_str_purge(void)
+{
+#if 0
+	/* The code here is needed when using the hex format output which will need
+    ** more decoding, but which may be necessary if the amount of information
+    ** being output causes problems in the BMI. Change the above #if to be '#if 1'
+    ** to use this format
+    */
+	TRACE_EVENT(mfw_twh_str);
+
+	memset(mfw_twh_str, 0, TWH_MAX_STR_LEN);
+	mfw_twh_strlen = 0;
+
+	vsi_t_sleep(VSI_CALLER 10);
+#endif
+	return;
+}
+