multipage.c

MCB2300_ucgui_LCD320240.rar LPC2368的uc/gui的移植

					(*WM_H2P(hBelow)->cb) (pMsg);
				}
			}
			else
			{
				WM_BringToTop(hObj);
			}
			Notification = WM_NOTIFICATION_CLICKED;
		}
		else
		{
			Notification = WM_NOTIFICATION_RELEASED;
		}
	}
	else
	{
		Notification = WM_NOTIFICATION_MOVED_OUT;
	}
	WM_NotifyParent(hObj, Notification);
}

/*********************************************************************
*
*   	_Callback
*/
static void _Callback(WM_MESSAGE *pMsg)
{
	MULTIPAGE_Handle hObj = pMsg->hWin;
	MULTIPAGE_Obj* pObj;
	int Handled;
	WM_LOCK();
	pObj = MULTIPAGE_H2P(hObj);
	Handled = WIDGET_HandleActive(hObj, pMsg);
	switch (pMsg->MsgId)
	{
		case WM_PAINT:
			_Paint(pObj);
			break;
		case WM_TOUCH:
			_OnTouch(hObj, pObj, pMsg);
			break;
		case WM_NOTIFY_PARENT:
			if (pMsg->Data.v == WM_NOTIFICATION_VALUE_CHANGED)
			{
				if (WM_GetId(pMsg->hWinSrc) == GUI_ID_HSCROLL)
				{
					pObj->ScrollState = SCROLLBAR_GetValue(pMsg->hWinSrc);
					WM_InvalidateWindow(hObj);
				}
			}
			break;
		case WM_GET_CLIENT_WINDOW:
			pMsg->Data.v = (int) pObj->hClient;
			break;
		case WM_GET_INSIDE_RECT:
			_CalcClientRect(pObj, (GUI_RECT *) (pMsg->Data.p));
			break;
		case WM_WIDGET_SET_EFFECT:
			WIDGET_SetEffect(WM_GetScrollbarH(hObj), (WIDGET_EFFECT const *) pMsg->Data.p);
		case WM_SIZE:
			_UpdatePositions(hObj, pObj);
			break;
		case WM_DELETE:
			GUI_ARRAY_Delete(&pObj->Handles);
			/* No break here ... WM_DefaultProc needs to be called */
		default:
			/* Let widget handle the standard messages */
			if (Handled)
			{
				WM_DefaultProc(pMsg);
			}
	}
	WM_UNLOCK();
}

/*********************************************************************
*
*   	_ClientCallback
*/
static void _ClientCallback(WM_MESSAGE *pMsg)
{
	WM_HWIN hObj = pMsg->hWin;
	WM_HWIN hParent = WM_GetParent(hObj);
	MULTIPAGE_Obj* pParent;
	WM_LOCK();
	pParent = MULTIPAGE_H2P(hParent);
	switch (pMsg->MsgId)
	{
		case WM_PAINT:
			LCD_SetBkColor(pParent->aBkColor[1]);
			GUI_Clear();
			break;
		case WM_TOUCH:
			WM_SetFocus(hParent);
			WM_BringToTop(hParent);
			break;
		case WM_GET_CLIENT_WINDOW:
			pMsg->Data.v = (int) hObj;
			break;
		case WM_GET_INSIDE_RECT:
			WM_DefaultProc(pMsg);
	}
	WM_UNLOCK();
}

/*********************************************************************
*
*   	Exported routines:  Create
*
**********************************************************************
*/

/* Note: the parameters to a create function may vary.
		 Some widgets may have multiple create functions */

/*********************************************************************
*
*   	MULTIPAGE_CreateEx
*/
MULTIPAGE_Handle MULTIPAGE_CreateEx(int x0, int y0, int xsize, int ysize, WM_HWIN hParent, int WinFlags, int ExFlags, int Id)
{
	MULTIPAGE_Handle hObj;
	GUI_USE_PARA(ExFlags);
	/* Create the window */
	hObj = WM_CreateWindowAsChild(x0, y0, xsize, ysize, hParent, WinFlags | WM_CF_HASTRANS, &_Callback, sizeof(MULTIPAGE_Obj) - sizeof(WM_Obj));
	if (hObj)
	{
		MULTIPAGE_Obj* pObj;
		GUI_RECT rClient;
		int Flags;
		WM_LOCK();
		pObj = MULTIPAGE_H2P(hObj);
		/* Init sub-classes */
		GUI_ARRAY_CREATE(&pObj->Handles);
		/* init widget specific variables */
		WIDGET__Init(&pObj->Widget, Id, WIDGET_STATE_FOCUSSABLE);
		/* init member variables */
		MULTIPAGE_INIT_ID(pObj);
		pObj->aBkColor[0] = MULTIPAGE__DefaultBkColor[0];
		pObj->aBkColor[1] = MULTIPAGE__DefaultBkColor[1];
		pObj->aTextColor[0] = MULTIPAGE__DefaultTextColor[0];
		pObj->aTextColor[1] = MULTIPAGE__DefaultTextColor[1];
		pObj->Font = MULTIPAGE__pDefaultFont;
		pObj->Align = MULTIPAGE__DefaultAlign;
		pObj->Selection = 0xffff;
		pObj->ScrollState = 0;
		pObj->Widget.State = 0;
		_CalcClientRect(pObj, &rClient);
		Flags = WM_CF_SHOW | WM_CF_ANCHOR_LEFT | WM_CF_ANCHOR_RIGHT | WM_CF_ANCHOR_TOP | WM_CF_ANCHOR_BOTTOM;
		pObj->hClient = WM_CreateWindowAsChild(rClient.x0, rClient.y0, rClient.x1 - rClient.x0 + 1, rClient.y1 - rClient.y0 + 1, hObj, Flags, &_ClientCallback, 0);
		_UpdatePositions(hObj, pObj);
		WM_UNLOCK();
	}
	else
	{
		GUI_DEBUG_ERROROUT_IF(hObj == 0, "MULTIPAGE_Create failed")
	}
	return hObj;
}

/*********************************************************************
*
*   	Exported routines:  Page management
*
**********************************************************************
*/
/*********************************************************************
*
*   	MULTIPAGE_AddPage
*/
void MULTIPAGE_AddPage(MULTIPAGE_Handle hObj, WM_HWIN hWin, const char *pText)
{
	MULTIPAGE_Obj* pObj;
	GUI_USE_PARA(hWin);
	if (hObj)
	{
		WM_LOCK();
		pObj = MULTIPAGE_H2P(hObj);
		MULTIPAGE_ASSERT_IS_VALID_PTR(pObj);
		if (!hWin)
		{
			/* If we get no handle we must find it. To do this, we search      */
			/* all children until we found one that has not yet become a page. */
			MULTIPAGE_PAGE* pPage;
			WM_HWIN hChild;
			WM_Obj* pChild;
			WM_Obj* pClient = WM_H2P(pObj->hClient);
			int i;
			for (hChild = pClient->hFirstChild; hChild && !hWin; hChild = pChild->hNext)
			{
				pChild = WM_H2P(hChild);
				hWin = hChild;
				for (i = 0; i < pObj->Handles.NumItems; i++)
				{
					pPage = (MULTIPAGE_PAGE *) GUI_ARRAY_GetpItem(&pObj->Handles, i);
					if (pPage->hWin == hChild)
					{
						hWin = 0;
						break;
					}
				}
			}
		}
		else
		{
			/* If we get a handle we must ensure that it was attached to the multipage */
			WM_AttachWindowAt(hWin, pObj->hClient, 0, 0);
		}
		if (hWin)
		{
			MULTIPAGE_PAGE Page;
			char NullByte = 0;
			if (!pText)
			{
				pText = &NullByte;
			}
			Page.hWin = hWin;
			Page.Status = MULTIPAGE_STATE_ENABLED;
			if (GUI_ARRAY_AddItem(&pObj->Handles, &Page, sizeof(MULTIPAGE_PAGE) + strlen(pText)) == 0)
			{
				MULTIPAGE_PAGE* pPage;
				pPage = (MULTIPAGE_PAGE *) GUI_ARRAY_GetpItem(&pObj->Handles, pObj->Handles.NumItems - 1);
				memcpy(&pPage->acText, pText, strlen(pText) + 1);
			}
			MULTIPAGE_SelectPage(hObj, pObj->Handles.NumItems - 1);
		}
		WM_UNLOCK();
	}
}

/*********************************************************************
*
*   	MULTIPAGE_DeletePage
*/
void MULTIPAGE_DeletePage(MULTIPAGE_Handle hObj, unsigned Index, int Delete)
{
	if (hObj)
	{
		MULTIPAGE_Obj* pObj;
		WM_LOCK();
		pObj = MULTIPAGE_H2P(hObj);
		MULTIPAGE_ASSERT_IS_VALID_PTR(pObj);
		if (pObj)
		{
			if ((int) Index < pObj->Handles.NumItems)
			{
				WM_HWIN hWin;
				MULTIPAGE_PAGE* pPage;
				pPage = (MULTIPAGE_PAGE *) GUI_ARRAY_GetpItem(&pObj->Handles, Index);
				hWin = pPage->hWin;
				/* Remove the page from the multipage object */
				if (Index == pObj->Selection)
				{
					if (Index == ((unsigned) pObj->Handles.NumItems - 1))
					{
						_ShowPage(pObj, Index - 1);
						pObj->Selection--;
					}
					else
					{
						_ShowPage(pObj, Index + 1);
					}
				}
				else
				{
					if (Index < pObj->Selection)
					{
						pObj->Selection--;
					}
				}
				GUI_ARRAY_DeleteItem(&pObj->Handles, Index);
				_UpdatePositions(hObj, pObj);
				/* Delete the window of the page */
				if (Delete)
				{
					WM_DeleteWindow(hWin);
				}
			}
		}
		WM_UNLOCK();
	}
}

/*********************************************************************
*
*   	MULTIPAGE_SelectPage
*/
void MULTIPAGE_SelectPage(MULTIPAGE_Handle hObj, unsigned Index)
{
	if (hObj)
	{
		MULTIPAGE_Obj* pObj;
		WM_LOCK();
		pObj = MULTIPAGE_H2P(hObj);
		MULTIPAGE_ASSERT_IS_VALID_PTR(pObj);
		if (pObj)
		{
			if ((int) Index < pObj->Handles.NumItems)
			{
				if (Index != pObj->Selection && _GetEnable(pObj, Index))
				{
					_ShowPage(pObj, Index);
					pObj->Selection = Index;
					_UpdatePositions(hObj, pObj);
				}
			}
		}
		WM_UNLOCK();
	}
}

/*********************************************************************
*
*   	MULTIPAGE_DisablePage
*/
void MULTIPAGE_DisablePage(MULTIPAGE_Handle hObj, unsigned Index)
{
	if (hObj)
	{
		MULTIPAGE_Obj* pObj;
		WM_LOCK();
		pObj = MULTIPAGE_H2P(hObj);
		MULTIPAGE_ASSERT_IS_VALID_PTR(pObj);
		if (pObj)
		{
			_SetEnable(pObj, Index, 0);
			WM_InvalidateWindow(hObj);
		}
		WM_UNLOCK();
	}
}

/*********************************************************************
*
*   	MULTIPAGE_EnablePage
*/
void MULTIPAGE_EnablePage(MULTIPAGE_Handle hObj, unsigned Index)
{
	if (hObj)
	{
		MULTIPAGE_Obj* pObj;
		WM_LOCK();
		pObj = MULTIPAGE_H2P(hObj);
		MULTIPAGE_ASSERT_IS_VALID_PTR(pObj);
		if (pObj)
		{
			_SetEnable(pObj, Index, 1);
			WM_InvalidateWindow(hObj);
		}
		WM_UNLOCK();
	}
}

/*********************************************************************
*
*   	Exported routines:  Various methods
*
**********************************************************************
*/
/*********************************************************************
*
*   	MULTIPAGE_SetText
*/
void MULTIPAGE_SetText(MULTIPAGE_Handle hObj, const char *pText, unsigned Index)
{
	MULTIPAGE_Obj* pObj;
	if (hObj && pText)
	{
		WM_LOCK();
		pObj = MULTIPAGE_H2P(hObj);
		MULTIPAGE_ASSERT_IS_VALID_PTR(pObj);
		if (pObj)
		{
			if ((int) Index < pObj->Handles.NumItems)
			{
				MULTIPAGE_PAGE* pPage;
				MULTIPAGE_PAGE Page;
				pPage = (MULTIPAGE_PAGE *) GUI_ARRAY_GetpItem(&pObj->Handles, Index);
				Page.hWin = pPage->hWin;
				Page.Status = pPage->Status;
				if (GUI_ARRAY_SetItem(&pObj->Handles, Index, &Page, sizeof(MULTIPAGE_PAGE) + strlen(pText)))
				{
					pPage = (MULTIPAGE_PAGE *) GUI_ARRAY_GetpItem(&pObj->Handles, Index);
					memcpy(&pPage->acText, pText, strlen(pText) + 1);   	   
					_UpdatePositions(hObj, pObj);
				}
			}
		}
		WM_UNLOCK();
	}
}

/*********************************************************************
*
*   	MULTIPAGE_SetBkColor
*/
void MULTIPAGE_SetBkColor(MULTIPAGE_Handle hObj, GUI_COLOR Color, unsigned Index)
{
	MULTIPAGE_Obj* pObj;
	if (hObj && ((int) Index < MULTIPAGE_NUMCOLORS))
	{
		WM_LOCK();
		pObj = MULTIPAGE_H2P(hObj);
		MULTIPAGE_ASSERT_IS_VALID_PTR(pObj);
		if (pObj)
		{
			pObj->aBkColor[Index] = Color;
			WM_InvalidateWindow(hObj);
		}
		WM_UNLOCK();
	}
}

/*********************************************************************
*
*   	MULTIPAGE_SetTextColor
*/
void MULTIPAGE_SetTextColor(MULTIPAGE_Handle hObj, GUI_COLOR Color, unsigned Index)
{
	MULTIPAGE_Obj* pObj;
	if (hObj && ((int) Index < MULTIPAGE_NUMCOLORS))
	{
		WM_LOCK();
		pObj = MULTIPAGE_H2P(hObj);
		MULTIPAGE_ASSERT_IS_VALID_PTR(pObj);
		if (pObj)
		{
			pObj->aTextColor[Index] = Color;
			WM_InvalidateWindow(hObj);
		}
		WM_UNLOCK();
	}
}

/*********************************************************************
*
*   	MULTIPAGE_SetFont
*/
void MULTIPAGE_SetFont(MULTIPAGE_Handle hObj, const GUI_FONT GUI_UNI_PTR *pFont)
{
	MULTIPAGE_Obj* pObj;
	if (hObj && pFont)
	{
		WM_LOCK();
		pObj = MULTIPAGE_H2P(hObj);
		MULTIPAGE_ASSERT_IS_VALID_PTR(pObj);
		if (pObj)
		{
			pObj->Font = pFont;
			_UpdatePositions(hObj, pObj);
		}
		WM_UNLOCK();
	}
}

/*********************************************************************
*
*   	MULTIPAGE_SetAlign
*/
void MULTIPAGE_SetAlign(MULTIPAGE_Handle hObj, unsigned Align)
{
	MULTIPAGE_Obj* pObj;
	GUI_RECT rClient;
	if (hObj)
	{
		WM_LOCK();
		pObj = MULTIPAGE_H2P(hObj);
		MULTIPAGE_ASSERT_IS_VALID_PTR(pObj);
		if (pObj)
		{
			pObj->Align = Align;
			_CalcClientRect(pObj, &rClient);
			WM_MoveTo(pObj->hClient, rClient.x0 + pObj->Widget.Win.Rect.x0, rClient.y0 + pObj->Widget.Win.Rect.y0);
			_UpdatePositions(hObj, pObj);
		}
		WM_UNLOCK();
	}
}

/*********************************************************************
*
*   	MULTIPAGE_GetSelection
*/
int MULTIPAGE_GetSelection(MULTIPAGE_Handle hObj)
{
	int r = 0;
	if (hObj)
	{
		MULTIPAGE_Obj* pObj;
		WM_LOCK();
		pObj = MULTIPAGE_H2P(hObj);
		MULTIPAGE_ASSERT_IS_VALID_PTR(pObj);
		if (pObj)
		{
			r = pObj->Selection;
		}
		WM_UNLOCK();
	}
	return r;
}

/*********************************************************************
*
*   	MULTIPAGE_GetWindow
*/
WM_HWIN MULTIPAGE_GetWindow(MULTIPAGE_Handle hObj, unsigned Index)
{
	WM_HWIN r = 0;
	if (hObj)
	{
		MULTIPAGE_Obj* pObj;
		WM_LOCK();
		pObj = MULTIPAGE_H2P(hObj);
		MULTIPAGE_ASSERT_IS_VALID_PTR(pObj);
		if (pObj)
		{
			if ((int) Index < pObj->Handles.NumItems)
			{
				MULTIPAGE_PAGE* pPage;
				pPage = (MULTIPAGE_PAGE *) GUI_ARRAY_GetpItem(&pObj->Handles, Index);
				r = pPage->hWin;
			}
		}
		WM_UNLOCK();
	}
	return r;
}

/*********************************************************************
*
*   	MULTIPAGE_IsPageEnabled
*/
int MULTIPAGE_IsPageEnabled(MULTIPAGE_Handle hObj, unsigned Index)
{
	int r = 0;
	if (hObj)
	{
		MULTIPAGE_Obj* pObj;
		WM_LOCK();
		pObj = MULTIPAGE_H2P(hObj);
		MULTIPAGE_ASSERT_IS_VALID_PTR(pObj);
		if (pObj)
		{
			r = _GetEnable(pObj, Index);
		}
		WM_UNLOCK();
	}
	return r;
}

#else /* avoid empty object files */

void MULTIPAGE_C(void);
void MULTIPAGE_C(void)
{
}

#endif  /* #if GUI_WINSUPPORT */