edit.c

MCB2300_ucgui_LCD320240.rar LPC2368的uc/gui的移植

	if (pMsg->Data.p)
	{
		/* Something happened in our area (pressed or released) */
		if (pState->Pressed)
		{
			GUI_DEBUG_LOG1("EDIT__Callback(WM_TOUCH, Pressed, Handle %d)\n", 1);
			EDIT_SetCursorAtPixel(hObj, pState->x);
		}
		else
		{
			GUI_DEBUG_LOG1("EDIT__Callback(WM_TOUCH, Released, Handle %d)\n", 1);
		}
	}
	else
	{
		GUI_DEBUG_LOG1("_EDIT_Callback(WM_TOUCH, Moved out, Handle %d)\n", 1);
	}
}

/*********************************************************************
*
*   	EDIT__Callback
*/
static void EDIT__Callback(WM_MESSAGE *pMsg)
{
	int IsEnabled;
	EDIT_Handle hObj = (EDIT_Handle) pMsg->hWin;
	EDIT_Obj*   pObj = (EDIT_Obj *) GUI_ALLOC_h2p(hObj);
	IsEnabled = WM__IsEnabled(hObj);
	/* Let widget handle the standard messages */
	if (WIDGET_HandleActive(hObj, pMsg) == 0)
	{
		return;
	}
	switch (pMsg->MsgId)
	{
		case WM_TOUCH:
			_OnTouch(hObj, pObj, pMsg);
			break;
		case WM_PAINT:
			GUI_DEBUG_LOG("EDIT: _Callback(WM_PAINT)\n");
			_Paint(pObj, hObj);
			return;
		case WM_DELETE:
			GUI_DEBUG_LOG("EDIT: _Callback(WM_DELETE)\n");
			_Delete(pObj);
			break;  	 /* No return here ... WM_DefaultProc needs to be called */
		case WM_KEY:
			if (IsEnabled)
			{
				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:
							break;  				  /* Send to parent by not doing anything */
						default:
							EDIT_AddKey(hObj, Key);
							return;
					}
				}
			}
			break;
	}
	WM_DefaultProc(pMsg);
}

/*********************************************************************
*
*   	Exported routines:  Create
*
**********************************************************************
*/
/*********************************************************************
*
*   	EDIT_CreateEx
*/
EDIT_Handle EDIT_CreateEx(int x0, int y0, int xsize, int ysize, WM_HWIN hParent, int WinFlags, int ExFlags, int Id, int MaxLen)
{
	EDIT_Handle hObj;
	GUI_USE_PARA(ExFlags);
	/* Alloc memory for obj */
	WinFlags |= WM_CF_LATE_CLIP;	/* Always use late clipping since widget is optimized for it. */
	hObj = WM_CreateWindowAsChild(x0, y0, xsize, ysize, hParent, WM_CF_SHOW | WinFlags, EDIT__Callback, sizeof(EDIT_Obj) - sizeof(WM_Obj));
	if (hObj)
	{
		EDIT_Obj* pObj;
		WM_LOCK();
		pObj = (EDIT_Obj *) GUI_ALLOC_h2p(hObj);
		/* init widget specific variables */
		WIDGET__Init(&pObj->Widget, Id, WIDGET_STATE_FOCUSSABLE);
		/* init member variables */
		INIT_ID(pObj);
		pObj->Props = EDIT__DefaultProps;
		pObj->XSizeCursor = 1;
		pObj->MaxLen = (MaxLen == 0) ? 8 : MaxLen;
		pObj->BufferSize = 0;
		pObj->hpText = 0;
		if (_IncrementBuffer(pObj, pObj->MaxLen + 1) == 0)
		{
			GUI_DEBUG_ERROROUT("EDIT_Create failed to alloc buffer");
			EDIT_Delete(hObj);
			hObj = 0;
		}
		WM_UNLOCK();
	}
	return hObj;
}

/*********************************************************************
*
*   	Exported routines:  Various methods
*
**********************************************************************
*/
/*********************************************************************
*
*   	EDIT_AddKey
*/
void EDIT_AddKey(EDIT_Handle hObj, int Key)
{
	if (hObj)
	{
		EDIT_Obj* pObj;
		WM_LOCK();
		pObj = EDIT_H2P(hObj);
		if (pObj)
		{
			if (pObj->pfAddKeyEx)
			{
				pObj->pfAddKeyEx(hObj, Key);
			}
			else
			{
				switch (Key)
				{
					case GUI_KEY_UP:
						if (pObj->hpText)
						{
							char* pText;
							U16 Char;
							pText = (char *) GUI_ALLOC_h2p(pObj->hpText);
							pText += GUI_UC__NumChars2NumBytes(pText, pObj->CursorPos);
							Char = GUI_UC_GetCharCode(pText);
							if (Char < 0x7f)
							{
								*pText = Char + 1;
								WM_NotifyParent(hObj, WM_NOTIFICATION_VALUE_CHANGED);
							}
						}
						break;
					case GUI_KEY_DOWN:
						if (pObj->hpText)
						{
							char* pText;
							U16 Char;
							pText = (char *) GUI_ALLOC_h2p(pObj->hpText);
							pText += GUI_UC__NumChars2NumBytes(pText, pObj->CursorPos);
							Char = GUI_UC_GetCharCode(pText);
							if (Char > 0x20)
							{
								*pText = Char - 1;
								WM_NotifyParent(hObj, WM_NOTIFICATION_VALUE_CHANGED);
							}
						}
						break;
					case GUI_KEY_RIGHT:
						EDIT__SetCursorPos(pObj, pObj->CursorPos + 1);
						break;
					case GUI_KEY_LEFT:
						EDIT__SetCursorPos(pObj, pObj->CursorPos - 1);
						break;
					case GUI_KEY_BACKSPACE:
						EDIT__SetCursorPos(pObj, pObj->CursorPos - 1);
						_DeleteChar(hObj, pObj);
						break;
					case GUI_KEY_DELETE:
						_DeleteChar(hObj, pObj);
						break;
					case GUI_KEY_INSERT:
						if (pObj->EditMode == GUI_EDIT_MODE_OVERWRITE)
						{
							pObj->EditMode = GUI_EDIT_MODE_INSERT;
						}
						else
						{
							pObj->EditMode = GUI_EDIT_MODE_OVERWRITE;
							EDIT__SetCursorPos(pObj, pObj->CursorPos);
						}
						break;
					case GUI_KEY_ENTER:
					case GUI_KEY_ESCAPE:
						break;
					default:
						if (Key >= 0x20)
						{
							if (pObj->EditMode != GUI_EDIT_MODE_INSERT)
							{
								_DeleteChar(hObj, pObj);
							}
							if (_InsertChar(hObj, pObj, Key))
							{
								EDIT__SetCursorPos(pObj, pObj->CursorPos + 1);
							}
						}
				}
			}
			EDIT_Invalidate(hObj);
		}
		WM_UNLOCK();
	}
}

/*********************************************************************
*
*   	EDIT_SetFont
*/
void EDIT_SetFont(EDIT_Handle hObj, const GUI_FONT GUI_UNI_PTR *pfont)
{
	EDIT_Obj* pObj;
	if (hObj == 0)
	{
		return;
	}
	WM_LOCK();
	pObj = EDIT_H2P(hObj);
	if (pObj)
	{
		pObj->Props.pFont = pfont;
		EDIT_Invalidate(hObj);
	}
	WM_UNLOCK();
}

/*********************************************************************
*
*   	EDIT_SetBkColor
*/
void EDIT_SetBkColor(EDIT_Handle hObj, unsigned int Index, GUI_COLOR color)
{
	EDIT_Obj* pObj;
	if (hObj == 0)
	{
		return;
	}
	WM_LOCK();
	pObj = EDIT_H2P(hObj);
	if (pObj)
	{
		if (Index < GUI_COUNTOF(pObj->Props.aBkColor))
		{
			pObj->Props.aBkColor[Index] = color;
			EDIT_Invalidate(hObj);
		}
	}
	WM_UNLOCK();
}

/*********************************************************************
*
*   	EDIT_SetTextColor
*/
void EDIT_SetTextColor(EDIT_Handle hObj, unsigned int Index, GUI_COLOR color)
{
	EDIT_Obj* pObj;
	if (hObj == 0)
	{
		return;
	}
	WM_LOCK();
	pObj = EDIT_H2P(hObj);
	if (pObj)
	{
		if (Index < GUI_COUNTOF(pObj->Props.aTextColor))
		{
			pObj->Props.aTextColor[Index] = color;
			EDIT_Invalidate(hObj);
		}
	}
	WM_UNLOCK();
}

/*********************************************************************
*
*   	EDIT_SetText
*/
void EDIT_SetText(EDIT_Handle hObj, const char *s)
{
	if (hObj)
	{
		EDIT_Obj* pObj;
		WM_LOCK();
		pObj = EDIT_H2P(hObj);
		if (s)
		{
			int NumBytesNew, NumBytesOld = 0;
			int NumCharsNew;
			if (pObj->hpText)
			{
				char* pText;
				pText = (char *) GUI_ALLOC_h2p(pObj->hpText);
				NumBytesOld = strlen(pText) + 1;
			}
			NumCharsNew = GUI__GetNumChars(s);
			if (NumCharsNew > pObj->MaxLen)
			{
				NumCharsNew = pObj->MaxLen;
			}
			NumBytesNew = GUI_UC__NumChars2NumBytes(s, NumCharsNew) + 1;
			if (_IsSpaceInBuffer(pObj, NumBytesNew - NumBytesOld))
			{
				char* pText;
				pText = (char *) GUI_ALLOC_h2p(pObj->hpText);
				memcpy(pText, s, NumBytesNew);
				pObj->CursorPos = NumBytesNew - 1;
				if (pObj->CursorPos == pObj->MaxLen)
				{
					if (pObj->EditMode == GUI_EDIT_MODE_OVERWRITE)
					{
						pObj->CursorPos--;
					}
				}
			}
		}
		else
		{
			GUI_ALLOC_FreePtr(&pObj->hpText);
			pObj->BufferSize = 0;
			pObj->CursorPos = 0;
		}
		EDIT_Invalidate(hObj);
		WM_UNLOCK();
	}
}

/*********************************************************************
*
*   	EDIT_GetText
*/
void EDIT_GetText(EDIT_Handle hObj, char *sDest, int MaxLen)
{
	if (sDest)
	{
		*sDest = 0;
		if (hObj)
		{
			EDIT_Obj* pObj;
			WM_LOCK();
			pObj = EDIT_H2P(hObj);
			if (pObj->hpText)
			{
				char* pText;
				int NumChars, NumBytes;
				pText = (char *) GUI_ALLOC_h2p(pObj->hpText);
				NumChars = GUI__GetNumChars(pText);
				if (NumChars > MaxLen)
				{
					NumChars = MaxLen;
				}
				NumBytes = GUI_UC__NumChars2NumBytes(pText, NumChars);
				memcpy(sDest, pText, NumBytes);
				*(sDest + NumBytes) = 0;
			}
			WM_UNLOCK();
		}
	}
}

/*********************************************************************
*
*   	EDIT_GetValue
*/
I32 EDIT_GetValue(EDIT_Handle hObj)
{
	EDIT_Obj* pObj;
	I32 r = 0;
	if (hObj)
	{
		WM_LOCK();
		pObj = EDIT_H2P(hObj);
		r = pObj->CurrentValue;
		WM_UNLOCK();
	}
	return r;
}

/*********************************************************************
*
*   	EDIT_SetValue
*/
void EDIT_SetValue(EDIT_Handle hObj, I32 Value)
{
	EDIT_Obj* pObj;
	if (hObj)
	{
		WM_LOCK();
		pObj = EDIT_H2P(hObj);
		/* Put in min/max range */
		if (Value < pObj->Min)
		{
			Value = pObj->Min;
		}
		if (Value > pObj->Max)
		{
			Value = pObj->Max;
		}
		if (pObj->CurrentValue != (U32) Value)
		{
			pObj->CurrentValue = Value;
			if (pObj->pfUpdateBuffer)
			{
				pObj->pfUpdateBuffer(hObj);
			}
			WM_InvalidateWindow(hObj);
			WM_NotifyParent(hObj, WM_NOTIFICATION_VALUE_CHANGED);
		}
		WM_UNLOCK();
	}
}

/*********************************************************************
*
*   	EDIT_SetMaxLen
*/
void EDIT_SetMaxLen(EDIT_Handle  hObj, int MaxLen)
{
	if (hObj)
	{
		EDIT_Obj* pObj;
		WM_LOCK();
		pObj = EDIT_H2P(hObj);
		if (MaxLen != pObj->MaxLen)
		{
			if (MaxLen < pObj->MaxLen)
			{
				if (pObj->hpText)
				{
					char* pText;
					int   NumChars;
					pText = (char *) GUI_ALLOC_h2p(pObj->hpText);
					NumChars = GUI__GetNumChars(pText);
					if (NumChars > MaxLen)
					{
						int NumBytes;
						NumBytes = GUI_UC__NumChars2NumBytes(pText, MaxLen);
						*(pText + NumBytes) = 0;
					}
				}
			}
			_IncrementBuffer(pObj, MaxLen - pObj->BufferSize + 1);
			pObj->MaxLen = MaxLen;
			EDIT_Invalidate(hObj);
		}
		WM_UNLOCK();
	}
}

/*********************************************************************
*
*   	EDIT_SetTextAlign
*/
void EDIT_SetTextAlign(EDIT_Handle hObj, int Align)
{
	EDIT_Obj* pObj;
	if (hObj == 0)
	{
		return;
	}
	WM_LOCK();
	pObj = EDIT_H2P(hObj);
	if (pObj)
	{
		pObj->Props.Align = Align;
		EDIT_Invalidate(hObj);
	}
	WM_UNLOCK();
}

#else  /* avoid empty object files */

void Edit_C(void)
{
}

#endif