/*
 * (c) SPDsoft 1993 + ATIC
 * Display a PICT2 file using Silicon Graphics gl
 */

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

#include <gl/gl.h>
#include <gl/device.h>

#include <pict.h>

#define ALPHA_OPAC	0x00
#define SCREEN_W	G_prefs.screen_w
#define SCREEN_H	G_prefs.screen_h

#define Boolean	int 
#define Output	if (G_prefs.Verbose) printf
#define IH	pictIn->image_H
#define IW	pictIn->image_W

#define MIN(a,b) ((a)>(b)?(b):(a))

typedef struct { 
			char 	*AppName;
			Boolean Foreground;	
			Boolean FullScreen;	
			Boolean FillScreen;	
			Boolean Growable;	
			Boolean KeepAspectRatio;	
			Boolean Verbose;	
			Boolean Alfa;
			long	screen_w;
			long	screen_h;
		}  pref;


void	init_graphics(void);
void	redraw(Pict image);
void    usage(char *name);
void    fatalError(char *str);
Boolean	get_options(int argc,char *argv[]);

extern char     *optarg;
extern int      optind,opterr;

pref	G_prefs;
static char __ident[] = "@(#)(c) SPDsoft, 04 Jul 1995";
#define VERS_STR    ((char*)&__ident[4])

Boolean	get_options(int argc,char *argv[])
{
	int opcion;
	int theError=0;

	G_prefs.AppName	= argv[0];
	G_prefs.Foreground	= 0;
	G_prefs.FullScreen	= 0;
	G_prefs.FillScreen	= 0;
	G_prefs.Growable	= 0;
	G_prefs.KeepAspectRatio	= 1;
	G_prefs.Verbose=0;
	G_prefs.Alfa=0;

	while ( (opcion=getopt(argc,argv,"afbFgGvh")) != EOF )
	{
		switch(opcion)
		{
				case 'a':
						G_prefs.Alfa = 1;
						break;
				case 'f':
						G_prefs.Foreground = 1;
						break;
				case 'b':
						G_prefs.FullScreen = 1;
						break;
				case 'F':
						G_prefs.FullScreen = 1;
						G_prefs.FillScreen = 1;
						break;
				case 'g':
						G_prefs.Growable = 1;
						break;
				case 'G':
						G_prefs.Growable = 1;
						G_prefs.KeepAspectRatio = 0;
						break;
				case 'v':
						printf("%s:%s\n",argv[0],VERS_STR);
						G_prefs.Verbose=1;
						break;
				default:
						usage(argv[0]);
		}
		if ( theError!=0)  usage(argv[0]);
	}
}

void    usage(char *name)
{
    fprintf(stderr,
    "usage: %s [-b|-F|-g|-G][-f][-v][-a][-h][files...]"
	"\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n",
	name,
	"-a: Alpha channel",
	"-f: Don't fork (run in foreground)",
	"-b: Full screen",
	"-F: Fill full screen",
	"-g: Growable, Keep aspect ratio",
	"-G: Growable",
	"-v: Version, debbug",
	"-h: This text. Note: Press <esc> to go to next image"
	);
    exit(-1);
}

void    fatalError(char *str)
{
    fprintf(stderr,
    "%s: Fatal Error: %s. bye...\n",G_prefs.AppName,str);
    exit(-2);
}

main(int argc,char *argv[])
{
	Pict	pictIn;
	int		ReadMode = P_READ;
	Boolean	Fill;
	int f,i,j;
	U_char	*pix;
	U_char	*unpacked,*r_ptr,*g_ptr,*b_ptr,*a_ptr;

	long gwid;
	long gw_x, gw_y;
	long MyEvent;
	short val;
	Boolean	quitting=0;
	Boolean	NeedRedraw=1;

	char tmpStr[64];

	get_options(argc,argv);
	init_graphics();

	if(G_prefs.FullScreen) 
	{
			prefposition( 0, SCREEN_W, 0, SCREEN_H );
			gwid=winopen("");
			RGBmode();
			gconfig();
	}

	if (optind==argc)
	{
		argc ++;
		ReadMode = P_STDI;
	}

	Fill = G_prefs.FillScreen;

	for(f=optind; f<argc; f++)
	{
		G_prefs.FillScreen = Fill;

		pictIn = pict_open(argv[f],ReadMode,0,0,0,NULL);

		Output("%s\t%d\t%d\t%d\n",(argv[f]==NULL?"stdin":argv[f]),
				pictIn->clr_mode,IH,IW );

		if((( IW > SCREEN_W ) || ( IH > SCREEN_H))&&(G_prefs.FullScreen))
			G_prefs.FillScreen=1;
			


			pictIn->pixels =
				(U_char *)calloc( 	(size_t)IH * (size_t)IW , (size_t)4);
						
			unpacked = (U_char *)malloc((size_t)IW*(size_t)pictIn->n_comp+1);

			if ((pictIn->pixels==NULL) || ( unpacked==NULL))
				fatalError("Se acabo la memoria");

			pix = pictIn->pixels + (size_t)4*IW*(IH-1);

			if(G_prefs.Alfa) pictIn->clr_mode = -1;

			for (i=0; i < IH; i++)
			{

				a_ptr = unpacked;
				r_ptr = a_ptr+IW;
				g_ptr = r_ptr+IW;
				b_ptr = g_ptr+IW;
				
				pict_get_line(pictIn,unpacked);

				switch(pictIn->clr_mode)
				{
					case M_MONO:
					case M_RGB8:
						for (j=0; j<IW; j++)
						{
							*pix++ = ALPHA_OPAC;
							*pix++ = pictIn->map[*a_ptr][2];
							*pix++ = pictIn->map[*a_ptr][1];
							*pix++ = pictIn->map[*a_ptr++][0];
						}
						break;
					case M_RGB24:
						for (j=0; j<IW; j++)
						{
							*pix++ = ALPHA_OPAC;
							*pix++ = *g_ptr++;
							*pix++ = *r_ptr++;
							*pix++ = *a_ptr++;
						}
						break;
					case M_RGBA32:
						for (j=0; j<IW; j++)
						{
							*pix++ = *a_ptr++;
							*pix++ = *b_ptr++;
							*pix++ = *g_ptr++;
							*pix++ = *r_ptr++;
						}
						break;

					default:
						for (j=0; j<IW; j++)
						{
							*pix++ = ALPHA_OPAC;
							*pix++ = *a_ptr;
							*pix++ = *a_ptr;
							*pix++ = *a_ptr++;
						}
						break;
						
				}
				pix -= 8*IW;
			}


			free((void*)unpacked);
			pict_close(pictIn);

		if(G_prefs.FullScreen) 
		{
			if(G_prefs.FillScreen)
			{
			float scale=1.0;
					getsize(&gw_x, &gw_y);

					scale= MIN(	(float)gw_x/(float)IW,
								(float)gw_y/(float)IH);

					rectzoom(scale,scale);
			}
			redraw(pictIn);
		}
		else
		{
				sprintf(tmpStr,"%s: %s", argv[0], 
									(argv[f]==NULL?"stdin":argv[f]));
				prefsize((long)IW,(long)IH);
				gwid=winopen(tmpStr);
				clear();
				RGBmode();
				gconfig();
				if(G_prefs.Growable)
				{
					if(G_prefs.KeepAspectRatio)
						keepaspect((long)IW,(long)IH);
					winconstraints();
				}
		}

/*
 * just for IRIX 5.3 (and later, I guess)
 *
 * IRIX 5.2 sends REDRAW properly
 */
		redraw(pictIn);
/*
 */
		
		for (quitting=0;!quitting;)
		{
			while (qtest() || (!NeedRedraw ))
			{
			/* Event Loop */

			switch(MyEvent=qread(&val))
			{
				case ESCKEY:
					quitting=!val;
					break;

				case REDRAW:
					NeedRedraw=1;
					redraw(pictIn);
					break;

				case WINQUIT:
					quitting=1;
					f=argc;
					break;

				case INPUTCHANGE:
					break;

				default:
					if(G_prefs.Verbose)
					{
						printf("Event: %ld\n", MyEvent);
						fflush(stdout);
					}
					break;

			}
			if (quitting) break;
			} /* while */
			redraw(pictIn);
			NeedRedraw=0;
		}

		if(!G_prefs.FullScreen) winclose(gwid);
		free(pictIn);
	}
	if(G_prefs.FullScreen) winclose(gwid);
	return(0);
}

void init_graphics(void)
{
		qdevice(ESCKEY);
		qdevice(REDRAW);
		qdevice(WINSHUT);
		qdevice(WINQUIT);

		G_prefs.screen_w = getgdesc(GD_XPMAX);
		G_prefs.screen_h = getgdesc(GD_YPMAX);

		if (( G_prefs.screen_w == -1 ) || ( G_prefs.screen_h == -1 ))
			fatalError("getgdesc failed");

		if(G_prefs.Foreground) foreground();
}

void	redraw(Pict pictIn)
{
	long gw_x, gw_y;

	if(G_prefs.FullScreen) 
	{
		clear();
		if(G_prefs.FillScreen) 
		{
			lrectwrite(	0,(IH-1),(IW-1),0,
				(unsigned long *)pictIn->pixels);
		}
		else
			lrectwrite(
				(SCREEN_W-IW+1)/2,(SCREEN_H+IH-1)/2,
				(SCREEN_W+IW-1)/2,(SCREEN_H-IH+1)/2,
				(unsigned long *)pictIn->pixels);
	}
	else
	{
		if(G_prefs.Growable)
		{
			getsize(&gw_x, &gw_y);
			viewport(0,gw_x-1,0,gw_y-1);
			rectzoom(	(float)gw_x/(float)IW,
						(float)gw_y/(float)IH);
		}
	lrectwrite(	0,(IH-1),(IW-1),0,
				(unsigned long *)pictIn->pixels);
	}
}