glekey.c

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

/*
 * Copyright (C) AU-System AB, 2000.
 * All rights reserved.
 *
 * This software is covered by the license agreement between
 * the end user and AU-System AB, and may be used and copied
 * only in accordance with the terms of the said agreement.
 *
 * AU-System AB does not assume any responsibility or 
 * liability for any errors or inaccuracies in this 
 * software, or any consequential, incidental or indirect 
 * damage arising out of the use of the Generic Layout Engine 
 * software.
 */

#include "gledef.h" 
#include "engine.h"
#include "ansilibs.h"

#ifdef SHOW_KEYS_IN_CONTENT
	#include "glekey.h"	
	#include "aapigle.h"
	#include "capimmi.h"
	VOID* WIPAlloc(UINT32 size);
	VOID WIPFree( VOID* memory );

	#ifdef SUPPORT_PEN_NAVIGATION
		BOOL GleKeyContains(GleViewType* viewP, const GleKey *self, GlePointType point)
			{
			GleRectangleType r;
			GleRectangleType intersectionR;
		
			GleRctSetRectangle(&r,viewP->horizOffset,viewP->vertOffset, viewP->width, viewP->height);
			GleRctGetIntersection(&r,(GleRectanglePtr)&self->bounds, &intersectionR);
			return( GleRctPtInRectangle( point.x + viewP->horizOffset, point.y + viewP->vertOffset, &intersectionR));
			}	
	#endif
	
	VOID GleKeyDraw(GleViewType* viewP, const GleKey* self){
		BOOL isInverted;
		GleRectangleType keyBounds;
	
		isInverted = (viewP->markedGleElement == (GleElement*)self);	
	
		memmove(&keyBounds, &self->bounds, sizeof(GleRectangleType) );
		keyBounds.topLeft.x += - viewP->horizOffset;
		keyBounds.topLeft.y += - viewP->vertOffset;	
		GLEa_keyDraw(viewP->viewId, self->label, self->eventType, isInverted, (GleRectangleType*)&keyBounds);	
		}
		
	BOOL GleKeyRenderX(GleKey* self, INT16  *xSum, INT16 *ySum, INT16 *ascentMax, INT16 *descenderMax, GleElementType *gleType, UINT16 *currentFontLineHeight, INT8 *myAlign, BOOL *myWrap, INT16 *columnLeftX, INT16 *columnWidth, VOID* viewP){
		INT16 neededWidth;
		*gleType = self->type;

		if(*xSum) {
			GLEa_keySize(self->label, self->eventType, -1, &self->bounds.extent.x, &self->bounds.extent.y, &self->ascent);
			neededWidth = self->bounds.extent.x + gle_horizontalSpaceBetweenElements;
			}
		else {
			GLEa_keySize(self->label, self->eventType, *columnWidth, &self->bounds.extent.x, &self->bounds.extent.y, &self->ascent);
			neededWidth = self->bounds.extent.x;
			}
				
		if	((*xSum + neededWidth < *columnWidth) || (!*xSum)) {					     

			self->bounds.topLeft.x = *xSum + neededWidth - self->bounds.extent.x;		
			*xSum += neededWidth;

			if (*xSum > *columnWidth)
				*xSum = *columnWidth;
			if (self->ascent > *ascentMax)
				*ascentMax = self->ascent;
			if (self->bounds.extent.y - self->ascent + gle_verticalSpaceBetweenElements > *descenderMax)
				*descenderMax = self->bounds.extent.y - self->ascent + gle_verticalSpaceBetweenElements ;
			return (TRUE);
			}
		else
			return (FALSE);		
		}
	
	VOID GleKeyRenderY(GleKey* self, INT16* xOffSet, INT16* ySum, INT16* ascentMax) {
		self->bounds.topLeft.y = *ySum - self->ascent + *ascentMax;
		self->bounds.topLeft.x += *xOffSet;
		}
	
	#ifdef SUPPORT_KEY_NAVIGATION 
		BOOL GleKeyIsMarkable(GleViewType* viewP, const GleKey* self) {
			BOOL onScreen = FALSE;
			if (self->bounds.topLeft.y >= viewP->vertOffset) 
				if ((self->bounds.topLeft.y + self->bounds.extent.y) < (viewP->vertOffset + viewP->height)) 
					onScreen=TRUE;
			return onScreen;
			}
	#endif
	VOID GleKeySelected(GleViewType* viewP, const GleKey* self) {
		if(!viewP->mMIa_wait)
			{	
			GLEa_playSoundClick();	
			CALL_GWC_API(MMIc_keySelected(viewP->viewId, self->keyId));
			/*WinDrawChars(self->eventType,GLEa_strlen(self->eventType),1,GLE_SCREENHEIGHT+GLE_SCREENTOPLEFTY+2);*/
			}
		}	
	
	VOID GleKeyDestruct(GleKey* self){
		WIPFree(self->eventType);	
		WIPFree(self->label);
		WIPFree(self);
		}
	
	GleElement *GleKeyConstruct(UINT8 viewId, UINT8 keyId, const WCHAR *eventType, const WCHAR *label, BOOL isOptional){
		GleKey *self;
		INT32 n1;
		INT32 n2;
		INT16 nullChar = 0;
		
		if(eventType)	
			n1 = GLEa_sizeofString(eventType);
		else
			n1 = GLEa_sizeofString((WCHAR*)&nullChar);
		
		if(label)
			n2 = GLEa_sizeofString(label);
		else
			n2 = GLEa_sizeofString((WCHAR*)&nullChar);
		
		self = (GleKey*)WIPAlloc(sizeof(GleKey));
		self->eventType = WIPAlloc(n1);
		self->label = WIPAlloc(n2);
		
		self->type = Key;
		self->chunkSize = sizeof(GleKey) + n1 + n2;
		self->keyId = keyId;
		self->viewId = viewId;
		self->isOptional = isOptional;
			
		if(eventType)
			GLEa_strcpyWchar2Gle(self->eventType, eventType);
		else 
			GLEa_strcpyWchar2Gle(self->eventType, (WCHAR*)&nullChar);
			
		if(label)
			GLEa_strcpyWchar2Gle(self->label, label);
		else 
			GLEa_strcpyWchar2Gle(self->label, (WCHAR*)&nullChar);
		
		#ifdef SUPPORT_PEN_NAVIGATION
			self->Contains=&GleKeyContains;
		#endif
		self->Draw=&GleKeyDraw;  
		self->RenderX=&GleKeyRenderX;
		self->RenderY=&GleKeyRenderY;
		self->Destruct=&GleKeyDestruct;
		#ifdef SUPPORT_KEY_NAVIGATION
			self->IsMarkable=&GleKeyIsMarkable;
		#endif
		self->Selected=&GleKeySelected;
		
		return (GleElement*)self;
		}
#endif