gleimage.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 "gleimage.h"
#include "aapigle.h"
#include "tapimmi.h"
#include "capimmi.h"
#include "ansilibs.h"

#ifdef BITMAP_POSITION_CLICK
	extern UINT16 gGleImageClickXCoord;
	extern UINT16 gGleImageClickYCoord;
#endif


VOID* WIPAlloc(UINT32 size);
VOID WIPFree( VOID* memory );

VOID GleImageAlign(GleImage* self, INT8 align) {
	switch (align) 
		{
		case ALIGN_MIDDLE:	
			self->ascent = self->bounds.extent.y / 2 + max(self->vSpace,gle_image_normalTextFontHeight/2);
			break;
		case ALIGN_TOP:
			self->ascent = max(self->vSpace,gle_image_normalTextFontHeight);
			break;
		default: /* = ALIGN_BOTTOM */
			self->ascent = self->bounds.extent.y + self->vSpace ;
			break;
		}
	}

#ifdef SUPPORT_PEN_NAVIGATION
	BOOL GleImageContains(GleViewType* viewP, const GleImage *self, GlePointType point) {
		GleRectangleType r;
		GleRectangleType intersectionR;
		if(!self->isLink)
			return FALSE;
		GleRctSetRectangle(&r,viewP->horizOffset,viewP->vertOffset, viewP->width, viewP->height);
		GleRctGetIntersection(&r,(GleRectanglePtr)&self->bounds, &intersectionR);
		if(GleRctPtInRectangle( point.x + viewP->horizOffset, point.y + viewP->vertOffset, &intersectionR)) {
			#ifdef BITMAP_POSITION_CLICK
				gGleImageClickXCoord = (point.x - self->bounds.topLeft.x + viewP->horizOffset);
				gGleImageClickYCoord = (point.y - self->bounds.topLeft.y + viewP->vertOffset);
			#endif
			return TRUE;
			}
		else
			return FALSE;

		}
#endif

VOID GleImageDraw(GleViewType* viewP, const GleImage* self) {
	BOOL isInverted;
	GleRectangleType imageBounds;

	if(self->bitmap) {
		isInverted = (viewP->markedGleElement == (GleElement*)self);	
		memmove(&imageBounds, &self->bounds, sizeof(GleRectangleType) );
		imageBounds.topLeft.x += - viewP->horizOffset;
		imageBounds.topLeft.y += - viewP->vertOffset ;	
		GLEa_imageDraw(self->viewId, self->bitmap, isInverted, (GleRectangleType*)&imageBounds);
		}
	}

BOOL GleImageRenderX(GleImage* self, INT16  *xSum, INT16 *ySum, INT16 *ascentMax, INT16 *descenderMax, GleElementType *gleType, UINT16 *currentFontLineHeight, INT8 *myAlign, BOOL *myWrap, INT16 *columnLeftX, INT16 *columnWidth, VOID* viewP) {
	INT16 descender;
	*gleType = self->type;
	if	(((*xSum + self->bounds.extent.x + 2*self->hSpace) < *columnWidth) || (!*xSum)) {
		self->bounds.topLeft.x = *xSum + self->hSpace;
		*xSum += self->bounds.extent.x + 2*self->hSpace;

		if (self->ascent > *ascentMax)
			*ascentMax = self->ascent;

		descender = self->bounds.extent.y + (2 * self->vSpace) - self->ascent;
		if (descender > *descenderMax )
			*descenderMax = descender;
			
		return (TRUE);
		}
	else{
		return (FALSE);
		}
	}

VOID GleImageRenderY(GleImage* self, INT16* xOffSet, INT16* ySum, INT16* ascentMax) {
		self->bounds.topLeft.y = *ySum - self->ascent + *ascentMax + self->vSpace;
		self->bounds.topLeft.x += *xOffSet;
	}

#ifdef SUPPORT_KEY_NAVIGATION
	BOOL GleImageIsMarkable(GleViewType* viewP, const GleImage* self) {
		BOOL onScreen = FALSE;
		if(!self->isLink)
			return 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 GleImageSelected(GleViewType* viewP, const GleImage* self) {
	if(!viewP->mMIa_wait)
		{
		CALL_GWC_API(MMIc_imageSelected(viewP->viewId, self->imageId));
		GLEa_playSoundClick();	
		}
	}
	
VOID GleImageDestruct(GleImage* self){
	WIPFree(self->altText);	
	WIPFree(self->localSrc);
	WIPFree(self->linkTitle);
	if(self->bitmap)
		GLEa_imageFree(self->bitmap);
	WIPFree(self);
	}
	
GleElement *GleImageConstruct(UINT8 viewId, UINT8 imageId, const CHAR *imageData, UINT16 imageSize, const CHAR *imageType, const WCHAR *altText, const WCHAR *localSrc, BOOL isLink, const WCHAR *linkTitle, INT8 vSpace, INT8 hSpace, INT16 width, INT16 height, INT8 isPercent, INT8 align) {
	GleImage *self;
	INT32 n1;
	INT32 n2;
	INT32 n3;
	INT16 nullChar = 0;

	if(altText)
		n1 = GLEa_sizeofString(altText);
	else
		n1 = GLEa_sizeofString((WCHAR*)&nullChar);

	if(linkTitle)
		n2 = GLEa_sizeofString(linkTitle);
	else
		n2 = GLEa_sizeofString((WCHAR*)&nullChar);

	if(localSrc)
		n3 = GLEa_sizeofString(localSrc);
	else
		n3 = GLEa_sizeofString((WCHAR*)&nullChar);


	self = (GleImage*)WIPAlloc(sizeof(GleImage));
	self->altText = WIPAlloc(n1);
	self->linkTitle = WIPAlloc(n2);
	self->localSrc = WIPAlloc(n3);	

	self->viewId = viewId;
	self->chunkSize = sizeof(GleImage) + n1 + n2 + n3;
	self->type = Image;
	self->viewId = viewId;
	self->imageId = imageId;
	self->imageSize = imageSize;
	self->isLink = isLink;
	
	if (vSpace==0)
		self->vSpace = gle_image_defaultVerticalSpace;
	else
		self->vSpace = vSpace;
	if (hSpace==0)
		self->hSpace = gle_image_defaultHorizontalSpace;
	else
		self->hSpace = hSpace;
	
	self->bounds.extent.x = width;
	self->bounds.extent.y = height;
	self->isPercent = isPercent;
	self->align = align;

	if(altText)
		GLEa_strcpyWchar2Gle(self->altText, altText);		
	else 
		GLEa_strcpyWchar2Gle(self->altText, (WCHAR*)&nullChar);

	if(localSrc)
		GLEa_strcpyWchar2Gle(self->localSrc, localSrc);		
	else 
		GLEa_strcpyWchar2Gle(self->localSrc, (WCHAR*)&nullChar);

	if(linkTitle)
		GLEa_strcpyWchar2Gle(self->linkTitle, linkTitle);
	else 
		GLEa_strcpyWchar2Gle(self->linkTitle, (WCHAR*)&nullChar);

	self->bitmap = 0;
	#ifdef SUPPORT_PEN_NAVIGATION
		self->Contains=&GleImageContains;
	#endif
	self->Draw=&GleImageDraw;  
	self->RenderX=&GleImageRenderX;
	self->RenderY=&GleImageRenderY;
	self->Destruct=&GleImageDestruct;
	#ifdef SUPPORT_KEY_NAVIGATION
		self->IsMarkable=&GleImageIsMarkable;
	#endif
	self->Selected=&GleImageSelected;
	
	return (GleElement*)self;
	}