gfx_drawlib.c.svn-base

sigmadesign smp8623 gui source code ,bingo

RMstatus gfxDrawTextTable(struct RUA *pRua, RMTextTableObject *obj, RMTextItemObject *items, RMuint8 itemcount)
{
	RMstatus status;
	//	RMuint8 fontindex;
	RMuint8 i, addrow = 0;
	GFXLib_rect rect, rctext;
	RMuint16 itemwidth;
	RMuint16 itemheight;
	//	GFXLib_textdata txt;
	RMuint8 xoffset;
	RMuint8 margindiff = 0;
	Prop prop;
	RMascii* pBuffer = NULL;
	prop.trunc = TRUNC_NONE;

	RMMemset(&prop.text, 0, sizeof(Prop));
	prop.scale = atoi(obj->fontfile);
	RMCopyAscii(prop.text, "ABC");

	gfxGetTextExtents(pRua, &prop, &rctext);

	if (obj->visible == FALSE)
		return RM_OK;

	status = SetOutputSurfaceBuffer(pRua, gdata.backBuffer.baseAddr, gdata.osdWidth);
	if (RMFAILED(status))
		return status;

	if (obj->redraw)
	{
		// draw background
		RoundRect(pRua, obj->x, obj->y, obj->width, obj->height, obj->backgroundcolor, TRUE, 0);//last param?
	}

	// divide area according to given number of columns
	if (obj->columns == 0)
		return RM_ERROR;

	itemwidth = obj->width / obj->columns; // default
	itemheight = (rctext.height << 2) / 3;//1 1/3 font height

	xoffset = 10;

	for (i = 0; i < itemcount; i++)
	{
		// add text
		if (obj->redraw || items[i].update)
		{
			// get column width
			if (obj->columnwidth != 0)
			{
				if (items[i].column != obj->columns - 1)
				{
					itemwidth = obj->columnwidth;
					rect.x = obj->x + items[i].column * itemwidth + xoffset;
				}
				else
				{
					itemwidth = (obj->width - (obj->columnwidth * (obj->columns - 1)));
					rect.x = obj->x + xoffset + items[i].column * obj->columnwidth;
					//	rect.x = obj->x + obj->columnwidth + (items[i].column - 1) * itemwidth + xoffset;
				}
			}
			else
				rect.x = obj->x + items[i].column * itemwidth + xoffset;

			//			if(rect.x < SAFE_TEXT_MARGIN){
			//				margindiff = SAFE_TEXT_MARGIN - rect.x;
			//				rect.x = SAFE_TEXT_MARGIN;
			//			}

			rect.y = obj->y + (items[i].row + addrow) * itemheight;
			rect.height = itemheight;

			// check if items expands across columns
			if (items[i].mergecolumns == TRUE)
				rect.width = obj->width - 2 * xoffset - margindiff;
			else
				rect.width = itemwidth - 2 * xoffset - margindiff;

			// redraw background for updated item
			if (items[i].update)
				SCBlendFill(pRua, rect.x, rect.y, rect.width, rect.height, obj->backgroundcolor, 0);

			RMCopyAscii(prop.text, items[i].text);
			prop.bgColor = items[i].foregroundcolor;
			prop.fgColor = obj->backgroundcolor & 0x00FFFFFF;
			prop.alignment = ALIGN_LEFT;
			pBuffer = where_split(pRua, &prop, &rect, &addrow, obj->y, items[i].row, itemheight, obj->y + obj->height);
			if (pBuffer != prop.text)
			{
				RMascii* newText = STRDUP(pBuffer);
				addrow++;
				*pBuffer = '\0';
				gfxTTDrawString(pRua, &rect, &prop, NULL);
				RMCopyAscii(prop.text, newText);
				RFREE(newText);

				rect.y = obj->y + (items[i].row + addrow) * itemheight;
			}
			gfxTTDrawString(pRua, &rect, &prop, NULL);
		}
	}

	return BitBlt(pRua);
}

RMstatus gfxHideButton(struct RUA *pRua, RMPageObject *page, RMButtonObject *obj)
{
	GFXLib_rect rect;
	RMstatus status;

	rect.x = obj->x;
	rect.y = obj->y;
	rect.width = obj->width;
	rect.height = obj->height;

	status = SetOutputSurfaceBuffer(pRua, gdata.backBuffer.baseAddr, gdata.osdWidth);
	if (RMFAILED(status))
		return status;

	if (page == NULL)
	{
		BlankRect(pRua, &rect);
		return BitBlt(pRua);
	}
	else
	{
		DrawPageRect(pRua, page, &rect);
		return BitBlt(pRua);
	}
}

RMstatus gfxHideBitmap(struct RUA *pRua, RMPageObject *page, RMBitmapObject *obj)
{
	GFXLib_rect rect;
	RMuint8 bmpindex;
	RMstatus status;

	status = GetBitmapIndex(pRua, obj->file, &bmpindex, FALSE);
	if (RMFAILED(status))
		return status;

	rect.x = obj->x;
	rect.y = obj->y;
	rect.width = GetBmpWidth(bmpindex);
	rect.height = GetBmpHeight(bmpindex);

	status = SetOutputSurfaceBuffer(pRua, gdata.backBuffer.baseAddr, gdata.osdWidth);
	if (RMFAILED(status))
		return status;

	if (page == NULL)
	{
		BlankRect(pRua, &rect);
		return BitBlt(pRua);
	}
	else
	{
		DrawPageRect(pRua, page, &rect);
		return BitBlt(pRua);
	}
}

RMstatus gfxHideString(struct RUA *pRua, RMPageObject *page, RMStringObject *obj)
{
	GFXLib_rect rect;
	RMstatus status;

	rect.x = obj->x;
	rect.y = obj->y;
	rect.width = obj->width;
	rect.height = obj->height;

	status = SetOutputSurfaceBuffer(pRua, gdata.backBuffer.baseAddr, gdata.osdWidth);
	if (RMFAILED(status))
		return status;

	if (page == NULL)
	{
		BlankRect(pRua, &rect);
		return BitBlt(pRua);
	}
	else
	{
		DrawPageRect(pRua, page, &rect);
		return BitBlt(pRua);
	}
}

RMstatus gfxHideMenu(struct RUA *pRua, RMPageObject *page, RMMenuObject *obj)
{
	GFXLib_rect rect;
	RMstatus status;

	status = SetOutputSurfaceBuffer(pRua, gdata.backBuffer.baseAddr, gdata.osdWidth);
	if (RMFAILED(status))
		return status;

	rect.x = obj->x;
	rect.y = obj->y;
	rect.width = obj->width;
	rect.height = obj->height;

	if (page == NULL)
	{
		BlankRect(pRua, &rect);
		return BitBlt(pRua);
	}
	else
	{
		DrawPageRect(pRua, page, &rect);
		return BitBlt(pRua);
	}
}

RMstatus gfxHideList(struct RUA *pRua, RMPageObject *page, RMListObject *obj)
{
	GFXLib_rect rect;
	RMstatus status;

	status = SetOutputSurfaceBuffer(pRua, gdata.backBuffer.baseAddr, gdata.osdWidth);
	if (RMFAILED(status))
		return status;

	rect.x = obj->x;
	rect.y = obj->y;
	rect.width = obj->width;
	rect.height = obj->height;

	if (page == NULL)
	{
		BlankRect(pRua, &rect);
		return BitBlt(pRua);
	}
	else
	{
		DrawPageRect(pRua, page, &rect);
		return BitBlt(pRua);
	}
}

RMstatus gfxHidePopup(struct RUA *pRua, RMPageObject *page, RMBitmapObject *obj)
{
	return gfxHideBitmap(pRua, page, obj);
}

RMstatus gfxHideTextTable(struct RUA *pRua, RMPageObject *page, RMTextTableObject *obj)
{
	GFXLib_rect rect;
	RMstatus status;

	status = SetOutputSurfaceBuffer(pRua, gdata.backBuffer.baseAddr, gdata.osdWidth);
	if (RMFAILED(status))
		return status;

	rect.x = obj->x;
	rect.y = obj->y;
	rect.width = obj->width;
	rect.height = obj->height;

	if (page == NULL)
	{
		BlankRect(pRua, &rect);
		return BitBlt(pRua);
	}
	else
	{
		DrawPageRect(pRua, page, &rect);
		return BitBlt(pRua);
	}
}

RMuint8 gfxGetListItemsPerPage(struct RUA *pRua, RMListObject *obj)
{
	RMuint8 count;
	RMuint8 itemheight;
	GFXLib_rect rctext;
	//	RMstatus status;
	//	RMuint8 fontindex;
	Prop prop;
	prop.trunc = TRUNC_NONE;

	prop.scale = atoi(obj->fontfile);
	RMCopyAscii(prop.text, "ABC");
	gfxGetTextExtents(pRua, &prop, &rctext);

	itemheight = rctext.height + 4;
	if (itemheight == 0)
		return 0;

	count = 7;//obj->height / (itemheight + 2);	// 2 pixels gap

	return count;
}

RMstatus gfxDrawEventBitmap(struct RUA *pRua, RMBitmapObject *obj)
{
	RMstatus status;
	RMuint8 index;
	GFXLib_rect rect;

	status = GetBitmapIndex(pRua, obj->file, &index, TRUE);
	if (RMFAILED(status))
		return status;

	status = SetOutputSurfaceBuffer(pRua, gdata.backBuffer.baseAddr, gdata.osdWidth);
	if (RMFAILED(status))
		return status;

	// if playing, refresh the event area before displaying new one
	if (gdata.osdOn == FALSE)
	{
		rect.x = obj->x;
		rect.y = obj->y;
		rect.width = GetBmpWidth(index);
		rect.height = GetBmpHeight(index);
		BlankRect(pRua, &rect);
	}

	printf("%d %d\n", obj->x, obj->y);

	//	printf("bitmap %s transp 0x%lx, use %d\n", obj->file, obj->transparentcolor, obj->usetransparentcolor);
	DrawBitmap(pRua, obj->x, obj->y, obj->transparentcolor, obj->usetransparentcolor, 0x80, index, gdata.osdOn == TRUE, 0);

	return BitBlt(pRua);
}

RMstatus gfxDrawEventBitmapWithText(struct RUA *pRua, RMBitmapObject *obj, RMStringObject *str)
{
	RMstatus status;

	// draw bitmap
	status = gfxDrawEventBitmap(pRua, obj);
	if (RMSUCCEEDED(status))
	{
		// draw text
		status = gfxDrawString(pRua, obj->x, obj->y, str);
	}
	return BitBlt(pRua);
}

RMstatus gfxHideEventBitmap(struct RUA *pRua, RMPageObject *page, RMBitmapObject *obj)
{
	GFXLib_rect rect;
	RMstatus status;
	RMuint8 index;

	status = GetBitmapIndex(pRua, obj->file, &index, TRUE);
	if (RMFAILED(status))
		return status;

	rect.x = obj->x;
	rect.y = obj->y;
	rect.width = GetBmpWidth(index);
	rect.height = GetBmpHeight(index);

	printf("%d %d %d %d\n", obj->x, obj->y, (RMuint16) rect.width, (RMuint16) rect.height);

	status = SetOutputSurfaceBuffer(pRua, gdata.backBuffer.baseAddr, gdata.osdWidth);
	if (RMFAILED(status))
		return status;

	if (page == NULL)
	{
		BlankRect(pRua, &rect);
	}
	else
	{
		DrawPageRect(pRua, page, &rect);
	}

	return BitBlt(pRua);
}

RMstatus gfxDrawSlider(struct RUA *pRua, RMuint16 xOrigen, RMuint16 yOrigen, RMSliderObject *obj, RMBitmapObject *objbitmap)
{

	//	RMstatus status = SetOutputSurfaceBuffer(pRua, gdata.backBuffer.baseAddr, gdata.osdWidth);
	//		if(RMFAILED(status))
	//			return status;

	//	if(obj->type == SLIDER_NORMAL)
	//		gfxDrawSliderSimple(pRua, xOrigen, yOrigen, (2 * obj->width) / 5, obj);
	//	else
	if (obj->type == SLIDER_BITMAPED)
	{
		gfxDrawSliderBitmaped(pRua, xOrigen, yOrigen, (2 * obj->width) / 5, obj, objbitmap);
	}
	else if (obj->type == SLIDER_VERTICAL)
	{
		gfxDrawSliderVertical(pRua, xOrigen, yOrigen, (2 * obj->width) / 5, obj, objbitmap);
	}
	else if (obj->type == SLIDER_INFO)
	{
		RMstatus status = SetOutputSurfaceBuffer(pRua, gdata.backBuffer.baseAddr, gdata.osdWidth);
		if (RMFAILED(status))
			return status;
		gfxDrawSliderInfo(pRua, xOrigen, yOrigen, (2 * obj->width) / 5, obj, objbitmap);

		return BitBlt(pRua);
	}

	//
	return RM_OK;
}

#define SLIDER_BORDER 			1
#define SLIDER_BORDER_OFFSET 	4

//void gfxDrawSliderSimple(struct RUA *pRua,
//	RMuint16 xOrigen,
//	RMuint16 yOrigen,
//	RMuint16 scaleoffset,
//	RMSliderObject *obj)
//{
//	GFXLib_rect rect;
//	RMuint8 dialwidth;
////	RMuint16 scaleoffset;
//	RMuint16 scalewidth;
//		Prop prop;
//		GFXLib_rect rctext;
//		prop.trunc = TRUNC_NONE;
//
//		RMMemset(&prop, 0, sizeof(Prop));
//		RMCopyAscii(prop.text, obj->text);
//		prop.fgColor = obj->backgroundcolor;
//		prop.bgColor = obj->foregroundcolor;
//		prop.scale = atoi( obj->fontfile );
//		prop.alignment = ALIGN_LEFT;
//		gfxGetTextExtents(pRua, &prop, &rctext);
//
//	//	innerheight = GetBmpHeight(fontindex);
//
//		if(obj->redraw){
//			// draw background
//			gfxDrawRect(pRua, obj->x + xOrigen ,obj->y + yOrigen, obj->width, obj->height, obj->backgroundcolor);
//
//			// draw string
//			rect.x = obj->x + xOrigen;
//			rect.y = obj->y + yOrigen + (obj->height - rctext.height) / 2;
//			rect.width = obj->width;
//			rect.height = rctext.height;
//
//			gfxTTDrawString(pRua, &rect, &prop, NULL);
//		}
//
//	//scaleoffset = (2 * obj->width) / 5;	// assume text occupies no more than 2 / 5 of given width
//	scalewidth = obj->width - scaleoffset;// - rctext.height / 2;
//	dialwidth = scalewidth / (obj->steps);	// + 2 = 1 dial width at beginning and one at end
//
//	// correct scale width
//	scalewidth = dialwidth * (obj->steps - 1);
//
//	// draw scale
//	rect.x = obj->x + xOrigen + scaleoffset;
//	rect.y = obj->y + yOrigen + SLIDER_BORDER_OFFSET;
//	rect.width = scalewidth;
//	rect.height = obj->height - (SLIDER_BORDER_OFFSET << 1);//rctext.height;
//	gfxDrawVLine(pRua, rect.x, rect.y, rect.height, SLIDER_BORDER, obj->foregroundcolor);
//	gfxDrawHLine(pRua, rect.x, rect.y, scalewidth, SLIDER_BORDER, obj->foregroundcolor);
//	gfxDrawHLine(pRua, rect.x, rect.y + rect.height - SLIDER_BORDER, scalewidth, SLIDER_BORDER, obj->foregroundcolor);
//	gfxDrawVLine(pRua, rect.x + scalewidth, rect.y, rect.height, SLIDER_BORDER, obj->foregroundcolor);
//	if( obj->stepnumber )
//	gfxDrawRect(pRua, rect.x + (SLIDER_BORDER << 1), rect.y + (SLIDER_BORDER << 1), dialwidth * obj->stepnumber - (SLIDER_BORDER_OFFSET),
//				 rect.height - SLIDER_BORDER_OFFSET, obj->foregroundcolor);
//
//	printf("start: %lu width: %lu\n",rect.x, (RMuint32)(dialwidth * obj->stepnumber));
//
//	// draw dial
//	if(dialwidth * obj->stepnumber < scalewidth)
//	{
//		rect.x = obj->x + xOrigen + scaleoffset + dialwidth * obj->stepnumber + 1;// + dialwidth;
//		rect.y = obj->y + yOrigen + SLIDER_BORDER_OFFSET + SLIDER_BORDER;