/*
 *	floatbg.c
 *	author: Jan Rekers
 *	purpose: This program slowly changes the color of the root window of X.
 */
/* 16bpp and 32bpp support added by Dave Holland <dave@zenda.demon.co.uk>
 * Code taken from xsetroot by Mark Lillibridge
 * Copyright (c) 1987,  X Consortium
 */
/* Further modifications by Varis (risto.varanka@helsinki.fi) 22.10.1999
 */

#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xatom.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>

#define MaxColor 	0xffff
#define MaxTime  	0x7fff
#define pi		3.1415926535
#define default_sf_in_hf	.25
#define default_s_mid	.375
#define default_s_var	.125
#define default_v_val	.87
#define default_l_time	10.00
#define atom_name	"floatbg_running"

char *program_name;
int gnome=0; /* call out to gconftool to affect Gnome background */
int xfce=0; /* call out to xfconf-query to affect Xfce background */
Display *dpy;
int screen;
Window root;
Atom running_flag;

struct hsv { float h,s,v; };
struct rgb { float r,g,b; };

void hsv2rgb (struct hsv *hsv, struct rgb *rgb);
void ticks2hsv (int ticks, struct hsv *hsv);
float sf_in_hf = default_sf_in_hf;
float s_mid = default_s_mid;
float s_var = default_s_var;
float v_val = default_v_val;
float l_time = default_l_time;

unsigned long GetMutableColor();
void SetColor (
    unsigned long pixel,
    struct rgb *rgb,
    Display *dpy,
    int screen,
    Window root);
/* We no longer need these, since we now include stdlib.h and time.h.  */
/* long time(), random(); */
/* double atof(); */

/* from xsetroot */
unsigned long NameToPixel(char *name, unsigned long pixel);
int save_colors=0;

char str[100];
int using8bpp=0;

void usage(void)
{
    fprintf(stderr, "usage: %s [options]\n", program_name);
    fprintf(stderr, "  where options are:\n");
    fprintf(stderr, "  -display <display>   or   -d <display>\n");
    fprintf(stderr, "  -help\n");
    fprintf(stderr, "  -gnome\n");
    fprintf(stderr, "  -xfce\n");
    fprintf(stderr, "  -value <float>   (default %1.2f)\n", default_v_val);
    fprintf(stderr, "  -satmid <float>  (default %1.3f)\n", default_s_mid);
    fprintf(stderr, "  -satvar <float>  (default %1.3f)\n", default_s_var);
    fprintf(stderr, "  -fase <float>    (default %1.2f)\n", default_sf_in_hf);
    fprintf(stderr, "  -time <float>    (default %1.2f)\n", default_l_time);
    fprintf(stderr, "  value, (satmid-satvar) and (satmid+satvar) must be between 0 and 1\n");
    exit(1);
}

void clear_flag_exit(int signum) {
    int i;

    //fprintf(stderr, "received signal %d: clearing flag and exiting\n", signum);
    i = XDeleteProperty(dpy, root, running_flag);
    //fprintf(stderr, "i=%d\n");
    XFlush(dpy);
    exit(0);
}

int main(int argc, char **argv)
{
    char *display_name = NULL;
    unsigned long cmapentry;
    register int ticks;
    int i;
    struct hsv hsv;
    struct rgb rgb;
    extern char *optarg;
    struct timeval looptime, tmptime; 
 
    program_name=argv[0];
    for (i = 1; i < argc; i++) {
	if (!strcmp ("-display", argv[i]) || !strcmp ("-d", argv[i])) {
	    if (++i>=argc) usage ();
	    display_name = argv[i];
	    continue;
	}
	if (!strcmp("-help", argv[i])) {
	    usage();
	}
	if (!strcmp("-gnome", argv[i])) {
	    gnome=1;
            continue;
	}
	if (!strcmp("-xfce", argv[i])) {
	    xfce=1;
            continue;
	}
	if (!strcmp("-value", argv[i])) {
	    if (++i>=argc) usage();
	    v_val = atof(argv[i]);
	    continue;
	}
	if (!strcmp("-satmid", argv[i])) {
	    if (++i>=argc) usage();
	    s_mid = atof(argv[i]);
	    continue;
	}
	if (!strcmp("-satvar", argv[i])) {
	    if (++i>=argc) usage();
	    s_var = atof(argv[i]);
	    continue;
	}
	if (!strcmp("-fase", argv[i])) {
	    if (++i>=argc) usage();
	    sf_in_hf = atof(argv[i]);
	    continue;
	}
	if (!strcmp("-time", argv[i])) {
	    if (++i>=argc) usage();
	    l_time = atof(argv[i]);
	    continue;
	}
	usage();
    } 

    if ( (v_val < 0) || (v_val > 1) ) usage();
    if ( ((s_mid - s_var) < 0) || ((s_mid + s_var) > 1) ) usage();

    dpy = XOpenDisplay(display_name);
    if (!dpy) {
	fprintf(stderr, "%s:  unable to open display '%s'\n",
		program_name, XDisplayName (display_name));
	exit(1);
    }
    screen = DefaultScreen(dpy);
    root = RootWindow(dpy, screen);

    /* create the atom if it's not already there */
    running_flag = XInternAtom(dpy, atom_name, False);

    Atom actual_type_return;
    int actual_format_return;
    unsigned long nitems_return, bytes_after_return;
    unsigned char *prop_return;
    /* look for signs of life elsewhere */
    i = XGetWindowProperty(dpy, root, running_flag, 0, 1, False, AnyPropertyType, 
            &actual_type_return, &actual_format_return, &nitems_return,
            &bytes_after_return, &prop_return);
    //fprintf(stderr, "i=%d, nitems_return=%d\n", i, nitems_return);
    if (nitems_return != 0) {
        fprintf(stderr, "%s: another copy may be running; exiting\n", program_name);
        exit(0);
    }
    i = XChangeProperty(dpy, root, running_flag, XA_ATOM, 32, PropModeReplace,
            "flbg", 1);
    //fprintf(stderr, "i=%d\n");
    i = XGetWindowProperty(dpy, root, running_flag, 0, 1, False, AnyPropertyType, 
            &actual_type_return, &actual_format_return, &nitems_return,
            &bytes_after_return, &prop_return);
    //fprintf(stderr, "i=%d, nitems_return=%d\n", i, nitems_return);

    /* if we can't create the signal handler, there's not much we can */
    /* do, so throw away the return code here */
    signal(SIGHUP, (void *)clear_flag_exit);
    signal(SIGTERM, (void *)clear_flag_exit);
    signal(SIGINT, (void *)clear_flag_exit);
    signal(SIGKILL, (void *)clear_flag_exit);

    srandom( (int)time(NULL) );
    ticks = (int)random() % MaxTime;

    /* this will trigger a change to using 8bpp if appropriate */
    cmapentry = GetMutableColor();

    /* for 16/32bpp this'll happen in the main loop */
    if(using8bpp) {
        XSetWindowBackground(dpy, root, cmapentry);
        XClearWindow(dpy, root);
    }

    /* Set time values for select - ie. how long to wait between loops */
    looptime.tv_sec = 0;
    looptime.tv_usec = 0;
    if (l_time >= 1) {
      looptime.tv_sec = l_time;
      l_time = l_time - looptime.tv_sec;
    }
    if ((l_time < 1) && (l_time > 0)) {
      looptime.tv_usec = 1000000*l_time;
    }

    if(gnome) {
        system("gconftool --type string --set /desktop/gnome/background/color_shading_type \"solid\"");
        system("gconftool --unset /desktop/gnome/background/picture_filename");
    }
    if(xfce) {
        system("xfconf-query -c xfce4-desktop -p /backdrop/screen0/monitor0/image-show -n -s false");
        system("xfconf-query -c xfce4-desktop -p /backdrop/screen0/monitor0/color-style -n -s 0");
    }

    /* The Linux kernel time share clock ticks at 100Hz on i386, */
    /* so this loop will not run more than 100 times a second. */
    /* On Alpha this is reported to be 1000Hz. */

    while ( 1 ) {
       	ticks2hsv(ticks, &hsv);
	hsv2rgb(&hsv, &rgb);
	SetColor(cmapentry, &rgb, dpy, root, screen);
	XFlush(dpy);
	ticks = ticks++ % MaxTime;
	/* select seems to alter the timeval struct, so we need */
	/* an extra variable */
	tmptime = looptime;
	select(0, NULL, NULL, NULL, &tmptime);
    }
}

unsigned long GetMutableColor ()
{
    XColor color;
    if (XAllocColorCells (dpy, DefaultColormap(dpy,screen),
			  0, 0, 0, &color.pixel, 1) == 0) {
	/* this is not an 8bpp display */
	return (unsigned long) 0;
	}
    using8bpp=1;
    return(color.pixel);
}

void SetColor (
    unsigned long pixel,
    struct rgb *rgb,
    Display *dpy,
    int screen,
    Window root)
{
    XColor color;
    unsigned int red = (int) MaxColor * rgb->r;
    unsigned int green = (int) MaxColor * rgb->g;
    unsigned int blue = (int) MaxColor * rgb->b;

    if(gnome) {
        /* I'm sorry. */
	char cmd[120];
	sprintf(cmd,"gconftool --type string --set /desktop/gnome/background/primary_color \"#%04x%04x%04x\"",
	    red, green, blue);
        /* printf("%s\n",cmd); */
	system(cmd);
    } else if(xfce) {
        /* I'm sorry for this, too. */
        char cmd[200];
        sprintf(cmd,"xfconf-query -c xfce4-desktop -p /backdrop/screen0/monitor0/color1 -n -t uint16 -s %d -t uint16 -s %d -t uint16 -s %d -t uint16 -s 65535", red, green, blue);
        system(cmd);
    } else {
        if(using8bpp) {
        /* this will not work in 16/32bpp */
            color.red = red; color.green = green; color.blue = blue;
            color.pixel = pixel;
            color.flags = DoRed|DoGreen|DoBlue;
            XStoreColor(dpy, DefaultColormap(dpy,screen), &color);
        } else {
        /* this method _does_ work in 16/32bpp; also 8bpp although
         * the above method is apparently less resource-hungry */
        sprintf(str,"#%.4x%.4x%.4x",red,green,blue);
            XSetWindowBackground(dpy, root,
    			 NameToPixel(str, BlackPixel(dpy,screen)));
            XClearWindow(dpy,root);
        }
    }
}

void ticks2hsv (int ticks, struct hsv *hsv)
{
    float s_fase /*, sin() */ ;

    hsv->h = ticks % 360;
    s_fase = sf_in_hf * (pi / 180) * ticks;
    hsv->s = s_mid - (s_var * sin(s_fase));
    hsv->v = v_val;
}

void hsv2rgb (struct hsv *hsv, struct rgb *rgb)
{
    int i;
    float f, p, q, r, h, v;

    v = hsv->v;
    if (hsv->s == 0) {
	rgb->r = v; rgb->g = v; rgb->b = v; }
    else {
	h = hsv->h / 60;
	i = (int) h;
	f = h - i;
	p = hsv->v * (1 - hsv->s);
	q = hsv->v * (1 - (hsv->s * f));
	r = hsv->v * (1 - (hsv->s * (1 - f)));
	switch (i) {
	    case 0: rgb->r = v; rgb->g = r; rgb->b = p; break;
	    case 1: rgb->r = q; rgb->g = v; rgb->b = p; break;
	    case 2: rgb->r = p; rgb->g = v; rgb->b = r; break;
	    case 3: rgb->r = p; rgb->g = q; rgb->b = v; break;
	    case 4: rgb->r = r; rgb->g = p; rgb->b = v; break;
	    case 5: rgb->r = v; rgb->g = p; rgb->b = q; break;
	}
    }
}

#define Dynamic 1

unsigned long NameToPixel(char *name, unsigned long pixel)
{
    XColor ecolor;

    if (!name || !*name)
	return pixel;
    if (!XParseColor(dpy,DefaultColormap(dpy,screen),name,&ecolor)) {
	fprintf(stderr,"%s:  unknown color \"%s\"\n",program_name,name);
	exit(1);
	/*NOTREACHED*/
    }
    if (!XAllocColor(dpy, DefaultColormap(dpy, screen),&ecolor)) {
	fprintf(stderr, "%s:  unable to allocate color for \"%s\"\n",
		program_name, name);
	exit(1);
	/*NOTREACHED*/
    }
    if ((ecolor.pixel != BlackPixel(dpy, screen)) &&
	(ecolor.pixel != WhitePixel(dpy, screen)) &&
	(DefaultVisual(dpy, screen)->class & Dynamic))
	save_colors = 1;
    return(ecolor.pixel);
}