source: npl/mediabox/lcdproc_edwin/src/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);
/*
   LL_Rewind(s->widgets);
   do {
      w = LL_Get(s->widgets);
      if( (w)  &&  (0 == strcmp(w->id, id)))
      {
         debug("widget_find:  Found %s\n", id);
         return w;
      }
      // TODO:  Search kids too!
      if( w->type == WID_FRAME )
      {
         err = widget_finder(w->kids, id);
         if(err) return err;
      }
      
   } while(LL_Next(s->widgets) == 0);

   return NULL;
*/
}

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;
      }
   }
   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;
}