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