path: root/src/gwin/gwin_tabset.c

/*
 * This file is subject to the terms of the GFX License. If a copy of
 * the license was not distributed with this file, you can obtain one at:
 *
 *              http://ugfx.org/license.html
 */

/**
 * @file    src/gwin/gwin_tabset.c
 * @brief   GWIN sub-system tabset code.
 */

#include "../../gfx.h"

#if GFX_USE_GWIN && GWIN_NEED_TABSET

#include "gwin_class.h"

#include <string.h>

// Some position values
#define GTABSET_BORDER			2
#define GTABSET_TXT_PAD			5

// Some color blending
#define GTABSET_TAB_CNR			8		// Diagonal corner on active tab
#define GTABSET_TOP_FADE		50		// (GTABSET_TOP_FADE/255)% fade to white for top of tab/button
#define GTABSET_BOTTOM_FADE		25		// (GTABSET_BOTTOM_FADE/255)% fade to black for bottom of tab/button
#define GTABSET_OUTLINE_FADE	128		// (GTABSET_OUTLINE_FADE/255)% fade to background for active tab edge

/* Internal state flags */
#define GWIN_TABSET_USER_FLAGS		(GWIN_TABSET_BORDER)
#if GWIN_TABSET_BORDER < GWIN_FIRST_CONTROL_FLAG
	#error "GWIN Tabset: - Flag definitions don't match"
#endif
#if GWIN_TABSET_BORDER > GWIN_LAST_CONTROL_FLAG
	#error "GWIN Tabset: - Flag definitions don't match"
#endif

/********************************************************************************************************************
 * Tab-page stuff
 */

static void FixTabSizePos(GHandle gh);

typedef GContainerObject GTabpageObject;

static coord_t TabpageBorderSize(GHandle gh)	{ (void)gh; return 0; }

static void gwinTabpageDraw_Std(GWidgetObject *gw, void *param) {
	(void)gw;
	(void)param;

	// The page is effectively transparent
}

static void TabpageDestroy(GHandle gh) {
	_gcontainerDestroy(gh);

	FixTabSizePos(gh->parent);
}

static const gcontainerVMT tabpageVMT = {
	{
		{
			"Tabpage",					// The classname
			sizeof(GTabpageObject),		// The object size
			TabpageDestroy,				// The destroy routine
			_gcontainerRedraw,			// The redraw routine
			0,							// The after-clear routine
		},
		gwinTabpageDraw_Std,			// The default drawing routine
		#if GINPUT_NEED_MOUSE
			{
				0,						// Process mouse down event
				0,						// Process mouse up events
				0,						// Process mouse move events
			},
		#endif
		#if GINPUT_NEED_KEYBOARD || GWIN_NEED_KEYBOARD
			{
				0						// Process keyboard events
			},
		#endif
		#if GINPUT_NEED_TOGGLE
			{
				0,						// 1 toggle role
				0,						// Assign Toggles
				0,						// Get Toggles
				0,						// Process toggle off events
				0,						// Process toggle on events
			},
		#endif
		#if GINPUT_NEED_DIAL
			{
				0,						// 1 dial roles
				0,						// Assign Dials
				0,						// Get Dials
				0,						// Process dial move events
			},
		#endif
	},
	TabpageBorderSize,					// The size of the left border (mandatory)
	TabpageBorderSize,					// The size of the top border (mandatory)
	TabpageBorderSize,					// The size of the right border (mandatory)
	TabpageBorderSize,					// The size of the bottom border (mandatory)
	0,									// A child has been added (optional)
	0,									// A child has been deleted (optional)
};

void gwinTabsetSetTitle(GHandle gh, const char *title, bool_t useAlloc) {
	if (gh->vmt != (gwinVMT *)&tabpageVMT)
		return;

	gwinSetText(gh, title, useAlloc);
	FixTabSizePos(gh->parent);
	gwinRedraw(gh->parent);
}

/********************************************************************************************************************
 * Tab-set stuff
 */

static coord_t	CalcTabHeight(GHandle gh) {
	GHandle		ph;
	coord_t		x, y, w;

	x = w = 0;
	y = GWIN_TABSET_TABHEIGHT;
	for(ph = gwinGetFirstChild(gh); ph; ph = gwinGetSibling(ph)) {
		if (ph->vmt == (gwinVMT *)&tabpageVMT) {
			w = gdispGetStringWidth(((GWidgetObject *)ph)->text, gh->font) + GTABSET_TXT_PAD*2;
			x += w;
			if (x > gh->width) {
				y += GWIN_TABSET_TABHEIGHT;
				x = w;
			}
		}
	}
	return y;
}

static void FixTabSizePos(GHandle gh) {
	coord_t		w, h, oldth;
	GHandle		vis, ph;

	oldth = ((GTabsetObject *)gh)->border_top;
	((GTabsetObject *)gh)->border_top = CalcTabHeight(gh);
	oldth -= ((GTabsetObject *)gh)->border_top;
	if (oldth == 0)
		return;

	vis = 0;
	w = gwinGetInnerWidth(gh);
	h = gwinGetInnerHeight(gh);
	for(ph = gwinGetFirstChild(gh); ph; ph = gwinGetSibling(ph)) {
		if (ph->vmt == (gwinVMT *)&tabpageVMT) {
			if (!vis || (ph->flags & GWIN_FLG_VISIBLE))
				vis = ph;
			gwinMove(ph, 0, 0);
			gwinResize(ph, w, h);
		} else {
			gwinMove(ph, ph->x-gh->x-((gh->flags & GWIN_TABSET_BORDER) ? GTABSET_BORDER : 0) , ph->y-oldth-gh->y);
		}
	}
	if (vis && !(vis->flags & GWIN_FLG_VISIBLE)) {
		vis->flags |= GWIN_FLG_VISIBLE;
		_gwinRippleVisibility();
	}
}

static coord_t TabSetBorderSize(GHandle gh)		{ return (gh->flags & GWIN_TABSET_BORDER) ? GTABSET_BORDER : 0; }
static coord_t TabSetBorderTop(GHandle gh)		{ return ((GTabsetObject *)gh)->border_top; }

#if GINPUT_NEED_MOUSE
	static void mouseDown(GWidgetObject *gw, coord_t mx, coord_t my) {
		GHandle		ph, gh;
		int			cnt;

		if (my < 0 || my > ((GTabsetObject *)gw)->border_top)
			return;

		// Work out which tab was pressed
		{
			coord_t		x, w, y;

			cnt = 0;
			x = w = 0;
			y = GWIN_TABSET_TABHEIGHT;
			gh = 0;
			for(ph = gwinGetFirstChild(&gw->g); ph; ph = gwinGetSibling(ph)) {
				if (ph->vmt == (gwinVMT *)&tabpageVMT) {
					w = gdispGetStringWidth(((GWidgetObject *)ph)->text, gw->g.font) + GTABSET_TXT_PAD*2;
					x += w;
					if (x > gw->g.width) {
						y += GWIN_TABSET_TABHEIGHT;
						x = w;
					}
					if (my < y && mx < x) {
						gh = ph;
						break;
					}
					cnt++;
				}
			}
			if (!gh || (gh->flags & GWIN_FLG_VISIBLE))
				return;
		}

		// Mark the existing tab as not visible
		for(ph = gwinGetFirstChild(&gw->g); ph; ph = gwinGetSibling(ph)) {
			if (ph->vmt == (gwinVMT *)&tabpageVMT && (ph->flags & GWIN_FLG_VISIBLE)) {
				// Mark this page invisible
				ph->flags &= ~GWIN_FLG_VISIBLE;
				break;
			}
		}

		// Mark this tab as visible
		gh->flags |= GWIN_FLG_VISIBLE;
		_gwinRippleVisibility();

		// Force a redraw of the whole tabset
		_gwinUpdate(&gw->g);

		// Send the Tabset Event
		{
			GSourceListener	*	psl;
			GEventGWinTabset *	pge;

			psl = 0;
			while ((psl = geventGetSourceListener(GWIDGET_SOURCE, psl))) {
				if (!(pge = (GEventGWinTabset *)geventGetEventBuffer(psl)))
					continue;
				pge->type = GEVENT_GWIN_TABSET;
				pge->gwin = &gw->g;
				#if GWIN_WIDGET_TAGS
					pge->tag = gw->tag;
				#endif
				pge->ghPage = gh;
				pge->nPage = cnt;
				geventSendEvent(psl);
			}
		}
	}
#endif

static const gcontainerVMT tabsetVMT = {
	{
		{
			"Tabset",					// The classname
			sizeof(GTabsetObject),		// The object size
			_gcontainerDestroy,			// The destroy routine
			_gcontainerRedraw,			// The redraw routine
			0,							// The after-clear routine
		},
		gwinTabsetDraw_Std,				// The default drawing routine
		#if GINPUT_NEED_MOUSE
			{
				mouseDown,				// Process mouse down event
				0,						// Process mouse up events
				0,						// Process mouse move events
			},
		#endif
		#if GINPUT_NEED_TOGGLE
			{
				0,						// 1 toggle role
				0,						// Assign Toggles
				0,						// Get Toggles
				0,						// Process toggle off events
				0,						// Process toggle on events
			},
		#endif
		#if GINPUT_NEED_DIAL
			{
				0,						// 1 dial roles
				0,						// Assign Dials
				0,						// Get Dials
				0,						// Process dial move events
			},
		#endif
	},
	TabSetBorderSize,					// The size of the left border (mandatory)
	TabSetBorderTop,					// The size of the top border (mandatory)
	TabSetBorderSize,					// The size of the right border (mandatory)
	TabSetBorderSize,					// The size of the bottom border (mandatory)
	0,									// A child has been added (optional)
	0,									// A child has been deleted (optional)
};

GHandle gwinGTabsetCreate(GDisplay *g, GTabsetObject *fo, GWidgetInit *pInit, uint32_t flags) {
	if (!(fo = (GTabsetObject *)_gcontainerCreate(g, (GContainerObject *)fo, pInit, &tabsetVMT)))
		return 0;

	// Set Tabset specific stuff
	fo->c.g.flags |= flags & GWIN_TABSET_USER_FLAGS;
	fo->border_top = GWIN_TABSET_TABHEIGHT;

	gwinSetVisible(&fo->c.g, pInit->g.show);

	return &fo->c.g;
}

///////////////////////////////////////////////////////////////////////////////////////////////////
// API calls
///////////////////////////////////////////////////////////////////////////////////////////////////

GHandle gwinTabsetAddTab(GHandle gh, const char *title, bool_t useAlloc) {
	GWidgetInit		wi;

	if (gh->vmt != (gwinVMT *)&tabsetVMT)
		return 0;

	// Set up the init structure
	gwinWidgetClearInit(&wi);
	wi.g.x = wi.g.y = 0;
	wi.g.width = gwinGetInnerWidth(gh);
	wi.g.height = gwinGetInnerHeight(gh);
	wi.g.show = !gwinTabsetCountTabs(gh);
	wi.g.parent = gh;

	// Create the page
	if (!(gh = _gcontainerCreate(gh->display, 0, &wi, &tabpageVMT)))
		return 0;

	// Set the text and visibility
	gwinSetText(gh, title, useAlloc);
	FixTabSizePos(gh->parent);

	gwinSetVisible(gh, wi.g.show);
	gwinRedraw(gh->parent);
	return gh;
}

int gwinTabsetCountTabs(GHandle gh) {
	int		cnt;

	if (gh->vmt != (gwinVMT *)&tabsetVMT)
		return 0;

	for(cnt = 0, gh = gwinGetFirstChild(gh); gh; gh = gwinGetSibling(gh)) {
		if (gh->vmt == (gwinVMT *)&tabpageVMT)
			cnt++;
	}
	return cnt;
}

GHandle gwinTabsetGetTabByIndex(GHandle gh, int index) {
	if (gh->vmt != (gwinVMT *)&tabsetVMT)
		return 0;

	for(gh = gwinGetFirstChild(gh); gh; gh = gwinGetSibling(gh)) {
		if (gh->vmt == (gwinVMT *)&tabpageVMT && !index--)
			return gh;
	}
	return 0;
}

GHandle gwinTabsetGetTabByTitle(GHandle gh, const char *title) {
	if (gh->vmt != (gwinVMT *)&tabsetVMT)
		return 0;

	for(gh = gwinGetFirstChild(gh); gh; gh = gwinGetSibling(gh)) {
		if (gh->vmt == (gwinVMT *)&tabpageVMT && !strcmp(title, ((GWidgetObject *)gh)->text))
			return gh;
	}
	return 0;
}

void gwinTabsetSetTab(GHandle gh) {
	GHandle ph;

	if (gh->vmt != (gwinVMT *)&tabpageVMT || (gh->flags & GWIN_FLG_VISIBLE))
		return;

	// We alter the visibility flags here directly as we know we are going to redraw everything
	for(ph = gwinGetFirstChild(gh->parent); ph; ph = gwinGetSibling(ph)) {
		if (ph->vmt == (gwinVMT *)&tabpageVMT && (ph->flags & GWIN_FLG_VISIBLE)) {
			// Mark this page invisible
			ph->flags &= ~GWIN_FLG_VISIBLE;
			break;
		}
	}

	// Mark this tab as visible
	gh->flags |= GWIN_FLG_VISIBLE;
	_gwinRippleVisibility();

	// Force a redraw of the tabset
	gwinRedraw(gh->parent);
}

///////////////////////////////////////////////////////////////////////////////////////////////////
// Default render routines                                                                       //
///////////////////////////////////////////////////////////////////////////////////////////////////

#if GWIN_FLAT_STYLING
	static void fgarea(GWidgetObjset *gw, const char *text, coord_t y, coord_t x, coord_t w) {
		const GColorSet *	pcol;

		pcol = (gw->g.flags & GWIN_FLG_SYSENABLED) ? &gw->pstyle->pressed : &gw->pstyle->disabled;

		gdispGDrawBox(gw->g.display, gw->g.x+x, gw->g.y+y, w, GWIN_TABSET_TABHEIGHT, pcol->edge);
		gdispGFillStringBox(gw->g.display, gw->g.x+x+1, gw->g.y+y+1, w-2, GWIN_TABSET_TABHEIGHT-1, text, gw->g.font, pcol->text, pcol->fill, justifyCenter);
	}
	static void bgarea(GWidgetObjset *gw, const char *text, coord_t y, coord_t x, coord_t w) {
		const GColorSet *	pcol;

		pcol = (gw->g.flags & GWIN_FLG_SYSENABLED) ? &gw->pstyle->enabled : &gw->pstyle->disabled;

		gdispGFillStringBox(gw->g.display, gw->g.x+x, gw->g.y+y, w-1, GWIN_TABSET_TABHEIGHT, text, gw->g.font, pcol->text, pcol->fill, justifyCenter);
		gdispGDrawLine(gw->g.display, gw->g.x+x+w-1, gw->g.y+y, gw->g.x+x+w-1, gw->g.y+y+GWIN_TABSET_TABHEIGHT-1, pcol->edge);
		gdispGDrawLine(gw->g.display, gw->g.x+x, gw->g.y+y+GWIN_TABSET_TABHEIGHT-1, gw->g.x+x+w-2, gw->g.y+y+GWIN_TABSET_TABHEIGHT-1, pcol->edge);
	}
	static void ntarea(GWidgetObjset *gw, coord_t y, coord_t x, coord_t w) {
		const GColorSet *	pcol;

		pcol = (gw->g.flags & GWIN_FLG_SYSENABLED) ? &gw->pstyle->pressed : &gw->pstyle->disabled;

		gdispGFillArea(gw->g.display, gw->g.x+x, gw->g.y, w+y, GWIN_TABSET_TABHEIGHT-1, gw->g.bgcolor);
		gdispGDrawLine(gw->g.display, gw->g.x+x, gw->g.y+y+GWIN_TABSET_TABHEIGHT-1, gw->g.x+x+w-1, gw->g.y+y+GWIN_TABSET_TABHEIGHT-1, pcol->edge);
	}
#else
	static void fgarea(GWidgetObject *gw, const char *text, coord_t y, coord_t x, coord_t w) {
		const GColorSet *	pcol;
		color_t				tcol;

		pcol = (gw->g.flags & GWIN_FLG_SYSENABLED) ? &gw->pstyle->pressed : &gw->pstyle->disabled;

		tcol = gdispBlendColor(pcol->edge, gw->pstyle->background, GTABSET_OUTLINE_FADE);
		gdispGFillStringBox(gw->g.display, gw->g.x+x, gw->g.y+y, w, GWIN_TABSET_TABHEIGHT, text, gw->g.font, pcol->text, gw->g.bgcolor, justifyCenter);
		gdispGDrawLine(gw->g.display, gw->g.x+x, gw->g.y+y, gw->g.x+x+w-(GTABSET_TAB_CNR+1), gw->g.y+y, tcol);
		gdispGDrawLine(gw->g.display, gw->g.x+x+w-(GTABSET_TAB_CNR+1), gw->g.y+y, gw->g.x+x+w-1, gw->g.y+y+GTABSET_TAB_CNR, tcol);
		gdispGDrawLine(gw->g.display, gw->g.x+x+w-1, gw->g.y+y+GTABSET_TAB_CNR, gw->g.x+x+w-1, gw->g.y+y+GWIN_TABSET_TABHEIGHT-1, tcol);
		if (!x)
			gdispGDrawLine(gw->g.display, gw->g.x, gw->g.y+y, gw->g.x, gw->g.y+y+GWIN_TABSET_TABHEIGHT-1, tcol);
	}
	static void bgarea(GWidgetObject *gw, const char *text, coord_t y, coord_t x, coord_t w) {
		const GColorSet *	pcol;
		fixed				alpha;
		coord_t				i;
		color_t				tcol, bcol;

		pcol = (gw->g.flags & GWIN_FLG_SYSENABLED) ? &gw->pstyle->enabled : &gw->pstyle->disabled;

		/* Fill the box blended from variants of the fill color */
		tcol = gdispBlendColor(White, pcol->fill, GTABSET_TOP_FADE);
		bcol = gdispBlendColor(Black, pcol->fill, GTABSET_BOTTOM_FADE);
		for(alpha = 0, i = 0; i < GWIN_TABSET_TABHEIGHT; i++, alpha += FIXED(255)/GWIN_TABSET_TABHEIGHT)
			gdispGDrawLine(gw->g.display, gw->g.x+x, gw->g.y+y+i, gw->g.x+x+w-2, gw->g.y+y+i, gdispBlendColor(bcol, tcol, NONFIXED(alpha)));
		gdispGDrawLine(gw->g.display, gw->g.x+x+w-1, gw->g.y+y, gw->g.x+x+w-1, gw->g.y+y+GWIN_TABSET_TABHEIGHT-1, pcol->edge);
		gdispGDrawStringBox(gw->g.display, gw->g.x+x+1, gw->g.y+y+1, w-2, GWIN_TABSET_TABHEIGHT-2, text, gw->g.font, pcol->text, justifyCenter);
	}
	static void ntarea(GWidgetObject *gw, coord_t y, coord_t x, coord_t w) {
		const GColorSet *	pcol;

		pcol = (gw->g.flags & GWIN_FLG_SYSENABLED) ? &gw->pstyle->pressed : &gw->pstyle->disabled;

		gdispGFillArea(gw->g.display, gw->g.x+x, gw->g.y+y, w, GWIN_TABSET_TABHEIGHT-1, gw->g.bgcolor);
		gdispGDrawLine(gw->g.display, gw->g.x+x, gw->g.y+y+GWIN_TABSET_TABHEIGHT-1, gw->g.x+x+w-1, gw->g.y+y+GWIN_TABSET_TABHEIGHT-1, pcol->edge);
	}
#endif

static coord_t drawtabs(GWidgetObject *gw) {
	GHandle		ph;
	coord_t		x, y, w;

	x = w = 0;
	y = 0;
	for(ph = gwinGetFirstChild(&gw->g); ph; ph = gwinGetSibling(ph)) {
		if (ph->vmt == (gwinVMT *)&tabpageVMT) {
			w = gdispGetStringWidth(((GWidgetObject *)ph)->text, gw->g.font) + GTABSET_TXT_PAD*2;
			if (x+w > gw->g.width) {
				ntarea(gw, y, x, gw->g.width - x);
				y += GWIN_TABSET_TABHEIGHT;
				x = 0;
			}
			if (ph->flags & GWIN_FLG_VISIBLE)
				fgarea(gw, ((GWidgetObject *)ph)->text, y, x, w);
			else
				bgarea(gw, ((GWidgetObject *)ph)->text, y, x, w);
			x += w;
		}
	}
	if (x < gw->g.width)
		ntarea(gw, y, x, gw->g.width - x);
	return y + GWIN_TABSET_TABHEIGHT;
}

static void drawborder(GWidgetObject *gw, coord_t y) {
	if ((gw->g.flags & GWIN_CONTAINER_BORDER)) {
		const GColorSet *	pcol;
		coord_t				x, w;

		pcol = (gw->g.flags & GWIN_FLG_SYSENABLED) ? &gw->pstyle->enabled : &gw->pstyle->disabled;
		x = gw->g.x+gw->g.width-1;
		w = gw->g.y+gw->g.height-1;
		gdispGDrawLine(gw->g.display, gw->g.x, gw->g.y+y, gw->g.x, w-1, pcol->edge);
		gdispGDrawLine(gw->g.display, gw->g.x, w, x, w, pcol->edge);
		gdispGDrawLine(gw->g.display, x, gw->g.y+y, x, w-1, pcol->edge);
	}
}

void gwinTabsetDraw_Transparent(GWidgetObject *gw, void *param) {
	(void)				param;

	if (gw->g.vmt != (gwinVMT *)&tabsetVMT)
		return;

	drawborder(gw, drawtabs(gw));

	// Don't touch the client area
}

void gwinTabsetDraw_Std(GWidgetObject *gw, void *param) {
	coord_t		y;
	(void)		param;

	if (gw->g.vmt != (gwinVMT *)&tabsetVMT)
		return;

	// Draw the frame
	y = drawtabs(gw);
	drawborder(gw, y);

	// Draw the client area
	if ((gw->g.flags & GWIN_CONTAINER_BORDER))
		gdispGFillArea(gw->g.display, gw->g.x+1, gw->g.y+y, gw->g.width-2, gw->g.height-y-1, gw->pstyle->background);
	else
		gdispGFillArea(gw->g.display, gw->g.x, gw->g.y+y, gw->g.width, gw->g.height-y, gw->pstyle->background);
}

#if GDISP_NEED_IMAGE
	void gwinTabsetDraw_Image(GWidgetObject *gw, void *param) {
		#define gi			((gdispImage *)param)
		coord_t				x, y, iw, ih, mx, my;

		if (gw->g.vmt != (gwinVMT *)&tabsetVMT)
			return;

		// Draw the frame
		y = drawtabs(gw);
		drawborder(gw, y);

		// Draw the client area by tiling the image
		mx = gw->g.x+gw->g.width;
		my = gw->g.y+gw->g.height;
		if ((gw->g.flags & GWIN_CONTAINER_BORDER)) {
			mx -= 2;
			my -= 1;
		}
		for(y = gw->g.y+y, ih = gi->height; y < my; y += ih) {
			if (ih > my - y)
				ih = my - y;
			x = gw->g.x;
			if ((gw->g.flags & GWIN_CONTAINER_BORDER))
				x++;
			for(iw = gi->width; x < mx; x += iw) {
				if (iw > mx - x)
					iw = mx - x;
				gdispGImageDraw(gw->g.display, gi, x, y, iw, ih, 0, 0);
			}
		}

		#undef gi
	}
#endif

#endif  /* (GFX_USE_GWIN && GWIN_NEED_TABSET) || defined(__DOXYGEN__) */