mfw_win.c

是一个手机功能的模拟程序

				winUpdate(r->data);
			r = r->next;
		}
		//JVJE    dspl_Enable(uMode);
		if (winUseAutoFocus)                /* automatic focussing      */
			mfwFocus = 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;
		mfwFocus = 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)
			mfwFocus = mfwFocus->next;  /* search focus root        */
		mfwFocus = mfwFocus->next;      /* the focus window         */
		if (mfwFocus->type != MfwTypWin)
		{
			mfwFocus = 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           */
	mfwFocus = 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);
				//				TRACE_FUNCTION("handler called");
			}
			
			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);

}

/*****************************
$Description:
talcon added 2004.07.20
**********************************/
MfwRes winUnMask(MfwHnd w,MfwEvt evt)
{ 
	MfwWin *win;
	win = ((MfwHdr *) w)->data;
	win->mask &= ~evt; 
	return MfwResOk;
}

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

MfwRes yq_free(MfwHnd win)
{
	MfwHdr *win_hdr;
	MfwWin *win_win;
	MfwHdr *win_eoc;
    MfwHdr *cur_eoc;
    MfwCb f;
    if(!win)
    	return MfwResIllHnd;
     if (((MfwHdr *) win)->type != MfwTypWin)
        return MfwResIllHnd;            /* element is not a window  */
    win_hdr=(MfwHdr *)win;
    win_win = (MfwWin *)(win_hdr->data);
    if (!win_win)
        return MfwResErr;
     win_win->flags |= MfwWinDelete;
    if (win_win->handler)
        if (win_win->mask & MfwWinDelete)
            win_win->handler(MfwWinDelete,win_win);
    win_eoc=(MfwHdr *)(win_win->elems);
    if(!win_eoc)
    	return MfwResErr;
	while(win_eoc&&win_eoc->type!=MfwTypMax)
		{
		    cur_eoc=win_eoc;
		    win_eoc=win_eoc->next;
			if(cur_eoc->type==MfwTypWin)
				{
				    
					yq_free(cur_eoc);
				}
			else
				{
					f = mfwCommand[cur_eoc->type];
                if (f)
                    f(MfwCmdDelete,cur_eoc);
				}
		}
	mfwFree((MfwHnd)win_eoc,sizeof(MfwHdr));
	freeandreg(win_win->user);
	mfwFree((void *)win_win,sizeof(MfwWin));
	mfwFree((MfwHnd)win_hdr,sizeof(MfwHdr));
	return MfwResOk;
}

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