lcdproc/server/widget.c

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include "shared/sockets.h"
#include "shared/debug.h"

#include "screen.h"
#include "widget.h"

char *types[] = { "none",
	"string",
	"hbar",
	"vbar",
	"icon",
	"title",
	"scroller",
	"frame",
	"num",
	//"",
	NULL,
};

static widget *widget_finder (LL * list, char *id);
static int widget_remover (LL * list, widget * w);

widget *
widget_create ()
{
	widget *w;

	debug ("widget_create()\n");

	w = malloc (sizeof (widget));
	if (!w) {
		fprintf (stderr, "widget_create: Error allocating widget\n");
		return NULL;
	}

	w->id = NULL;
	w->type = 0;
	w->x = 1;
	w->y = 1;
	w->wid = 0;
	w->hgt = 0;
	w->left = 1;
	w->top = 1;
	w->right = 0;
	w->bottom = 0;
	w->length = 1;
	w->speed = 1;
	w->text = NULL;
	w->kids = NULL;

	return w;
}

int
widget_destroy (widget * w)
{
	LL *list;
	widget *foo;

	if (!w)
		return -1;

	debug ("widget_destroy(%s)\n", w->id);

	if (w->id)
		free (w->id);
	//debug("widget_destroy: id...\n");
	if (w->text)
		free (w->text);
	//debug("widget_destroy: text...\n");

	// TODO: Free kids!
	if (w->kids) {
		list = w->kids;
		LL_Rewind (list);
		do {
			foo = LL_Get (list);
			if (foo)
				widget_destroy (foo);
		} while (0 == LL_Next (list));

		LL_Destroy (list);
		w->kids = NULL;
	}

	free (w);
	//debug("widget_destroy: widget...\n");

	return 0;
}

widget *
widget_find (screen * s, char *id)
{
	//widget *w, *err;

	if (!s)
		return NULL;
	if (!id)
		return NULL;

	debug ("widget_find(%s)\n", id);

	return widget_finder (s->widgets, id);
}

widget *
widget_finder (LL * list, char *id)
{
	widget *w, *err;

	if (!list)
		return NULL;
	if (!id)
		return NULL;

	debug ("widget_finder(%s)\n", id);

	LL_Rewind (list);
	do {
		//debug("widget_finder: Iteration\n");
		w = LL_Get (list);
		if (w) {
			//debug("widget_finder: ...\n");
			if (0 == strcmp (w->id, id)) {
				debug ("widget_finder:  Found %s\n", id);
				return w;
			}
			// Search kids recursively
			//debug("widget_finder: ...\n");
			if (w->type == WID_FRAME) {
				err = widget_finder (w->kids, id);
				if (err)
					return err;
			}
			//debug("widget_finder: ...\n");
		}

	} while (LL_Next (list) == 0);

	return NULL;
}

int
widget_add (screen * s, char *id, char *type, char *in, int sock)
{
	int i;
	int valid = 0;
	int wid_type = 0;
	widget *w, *parent;
	LL *list;

	debug ("widget_add(%s, %s, %s)\n", id, type, in);

	if (!s)
		return -1;
	if (!id)
		return -1;

	list = s->widgets;

	if (0 == strcmp (id, "heartbeat")) {
		s->heartbeat = 1;
		return 0;
	}

	// Make sure this screen doesn't already exist...
	w = widget_find (s, id);
	if (w) {
		// already exists
		sock_send_string (sock, "huh? You already have a widget with that id#\n");
		return 1;
	}
	// Make sure the container, if any, is real
	if (in) {
		parent = widget_find (s, in);
		if (!parent) {
			// no frame to use as parent
			sock_send_string (sock, "huh? Frame doesn't exist\n");
			return 3;
		} else {
			if (parent->type == WID_FRAME) {
				list = parent->kids;
				if (!list)
					fprintf (stderr, "widget_add: Parent has no kids\n");
			} else {
				// no frame to use as parent
				sock_send_string (sock, "huh? Not a frame\n");
				return 4;
			}
		}
	}

	// Make sure it's a valid widget type
	for (i = 1; types[i]; i++) {
		if (0 == strcmp (types[i], type)) {
			valid = 1;
			wid_type = i;
			break; // it's valid: skip out...
		}
	}

	if (!valid) {
		// invalid widget type
		sock_send_string (sock, "huh? Invalid widget type\n");
		return 2;
	}

	debug ("widget_add: making widget\n");

	// Now, make it...
	w = widget_create ();
	if (!w) {
		fprintf (stderr, "widget_add:  Error creating widget\n");
		return -1;
	}

	w->id = strdup (id);
	if (!w->id) {
		fprintf (stderr, "widget_add:  Error allocating id\n");
		return -1;
	}

	w->type = wid_type;

	// Set up the container's widget list...
	if (w->type == WID_FRAME) {
		if (!w->kids) {
			w->kids = LL_new ();
			if (!w->kids) {
				fprintf (stderr, "widget_add: error allocating kids for frame\n");
				return -1;
			}
		}
	}

	// TODO:  Check for errors here?
	LL_Push (list, (void *) w);

	return 0;
}

int
widget_remove (screen * s, char *id, int sock)
{
	widget *w;
	LL *list;

	debug ("widget_remove(%s)\n", id);

	if (!s)
		return -1;
	if (!id)
		return -1;

	list = s->widgets;

	if (0 == strcmp (id, "heartbeat")) {
		s->heartbeat = 0;
		return 0;
	}
	// Make sure this screen *does* exist...
	w = widget_find (s, id);
	if (!w) {
		sock_send_string (sock, "huh? You don't have a widget with that id#\n");
		debug ("widget_remove:  Error finding widget %s\n", id);
		return 1;
	}

//	TODO: Check for errors here?
//	TODO: Make this work with frames...
//	LL_Remove(list, (void *)w);

   
//	TODO: Check for errors here?
//	widget_destroy(w);

	return widget_remover (list, w);

//	return 0;
}

int
widget_remover (LL * list, widget * w)
{
	widget *foo, *bar;
	int err;

	debug ("widget_remover\n");

	if (!list)
		return 0;
	if (!w)
		return 0;

	// Search through the list...
	LL_Rewind (list);
	do {
		// Test each item
		foo = LL_Get (list);
		if (foo) {
			// Frames require recursion to search and/or destroy
			if (foo->type == WID_FRAME) {
				// If removing a frame, kill all its kids, too...
				if (foo == w) {
					if (!foo->kids) {
						fprintf (stderr, "widget_remover: frame has no kids\n");
					} else			  // Kill the kids...
					{
						LL_Rewind (foo->kids);
						do {
							bar = LL_Get (foo->kids);
							err = widget_remover (foo->kids, bar);
						} while (0 == LL_Next (foo->kids));

						// Then kill the parent...
						LL_Remove (list, (void *) w);
						widget_destroy (w);
					}

				} else				  // Otherwise, search the frame recursively...
				{
					if (!foo->kids) {
						fprintf (stderr, "widget_remover: frame has no kids\n");
					} else
						err = widget_remover (foo->kids, w);

				}
			} else					  // If not a frame, remove it if it matches...
			{
				if (foo == w) {
					LL_Remove (list, (void *) w);
					widget_destroy (w);
				}
			}
		}
	} while (0 == LL_Next (list));

	return 0;
}