/*
 * Source generated with ARexxBox 1.12 (May 18 1993)
 * which is Copyright (c) 1992,1993 Michael Balzer
 */

#define LATTICE

#include <exec/types.h>
#include <exec/memory.h>
#include <dos/dos.h>
#include <rexx/storage.h>
#include <rexx/rxslib.h>

#ifdef __GNUC__
/* GCC needs all struct defs */
#include <dos/exall.h>
#include <graphics/graphint.h>
#include <intuition/classes.h>
#include <devices/keymap.h>
#include <exec/semaphores.h>
#endif

#include <clib/alib_protos.h>
#include <clib/exec_protos.h>
#include <clib/dos_protos.h>
#include <clib/rexxsyslib_protos.h>

#ifndef __NO_PRAGMAS

#ifdef AZTEC_C
#include <pragmas/exec_lib.h>
#include <pragmas/dos_lib.h>
#include <pragmas/rexxsyslib_lib.h>
#endif

#ifdef LATTICE
#include <pragmas/exec_pragmas.h>
#include <pragmas/dos_pragmas.h>
#include <pragmas/rexxsyslib_pragmas.h>
#endif

#endif /* __NO_PRAGMAS */

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

#ifdef LATTICE
#undef toupper
#define inline __inline
#endif

#ifdef __GNUC__
#undef toupper
static inline char toupper( char c )
{
	return( islower(c) ? c - 'a' + 'A' : c );
}
#endif

#ifdef AZTEC_C
#define inline
#endif

#include "TeXPrtRexx.h"
#include "TeXPrt_protos.h"


/* $ARB: I 739658785 */


/* $ARB: B 1 CONFIG */
void rx_config( struct RexxHost *host, struct rxd_config **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_config *rd = *rxd;
	char              *temp;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
			if( rd = *rxd )
			   {
            temp = calloc (FMSIZE, 1);
			   }
			break;

		case RXIF_ACTION:
 			rd->rc = 2;

			if ((*rxd)->arg.save)
            rd->rc = !SaveDriverSpec (TeXDriver.MenuItem, ((struct ARexxSupport *)host->userdata)->Gadgets);

         if ((*(*rxd)->arg.saveas) && temp)
            {
            stpcpy (temp, Drivers.DriverFiles);
            stpcpy (Drivers.DriverFiles, (*rxd)->arg.saveas);
            rd->rc = !SaveDriverSpec (0, ((struct ARexxSupport *)host->userdata)->Gadgets);
            stpcpy (Drivers.DriverFiles, temp);
            }
			break;

		case RXIF_FREE:
			FreeVec( rd );
			free (temp);
			break;
	}
	return;
}
/* $ARB: E 1 CONFIG */

/* $ARB: B 2 COPIES */
void rx_copies( struct RexxHost *host, struct rxd_copies **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_copies *rd = *rxd;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
			if( rd = *rxd )
			{
				/* set your DEFAULTS here */
			}
			break;

		case RXIF_ACTION:
			if (*((*rxd)->arg.number) > 0)
			   {
   			GT_SetGadgetAttrs (((struct ARexxSupport *)host->userdata)->Gadgets[ID_NO_COPIES],
                               Window, NULL, GTIN_Number, *((*rxd)->arg.number), TAG_END);
   			rd->rc = 0;
   			}
         else
            rd->rc = 2;
			break;

		case RXIF_FREE:
			/* FREE your local data here */
			FreeVec( rd );
			break;
	}
	return;
}
/* $ARB: E 2 COPIES */

/* $ARB: B 3 FROM_TO */
void rx_from_to( struct RexxHost *host, struct rxd_from_to **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_from_to *rd = *rxd;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
			if( rd = *rxd )
			{
				/* set your DEFAULTS here */
			}
			break;

		case RXIF_ACTION:
		   if ((*rxd)->arg.document)
            TeXDriver.act_Orientation = DOCUMENT;
         else
            {
            TeXDriver.act_Orientation = FROMTO;
    			GT_SetGadgetAttrs (((struct ARexxSupport *)host->userdata)->Gadgets[ID_FROM_PAGE],
                               Window, NULL, GTIN_Number, *((*rxd)->arg.from), TAG_END);
 		   	GT_SetGadgetAttrs (((struct ARexxSupport *)host->userdata)->Gadgets[ID_TO_PAGE],
                               Window, NULL, GTIN_Number, *((*rxd)->arg.to), TAG_END);
            }

         GT_SetGadgetAttrs (((struct ARexxSupport *)host->userdata)->Gadgets[ID_PAGESEL], Window, NULL,
                            GTMX_Active, TeXDriver.act_Orientation, TAG_END, NULL);
			rd->rc = 0;
			break;

		case RXIF_FREE:
			/* FREE your local data here */
			FreeVec( rd );
			break;
	}
	return;
}
/* $ARB: E 3 FROM_TO */

/* $ARB: B 4 HOFFSET */
void rx_hoffset( struct RexxHost *host, struct rxd_hoffset **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_hoffset *rd = *rxd;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
			if( rd = *rxd )
			{
				/* set your DEFAULTS here */
			}
			break;

		case RXIF_ACTION:
 			GT_SetGadgetAttrs (((struct ARexxSupport *)host->userdata)->Gadgets[ID_HOFFSET],
                            Window, NULL, GTIN_Number, *((*rxd)->arg.mm), TAG_END);
			rd->rc = 0;
			break;

		case RXIF_FREE:
			/* FREE your local data here */
			FreeVec( rd );
			break;
	}
	return;
}
/* $ARB: E 4 HOFFSET */

/* $ARB: B 7 ORIENTATION */
void rx_orientation( struct RexxHost *host, struct rxd_orientation **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_orientation *rd = *rxd;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
			if( rd = *rxd )
			{
				/* set your DEFAULTS here */
			}
			break;

		case RXIF_ACTION:
         if ((*rxd)->arg.portrait)
            TeXDriver.act_Orientation = PORTRAIT;
         else
            TeXDriver.act_Orientation = LANDSCAPE;

         GT_SetGadgetAttrs (((struct ARexxSupport *)host->userdata)->Gadgets[ID_ORIENTATION], Window, NULL,
                            GTMX_Active, TeXDriver.act_Orientation, TAG_END, NULL);
			rd->rc = 0;
			break;

		case RXIF_FREE:
			/* FREE your local data here */
			FreeVec( rd );
			break;
	}
	return;
}
/* $ARB: E 7 ORIENTATION */

/* $ARB: B 8 PAGES */
void rx_pages( struct RexxHost *host, struct rxd_pages **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_pages *rd = *rxd;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
			if( rd = *rxd )
			{
				/* set your DEFAULTS here */
			}
			break;

		case RXIF_ACTION:
         if ((*rxd)->arg.all)
            TeXDriver.act_PageType = ALL;
         if ((*rxd)->arg.odd)
            TeXDriver.act_PageType = ODD;
         if ((*rxd)->arg.even)
            TeXDriver.act_PageType = EVEN;

         GT_SetGadgetAttrs (((struct ARexxSupport *)host->userdata)->Gadgets[ID_PAGETYPE], Window, NULL,
                            GTMX_Active, TeXDriver.act_PageType, TAG_END, NULL);
			break;

		case RXIF_FREE:
			/* FREE your local data here */
			FreeVec( rd );
			break;
	}
	return;
}
/* $ARB: E 8 PAGES */

/* $ARB: B 9 PRINT */
void rx_print( struct RexxHost *host, struct rxd_print **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_print *rd = *rxd;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
			break;

		case RXIF_ACTION:
            CallPrinterDriver (((struct ARexxSupport *)host->userdata)->Gadgets, FALSE);
   			rd->rc = 0;
			break;

		case RXIF_FREE:
			/* FREE your local data here */
			FreeVec( rd );
			break;
	}
	return;
}
/* $ARB: E 9 PRINT */

/* $ARB: B 10 QUIT */
void rx_quit( struct RexxHost *host, struct rxd_quit **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_quit *rd = *rxd;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
			if( rd = *rxd )
			{
				/* set your DEFAULTS here */
			}
			break;
			
		case RXIF_ACTION:
         if ((*rxd)->arg.force)
            Status.Exit = TRUE;
         else
            Status.Exit = EasyRequest (Window, &QuitReq, &IDCMPFlag, NULL);
			rd->rc = 0;
			break;

		case RXIF_FREE:
			/* FREE your local data here */
			FreeVec( rd );
			break;
	}
	return;
}
/* $ARB: E 10 QUIT */

/* $ARB: B 11 VOFFSET */
void rx_voffset( struct RexxHost *host, struct rxd_voffset **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_voffset *rd = *rxd;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
			if( rd = *rxd )
			{
				/* set your DEFAULTS here */
			}
			break;

		case RXIF_ACTION:
			/* Insert your CODE here */
 			GT_SetGadgetAttrs (((struct ARexxSupport *)host->userdata)->Gadgets[ID_VOFFSET],
                            Window, NULL, GTIN_Number, *((*rxd)->arg.mm), TAG_END);
			rd->rc = 0;
			break;

		case RXIF_FREE:
			/* FREE your local data here */
			FreeVec( rd );
			break;
	}
	return;
}
/* $ARB: E 11 VOFFSET */

/* $ARB: B 12 OPTION1 */
void rx_option1( struct RexxHost *host, struct rxd_option1 **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_option1 *rd = *rxd;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
			if( rd = *rxd )
			{
				/* set your DEFAULTS here */
			}
			break;

		case RXIF_ACTION:
		   if (!(((struct ARexxSupport *)host->userdata)->Gadgets[ID_OPT_1]->Flags & GFLG_DISABLED))
            GT_SetGadgetAttrs (((struct ARexxSupport *)host->userdata)->Gadgets[ID_OPT_1],
                               Window, NULL, GTCB_Checked, (*rxd)->arg.on, TAG_END);
			rd->rc = 0;
			break;

		case RXIF_FREE:
			/* FREE your local data here */
			FreeVec( rd );
			break;
	}
	return;
}
/* $ARB: E 12 OPTION1 */

/* $ARB: B 13 OPTION2 */
void rx_option2( struct RexxHost *host, struct rxd_option2 **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_option2 *rd = *rxd;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
			if( rd = *rxd )
			{
				/* set your DEFAULTS here */
			}
			break;

		case RXIF_ACTION:
		   if (!(((struct ARexxSupport *)host->userdata)->Gadgets[ID_OPT_2]->Flags & GFLG_DISABLED))
            GT_SetGadgetAttrs (((struct ARexxSupport *)host->userdata)->Gadgets[ID_OPT_2],
                               Window, NULL, GTCB_Checked, (*rxd)->arg.on, TAG_END);
			rd->rc = 0;
			break;

		case RXIF_FREE:
			/* FREE your local data here */
			FreeVec( rd );
			break;
	}
	return;
}
/* $ARB: E 13 OPTION2 */

/* $ARB: B 14 OPTION3 */
void rx_option3( struct RexxHost *host, struct rxd_option3 **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_option3 *rd = *rxd;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
			if( rd = *rxd )
			{
				/* set your DEFAULTS here */
			}
			break;

		case RXIF_ACTION:
		   if (!(((struct ARexxSupport *)host->userdata)->Gadgets[ID_OPT_3]->Flags & GFLG_DISABLED))
            GT_SetGadgetAttrs (((struct ARexxSupport *)host->userdata)->Gadgets[ID_OPT_3],
                               Window, NULL, GTCB_Checked, (*rxd)->arg.on, TAG_END);
			rd->rc = 0;
			break;

		case RXIF_FREE:
			/* FREE your local data here */
			FreeVec( rd );
			break;
	}
	return;
}
/* $ARB: E 14 OPTION3 */

/* $ARB: B 15 OPTION4 */
void rx_option4( struct RexxHost *host, struct rxd_option4 **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_option4 *rd = *rxd;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
			if( rd = *rxd )
			{
				/* set your DEFAULTS here */
			}
			break;

		case RXIF_ACTION:
		   if (!(((struct ARexxSupport *)host->userdata)->Gadgets[ID_OPT_4]->Flags & GFLG_DISABLED))
            GT_SetGadgetAttrs (((struct ARexxSupport *)host->userdata)->Gadgets[ID_OPT_4],
                               Window, NULL, GTCB_Checked, (*rxd)->arg.on, TAG_END);
			rd->rc = 0;
			break;

		case RXIF_FREE:
			/* FREE your local data here */
			FreeVec( rd );
			break;
	}
	return;
}
/* $ARB: E 15 OPTION4 */

/* $ARB: B 16 DVIFILE */
void rx_dvifile( struct RexxHost *host, struct rxd_dvifile **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_dvifile *rd = *rxd;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
			if( rd = *rxd )
			{
				/* set your DEFAULTS here */
			}
			break;

		case RXIF_ACTION:
         stpcpy (Args.ArgStr[KW_FILE], (*rxd)->arg.file);
         GT_SetGadgetAttrs (((struct ARexxSupport *)host->userdata)->Gadgets[ID_DVIFILE], Window, NULL,
                            GTST_String, Args.ArgStr[KW_FILE], TAG_END, NULL);
			rd->rc = 0;
			break;

		case RXIF_FREE:
			/* FREE your local data here */
			FreeVec( rd );
			break;
	}
	return;
}
/* $ARB: E 16 DVIFILE */

/* $ARB: B 17 TOFRONT */
void rx_tofront( struct RexxHost *host, struct rxd_tofront **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_tofront *rd = *rxd;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
			break;

		case RXIF_ACTION:
		   WindowToFront (Window);

		   if (PubScreen)
            ScreenToFront (PubScreen);
         else
            WBenchToFront ();

			rd->rc = 0;
			break;

		case RXIF_FREE:
			/* FREE your local data here */
			FreeVec( rd );
			break;
	}
	return;
}
/* $ARB: E 17 TOFRONT */

/* $ARB: B 18 TOBACK */
void rx_toback( struct RexxHost *host, struct rxd_toback **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_toback *rd = *rxd;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
			break;

		case RXIF_ACTION:
		   WindowToBack (Window);

		   if (PubScreen)
            ScreenToBack (PubScreen);
         else
            WBenchToBack ();

			rd->rc = 0;
			break;

		case RXIF_FREE:
			/* FREE your local data here */
			FreeVec( rd );
			break;
	}
	return;
}
/* $ARB: E 18 TOBACK */

/* $ARB: B 19 DRIVER */
void rx_driver( struct RexxHost *host, struct rxd_driver **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_driver *rd = *rxd;
	struct Menu       *pMenu;
	struct MenuItem   *pMenuItem;
	long               ItemNumber;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
			if( rd = *rxd )
			{
				/* set your DEFAULTS here */
			}
			break;

		case RXIF_ACTION:
         if ((*((*rxd)->arg.number) >= 1) && (*((*rxd)->arg.number) <= Drivers.NoOfDrivers))
            {
            ClearMenuStrip (Window);
            pMenu = Menu->NextMenu;       // pointer to the Drivers menu
            TeXDriver.MenuItem = *((*rxd)->arg.number);
            for (pMenuItem = pMenu->FirstItem, ItemNumber = 1; pMenuItem != NULL; pMenuItem = pMenuItem->NextItem, ItemNumber++)
               if (*((*rxd)->arg.number) == ItemNumber)
                  pMenuItem->Flags |= CHECKED;
               else
                  pMenuItem->Flags &= ~CHECKED;
            SetMenuStrip (Window, Menu);
   			rd->rc = 0;
   			}
   		else
   		   rd->rc = 2;
			break;

		case RXIF_FREE:
			/* FREE your local data here */
			FreeVec( rd );
			break;
	}
	return;
}
/* $ARB: E 19 DRIVER */


/* $ARB: B 20 REVERSE */
void rx_reverse( struct RexxHost *host, struct rxd_reverse **rxd, long action, struct RexxMsg *rexxmsg )
{
	struct rxd_reverse *rd = *rxd;

	switch( action )
	{
		case RXIF_INIT:
			*rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
			break;

		case RXIF_ACTION:
         GT_SetGadgetAttrs (((struct ARexxSupport *)host->userdata)->Gadgets[ID_REVERSE],
                            Window, NULL, GTCB_Checked, (*rxd)->arg.on, TAG_END);
			rd->rc = 0;
			break;

		case RXIF_FREE:
			/* FREE your local data here */
			FreeVec( rd );
			break;
	}
	return;
}
/* $ARB: E 20 REVERSE */


#ifndef RX_ALIAS_C
char *ExpandRXCommand( struct RexxHost *host, char *command )
{
	/* Insert your ALIAS-HANDLER here */
	return( NULL );
}
#endif