framewin.c

MCB2300_ucgui_LCD320240.rar LPC2368的uc/gui的移植

					{
						WM_SetFocus(hWin);
					}
				}
			}
			break;
		case WM_NOTIFY_CHILD_HAS_FOCUS:
			_OnChildHasFocus(hWin, pObj, pMsg);
			break;
		case WM_DELETE:
			GUI_DEBUG_LOG("FRAMEWIN: _FRAMEWIN_Callback(WM_DELETE)\n");
			GUI_ALLOC_FreePtr(&pObj->hText);
			break;
	}
	/* Let widget handle the standard messages */
	if (WIDGET_HandleActive(hWin, pMsg) == 0)
	{
		return;
	}
	WM_DefaultProc(pMsg);
}

/*********************************************************************
*
*   	Client Callback
*/
static void FRAMEWIN__cbClient(WM_MESSAGE *pMsg)
{
	WM_HWIN hWin = pMsg->hWin;
	WM_HWIN hParent = WM_GetParent(pMsg->hWin);
	FRAMEWIN_Obj* pObj = FRAMEWIN_H2P(hParent);
	WM_CALLBACK* cb = pObj->cb;
	switch (pMsg->MsgId)
	{
		case WM_PAINT:
			if (pObj->Props.ClientColor != GUI_INVALID_COLOR)
			{
				LCD_SetBkColor(pObj->Props.ClientColor);
				GUI_Clear();
			}
			/* Give the user callback  a chance to draw.
			 * Note that we can not run into the bottom part, as this passes the parents handle
			 */
			if (cb)
			{
				WM_MESSAGE Msg;
				Msg = *pMsg;
				Msg.hWin = hWin;
				(*cb) (&Msg);
			}
			return;
		case WM_SET_FOCUS:
			if (pMsg->Data.v)
			{
				/* Focus received */
				if (pObj->hFocussedChild && (pObj->hFocussedChild != hWin))
				{
					WM_SetFocus(pObj->hFocussedChild);
				}
				else
				{
					pObj->hFocussedChild = WM_SetFocusOnNextChild(hWin);
				}
				pMsg->Data.v = 0;     /* Focus change accepted */
			}
			return;
		case WM_GET_ACCEPT_FOCUS:
			WIDGET_HandleActive(hParent, pMsg);
			return;
		case WM_KEY:
			if (((const WM_KEY_INFO *) (pMsg->Data.p))->PressedCnt > 0)
			{
				int Key = ((const WM_KEY_INFO *) (pMsg->Data.p))->Key;
				switch (Key)
				{
					case GUI_KEY_TAB:
						pObj->hFocussedChild = WM_SetFocusOnNextChild(hWin);
						return;
				}
			}
			break;						   /* Send to parent by not doing anything */
		case WM_GET_BKCOLOR:
			pMsg->Data.Color = pObj->Props.ClientColor;
			return; 					  /* Message handled */
		case WM_GET_INSIDE_RECT:
			/* This should not be passed to parent ... (We do not want parents coordinates)*/
		case WM_GET_ID:
			/* This should not be passed to parent ... (Possible recursion problem)*/
		case WM_GET_CLIENT_WINDOW:
			/* return handle to client window. For most windows, there is no seperate client window, so it is the same handle */
			WM_DefaultProc(pMsg);
			return; 					  /* We are done ! */
	}
	/* Call user callback. Note that the user callback gets the handle of the Framewindow itself, NOT the Client. */
	if (cb)
	{
		pMsg->hWin = hParent;
		(*cb) (pMsg);
	}
	else
	{
		WM_DefaultProc(pMsg);
	}
}

/*********************************************************************
*
*   	 Exported module-internal routines:
*
**********************************************************************
*/
/*********************************************************************
*
*   	FRAMEWIN__CalcTitleHeight
*/
int FRAMEWIN__CalcTitleHeight(FRAMEWIN_Obj *pObj)
{
	int r = 0;
	if (pObj->Widget.State & FRAMEWIN_SF_TITLEVIS)
	{
		r = pObj->Props.TitleHeight;
		if (r == 0)
		{
			r = 2 + GUI_GetYSizeOfFont(pObj->Props.pFont);
		}
	}
	return r;
}

/*********************************************************************
*
*   	FRAMEWIN__CalcPositions
*/
void FRAMEWIN__CalcPositions(FRAMEWIN_Obj *pObj, POSITIONS *pPos)
{
	WM_HWIN hChild;
	WM_Obj* pChild;
	int TitleHeight;
	int MenuHeight = 0;
	int IBorderSize = 0;
	int BorderSize;
	int xsize, ysize;
	int x0, x1, y0;
	BorderSize = pObj->Props.BorderSize;
	xsize = WM__GetWindowSizeX(&pObj->Widget.Win);
	ysize = WM__GetWindowSizeY(&pObj->Widget.Win);
	if (pObj->Widget.State & FRAMEWIN_SF_TITLEVIS)
	{
		IBorderSize = pObj->Props.IBorderSize;
	}
	TitleHeight = FRAMEWIN__CalcTitleHeight(pObj);
	if (pObj->hMenu)
	{
		MenuHeight = WM_GetWindowSizeY(pObj->hMenu);
	}
	pPos->TitleHeight = TitleHeight;
	pPos->MenuHeight = MenuHeight;
	/* Set object properties accordingly */
	pPos->rClient.x0 = BorderSize;
	pPos->rClient.x1 = xsize - BorderSize - 1;
	pPos->rClient.y0 = BorderSize + IBorderSize + TitleHeight + MenuHeight;
	pPos->rClient.y1 = ysize - BorderSize - 1;
	/* Calculate title rect */
	pPos->rTitleText.x0 = BorderSize;
	pPos->rTitleText.x1 = xsize - BorderSize - 1;
	pPos->rTitleText.y0 = BorderSize;
	pPos->rTitleText.y1 = BorderSize + TitleHeight - 1;
	/* Iterate over all children */
	for (hChild = pObj->Widget.Win.hFirstChild; hChild; hChild = pChild->hNext)
	{
		pChild = WM_H2P(hChild);
		x0 = pChild->Rect.x0 - pObj->Widget.Win.Rect.x0;
		x1 = pChild->Rect.x1 - pObj->Widget.Win.Rect.x0;
		y0 = pChild->Rect.y0 - pObj->Widget.Win.Rect.y0;
		if (y0 == BorderSize)
		{
			if (pChild->Status & WM_SF_ANCHOR_RIGHT)
			{
				if (x0 <= pPos->rTitleText.x1)
				{
					pPos->rTitleText.x1 = x0 - 1;
				}
			}
			else
			{
				if (x1 >= pPos->rTitleText.x0)
				{
					pPos->rTitleText.x0 = x1 + 1;
				}
			}
		}
	}
}

/*********************************************************************
*
*   	FRAMEWIN__UpdatePositions
*/
void FRAMEWIN__UpdatePositions(FRAMEWIN_Obj *pObj)
{
	/* Move client window accordingly */
	if (pObj->hClient || pObj->hMenu)
	{
		POSITIONS Pos;
		FRAMEWIN__CalcPositions(pObj, &Pos);
		if (pObj->hClient)
		{
			WM_MoveChildTo(pObj->hClient, Pos.rClient.x0, Pos.rClient.y0);
			WM_SetSize(pObj->hClient, Pos.rClient.x1 - Pos.rClient.x0 + 1, Pos.rClient.y1 - Pos.rClient.y0 + 1);
		}
		if (pObj->hMenu)
		{
			WM_MoveChildTo(pObj->hMenu, Pos.rClient.x0, Pos.rClient.y0 - Pos.MenuHeight);
		}
	}
}

/*********************************************************************
*
*   	 Exported API routines:  Create
*
**********************************************************************
*/
/*********************************************************************
*
*   	FRAMEWIN_CreateEx
*/
FRAMEWIN_Handle FRAMEWIN_CreateEx(int x0, int y0, int xsize, int ysize, WM_HWIN hParent, int WinFlags, int ExFlags, int Id, const char *pTitle, WM_CALLBACK *cb)
{
	FRAMEWIN_Handle hObj;
	/* Create the window */
	WinFlags |= WM_CF_LATE_CLIP;	/* Always use late clipping since widget is optimized for it. */
	hObj = WM_CreateWindowAsChild(x0, y0, xsize, ysize, hParent, WinFlags, _FRAMEWIN_Callback, sizeof(FRAMEWIN_Obj) - sizeof(WM_Obj));
	if (hObj)
	{
		FRAMEWIN_Obj* pObj;
		POSITIONS Pos;
		GUI_LOCK();
		pObj = FRAMEWIN_H2P(hObj);
		/* init widget specific variables */
		WIDGET__Init(&pObj->Widget, Id, WIDGET_STATE_FOCUSSABLE | FRAMEWIN_SF_TITLEVIS);
		/* init member variables */
		pObj->Props = FRAMEWIN__DefaultProps;
		pObj->TextAlign = GUI_TA_LEFT;
		pObj->cb = cb;
		pObj->Flags = ExFlags;
		pObj->hFocussedChild = 0;
		pObj->hMenu = 0;
		pObj->pFirstHook = NULL;
		FRAMEWIN__CalcPositions(pObj, &Pos);
		pObj->hClient = WM_CreateWindowAsChild(Pos.rClient.x0, Pos.rClient.y0, Pos.rClient.x1 - Pos.rClient.x0 + 1, Pos.rClient.y1 - Pos.rClient.y0 + 1, hObj, WM_CF_ANCHOR_RIGHT | WM_CF_ANCHOR_LEFT | WM_CF_ANCHOR_TOP | WM_CF_ANCHOR_BOTTOM | WM_CF_SHOW | WM_CF_LATE_CLIP, FRAMEWIN__cbClient, 0);
		/* Normally we disable memory devices for the frame window:
		 * The frame window does not flicker, and not using memory devices is usually faster.
		 * You can still use memory by explicitly specifying the flag
		 */
		if ((WinFlags & (WM_CF_MEMDEV | (WM_CF_MEMDEV_ON_REDRAW))) == 0)
		{
			WM_DisableMemdev(hObj);
		}
		FRAMEWIN_SetText(hObj, pTitle);
		GUI_UNLOCK();
	}
	return hObj;
}

/*********************************************************************
*
*   	 Exported routines:  Set Properties
*
**********************************************************************
*/
/*********************************************************************
*
*   	FRAMEWIN_SetText
*/
void FRAMEWIN_SetText(FRAMEWIN_Handle hObj, const char *s)
{
	if (hObj)
	{
		FRAMEWIN_Obj* pObj;
		GUI_LOCK();
		pObj = FRAMEWIN_H2P(hObj);
		if (GUI__SetText(&pObj->hText, s))
		{
			FRAMEWIN_Invalidate(hObj);
		}
		GUI_UNLOCK();
	}
}

/*********************************************************************
*
*   	FRAMEWIN_SetTextAlign
*/
void FRAMEWIN_SetTextAlign(FRAMEWIN_Handle hObj, int Align)
{
	if (hObj)
	{
		FRAMEWIN_Obj* pObj;
		GUI_LOCK();
		pObj = FRAMEWIN_H2P(hObj);
		if (pObj->TextAlign != Align)
		{
			pObj->TextAlign = Align;
			FRAMEWIN_Invalidate(hObj);
		}
		GUI_UNLOCK();
	}
}

/*********************************************************************
*
*   	FRAMEWIN_SetMoveable
*/
void FRAMEWIN_SetMoveable(FRAMEWIN_Handle hObj, int State)
{
	if (hObj)
	{
		FRAMEWIN_Obj* pObj;
		GUI_LOCK();
		pObj = FRAMEWIN_H2P(hObj);
		if (State)
		{
			pObj->Flags |= FRAMEWIN_CF_MOVEABLE;
		}
		else
		{
			pObj->Flags &= ~FRAMEWIN_CF_MOVEABLE;
		}
		GUI_UNLOCK();
	}
}

/*********************************************************************
*
*   	FRAMEWIN_SetActive
*/
void FRAMEWIN_SetActive(FRAMEWIN_Handle hObj, int State)
{
	if (hObj)
	{
		WM_LOCK();
		_SetActive(hObj, State);
		WM_UNLOCK();
	}
}

#else
void WIDGET_FrameWin(void)
{
} /* avoid empty object files */
#endif /* GUI_WINSUPPORT */