graphic_loader.c

sigmadesign smp8623 gui source code ,bingo

	//find last item
	while(nlru->entries.le_next)
	{
		nlru = nlru->entries.le_next;
	}

//	do
//	{
//		if(nlru->item->size < size)
//		{
//			nlru = nlru->entries.le_prev;
//			printf("next\n");
//			printf("item size: %lu", nlru->item->size);
//			if(nlru->item == cache.lh_first)
//			{
//					return RM_ERROR;
//			}
//			else{
//				entry* prev = (nlru->item->entries.le_prev);
//
//				for(i = 0; i < MAX_BITMAPS; i ++)
//				{
//					if(g_bitmaps[i].pBmpAddr == prev->begin)
//					{
//						RMMemset(&g_bitmaps[i], 0, sizeof(RMbitmapdata));
//						*newindex = i;
//						break;
//					}
//				}
//
//				prev->end = nlru->item->end;
//				prev->size += nlru->item->size;
//				prev->entries.le_next = nlru->item->entries.le_next;
//				LIST_REMOVE(&cache, nlru->item, entries);
//				RFREE(nlru->item);
//				printf("item size: %lu", prev->size);
//				nlru->item = prev;
//			}
//		} else {
//			printf("clear\n");
//
//		}
//	} while (nlru->item->size < size);
//again:
	while((nlru->entries.le_prev && nlru->item->size < size) || (nlru->item->locked))
	{
		if(nlru == lru.lh_first && nlru->item->size < size)
			return RM_ERROR;

		nlru = nlru->entries.le_prev;
	}

//	RMASSERT( nlru != lru.lh_first);

//	{
//		RMuint32 innersize = ((size / TILESIZE) + 1) * TILESIZE;
//		if(innersize < nlru->item->size)
//		{
//			printf("size: %lu, innersize %lu\n", nlru->item->size, innersize);
//			if(nlru->item->entries.le_next && nlru->item->entries.le_next->freeBlock) {
//				nlru->item->size = innersize;
//				nlru->item->end = nlru->item->begin + innersize;
//				nlru->item->entries.le_next->begin = nlru->item->end;
//				nlru->item->entries.le_next->size = nlru->item->entries.le_next->end - nlru->item->entries.le_next->begin;
//
//			} else {
//				entry* np = (entry*) MALLOC(sizeof(entry));
//
//				nlru->item->size = innersize;
//				np->end = nlru->item->end;
//				nlru->item->end = nlru->item->begin + innersize;
//				np->begin = nlru->item->end;
//				np->freeBlock = TRUE;
//				np->locked = FALSE;
//				np->size = np->end - np->begin;
//
//				LIST_INSERT_AFTER(nlru->item, np, entries);
//
//			}
//		}
//	}

	for(i = 0; i < MAX_BITMAPS; i ++)
	{
		if(g_bitmaps[i].pBmpAddr == nlru->item->begin)
		{
			printf("%s\n", g_bitmaps[i].path);
			RMMemset(&g_bitmaps[i], 0, sizeof(RMbitmapdata));
			nlru->item->freeBlock = TRUE;
			*newindex = i;
			break;
		}
	}

//	if(i > MAX_BITMAP)


	printf("new index is: %d size %lu\n", *newindex, nlru->item->size);

	LIST_REMOVE(&lru, nlru, entries);
	RFREE(nlru);
//	LIST_INSERT_HEAD(&lru, nlru, entries);

	return RM_OK;
}

RMstatus ResetUsedBuffer(RMuint32 offset)
{
//	if(g_BaseBuffer.offset > offset){
///		g_BaseBuffer.offset -= offset;
//		return RM_OK;
//	}
	entryLRU* lp;
	entry* np;

	for(np = cache.lh_first; np != NULL; np = np->entries.le_next)
	{
		if(np->begin != g_bitmaps[0].pBmpAddr && np->locked == FALSE) {
			np->freeBlock = TRUE;

			if(np->entries.le_prev && np->entries.le_prev->freeBlock) {
				entry* t = np;

				np->entries.le_prev->end = np->end;
				np->entries.le_prev->size += np->size;
				np->entries.le_prev->locked = FALSE;

				np = np->entries.le_prev;
				LIST_REMOVE(&cache, t, entries);
				RFREE(t);

			}
		}
	}

	lp = lru.lh_first;

	while(lp->entries.le_next) {
		entryLRU* t = lp;
		lp = lp->entries.le_next;

		if(t->item->begin != g_bitmaps[0].pBmpAddr)
		{
			LIST_REMOVE(&lru, t, entries);
			RFREE(t);
		}
	}

	PrintCacheStatys("Reset Used Buffer");

	return RM_ERROR;
}

RMbool CanReuseBuffer(
	RMuint32 used,
	RMuint32 needed)
{
	RMuint32 limit;

	if(g_BaseBuffer.baseAddr){
		limit = g_BaseBuffer.baseAddr + g_BaseBuffer.offset - used + needed;
		return (limit <= g_BaseBuffer.limit);
	}
	return FALSE;
}

RMstatus convertCodepage(RMascii *text)
{
	RMascii tempString[MAX_STR_LENGTH];
	RMuint8 position = 0;
	RMuint8 skipBytes = 0;
	RMuint8 i;

	for(i=0; i < strlen(text); i++){
		if(skipBytes != 0){
			skipBytes--;
		}
		else{
			if((RMuint8)text[i] > 0x80){
				if((text[i] & 0xe0) == 0xc0){
					tempString[position] = (((text[i] - 0xc0)<<6) + (text[i+1] - 0x80));
					skipBytes = 1;
				}//3 byte Chars are not yet supported (only 2 byte special chars. (1 byte chars are passed thru)
			}
			else{
				tempString[position] = text[i];
			}
			position++;
		}
	}
	tempString[position] = '\0';

	//fprintf(stderr, "Original string: %s, length: %ld\n", text, strlen(text));
	//fprintf(stderr, "Converted string: %s, length: %ld\n", tempString, strlen(tempString));

	RMCopyAscii(text, tempString);

	return RM_OK;
}

RMbool isPredefinedFont(RMascii *path)
{
	RMuint8 i;

	for(i = 0; i < PREDEFINED_FONTS; i++){
		if(!strcmp(PredefinedFonts[i]->name, path))
			return TRUE;
	}

	return FALSE;
}


RMstatus getPredefinedFontIndex(
	RMascii *path,
	RMuint8 *index)
{
	RMuint8 i;

	// get index
	for(i = 0; i < PREDEFINED_FONTS; i++){
		if(!strcmp(PredefinedFonts[i]->name, path)){
			*index = i;
			return RM_OK;
		}
	}

	return RM_ERROR;
}

RMstatus setPredefinedFont(
	struct RUA* pRua,
	RMbitmapdata *pBmpData,
	RMuint32 *size)
{
	RMuint8 i;
	RMuint32 datasize;
	RMuint8 fontindex = 0xff;
	RMdrawBuffer bmpbuffer;
	RMstatus status;

	// get index
	for(i = 0; i < PREDEFINED_FONTS; i++){
		if(!strcmp(PredefinedFonts[i]->name, pBmpData->path)){
			fontindex = i;
			break;
		}
	}

	if(fontindex == 0xff)
		return RM_ERROR;

	// allocate buffer of 4 * 128 chars (width = 128 * 4bytes)
	pBmpData->bmp.uiHeight = PredefinedFonts[fontindex]->height;
	pBmpData->bmp.uiNbBitPerPixel = 1;
	pBmpData->bmp.uiWidthLenInBytes = 4 * MAX_STR_LENGTH * MAX_STR_BUFFERS;
	pBmpData->bmp.uiWidth = 4 * MAX_STR_LENGTH * MAX_STR_BUFFERS;

	datasize = pBmpData->bmp.uiHeight * pBmpData->bmp.uiWidth;
	*size = datasize;
	status = AllocateBuffer(&bmpbuffer, datasize, FALSE);
	if(RMFAILED(status)){
		fprintf(stderr, "GFXLIB: Failed to allocate %ld for predefined font buffer!\n", datasize);
		return RM_FATALOUTOFMEMORY;
	}

	pBmpData->pBmpAddr = bmpbuffer.baseAddr;
	pBmpData->bmp.pData = bmpbuffer.pMappedAddr;
	pBmpData->bmp.uiDataSize = datasize;
	pBmpData->bmp.uiBufferSize = datasize / MAX_STR_BUFFERS;

	return RM_OK;
}

RMuint32 getTextWidth(
	RMascii* text,
	RMuint8 index)
{
	RMuint32 width = 0;
	RMuint16 i;
	RMuint16 length = 0;
	RMuint16 charindex = 0;

	union
	{
		RMuint16 l;
		RMint8 b[2];
	} big;

	length = RMasciiLength(text);

	for(i = 0; i < length; i++){
		RMbool double_inc = FALSE;
		if ((text[i] & 0x80) == 0)
		{
			big.l = text[i];
		}
		else if (text[i] & 0xC0)
		{
			RMuint8 _t;
			_t = text[i];
			_t <<= 6;
			_t &= 0xC0;
			//			printf("draw string: %X %X\n", prop->text[i], prop->text[i+1]);
			big.b[0] = (text[i + 1] & 0x3F) | _t;
			big.b[1] = (text[i] & 0x1f) >> 2;

			//i++;
			double_inc = TRUE;
			//			RMDBGLOG((GFXDBG, "TwoBytes \'%X\'\n", big.l));
		}
		charindex = /*text[i]*/big.l - PredefinedFonts[index]->firstchar;
		width += PredefinedFonts[index]->width[charindex];
		if(double_inc)
			i++;
	}

	return width;
}

RMuint32 getModifiedTextWidth(
	RMascii *text,
	RMuint16 maxWidth,
	RMascii *modifiedText,
	RMuint8 index,
	RMbool dots)
{
	RMuint32 width = 0;
	RMuint16 i;
	RMuint8 length = strlen(text);
	RMuint8 charindex;
	RMuint32 charwidth;
	RMuint32 endwidth = 0;

	union
	{
		RMuint16 l;
		RMint8 b[2];
	} big;

	// get '...' width
	if(dots)
	{
		charindex = '.' - PredefinedFonts[index]->firstchar;
		endwidth = 3 * PredefinedFonts[index]->width[charindex];
		maxWidth -= endwidth;
	}

	for(i = 0; i < length; i++){
		RMbool double_inc = FALSE;
		if ((text[i] & 0x80) == 0)
		{
			big.l = text[i];
		}
		else if (text[i] & 0xC0)
		{
			RMuint8 _t;
			_t = text[i];
			_t <<= 6;
			_t &= 0xC0;
			//			printf("draw string: %X %X\n", prop->text[i], prop->text[i+1]);
			big.b[0] = (text[i + 1] & 0x3F) | _t;
			big.b[1] = (text[i] & 0x1f) >> 2;

			//i++;
			double_inc = TRUE;
			//			RMDBGLOG((GFXDBG, "TwoBytes \'%X\'\n", big.l));
		}
		charindex = /*text[i]*/big.l - PredefinedFonts[index]->firstchar;
		charwidth = PredefinedFonts[index]->width[charindex];
		if(width + charwidth <= maxWidth){
			width += charwidth;
			modifiedText[i] = text[i];
			if(double_inc)
				modifiedText[i+1] = text[i+1];
		}
		else if (dots)
		{
			RMAppendAscii(modifiedText, "...");
			width += endwidth;
			break;
		}
		else
		{
			RMAppendAscii(modifiedText, "");
			break;
		}

		if(double_inc)
			i++;
	}

	return width;
}

RMuint8 getTextLines(
	const RMascii *text,
	RMuint8 fontindex,
	RMuint16 maxwidth,
	RMuint16 maxchars,
	RMuint8 maxlines,
	RMtextitem *lines)
{
	RMuint32 width = 0;
	RMuint16 i, j, k;
	RMuint8 index;
	RMuint8 length = strlen(text);
	RMuint8 charindex;
	RMuint16 position = 0;
	RMuint16 from = 0;

	for(index = 0; index < maxlines; index++){
		RMMemset(lines[index], 0, sizeof(lines[index]));
		width = 0;
		position = from;
		for(i = from, j = 0; i < length; i++, j++){
			charindex = text[i] - PredefinedFonts[fontindex]->firstchar;
			width += PredefinedFonts[fontindex]->width[charindex];
			if(width < maxwidth){
				if(strlen(lines[index]) >= maxchars){
					for(k = position; k > 0; k--){
						lines[index][k - from] = 0;
						if(text[k] == ' '){
							from = k + 1;
							break;
						}
					}
					break;
				}

				lines[index][j] = text[i];
				position++;
			}
			else{
				for(k = position; k > 0; k--){
					lines[index][k - from] = 0;
					if(text[k] == ' '){
						from = k + 1;
						break;
					}
				}
				break;
			}
		}
		if(position == length)
			break;
	}

	return (index + 1);
}


RMuint8 getFontFirstChar(RMuint8 index)
{
	return PredefinedFonts[index]->firstchar;
}

RMuint8 getCharWidth(
	RMuint8 index,
	RMuint16 charindex)
{
	return PredefinedFonts[index]->width[charindex];
}

RMuint8 getFontHeight(RMuint8 index)
{
	return PredefinedFonts[index]->height;
}

RMstatus getCharData(
	struct RUA *pRua,
	RMbitmapdata *pBmpData,
	RMuint8 fontindex,
	RMuint16 charindex,
	RMuint16 *width,
	RMuint8 scanindex,
	RMuint16 slen,
	RMuint8 bufferindex)
{
	RMuint16 bit;
	RMuint16 index = 0;
	RMuint8 columns;
	RMuint16 row;
	RMuint16 bitvalue;

	columns = PredefinedFonts[fontindex]->width[charindex] > 16 ? 2 : 1;
	index = 0;

	for(row = 0; row < PredefinedFonts[fontindex]->height; row++){
		index = row * (4 * slen) + scanindex * 4;
		bit = PredefinedFonts[fontindex]->offset[charindex] + row * columns;
#if((EM86XX_CHIP==EM86XX_CHIPID_MAMBOLIGHT) || (EM86XX_CHIP==EM86XX_CHIPID_MAMBO))
		bitvalue = ~rev16(PredefinedFonts[fontindex]->bits[bit]);	//~ : bits are inverted
		(pBmpData->bmp.pData + bufferindex * pBmpData->bmp.uiBufferSize)[index++] = LOBYTE(bitvalue);
		(pBmpData->bmp.pData + bufferindex * pBmpData->bmp.uiBufferSize)[index++] = HIBYTE(bitvalue);
#else
		bitvalue = ~(PredefinedFonts[fontindex]->bits[bit]);	//~ : bits are inverted
		(pBmpData->bmp.pData + bufferindex * pBmpData->bmp.uiBufferSize)[index++] = HIBYTE(bitvalue);
		(pBmpData->bmp.pData + bufferindex * pBmpData->bmp.uiBufferSize)[index++] = LOBYTE(bitvalue);
#endif

		if(columns > 1){
#if((EM86XX_CHIP==EM86XX_CHIPID_MAMBOLIGHT) || (EM86XX_CHIP==EM86XX_CHIPID_MAMBO))
			bitvalue = ~rev16(PredefinedFonts[fontindex]->bits[bit + 1]);//~ : bits are inverted
			(pBmpData->bmp.pData + bufferindex * pBmpData->bmp.uiBufferSize)[index++] = LOBYTE(bitvalue);
			(pBmpData->bmp.pData + bufferindex * pBmpData->bmp.uiBufferSize)[index++] = HIBYTE(bitvalue);
#else
			bitvalue = ~(PredefinedFonts[fontindex]->bits[bit + 1]);//~ : bits are inverted
			(pBmpData->bmp.pData + bufferindex * pBmpData->bmp.uiBufferSize)[index++] = HIBYTE(bitvalue);
			(pBmpData->bmp.pData + bufferindex * pBmpData->bmp.uiBufferSize)[index++] = LOBYTE(bitvalue);
#endif
		}
	}

	*width = PredefinedFonts[fontindex]->width[charindex];

	return RM_OK;
}