source: npl/mediabox/lcdproc_edwin/src/server/screenlist.c

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

#include "../shared/LL.h"
#include "../shared/sockets.h"
#include "../shared/debug.h"
#include "screenlist.h"
#include "screen.h"
#include "clients.h"



int screenlist_action=0;

int timer=0;

LL * screenlist;


int screenlist_add_end(screen *screen);
screen * screenlist_next_roll();
screen * screenlist_prev_roll();
screen * screenlist_next_priority();

int compare_priority(void *one, void *two);
int compare_addresses(void *one, void *two);


int screenlist_init()
{
   debug("screenlist_init()\n");
   
   screenlist = LL_new();
   if(!screenlist)
   {
      fprintf(stderr, "screenlist_init: Error allocating list\n");
      return -1;
   }

   screenlist_action = 0;
   timer = 0;
   
   return 0;
}

int screenlist_shutdown()
{
   debug("screenlist_shutdown()\n");
   
   LL_Destroy(screenlist);
   
   return 0;
}

int screenlist_remove(screen *s)
{
   debug("screenlist_remove()\n");
   
   if(!LL_Remove(screenlist, s))
      return -1;
   else return 0;
}

int screenlist_remove_all(screen *s)
{
   int i=0;
   
   debug("screenlist_remove_all()\n");
   
   while(LL_Remove(screenlist, s))
      i++;

   debug("screenlist_remove_all()... got %i\n", i);

   return i;
}

LL * screenlist_getlist()
{
   debug("screenlist_getlist()\n");
   
   return screenlist;
}

screen * screenlist_current()
{
   char str[256];
   screen *s;
   static screen *old_s = NULL;
   client *c;


   //debug("screenlist_current:\n");
   //LL_dprint(screenlist);
   

   s = (screen *)LL_GetFirst(screenlist);

   // FIXME:  Make sure the screen/client exists!
   if(s != old_s)
   {
      debug("screenlist_current: new screen\n");
      timer = 0;
      
      // Tell the client we're done with the current screen
      if(old_s)
      {
         //debug("screenlist_current: ignoring old screen\n");
         LL_Rewind(screenlist);
         if(old_s != LL_Find(screenlist, compare_addresses, old_s))
         {
            debug("screenlist: Didn't find screen 0x%8x!\n", (int)old_s);
         }
         else {
            //debug("screenlist_current: ... sending ignore\n");
            c = old_s->parent;
            if(c)  // Tell the client we're not listening any more...
            {
               sprintf(str, "ignore %s\n", old_s->id);
               sock_send_string(c->sock, str);
            }
            else  // The server has the display, so do nothing
            {
            }
            //debug("screenlist_current: ... sent ignore\n");
         }
      }
      if(s)
      {
         //debug("screenlist_current: listening to new screen\n");
         c = s->parent;
         if(c)  // Tell the client we're paying attention...
         {
            sprintf(str, "listen %s\n", s->id);
            sock_send_string(c->sock, str);
         }
         else  // The server has the display, so do nothing
         {
         }
      }
   }
   
   

   old_s = s;

   //debug("screenlist_current: return %8x\n", s);

   return s;
}

int screenlist_add(screen *s)
{
   // TODO:  Different queueing modes...
   return screenlist_add_end(s);
}

screen * screenlist_next()
{
   screen *s;
   
   //debug("Screenlist_next()\n");
   
   s = screenlist_current();

   // If we're on hold, don't advance!
   if(screenlist_action == SCR_HOLD) return s;
   //if(screenlist_action == RENDER_HOLD) return s;

   // Otherwise, reset it to regular operation
   screenlist_action = 0;
   

   //debug("Screenlist_next: calling handler...\n");

   // Call the selected queuing function...
   // TODO:  Different queueing modes...
   s = screenlist_next_priority();
   //s = screenlist_next_roll();

   //debug("Screenlist_next() done\n");

   return s;
}

screen * screenlist_prev()
{
   screen *s;

   s = screenlist_current();

   // If we're on hold, don't advance!
   if(screenlist_action == SCR_HOLD) return s;
   if(screenlist_action == RENDER_HOLD) return s;
   
   // Otherwise, reset it no regular operation
   screenlist_action = 0;
   

   // Call the selected queuing function...
   // TODO:  Different queueing modes...
   s = screenlist_prev_roll();

   return s;
}


// Adds new screens to the end of the screenlist...
int screenlist_add_end(screen *screen)
{
   debug("screenlist_add_end()\n");
   
   return LL_Push(screenlist, (void *)screen);
}

// Simple round-robin approach to screen cycling...
screen * screenlist_next_roll()
{
   //debug("screenlist_next_roll()\n");
   
   if(LL_UnRoll(screenlist) != 0) return NULL;

   return screenlist_current();
}

// Strict priority queue approach...
screen * screenlist_next_priority()
{
   //screen *s, *t;
   //debug("screenlist_next_priority\n");

   if(LL_UnRoll(screenlist) != 0) return NULL;

   LL_Sort(screenlist, compare_priority);
   
   return screenlist_current();
}

// Simple round-robin approach to screen cycling...
screen * screenlist_prev_roll()
{
   //debug("screenlist_prev_roll()\n");
   
   if(LL_Roll(screenlist) != 0) return NULL;

   return screenlist_current();
}


int compare_priority(void *one, void *two)
{
   screen *a, *b;

   //debug("compare_priority: %8x %8x\n", one, two);
   
   if(!one) return 0;
   if(!two) return 0;
   
   a = (screen *)one;
   b = (screen *)two;

   //debug("compare_priority: done?\n");

   return (a->priority - b->priority);
}

int compare_addresses(void *one, void *two)
{
   //printf("compare_addresses: 0x%x == 0x%x ???\n", one, two);
   //if(one == two) printf("Yes!\n");
   //else printf("No!\n");
   return (one != two);
}