/****************************************/
/*	iisctrl		valdes 8 27 88	*/
/*					*/
/*	IIS subroutines			*/
/****************************************/
#include	"misc.h"
#include	"iisfv.h"


static char iiszero[800];	/* One line of zeros */
int	lastwin;

static struct iiscdf    cursor = STDCRS;

/*Initialize IIS*/
iisinit () {
    short   hdr[8], words[2], *lut;
    int     screen[4], frame, irpos[2];
    char    mono[1];

 /* Predefined windows */
    screen[0] = screen[1] = 0;
    screen[2] = iisxsize - 1;
    screen[3] = iisysize - 1;
    iisdfw (0, screen, 1, ALLBITPL, ALLBITPL);
    iisdfw (1, screen, 2, ALLBITPL, ALLBITPL);
    iisdfw (2, screen, 4, ALLBITPL, ALLBITPL);
    iisdfw (3, screen, 8, ALLBITPL, ALLBITPL);

 /* Standard cursor */
    iiswda[0].cursor = cursor;
    iiswda[1].cursor = cursor;
    iiswda[2].cursor = cursor;
    iiswda[3].cursor = cursor;

 /* LUT  Assume monochrome */
    switch (iisdev) {
    case 1:
        lut = iiswda[0].lut;
        iishdr (hdr, IREAD + VRETRACE, 256, LUT, ADVXONTC, 0, 0, 1);
        iiswrite (hdr, 0, 0);
        iisread (lut, 512);
        lut = iiswda[1].lut;
        iishdr (hdr, IREAD + VRETRACE, 256, LUT, ADVXONTC, 0, 0, 2);
        iiswrite (hdr, 0, 0);
        iisread (lut, 512);
        lut = iiswda[2].lut;
        iishdr (hdr, IREAD + VRETRACE, 256, LUT, ADVXONTC, 0, 0, 4);
        iiswrite (hdr, 0, 0);
        iisread (lut, 512);
        lut = iiswda[3].lut;
        iishdr (hdr, IREAD + VRETRACE, 256, LUT, ADVXONTC, 0, 0, 8);
        iiswrite (hdr, 0, 0);
        iisread (lut, 512);

     /* Graphics maps */
        iisgmap (0, ALLBITPL, 0174037);
        iisgmap (1, ALLBITPL, 0174037);
        iisgmap (2, ALLBITPL, 0174037);
        iisgmap (3, ALLBITPL, 0174037);

     /* Output function map */
        iisomap ("m");

     /* Determine current frame */
        iishdr (hdr, IREAD + VRETRACE, 1, LUT + COMMAND, ADVXONTC, 0, 0, 0);
        iiswrite (hdr, 0, 0);
        iisread (&frame, 2);
        if (frame & 01)
	    iiswdw (0);
        else if (frame & 02)
	    iiswdw (1);
	else if (frame & 04)
	    iiswdw (2);
	else
	    iiswdw (3);

	break;
    case 2:

        iiscr(0,0,irpos);	/* read buttons to clear any inadvertent
					presses	*/

	/*LUT  Assume monochrome*/
	lut = iiswda[0].lut;
	iishdr(hdr, IREAD + VRETRACE, 256, LUT, 0, 0, 4, 1);
	iiswrite(hdr, 0, 0);
	iisread(lut, 512);
	lut = iiswda[1].lut;
	iishdr(hdr, IREAD + VRETRACE, 256, LUT, 0, 0, 4, 2);
	iiswrite(hdr, 0, 0);
	iisread(lut, 512);
	lut = iiswda[2].lut;
	iishdr(hdr, IREAD + VRETRACE, 256, LUT, 0, 0, 4, 4);
	iiswrite(hdr, 0, 0);
	iisread(lut, 512);
	lut = iiswda[3].lut;
	iishdr(hdr, IREAD + VRETRACE, 256, LUT, 0, 0, 4, 8);
	iiswrite(hdr, 0, 0);
	iisread(lut, 512);

                  			  	 /* NEW CODE */
/*
        I change the LUT loadings.  The above READS seem to make
        some assumption about the previous state of the Model 70, perhaps
        set by another routine.  To avoid this assumption I recompute
        the LUT's.   Also it is not proper to select 0 for ZREG as was done
        above.  This 0 selection will not work on the Model 75 and probably
        was meant to be the red channel (4) as changed above.
        Ask Frank Valdes what the above LUT loadings were suppose to do.
        The above reads are now totally meaningless and are preserved
        only to minimize changes.
*/
        mono[0] = 'w';  
        iismap(0, mono, 0, 255);
        iislut(0);
        iismap(1, mono, 0, 255);
        iislut(1);
        iismap(2, mono, 0, 255);
        iislut(2);
        iismap(3, mono, 0, 255);
        iislut(3);

/*     The following is needed to set up the Model 75.  */

/*	set Z+S for chan 15		*/

	words[0]=04000;
	words[1]=04000;

	iishdr(hdr, 0, 2, M75_ZOOM & SCROLL, 0, 0, 0177, 011001);
	iiswrite(hdr, words, 4);

        words[0] = 0;
        words[1] = 0;

/*
        Set Zoom and Scroll subunit registers so that Zoom = 0, 
        Wrap = 0, X and Y Scroll = 0.
*/
	iishdr(hdr, 0, 2, M75_ZOOM & SCROLL, 0, 0, 0377, 011001);
	iiswrite(hdr, words, 4);
       
/*
	Set Graphics subunit so that status plane is off and deselected,
        Region of Interest is not selected; Graphics, Video, and Cursor
        are on.
*/

	iishdr(hdr, 0, 1, COMMAND | GRAPHICS, 0, 0, 0, 0177777);
	iiswrite(hdr, words, 2);

        	                                 /* END NEW CODE */

	/*Graphics maps*/
	iisgmap(0, ALLBITPL, 0174037);
	iisgmap(1, ALLBITPL, 0174037);
	iisgmap(2, ALLBITPL, 0174037);
	iisgmap(3, ALLBITPL, 0174037);
/* 	load green into all but bit plane 0 
	iisgmap(0, ALLBITPL - BITPL0 , 0101740);
	iisgmap(1, ALLBITPL - BITPL0 , 0101740);
	iisgmap(2, ALLBITPL - BITPL0 , 0101740);
	iisgmap(3, ALLBITPL - BITPL0 , 0101740);
*/
	/*Output function map*/
	iisomap("m");

	/*Determine current frame*/
	iishdr(hdr, IREAD + VRETRACE, 1, LUT + COMMAND, 0, 0, 0, 0);
	iiswrite(hdr, 0, 0);
	iisread( &frame, 2);
	if (frame & 01) iiswdw(0);
	else if (frame & 02) iiswdw(1);
	else if (frame & 04) iiswdw(2);
	else iiswdw(3);

	break;
    case 3:
	iiswdw (0);
	break;
    }
}

/*Form iis header*/
iishdr (hdr, id, count, subunit, x, y, z, t)
short  *hdr;
int     id, count, subunit, x, y, z, t;
{
    hdr[XFERID] = id;
    hdr[THINGCT] = count;
    hdr[SUBUNIT] = subunit;
    hdr[XREG] = x;
    hdr[YREG] = y;
    hdr[ZREG] = z;
    hdr[TREG] = t;
}

/*Erase window*/
iiserase (window, type)
int     window;
char   *type;
{
    short   erase, hdr[8];
    short  *wdp, *hdp, *ghdp, i, dx;

    wdp = iiswda[window].wndw;
    hdp = iiswda[window].hdr;
    ghdp = iiswda[window].ghdr;
    dx = wdp[2] - wdp[0] + 1;
    erase = 0100000;
    switch (iisdev) {
    case 1:
        switch (type[0]) {
	case 'f': 
	    iishdr (hdr, IWRITE + BYPASSIFM + BYTE + BLOCKXFER + VRETRACE, 1,
		FEEDBACK, ADVXONTC, ADVYONXOV, hdp[ZREG], hdp[TREG]);
	    iiswrite (hdr, &erase, 2);
	    break;
	case 'F': 
	    iishdr (hdr, IWRITE + BYPASSIFM + BYTE + BLOCKXFER + VRETRACE, 1,
		 FEEDBACK, ADVXONTC, ADVYONXOV, ghdp[ZREG], ghdp[TREG]);
	    iiswrite (hdr, &erase, 2);
	    break;
	case 'w': 
	    for (i = wdp[1]; i <= wdp[3]; i++) {
		hdp[THINGCT] = -dx;
		hdp[XREG] = wdp[0] | ADVXONTC;
		hdp[YREG] = i | 0100000;
		iiswrite (hdp, iiszero, dx);
	    }
	    break;
	case 'W': 
	    for (i = wdp[1]; i <= wdp[3]; i++) {
		ghdp[THINGCT] = -dx;
		ghdp[XREG] = wdp[0] | ADVXONTC;
		ghdp[YREG] = i | 0100000;
		iiswrite (ghdp, iiszero, dx);
	    }
	    break;
	}
	break;
    case 2:
        switch (type[0]) {
	case 'f': 
	    iishdr (hdr, IWRITE + BYPASSIFM + BLOCKXFER + VRETRACE, 1,
		M75_FEEDBACK, 0, 0, hdp[ZREG], hdp[TREG]);
	    iiswrite (hdr, &erase, 2);
	    break;
	case 'F': 
	    iishdr (hdr, IWRITE + BYPASSIFM + BLOCKXFER + VRETRACE, 1,
		 M75_FEEDBACK, 0, 0, ghdp[ZREG], ghdp[TREG]);
	    iiswrite (hdr, &erase, 2);
	    break;
	case 'w': 
	    for (i = wdp[1]; i <= wdp[3]; i++) {
		hdp[THINGCT] = -dx;
		hdp[XREG] = wdp[0] | M75_ADVXONTC;
		hdp[YREG] = i | 0100000;
		iiswrite (hdp, iiszero, dx);
	    }
	    break;
	case 'W': 
	    for (i = wdp[1]; i <= wdp[3]; i++) {
		ghdp[THINGCT] = -dx;
		ghdp[XREG] = wdp[0] | M75_ADVXONTC;
		ghdp[YREG] = i | 0100000;
		iiswrite (ghdp, iiszero, dx);
	    }
	    break;
	}
	break;
    case 3:
        switch (type[0]) {
	case 'f': 
	    iishdr (hdr, fbconf - 1, 1,
		FEEDBACK, ADVXONTC, ADVYONXOV, hdp[ZREG], hdp[TREG]);
	    iiswrite (hdr, &erase, 2);
	    break;
	case 'w': 
	    for (i = wdp[1]; i <= wdp[3]; i++) {
		hdp[THINGCT] = -dx;
		hdp[XREG] = wdp[0] | ADVXONTC;
		hdp[YREG] = i | 0100000;
		iiswrite (hdp, iiszero, dx);
	    }
	    break;
	}
	lastwin = -1;
    }
}

/*Make window current*/
iiswdw (window)
int     window;
{

    if ((window >= NWDW) || (window < 0))
	iiserr (2);
    if (iiswda[window].hdr[6] == 0)
	focaserr (1, "iiswdw: Window not defined", "");
    iislut (window);
    iisgrf (window);
    iisetcr (window);
    iiszoom (window);
    iisframe (window);
    iiswdn = window;
}

/*Set window flag*/
iisflag (window, flag)
int     window;
int     flag;
{

    iiswda[window].flag = flag;
}



/*Define window n to interface package	*/
iisdfw (window, wdw, frame, bitpl, gbitpl)
int     window;			/* Window number of window being defined */
int     wdw[4];			/* Coord of window, upper left = (0, 0) */
int     frame;			/* Display frame */
int     bitpl;			/* Display bitplanes */
int     gbitpl;			/* Graphics bitplanes */
{
    register short  i;
    short  *wdp, *hdp, *ghp;

    if ((window >= NWDW) || (window < 0))
	iiserr (4);
    wdp = iiswda[window].wndw;
    hdp = iiswda[window].hdr;
    ghp = iiswda[window].ghdr;
    for (i = 0; i < 4; i++)
	wdp[i] = wdw[i];

    switch (iisdev) {
    case 1:
        iishdr (hdp, IWRITE + BYPASSIFM + PACKED, 0, REFRESH, 0, 0, frame,
	    bitpl);
        iishdr (ghp, IWRITE + BYPASSIFM + PACKED, 0, REFRESH, 0, 0, GRCHAN,
	    gbitpl);
	break;
    case 2:
	iishdr(hdp, IWRITE + BYPASSIFM + PACKED, 0,
           M75_ADVXONTC + M75_ADVYONXOV + REFRESH, 0, 0, frame, bitpl);
	iishdr(ghp, IWRITE + BYPASSIFM + PACKED, 0,
           M75_ADVXONTC + M75_ADVYONXOV + REFRESH, 0, 0, M75_GRCHAN, gbitpl);
	break;
    case 3:
        /* For IMTOOL define graphics frame the same as data frame */
        iishdr (hdp, IWRITE + BYPASSIFM + PACKED, 0, REFRESH, 0, 0, frame,
	    bitpl);
        iishdr (ghp, IWRITE + BYPASSIFM + PACKED, 0, REFRESH, 0, 0, frame,
	    gbitpl);
	break;
    }
    iisflag (window, 1);
}

/*Print error message*/
iiserr (n)
int     n;			/* Error message number */
{
    focaserr (n, "iisctrl: IIS interface error", "");
}

/*Write byte mode image data to iis (doesn't work)*/
iisbyte (window, x, y, an, pic)
int     x, y;			/* Starting point of image data relative to
				   window origin */
int     an;			/* Number of pixels in picture */
char   *pic;			/* Array containing an pixels */
int     window;			/* Window to write to */
{
    short  *wdp;
    int     xa, ya;
    char   *ps;

    wdp = iiswda[window].wndw;
    xa = x + wdp[0];
    ya = y + wdp[1];
    ps = pic;

    if ((xa > wdp[2]) || (xa + an < wdp[0]) || (ya > wdp[3]) || (ya < wdp[1]));
    else {
	if (x < 0) {
	    ps -= x;
	    an += x;
	    xa -= x;
	}
	if (an > wdp[2] - xa + 1)
	    an = wdp[2] - xa + 1;
	if (iiswda[window].flag & 01) {
	    iiswda[window].hdr[XFERID] = IWRITE + BYPASSIFM + PACKED + BYTE;
	    iiswda[window].hdr[THINGCT] = -an;
	    iiswda[window].hdr[XREG] = xa;
	    iiswda[window].hdr[YREG] = ya | 0100000;
	    iiswrite (iiswda[window].hdr, ps, an);
	    iiswda[window].hdr[XFERID] = IWRITE + BYPASSIFM + PACKED;
	}
	if (iiswda[window].flag & 02) {
	    iiswda[window].ghdr[XFERID] = IWRITE + BYPASSIFM + PACKED + BYTE;
	    iiswda[window].ghdr[THINGCT] = -an;
	    iiswda[window].ghdr[XREG] = xa;
	    iiswda[window].ghdr[YREG] = ya | 0100000;
	    iiswrite (iiswda[window].ghdr, ps, an);
	    iiswda[window].hdr[XFERID] = IWRITE + BYPASSIFM + PACKED;
	}
    }
}

/*Write byte image data to iis.  This differs from iisline in that it does
  not check for out of bounds but uses wrap around instead to transmit a
  block of data.  It is the callers responsibility to manage the window. */
iisblock (window, x, y, an, pic)
int     x, y;			/* Starting point of image data relative to
				   window origin */
int     an;			/* Number of pixels in picture */
char   *pic;			/* Array containing an pixels */
int     window;			/* Window to write to */
{
    switch (iisdev) {
    case 1:
    case 3:
	if (iiswda[window].flag & 01) {
	    iiswda[window].hdr[THINGCT] = -an;
	    iiswda[window].hdr[XREG] = x | ADVXONTC;
	    iiswda[window].hdr[YREG] = y | 0100000;
	    iiswrite (iiswda[window].hdr, pic, an);
	}
	if (iiswda[window].flag & 02) {
	    iiswda[window].ghdr[THINGCT] = -an;
	    iiswda[window].ghdr[XREG] = x | ADVXONTC;
	    iiswda[window].ghdr[YREG] = y | 0100000;
	    iiswrite (iiswda[window].ghdr, pic, an);
	}
	break;
    case 2:
	if(graphics_on == 'y') {
	    iiswda[window].ghdr[THINGCT] = -an;
	    iiswda[window].ghdr[XREG] = x;
	    iiswda[window].ghdr[YREG] = y;
	    if(an == 1)
		an = 2;
	    iiswrite(iiswda[window].ghdr, pic, an);
	} else {
	    if (iiswda[window].flag & 01) {
		iiswda[window].hdr[THINGCT] = -an;
		iiswda[window].hdr[XREG] = x;
		iiswda[window].hdr[YREG] = y;
		if(an == 1)
		    an = 2;
		iiswrite(iiswda[window].hdr, pic, an);
	    }
	    if (iiswda[window].flag & 02) {
		iiswda[window].ghdr[THINGCT] = -an;
		iiswda[window].ghdr[XREG] = x;
		iiswda[window].ghdr[YREG] = y;
		if(an == 1)
		    an = 2;
		iiswrite(iiswda[window].ghdr, pic, an);
	    }
	}
	break;
    }
}

/*Write byte image data to iis	*/
iisline (window, x, y, an, pic)
int     x, y;			/* Starting point of image data relative to
				   window origin */
int     an;			/* Number of pixels in picture */
char   *pic;			/* Array containing an pixels */
int     window;			/* Window to write to */
{
    short  *wdp;
    int     xa, ya;
    char   *ps;

    wdp = iiswda[window].wndw;
    xa = x + wdp[0];
    ya = y + wdp[1];
    ps = pic;

    if ((xa > wdp[2]) || (xa + an < wdp[0]) || (ya > wdp[3]) || (ya < wdp[1]))
	;
    else {
	if (x < 0) {
	    ps -= x;
	    an += x;
	    xa -= x;
	}
	if (an > wdp[2] - xa + 1)
	    an = wdp[2] - xa + 1;
	switch (iisdev) {
	case 1:
	case 3:
	    if (iiswda[window].flag & 01) {
	        iiswda[window].hdr[THINGCT] = -an;
	        iiswda[window].hdr[XREG] = xa | ADVXONTC;
	        iiswda[window].hdr[YREG] = ya | 0100000;
	        iiswrite (iiswda[window].hdr, ps, an);
	    }
	    if (iiswda[window].flag & 02) {
	        iiswda[window].ghdr[THINGCT] = -an;
	        iiswda[window].ghdr[XREG] = xa | ADVXONTC;
	        iiswda[window].ghdr[YREG] = ya | 0100000;
	        iiswrite (iiswda[window].ghdr, ps, an);
	    }
	    break;
	case 2:
	    if(graphics_on == 'y') {
		iiswda[window].ghdr[THINGCT] = -an;
		iiswda[window].ghdr[XREG] = xa;
		iiswda[window].ghdr[YREG] = ya;
		if(an == 1)
		    an = 2;
		iiswrite(iiswda[window].ghdr, ps, an);
	    } else {
		if (iiswda[window].flag & 01) {
		    iiswda[window].hdr[THINGCT] = -an;
		    iiswda[window].hdr[XREG] = xa;
		    iiswda[window].hdr[YREG] = ya;
		    if(an == 1)
			an = 2;
		    iiswrite(iiswda[window].hdr, ps, an);
		}
		if (iiswda[window].flag & 02) {
		    iiswda[window].ghdr[THINGCT] = -an;
		    iiswda[window].ghdr[XREG] = xa;
		    iiswda[window].ghdr[YREG] = ya;
		    if(an == 1)
			an = 2;
		    iiswrite(iiswda[window].ghdr, ps, an);
		}
	    }
	    break;
        }
    }
}

/*Read byte image data from iis	*/
iisrline (window, x, y, an, pic)
int     x, y;			/* Starting point of image data relative to
				   window origin */
int     an;			/* Number of pixels in picture */
char   *pic;			/* Array containing an pixels */
int     window;			/* Window to write to */
{
    short  *wdp, hdr[8];
    int     xa, ya, frame;
    char   *ps;

    wdp = iiswda[window].wndw;
    xa = x + wdp[0];
    ya = y + wdp[1];
    ps = pic;

    if ((xa > wdp[2]) || (xa + an < wdp[0]) || (ya > wdp[3]) || (ya < wdp[1]))
	;
    else {
	if (x < 0) {
	    ps -= x;
	    an += x;
	    xa -= x;
	}
	if (an > wdp[2] - xa + 1)
	    an = wdp[2] - xa + 1;
	switch (iisdev) {
	case 1:
	case 2:
	    fprintf (stderr, "iisgline: Reading from IIS not implemented\n");
	    break;
	case 3:
	    if (iiswda[window].flag & 01)
	        frame = iiswda[window].hdr[ZREG];
	    if (iiswda[window].flag & 02)
	        frame = iiswda[window].ghdr[ZREG];

            iishdr (hdr, IREAD + PACKED, -an, REFRESH, xa, ya, frame, 0);
	    iiswrite (hdr, 0, 0);
	    iisread (ps, an);
	    break;
        }
    }
}

/*Set current frame*/
iisframe (window)
int     window;
{
    short   buffer[12];
    short   hdr[8], frame;

    frame = iiswda[window].hdr[ZREG];
    switch (iisdev) {
    case 1:
    case 3:
        iishdr (hdr, IWRITE + VRETRACE, -12, COMMAND + LUT, ADVXONTC, 0, 0, 0);
        buffer[0] = buffer[1] = buffer[2] = buffer[3] = frame;
        buffer[4] = buffer[5] = buffer[6] = buffer[7] = frame;
        buffer[8] = buffer[9] = buffer[10] = buffer[11] = frame;
        iiswrite (hdr, buffer, 24);
        break;
    case 2:
	/* For the following to work we rely upon a 28 word transfer of zero
           to the LUT's during initialization.  */
	iishdr(hdr, IWRITE + VRETRACE, -12, COMMAND + LUT, 0, 0, 0, 0);
	buffer[ 0] = buffer[ 1] = buffer[ 2] = buffer[ 3] = frame;
	buffer[ 4] = buffer[ 5] = buffer[ 6] = buffer[ 7] = frame;
	buffer[ 8] = buffer[ 9] = buffer[10] = buffer[11] = frame;
	iiswrite(hdr, buffer, 24);
	break;
    }
}

/*Load lut to current window*/
iislut (window)
int     window;
{
    short  *hdp, hdr[8];
    short  *lut;

    if (iisdev == 3)
	return;

    hdp = iiswda[window].hdr;
    lut = iiswda[window].lut;

    switch (iisdev) {
    case 1:
        iishdr (hdr, IWRITE + VRETRACE, 256, LUT, ADVXONTC, 0,
	    RED + GREEN + BLUE, (int) hdp[ZREG]);
        iiswrite (hdr, lut, 512);
	break;
    case 2:
	iishdr(hdr, IWRITE + VRETRACE, 256, LUT, 0, 0,
	    RED + GREEN + BLUE, (int)hdp[ZREG]);
	iiswrite(hdr, lut, 512);
	break;
    }
}

iisgrf (window)
int     window;
{
    short   hdr[8], *glut, glut2[512];
    int i;

    switch (iisdev) {
    case 1:
        glut = iiswda[window].glut;
        iishdr (hdr, IWRITE + VRETRACE, 256, GRAPHICS, ADVXONTC, 0, 0, 0);
        iiswrite (hdr, glut, 512);
	break;
    case 2:
	glut = iiswda[window].glut;
	iishdr(hdr, IWRITE + VRETRACE, 512, GRAPHICS, 0, 0, 0, 0);
	for(i=0;i<127;i++){
		glut2[i]= *(glut + i);
		glut2[i+128] =   *(glut + i);
		glut2[i+256] = *(glut + i + 128);
		glut2[i+256+128] =  *(glut + i + 128);
	}
	iiswrite(hdr, glut2, 1024);
	break;
    }
}

/*Write monochrome map in one data transfer*/
iisofm1 (table)
short  *table;
{
    short   hdr[8];

    switch (iisdev) {
    case 1:
        iishdr (hdr, IWRITE + VRETRACE, 1024, OFM, ADVXONTC, ADVYONXOV, 7, 0);
        iiswrite (hdr, table, 2048);
	break;
    case 2:
	iishdr(hdr, IWRITE + VRETRACE, 1024, OFM, 0, 0, 7, 0);
	iiswrite(hdr, table, 2048);
	break;
    }
}


/*Write three lut's to ofm in three data transfers*/
iisofm (red, green, blue)
short  *red, *green, *blue;
{
    short   hdr[8];

    switch (iisdev) {
    case 1:
        iishdr (hdr, IWRITE + VRETRACE, 1024, OFM, ADVXONTC, ADVYONXOV, BLUE,
	    0);
        iiswrite (hdr, blue, 2048);

        iishdr (hdr, IWRITE + VRETRACE, 1024, OFM, ADVXONTC, ADVYONXOV, GREEN,
	    0);
        iiswrite (hdr, green, 2048);

        iishdr (hdr, IWRITE + VRETRACE, 1024, OFM, ADVXONTC, ADVYONXOV, RED,
	    0);
        iiswrite (hdr, red, 2048);
	break;
    case 2:
	iishdr (hdr, IWRITE + VRETRACE, 1024, OFM, 0, 0, BLUE, 0);
	iiswrite (hdr, blue, 2048);

	iishdr (hdr, IWRITE + VRETRACE, 1024, OFM, 0, 0, GREEN, 0);
	iiswrite (hdr, green, 2048);

	iishdr (hdr, IWRITE + VRETRACE, 1024, OFM, 0, 0, RED, 0);
	iiswrite (hdr, red, 2048);
	break;
    }
}

/*Switch iis functions*/
iiswitch (window, mode)
int     window;
char    mode;
/* Bit 0 - cursor */
/* Bit 1 - zoom */
{

 /* Cursor */
    if (mode & 01) {
	if (iiswda[window].cursor.on)
	    iiswda[window].cursor.on = 0;
	else
	    iiswda[window].cursor.on = 1;
	iisetcr (window);
    }
 /* Zoom */
    if (iisdev == 3)
	return;
    if (mode & 02) {
	iiswda[window].zoom[0] = (iiswda[window].zoom[0] + 1) % 4;
	iiszoom (window);
    }
}

/*
*	Set up LUT's to get true color image from memory planes window, window+1
*	and window+2
*/
ciisframe(window)
int	window;
{
	short	buffer[12];
	short	hdr[8], frame;

	if (iisdev == 3)
	    return;

	frame = iiswda[window].hdr[ZREG];

	/* For the following to work we rely upon a 28 word transfer of zero */
        /* to the LUT's during initialization.  */
	iishdr(hdr, IWRITE + VRETRACE, -12, COMMAND + LUT, 0, 0, 0, 0);

	/* red */
	buffer[ 8] = buffer[ 9] = buffer[10] = buffer[11] = frame;

	/* green */
	frame = (frame<<1);
	buffer[ 4] = buffer[ 5] = buffer[ 6] = buffer[ 7] = frame;

	/* blue */
	frame = (frame<<1);
	buffer[ 0] = buffer[ 1] = buffer[ 2] = buffer[ 3] = frame;

	iiswrite(hdr, buffer, 24);
}

/*Load color lut to OFMs */
ciisofm()
{
	short lutb[1024], lutr[1024], lutg[1024];
	short	*hdp, hdr[8];
	short	*lut;
	int ii,i,j;

	if (iisdev == 3)
	    return;

	for(i = 0;i < 7; i++){
		lutb[i] = i;
		lutg[i] = 0;
		lutr[i] = 0;
	}
	for(j = 0, ii = i; ii >= 1; ii--){
		lutb[i] = ii;
		lutr[i] = j;
		lutg[i] = 0;
		j++;
		i++;
		lutb[i] = ii;
		lutr[i] = j;
		lutg[i] = 0;
		j++;
		i++;
		lutb[i] = ii;
		lutr[i] = j;
		lutg[i] = 0;
		i++;
	}
	lutb[i] = lutb[i - 1];
	lutr[i] = lutr[i - 1];
	lutg[i] = lutg[i - 1];
	i++;
	lutb[i] = 0;
	lutr[i] = 0xE;
	lutg[i] = 0;
	i++;
	lutb[i] = 0;
	lutr[i] = 0xE;
	lutg[i] = 0;
	i++;
	for(ii = 0; ii <= 0xE; ii++){
		lutb[i] = 0;
		lutg[i] = ii;
		lutr[i] = 0xF;
		i++;
		lutb[i] = 0;
		lutg[i] = ii;
		lutr[i] = 0xF;
		i++;
	}
	for(ii = 0; ii <= 0xF; ii++){
		lutb[i] = ii;
		lutr[i] = 0xF;
		lutg[i] = 0xF;
		i++;
		lutb[i] = ii;
		lutr[i] = 0xF;
		lutg[i] = 0xF;
		i++;
		lutb[i] = ii;
		lutr[i] = 0xF;
		lutg[i] = 0xF;
		i++;
	}
	
	/* fill in rest of table with FFF	*/
	for(ii = i - 1;i < 1024;i++ ){
		lutb[i] = lutb[ii];
		lutr[i] = lutr[ii];
		lutg[i] = lutg[ii];
	}	
	for(i = 0;i < 1024;i++){
		lutb[i] *= 16;
		lutr[i] *= 16;
		lutg[i] *= 16;
	}	
	
	iisofm(lutr, lutg, lutb);
}

/*Load color lut to OFMs */
rciisofm()
{
	short lutb[1024], lutr[1024], lutg[1024];
	short	*hdp, hdr[8];
	short	*lut;
	int ii,i,j;
	char filename[40];
	FILE *fp;

	if (iisdev == 3)
	    return;

	fprintf(stderr,"Enter color table filename: ");
	scanf("%s",filename);
	fp=fopen(filename,"r");
	for(i = 0;i < 512; i++){
		fscanf(fp,"%d %d %d",&lutb[i],&lutg[i],&lutr[i]);
	}

	for(i = 512;i < 1024; i++){
		lutb[i] = lutb[511];
		lutg[i] = lutg[511];
		lutr[i] = lutr[511];
	}
	
	iisofm(lutr, lutg, lutb);
}

/* IISWWCS - Write WCS info. */
iiswwcs (window, image, title, a, b, c, d, tx, ty, z1, z2, zt)
int     window;
char	*image;
char	*title;
float	a, b, c, d, tx, ty, z1, z2;
int	zt;
{
    char    wcs[256];
    short   hdr[8], *hdp;

    switch (iisdev) {
    case 1:
    case 2:
	break;
    case 3:
	sprintf (wcs, "%s - %s\n%f %f %f %f %f %f %f %f %d",
	    image, title, a, b, c, d, tx, ty+1, z1, z2, zt);
        hdp = iiswda[window].hdr;
	iishdr (hdr, IWRITE+PACKED, 256, WCS, 0, 0, hdp[ZREG], fbconf - 1);
	iiswrite (hdr, wcs, 256);
	break;
    }
}