widget.c

MCB2300_ucgui_LCD320240.rar LPC2368的uc/gui的移植

/*
*********************************************************************************************************
*   											 uC/GUI
*   					 Universal graphic software for embedded applications
*
*   					(c) Copyright 2002, Micrium Inc., Weston, FL
*   					(c) Copyright 2002, SEGGER Microcontroller Systeme GmbH
*
*   		   礐/GUI is protected by international copyright laws. Knowledge of the
*   		   source code may not be used to write a similar product. This file may
*   		   only be used in accordance with a license and should not be redistributed
*   		   in any way. We appreciate your understanding and fairness.
*
----------------------------------------------------------------------
File		: WIDGET.c
Purpose 	: Widget core routines
---------------------------END-OF-HEADER------------------------------
*/

#include <stdlib.h>
#include <string.h>

#include "WIDGET.h"
#include "GUIDebug.h"
#include "GUI.h"
#include "GUI_Protected.h"
#include "WM_Intern.h"

#if GUI_WINSUPPORT

/*********************************************************************
*
*   	Static data
*
**********************************************************************
*/

const WIDGET_EFFECT* _pEffectDefault = &WIDGET_Effect_3D;

/*********************************************************************
*
*   	Static routines
*
**********************************************************************
*/
/*********************************************************************
*
*   	_UpdateChildPositions
*/
static void _UpdateChildPostions(WM_HWIN hObj, int Diff)
{
	WM_Obj* pObj;
	WM_LOCK();
	pObj = (WM_Obj *) WM_H2P(hObj);
	WM__UpdateChildPositions(pObj, -Diff, -Diff, Diff, Diff);
	WM_UNLOCK();
}

/*********************************************************************
*
*   	_EffectRequiresRedraw
*
* Purpose
*   Check if the effect to draw is inside the invalid rectangle.
* Returns:
*   0 if nothing need to be done.
*   1 if the effect needs to be drawn
*/
static int _EffectRequiresRedraw(const WIDGET *pWidget, const GUI_RECT *pRect)
{
	int EffectSize = pWidget->pEffect->EffectSize;
	GUI_RECT InvalidRect;
	InvalidRect = pWidget->Win.InvalidRect;
	WM__Client2Screen(&pWidget->Win, &InvalidRect);
	/* Check if there a part of the effect is inside the invalid rectangle */
	if ((pRect->x0 + EffectSize) > InvalidRect.x0)
	{
		return 1;   			/* Overlap ... Drawing required */
	}
	if ((pRect->x1 - EffectSize) < InvalidRect.x1)
	{
		return 1;   			/* Overlap ... Drawing required */
	}
	if ((pRect->y0 + EffectSize) > InvalidRect.y0)
	{
		return 1;   			/* Overlap ... Drawing required */
	}
	if ((pRect->y1 - EffectSize) < InvalidRect.y1)
	{
		return 1;   			/* Overlap ... Drawing required */
	}
	return 0;   			  /* No overlap ! */
}


/*********************************************************************
*
*   	Public routines
*
**********************************************************************
*/
/*********************************************************************
*
*   	WIDGET__RotateRect90
*/
void WIDGET__RotateRect90(WIDGET *pWidget, GUI_RECT *pDest, const GUI_RECT *pRect)
{
	int x0, x1, XSize;
	x0 = pRect->x0;
	x1 = pRect->x1;
	XSize = pWidget->Win.Rect.x1 - pWidget->Win.Rect.x0;
	pDest->x0 = XSize - pRect->y1;
	pDest->x1 = XSize - pRect->y0;
	pDest->y0 = x0;
	pDest->y1 = x1;
}

/*********************************************************************
*
*   	WIDGET__GetClientRect

  Returns the logical client rectangle, which means the normal
  client rectangle for widgets with their standard orientation
  and the rotated one for rotated widgets.
*/
void WIDGET__GetClientRect(WIDGET *pWidget, GUI_RECT *pRect)
{
	if (pWidget->State & WIDGET_STATE_VERTICAL)
	{
		GUI_RECT Rect;
		WM_GetClientRect(&Rect);
		pRect->x0 = Rect.y0;
		pRect->x1 = Rect.y1;
		pRect->y0 = Rect.x0;
		pRect->y1 = Rect.x1;
	}
	else
	{
		WM_GetClientRect(pRect);
	}
}

/*********************************************************************
*
*   	WIDGET__GetBkColor
*/
GUI_COLOR WIDGET__GetBkColor(WM_HWIN hObj)
{
	GUI_COLOR BkColor = WM_GetBkColor(WM_GetParent(hObj));
	if (BkColor == GUI_INVALID_COLOR)
	{
		BkColor = DIALOG_GetBkColor();
	}
	return BkColor;
}

/*********************************************************************
*
*   	WIDGET__GetInsideRect
*/
void WIDGET__GetInsideRect(WIDGET *pWidget, GUI_RECT *pRect)
{
	WM__GetClientRectWin(&pWidget->Win, pRect);
	GUI__ReduceRect(pRect, pRect, pWidget->pEffect->EffectSize);
}

/*********************************************************************
*
*   	WIDGET__GetXSize
*/
int WIDGET__GetXSize(const WIDGET *pWidget)
{
	int r;
	if (pWidget->State & WIDGET_STATE_VERTICAL)
	{
		r = pWidget->Win.Rect.y1 - pWidget->Win.Rect.y0;
	}
	else
	{
		r = pWidget->Win.Rect.x1 - pWidget->Win.Rect.x0;
	}
	return r + 1;
}

/*********************************************************************
*
*   	WIDGET__GetYSize
*/
int WIDGET__GetYSize(const WIDGET *pWidget)
{
	int r;
	if (pWidget->State & WIDGET_STATE_VERTICAL)
	{
		r = pWidget->Win.Rect.x1 - pWidget->Win.Rect.x0;
	}
	else
	{
		r = pWidget->Win.Rect.y1 - pWidget->Win.Rect.y0;
	}
	return r + 1;
}

/*******************************************************************
*
*   	WIDGET__GetWindowSizeX

  Return width (or height in case of rotation) of window in pixels
*/
int WIDGET__GetWindowSizeX(WM_HWIN hWin)
{
	WIDGET* pWidget = WIDGET_H2P(hWin);
	if (pWidget->State & WIDGET_STATE_VERTICAL)
	{
		return WM_GetWindowSizeY(hWin);
	}
	else
	{
		return WM_GetWindowSizeX(hWin);
	}
}

/*********************************************************************
*
*   	WIDGET_SetState
*/
void WIDGET_SetState(WM_HWIN hObj, int State)
{
	WIDGET* pWidget;
	WM_LOCK();
	pWidget = WIDGET_H2P(hObj);
	if (State != pWidget->State)
	{
		pWidget->State = State;
		WM_Invalidate(hObj);
	}
	WM_UNLOCK();
}

/*********************************************************************
*
*   	WIDGET_GetState
*/
int WIDGET_GetState(WM_HWIN hObj)
{
	int Ret = 0;
	WIDGET * pWidget;
	if (hObj)
	{
		WM_LOCK();
		pWidget = WIDGET_H2P(hObj);
		Ret = pWidget->State;
		WM_UNLOCK();
	}
	return Ret;
}

/*********************************************************************
*
*   	WIDGET_OrState
*/
void WIDGET_OrState(WM_HWIN hObj, int State)
{
	if (hObj)
	{
		WIDGET* pWidget;
		WM_LOCK();
		pWidget = WIDGET_H2P(hObj);
		if (State != (pWidget->State & State))
		{
			pWidget->State |= State;
			WM_Invalidate(hObj);
		}
		WM_UNLOCK();
	}
}

/*********************************************************************
*
*   	WIDGET_AndState

  Purpose:
	Clear flags in the State element of the widget.
	The bits to be cleared are set.
  Example:
	...(..., 3);   // Clears bit 0, 1 int the state member 

*/
void WIDGET_AndState(WM_HWIN hObj, int Mask)
{
	U16 StateNew;
	if (hObj)
	{
		WIDGET* pWidget;
		WM_LOCK();
		pWidget = WIDGET_H2P(hObj);
		StateNew = pWidget->State & (~Mask);
		if (pWidget->State != StateNew)
		{
			pWidget->State = StateNew;
			WM_Invalidate(hObj);
		}
		WM_UNLOCK();
	}
}

/*********************************************************************
*
*   	WIDGET__Init
*/
void WIDGET__Init(WIDGET *pWidget, int Id, U16 State)
{
	pWidget->pEffect = _pEffectDefault;
	pWidget->State = State;
	pWidget->Id = Id;
}


/*********************************************************************
*
*   	WIDGET_HandleActive
*/
int WIDGET_HandleActive(WM_HWIN hObj, WM_MESSAGE *pMsg)
{
	int Diff, Notification;
	WIDGET* pWidget = WIDGET_H2P(hObj);
	switch (pMsg->MsgId)
	{
		case WM_WIDGET_SET_EFFECT:
			Diff = pWidget->pEffect->EffectSize;
			pWidget->pEffect = (const WIDGET_EFFECT *) pMsg->Data.p;
			Diff -= pWidget->pEffect->EffectSize;
			_UpdateChildPostions(hObj, Diff);
			WM_InvalidateWindow(hObj);
			return 0;   					 /* Message handled -> Return */
		case WM_GET_ID:
			pMsg->Data.v = pWidget->Id;
			return 0;   					 /* Message handled -> Return */
		case WM_PID_STATE_CHANGED:
			if (pWidget->State & WIDGET_STATE_FOCUSSABLE)
			{
				const WM_PID_STATE_CHANGED_INFO * pInfo = (const WM_PID_STATE_CHANGED_INFO *) pMsg->Data.p;
				if (pInfo->State)
				{
					WM_SetFocus(hObj);
				}
			}
			break;
		case WM_TOUCH_CHILD:
			/* A descendent (child) has been touched or released.
			   If it has been touched, we need to get to top.
			 */
			{
				const WM_MESSAGE * pMsgOrg;
				const GUI_PID_STATE * pState;
				pMsgOrg = (const WM_MESSAGE *) pMsg->Data.p;	  /* The original touch message */
				pState = (const GUI_PID_STATE *) pMsgOrg->Data.p;
				if (pState)
				{
					/* Message may not have a valid pointer (moved out) ! */
					if (pState->Pressed)
					{
						WM_BringToTop(hObj);
						return 0;   				 /* Message handled -> Return */
					}
				}
			}
			break;
		case WM_SET_ID:
			pWidget->Id = pMsg->Data.v;
			return 0;   					 /* Message handled -> Return */
		case WM_SET_FOCUS:
			if (pMsg->Data.v == 1)
			{
				WIDGET_SetState(hObj, pWidget->State | WIDGET_STATE_FOCUS);
				Notification = WM_NOTIFICATION_GOT_FOCUS;
			}
			else
			{
				WIDGET_SetState(hObj, pWidget->State & ~WIDGET_STATE_FOCUS);
				Notification = WM_NOTIFICATION_LOST_FOCUS;
			}
			WM_NotifyParent(hObj, Notification);
			pMsg->Data.v = 0;   /* Focus change accepted */
			return 0;
		case WM_GET_ACCEPT_FOCUS:
			pMsg->Data.v = (pWidget->State & WIDGET_STATE_FOCUSSABLE) ? 1 : 0;  			 /* Can handle focus */
			return 0;   					  /* Message handled */
		case WM_GET_INSIDE_RECT:
			WIDGET__GetInsideRect(pWidget, (GUI_RECT *) pMsg->Data.p);
			return 0;   					  /* Message handled */
	}
	return 1;   						/* Message NOT handled */
}

/*********************************************************************
*
*   	WIDGET__SetScrollState
*/
void WIDGET__SetScrollState(WM_HWIN hWin, const WM_SCROLL_STATE *pVState, const WM_SCROLL_STATE *pHState)
{
	WM_HWIN hScroll;
	/* vertical scrollbar */
	hScroll = WM_GetDialogItem(hWin, GUI_ID_VSCROLL);
	WM_SetScrollState(hScroll, pVState);
	/* horizontal scrollbar */
	hScroll = WM_GetDialogItem(hWin, GUI_ID_HSCROLL);
	WM_SetScrollState(hScroll, pHState);
}

/*********************************************************************
*
*   	WIDGET__DrawFocusRect
*/
void WIDGET__DrawFocusRect(WIDGET *pWidget, const GUI_RECT *pRect, int Dist)
{
	GUI_RECT Rect;
	if (pWidget->State & WIDGET_STATE_VERTICAL)
	{
		WIDGET__RotateRect90(pWidget, &Rect, pRect);
		pRect = &Rect;
	}
	GUI_DrawFocusRect(pRect, Dist);
}

/*********************************************************************
*
*   	WIDGET__DrawVLine
*/
void WIDGET__DrawVLine(WIDGET *pWidget, int x, int y0, int y1)
{
	if (pWidget->State & WIDGET_STATE_VERTICAL)
	{
		GUI_RECT r0, r1;
		r0.x0 = x;
		r0.x1 = x;
		r0.y0 = y0;
		r0.y1 = y1;
		WIDGET__RotateRect90(pWidget, &r1, &r0);
		GUI_DrawHLine(r1.y0, r1.x0, r1.x1);
	}
	else
	{
		GUI_DrawVLine(x, y0, y1);
	}
}

/*********************************************************************
*
*   	WIDGET__FillRectEx
*/
void WIDGET__FillRectEx(WIDGET *pWidget, const GUI_RECT *pRect)
{
	if (pWidget->State & WIDGET_STATE_VERTICAL)
	{
		GUI_RECT r;
		WIDGET__RotateRect90(pWidget, &r, pRect);
		pRect = &r;
	}
	GUI_FillRectEx(pRect);
}

/*********************************************************************
*
*   	WIDGET__EFFECT_DrawDownRect
*/
void WIDGET__EFFECT_DrawDownRect(WIDGET *pWidget, GUI_RECT *pRect)
{
	GUI_RECT Rect;
	if (pRect == NULL)
	{
		WM_GetClientRect(&Rect);
		pRect = &Rect;
	}
	if (pWidget->State & WIDGET_STATE_VERTICAL)
	{
		WIDGET__RotateRect90(pWidget, &Rect, pRect);
		pRect = &Rect;
	}
	if (_EffectRequiresRedraw(pWidget, pRect))
	{
		pWidget->pEffect->pfDrawDownRect(pRect);
	}
}

/*********************************************************************
*
*   	WIDGET__EFFECT_DrawDown
*/
void WIDGET__EFFECT_DrawDown(WIDGET *pWidget)
{
	WIDGET__EFFECT_DrawDownRect(pWidget, NULL);
}

/*********************************************************************
*
*   	WIDGET__EFFECT_DrawUpRect
*/
void WIDGET__EFFECT_DrawUpRect(WIDGET *pWidget, GUI_RECT *pRect)
{
	GUI_RECT Rect;
	if (pWidget->State & WIDGET_STATE_VERTICAL)
	{
		WIDGET__RotateRect90(pWidget, &Rect, pRect);
		pRect = &Rect;
	}
	if (_EffectRequiresRedraw(pWidget, pRect))
	{
		pWidget->pEffect->pfDrawUpRect(pRect);
	}
}

/*********************************************************************
*
*   	WIDGET_SetDefaultEffect
*/
const WIDGET_EFFECT * WIDGET_SetDefaultEffect(const WIDGET_EFFECT *pEffect)
{
	const WIDGET_EFFECT* r;
	r = _pEffectDefault;
	_pEffectDefault = pEffect;
	return r;
}

/*********************************************************************
*
*   	WIDGET_GetDefaultEffect
*/
const WIDGET_EFFECT * WIDGET_GetDefaultEffect(void)
{
	return _pEffectDefault;
}


#else   						 /* Avoid problems with empty object modules */
void WIDGET_C(void)
{
}
#endif /* GUI_WINSUPPORT */