mfw_win.c

GSM手机设计软件代码

+--------------------------------------------------------------------+
| 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];
static unsigned int mfw_twh_strlen;

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;

    	case MfwTypWin:                          /* window                   */
    		return("MfwTypWin");
    		break;

		case MfwTypEdt:                          /* editor                   */
			return("MfwTypEdt");
			break;

    	case MfwTypMnu:                          /* menu handler             */
    		return("MfwTypMnu");
    		break;

		case MfwTypIcn:                          /* icon handler             */
			return("MfwTypIcn");
			break;

		case MfwTypKbd:                          /* keyboard                 */
			return("MfwTypKbd");
			break;

		case MfwTypTim:                          /* timer                    */
			return("MfwTypTim");
			break;

		case MfwTypMme:                          /* misc. mobile equipment   */
			return("MfwTypMme");
			break;

		case MfwTypVmm:                          /* MDL virtual machine      */
			return("MfwTypVmm");
			break;

		case MfwTypNm:                           /* network                  */
			return("MfwTypNm");
			break;

		case MfwTypSim:                          /* SIM card                 */
			return("MfwTypSim");
			break;

		case MfwTypCm:                           /* call handling            */
			return("MfwTypCm");
			break;

		case MfwTypPhb:                          /* phonebook handling       */
			return("MfwTypPhb");
			break;

		case MfwTypSms:                          /* short message handling   */
			return("MfwTypSms");
			break;

		case MfwTypSs:                           /* supl. services handling  */
			return("MfwTypSs");
			break;

		case MfwTypSat:                          /* SIM Toolkit handling     */
			return("MfwTypSat");
			break;

		case MfwTypLng:                          /* language handling        */
			return("MfwTypLng");
			break;

		case MfwTypInp:                          /* input handling           */
			return("MfwTypInp");
			break;

		case MfwTypNode:                         /* node element             */
			return("MfwTypNode");
			break;

		case MfwTypCphs:                         /* CPHS element             */
			return("MfwTypCphs");
			break;

		case MfwTypGprs:                         /* GPRS handling            */
			return("MfwTypGprs");
			break;

		case MfwTypEm:							/*MC, SPR 1209 Eng Mode handling*/
			return("MfwTypEm");
			break;

#ifdef BT_INTERFACE
		case MfwTypBt:                           /* bluetooth handling       */
			return("MfwTypBt");
			break;
#endif

		case MfwTypMax:                          /* end of types (last !!)   */
			return("MfwTypMax");
			break;

		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;
}