path: root/src/view.c

/**
 * @file
 *
 * @section DESCRIPTION
 * Handle "views" in the server.
 * These are rectangular regions of in a screen "buffer",
 * which often contain specific windows.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
//#include <poa/poa.h>
#include <unistd.h>
#include <directfb.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <unistd.h>
#include <fcntl.h>

#include "view.h"
#include "buffer.h"
#include "client.h"
#include "display.h"

enum border_mode {
    BORDER_NONE,
    BORDER_BORDER,
    BORDER_CORNER,
    BORDER_OVERLAY,
    NUM_BORDER
};

static struct view_tailq all_views;
static enum border_mode mode = BORDER_BORDER;


/*** LOOK UP VIEW STRUCT BY CLIENT ID AND VIEW ID ***/
struct view *
view_lookup(struct client *c, int viewid)
{
	struct view *v;
	
	TAILQ_FOREACH(v, &c->views, client_next)
		if (v->id == viewid)
			return v;

	return NULL;

}


/*** UPDATE VIEW AREA ON SCREEN ***/
void
view_refresh(struct view *v)
{
	int i;

	/* Don't bother if the view isn't visible */
	if (v->opacity == 0)
		return;

	if (mode == BORDER_OVERLAY) {
		/* Fill entire view with label background */
		v->wsurface->SetColor(v->wsurface,
				      v->label->bg.r, v->label->bg.g, v->label->bg.b,
				      0x80);
		v->wsurface->FillRectangle(v->wsurface, 0, 0, v->spos.w, v->spos.h);
	}

	/* Transfer the actual guest content from the guest surface */
	if (v->bpos.w == v->spos.w && v->bpos.h == v->spos.h)
		v->wsurface->Blit(v->wsurface, v->vsurface, NULL, 0, 0);
	else
		v->wsurface->StretchBlit(v->wsurface, v->vsurface, NULL, NULL);

	/* Draw borders and labels as appropriate */
	switch (mode) {
	case BORDER_BORDER:
		v->wsurface->SetColor(v->wsurface,
				      v->label->bg.r, v->label->bg.g, v->label->bg.b,
				      0xff);
		for (i = 0; i < SEC_BORDER; i++)
			v->wsurface->DrawRectangle(v->wsurface,
						   i, i,
						   v->spos.w - 2 * i,
						   v->spos.h - 2 * i);
		break;
	case BORDER_CORNER:
		v->wsurface->SetColor(v->wsurface,
				      v->label->bg.r, v->label->bg.g, v->label->bg.b,
				      0xff);
		v->wsurface->FillTriangle(v->wsurface,
					  0, 0,
					  SEC_CORNER, 0,
					  0, SEC_CORNER);
		v->wsurface->FillTriangle(v->wsurface,
					  v->spos.w, 0,
					  v->spos.w, SEC_CORNER,
					  v->spos.w - SEC_CORNER, 0);
		v->wsurface->FillTriangle(v->wsurface,
					  v->spos.w, v->spos.h,
					  v->spos.w - SEC_CORNER, v->spos.h,
					  v->spos.w, v->spos.h - SEC_CORNER);
		v->wsurface->FillTriangle(v->wsurface,
					  0, v->spos.h,
					  0, v->spos.h - SEC_CORNER,
					  SEC_CORNER, v->spos.h);
		break;

	case BORDER_OVERLAY:
		if (!(v->flags & (VIEW_FLAGS_SERVER|VIEW_FLAGS_BACKGROUND)))
			display_draw_label(v);
		break;

	default:
		break;
	}

	v->wsurface->Flip(v->wsurface, NULL, DSFLIP_ONSYNC);
}

static void
view_free(struct view *v)
{
	/* remove view from global list */
	TAILQ_REMOVE(&all_views, v, view_next);
	/* remove view from its buffer list */
	TAILQ_REMOVE(&v->buffer->views, v, buffer_next);
	/* remove view from its client list */
	TAILQ_REMOVE(&v->client->views, v, client_next);

	/* bump client view count */
	v->client->num_views--;

	/* free resources */
	v->wsurface->Release(v->wsurface);
	v->window->Destroy(v->window);
	v->window->Release(v->window);
	v->vsurface->Release(v->vsurface);

	free(v);
}

/***************************
 *** INTERFACE FUNCTIONS ***
 ***************************/

/*** INTERFACE: CREATE NEW VIEW ***/
struct view *
view_new(struct client *c, struct buffer *b, int id, unsigned int flags)
{
	struct view *v;
	IDirectFBSurface *vsurf, *wsurf;
	DFBWindowDescription wdesc;
	IDirectFBWindow *window;

	if (c->num_views >= c->max_views)
		return NULL;

	/* create subsurface */
	if (b->bsurface->GetSubSurface(b->bsurface, NULL, &vsurf) != DFB_OK)
		return NULL;

	/* create main window */
	memset(&wdesc, 0, sizeof(wdesc));
	wdesc.flags = DWDESC_CAPS | DWDESC_PIXELFORMAT | DWDESC_SURFACE_CAPS |  DWDESC_OPTIONS;
	wdesc.caps = DWCAPS_DOUBLEBUFFER | DWCAPS_NODECORATION | DWCAPS_NOFOCUS;
	wdesc.surface_caps = DSCAPS_FLIPPING;
	wdesc.pixelformat = DSPF_ARGB;
	wdesc.options = DWOP_SCALE | DWOP_INDESTRUCTIBLE | DWOP_GHOST;
	if (dl->CreateWindow(dl, &wdesc, &window) != DFB_OK)
		return NULL;
        window->GetSurface(window, &wsurf);
	window->SetOpacity(window, 0);
	window->SetStackingClass(window, (flags & VIEW_FLAGS_THUMBNAIL) ? DWSC_MIDDLE : DWSC_LOWER);
	wsurf->SetRenderOptions(wsurf, DSRO_SMOOTH_UPSCALE | DSRO_SMOOTH_DOWNSCALE);
	wsurf->SetPorterDuff(wsurf, DSPD_DST_OVER);
	wsurf->SetBlittingFlags(wsurf, (mode == BORDER_OVERLAY) ? DSBLIT_BLEND_COLORALPHA : 0);

        /* get memory for the view header */
	v = calloc(1, sizeof(struct view));
	if (!v)
		return NULL;

	v->id          = id;
        v->client      = c;
	v->buffer      = b;
	v->flags       = flags;
        v->label       = &b->client->label;
	v->bsurface    = b->bsurface;
	v->vsurface    = vsurf;
	v->window      = window;
	v->wsurface    = wsurf;

	/* bump client view count */
	c->num_views++;

	TAILQ_INSERT_HEAD(&all_views, v, view_next);

	if (flags & VIEW_FLAGS_SERVER) {
		TAILQ_INSERT_TAIL(&c->views, v, client_next);
		TAILQ_INSERT_TAIL(&b->views, v, buffer_next);
	} else {
		TAILQ_INSERT_HEAD(&c->views, v, client_next);
		TAILQ_INSERT_HEAD(&b->views, v, buffer_next);

		/* notify display subsystem */
		if (display_view_new(v) < 0) {
			view_free(v);
			return NULL;
		}
	}

	return v;
}


/*** INTERFACE: DESTROY VIEW ***/
void
view_remove(struct view *v)
{
	/* call display hook */
	if (!(v->flags & VIEW_FLAGS_SERVER))
		display_view_remove(v);

	/* free view resources */
	view_free(v);
}

int
view_show(struct view *v)
{
	DFBRectangle zero = { 0, 0, 0, 0 };
	int val = 0;

	if (v->visible && (v->mapped || v->flags & VIEW_FLAGS_BACKGROUND))
		val = 0xff;

	/* Zero-sized views cannot be shown */
	if (memcmp(&v->bpos, &zero, sizeof(zero)) == 0)
		val = 0;

	if (!(v->flags & VIEW_FLAGS_SERVER))
		display_view_show(v);

	if (val != v->opacity) {
		v->opacity = val;
		v->window->SetOpacity(v->window, val);
		if (val)
			view_refresh(v);
	}

	return 0;
}

int
view_update_surface(struct view *v)
{
	IDirectFBSurface *bsurf, *vsurf;

	/* XXX check if the view falls outside the surface boundaries */

	bsurf = v->buffer->bsurface;
	v->vsurface->Release(v->vsurface);

	if (bsurf->GetSubSurface(bsurf, &v->bpos, &vsurf) != DFB_OK)
	    return -1;

	v->bsurface = bsurf;
	v->vsurface = vsurf;

	view_refresh(v);
	return 0;
}

/*** INTERFACE: SET VIEW POSITION, SIZE, AND BUFFER OFFSET ***/
int
view_set_viewport(struct view *v,
		  const DFBRectangle *bp, const DFBRectangle *sp,
		  int force_refresh)
{
	/* Check if the view has moved within the buffer */
	if (bp && memcmp(&v->bpos, bp, sizeof(DFBRectangle))) {
		v->vsurface->MakeSubSurface(v->vsurface, v->bsurface, bp);
		memcpy(&v->bpos, bp, sizeof(DFBRectangle));
	}

	/* Check if the window position has changed */
	if (sp && memcmp(&v->spos, sp, sizeof(DFBRectangle))) {
		v->window->SetBounds(v->window, sp->x, sp->y, sp->w, sp->h);
		v->window->ResizeSurface(v->window, sp->w, sp->h);
		memcpy(&v->spos, sp, sizeof(DFBRectangle));

		/* Notify display subsystem */
		if (!(v->flags & VIEW_FLAGS_SERVER))
			display_view_resize(v);
	}

	if (force_refresh)
		view_refresh(v);

	return 0;
}

/*** INTERFACE: SET VIEW POSITION ONLY ***/
int
view_set_position(struct view *v, int x, int y)
{
	if (v->spos.x != x || v->spos.y != y) {
		v->window->MoveTo(v->window, x, y);
		v->spos.x = x;
		v->spos.y = y;

		/* Notify display subsystem */
		if (!(v->flags & VIEW_FLAGS_SERVER))
			display_view_move(v);
	}

	return 0;
}

int
view_translate(struct view *v, int dx, int dy)
{
	if (dx != 0 || dy != 0) {
		v->window->Move(v->window, dx, dy);
		v->spos.x += dx;
		v->spos.y += dy;

		/* Notify display subsystem */
		if (!(v->flags & VIEW_FLAGS_SERVER))
			display_view_move(v);
	}

	return 0;
}

int
view_stack(struct view *v, unsigned op, struct view *sibling)
{
	struct display *d = v->display;
	struct view *prev;

	switch (op) {
	case VIEW_STACK_TOP:
		if (TAILQ_FIRST(&d->views) == v)
			break;
		TAILQ_REMOVE(&d->views, v, display_next);
		TAILQ_INSERT_HEAD(&d->views, v, display_next);
		v->window->RaiseToTop(v->window);
		break;
	case VIEW_STACK_BOTTOM:
		if (TAILQ_LAST(&d->views, view_tailq) == v)
			break;
		TAILQ_REMOVE(&d->views, v, display_next);
		TAILQ_INSERT_TAIL(&d->views, v, display_next);
		v->window->LowerToBottom(v->window);
		break;
	case VIEW_STACK_ABOVE:
		if (TAILQ_FIRST(&d->views) == v)
			break;
		/*
		 * We need to not only stack above the sibling, but also above
		 * all other views immediately above sibling that do not belong
		 * to the same guest as v/sibling (and are not v itself).
		 */
		while ((prev = TAILQ_PREV(sibling, view_tailq, display_next)))
		{
			if (prev->buffer == v->buffer && prev != v)
				break;
			sibling = prev;
		}
		/*
		 * This will occur if v is already in the right place.
		 * Also, this check prevents list corruption.
		 */
		if (v == sibling)
			break;

		TAILQ_REMOVE(&d->views, v, display_next);
		TAILQ_INSERT_BEFORE(sibling, v, display_next);
		v->window->PutAtop(v->window, sibling->window);
		break;
	case VIEW_STACK_BELOW:
		if (TAILQ_LAST(&d->views, view_tailq) == v)
			break;
		if (TAILQ_NEXT(sibling, display_next) == v)
			break;
		TAILQ_REMOVE(&d->views, v, display_next);
		TAILQ_INSERT_AFTER(&d->views, sibling, v, display_next);
		v->window->PutBelow(v->window, sibling->window);
		break;
	}

	return 0;
}

void
view_toggle_labeling(void)
{
	struct view *v;
	unsigned flags;

	mode = (mode + 1) % NUM_BORDER;
	flags = (mode == BORDER_OVERLAY) ? DSBLIT_BLEND_COLORALPHA : 0;

	TAILQ_FOREACH(v, &all_views, view_next) {
		v->wsurface->SetBlittingFlags(v->wsurface, flags);
		view_refresh(v);
	}
}

/*** DEBUG INTERFACES ***/
void
view_debug_dump(void)
{
	struct view *v;

	TAILQ_FOREACH(v, &all_views, view_next) {
		fprintf(stderr, "View: %p Client: %d Buffer: %d ID: %x\n\tFlags: %x\n\t"
			"Buffer Position: %d,%d %dx%d\n\tScreen Position: %d,%d %dx%d\n\t"
			"Thumbnail Position: %d,%d %dx%d\n\t"
			"Mapped: %d Visible: %d Opacity: %d\n",

			v, v->client->id, v->buffer->id, v->id, v->flags,
			v->bpos.x, v->bpos.y, v->bpos.w, v->bpos.h,
			v->spos.x, v->spos.y, v->spos.w, v->spos.h,
			v->tpos.x, v->tpos.y, v->tpos.w, v->tpos.h,
			v->mapped, v->visible, v->opacity);

		if (v->thumb)
			fprintf(stderr, "\tThumbnail: %p Client: %d Buffer: %d ID: %x\n\tFlags: %x\n\t"
				"Buffer Position: %d,%d %dx%d\n\tScreen Position: %d,%d %dx%d\n\t"
				"Mapped: %d Visible: %d Opacity: %d\n\n",
				v->thumb, v->thumb->client->id, v->thumb->buffer->id, v->thumb->id, v->thumb->flags,
				v->thumb->bpos.x, v->thumb->bpos.y, v->thumb->bpos.w, v->thumb->bpos.h,
				v->thumb->spos.x, v->thumb->spos.y, v->thumb->spos.w, v->thumb->spos.h,
				v->thumb->mapped, v->thumb->visible, v->thumb->opacity);
		else
			fprintf(stderr, "\n");
	}
}