lcdproc/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);
}