/***************************************************************************
 *                                                                         *
 *  Filename : Process.c                                                   *
 *                                                                         *
 *  Description : Processing routines for user inputs.                     *
 *                                                                         *
 ***************************************************************************
 *                                                                         *
 *                         Modification History                            *
 *                                                                         *
 *  Date      Author       Comments                                        *
 * ----------------------------------------------------------------------  *
 * 10.6.93    R.Bödi       Created.                                        *
 *                                                                         *
 ***************************************************************************
 *                                                                         *
 * Copyright © 1993 Richard Bödi,  All rights reserved.                    *
 *                                                                         *
 ***************************************************************************/

/*----------------------------- INCLUDES ----------------------------------*/

#include "TeXPrt.h"
#include "TexPrt_protos.h"
#include "TexPrt_globals.h"
#include "TeXPrtRexx.h"

/*-------------------------- GLOBAL DATA ----------------------------------*/

struct FileRequester   *FileRequester;

/*------------------------------- CODE ------------------------------------*/


/***************************************************************************
 *                                                                         *
 *  Function name : ProcessIDCMP                                           *
 *                                                                         *
 *  Description : Tests window's IDCMP port for incoming messages.         *
 *                This function returns if the window close gaget or the   *
 *                CANCEL gadget was activated.                             *
 *                                                                         *
 ***************************************************************************
 *                                                                         *
 *  Synopsis : ProcessIDCMP (Signals, Gadgets)                             *
 *                                                                         *
 *  Parameters :                                                           *
 *       (long *) Signals : Array of signals to listen to.                 *
 *                          Number of signals is specified by LAST_SIG,    *
 *                          see TeXPrt.h.                                  *
 *       (struct Gadget **) Gadgets : Pointer array for the window's       *
 *                                    gadgets.                             *
 *                                                                         *
 *  Return value : None                                                    *
 *                                                                         *
 ***************************************************************************/

void ProcessIDCMP (long *Signals, struct Gadget **Gadgets)

{
long                 Signal;
ULONG                IClass;
UWORD                ICode;
struct IntuiMessage *IMsg;
struct AppMessage   *AMsg;
struct Gadget       *Gadget;
struct ARexxSupport  ARexxSupp;
char                 Buffer[FMSIZE];


while (!Status.Exit)
   {
   Signal = Wait (Signals[SIG_WINDOW] | Signals[SIG_APP] | Signals[SIG_AREXX]);

   if (Signal == Signals[SIG_WINDOW])
      {
      Status.ARexx = FALSE;

      while (IMsg = GT_GetIMsg (Window->UserPort))
         {
         IClass  = IMsg->Class;
         ICode   = IMsg->Code;

         GT_ReplyIMsg (IMsg);

         switch (IClass)
            {
            case IDCMP_GADGETUP:
            case IDCMP_GADGETDOWN:
               Gadget = (struct Gadget *) IMsg->IAddress;
               HandleGadgetEvent (ICode, Gadget, Gadgets);
               break;

            case IDCMP_MENUPICK:
               HandleMenuEvent (ICode, Gadgets);
               break;

            case IDCMP_VANILLAKEY:
               HandleVanillyKey (ICode, Gadgets);
               break;

            case IDCMP_CLOSEWINDOW:
               Status.Exit = TRUE;
               break;
            }
         }
      }

   if (Signal == Signals[SIG_APP])
      {
      while (AMsg = (struct AppMessage *)GetMsg (AppMsgPort))
         {
         Status.ARexx = FALSE;

         switch (AMsg->am_Type)
            {
            case MTYPE_APPWINDOW:
               NameFromLock (AMsg->am_ArgList->wa_Lock, Buffer, sizeof (Buffer));
               strmfp (Args.ArgStr[KW_FILE], Buffer, AMsg->am_ArgList->wa_Name);
               GT_SetGadgetAttrs (Gadgets[ID_DVIFILE], Window, NULL,
                                  GTST_String, Args.ArgStr[KW_FILE],
                                  TAG_END, NULL);
               break;

            case MTYPE_APPICON:
               if (AMsg->am_NumArgs == 0)
                  Status.Exit = !EasyRequest (NULL, &AppIconReq, &IDCMPFlag, NULL);
               else
                  {
                  NameFromLock (AMsg->am_ArgList->wa_Lock, Buffer, sizeof (Buffer));
                  strmfp (Args.ArgStr[KW_FILE], Buffer, AMsg->am_ArgList->wa_Name);
                  GT_SetGadgetAttrs (Gadgets[ID_DVIFILE], Window, NULL,
                                     GTST_String, Args.ArgStr[KW_FILE],
                                     TAG_END, NULL);
                  }
               break;
            }

         ReplyMsg ((struct Message *)AMsg);
         }
      }

   if (Signal == Signals[SIG_AREXX])
      {
      Status.ARexx = TRUE;
      ARexxSupp.Gadgets       = Gadgets;
      ARexxSupp.DriverNumber  = TeXDriver.MenuItem;
      TeXPrtHost->userdata    = (struct ARexxSupport *)&ARexxSupp;
      ARexxDispatch (TeXPrtHost);
      }

   if (Status.Exit & !Status.ARexx)
      Status.Exit = EasyRequest (Window, &QuitReq, &IDCMPFlag, NULL);
   }
}


/***************************************************************************
 *                                                                         *
 *  Function name : HandleGadgetEvent                                      *
 *                                                                         *
 *  Description : Processes the various gadget events.                     *
 *                                                                         *
 ***************************************************************************
 *                                                                         *
 *  Synopsis : HandleGadgetEvent (Gad, **Gadgets)                          *
 *                                                                         *
 *  Parameters :                                                           *
 *       (UWORD) Code : Contains information about selected gadget.        *
 *       (struct Gadget *) Gad : Pointer to the activated gadget.          *
 *       (struct Gadget **) Gadgets : Pointer array for the window's       *
 *                                    gadgets.                             *
 *                                                                         *
 *  Return value : None                                                    *
 *                                                                         *
 ***************************************************************************/

void  HandleGadgetEvent (UWORD Code, struct Gadget *Gad, struct Gadget **Gadgets)

{
switch (Gad->GadgetID)
   {
   case ID_PAGESEL:
      TeXDriver.act_PageSel = Code;
      break;

   case ID_PAGETYPE:
      TeXDriver.act_PageType = Code;
      break;

   case ID_ORIENTATION:
      TeXDriver.act_Orientation = Code;
      break;

   case ID_FROM_PAGE:
      GT_SetGadgetAttrs (Gadgets[ID_PAGESEL], Window, NULL,
                         GTMX_Active, FROMTO,
                         TAG_END, NULL);
      TeXDriver.act_PageSel = FROMTO;
      break;

   case ID_TO_PAGE:
      GT_SetGadgetAttrs (Gadgets[ID_PAGESEL], Window, NULL,
                         GTMX_Active, FROMTO,
                         TAG_END, NULL);
      TeXDriver.act_PageSel = FROMTO;
      break;

   case ID_GETFILE:
      if (FileRequester = (struct FileRequester *)AllocAslRequestTags (ASL_FileRequest, ASL_Window, Window, TAG_DONE))
         {
         if (AslRequestTags (FileRequester, ASL_Hail, "Select DVI File", TAG_DONE))
            {
            strmfp (Args.ArgStr[KW_FILE], FileRequester->rf_Dir, FileRequester->rf_File);
            GT_SetGadgetAttrs (Gadgets[ID_DVIFILE], Window, NULL,
                               GTST_String, Args.ArgStr[KW_FILE],
                               TAG_END, NULL);
            }
         FreeAslRequest (FileRequester);
         }
      break;

   case ID_QUIT:
      Status.Exit = TRUE;
      break;

   case ID_PRINT:
      if (TeXPrtHost)
         {
         system (RexxPrintMacro);
         }
      else
         CallPrinterDriver (Gadgets, FALSE);
      break;
   }
}


/***************************************************************************
 *                                                                         *
 *  Function name : HandleMenuEvent                                        *
 *                                                                         *
 *  Description : Processes the various menu events.                       *
 *                                                                         *
 ***************************************************************************
 *                                                                         *
 *  Synopsis : HandleMenuEvent (Gad, **Gadgets)                            *
 *                                                                         *
 *  Parameters :                                                           *
 *       (UWORD) Code : Contains information about selected menu item.     *
 *       (struct Gadget **) Gadgets : Pointer array for the window's       *
 *                                    gadgets.                             *
 *                                                                         *
 *  Return value : None                                                    *
 *                                                                         *
 ***************************************************************************/

void  HandleMenuEvent (UWORD Code, struct Gadget **Gadgets)

{
USHORT                  Menu, MenuItem , SubItem;
char                    TempName[NAMELENGTH];


Menu     = MENUNUM (Code);
MenuItem = ITEMNUM (Code);
SubItem  = SUBNUM  (Code);

switch (Menu)
   {
   case 0:          /* PROJECT */
      switch (MenuItem)
         {
         case 0:    /* SAVE */
            if (!(SaveDriverSpec (TeXDriver.MenuItem, Gadgets)))
               EasyRequest (Window, &SaveErrorReq, &IDCMPFlag, Drivers.DriverFiles + TeXDriver.MenuItem * NAMELENGTH);
            break;
         case 1:   /* SAVE AS */
            if (FileRequester = (struct FileRequester *)AllocAslRequestTags (ASL_FileRequest, ASL_Window, Window, TAG_DONE))
               if (AslRequestTags (FileRequester, ASL_File, Drivers.DriverFiles + TeXDriver.MenuItem * NAMELENGTH,
                                                  ASL_Dir, DriverDrawer,
                                                  ASL_Hail, "Save spec file as",
                                                  TAG_DONE))
                  {
                  stpcpy (TempName, Drivers.DriverFiles);
                  stpcpy (Drivers.DriverFiles, FileRequester->rf_File);
                  if (!(SaveDriverSpec (0, Gadgets)))
                     EasyRequest (Window, &SaveErrorReq, &IDCMPFlag, Drivers.DriverFiles + TeXDriver.MenuItem * NAMELENGTH);
                  stpcpy (Drivers.DriverFiles, TempName);
                  FreeAslRequest (FileRequester);
                  }
            break;
         case 3:   /* ABOUT */
            EasyRequest (Window, &AboutReq, &IDCMPFlag, &Version[6]);
            break;
         case 5:   /* QUIT */
            Status.Exit = TRUE;
            break;
         }
      break;

   case 1:        /* DRIVERS */
      if (LoadDriverSpec (MenuItem))
         UpdateGUI (Gadgets);
      else
         EasyRequest (Window, &LoadErrorReq, &IDCMPFlag, Drivers.DriverFiles + MenuItem * NAMELENGTH);
   break;
   }
}


/***************************************************************************
 *                                                                         *
 *  Function name : HandleVanillaKey                                       *
 *                                                                         *
 *  Description : Processes the various menu events.                       *
 *                                                                         *
 ***************************************************************************
 *                                                                         *
 *  Synopsis : HandleVanillyKey (Gad, **Gadgets)                           *
 *                                                                         *
 *  Parameters :                                                           *
 *       (UWORD) Code : Contains information about pressed key.            *
 *       (struct Gadget **) Gadgets : Pointer array for the window's       *
 *                                    gadgets.                             *
 *                                                                         *
 *  Return value : None                                                    *
 *                                                                         *
 ***************************************************************************/

void  HandleVanillyKey (UWORD Code, struct Gadget **Gadgets)

{
BOOL  Toggle;

switch (Code)
   {
   case 'c':
   case 'C':
      ActivateGadget (Gadgets[ID_NO_COPIES], Window, NULL);
      break;

   case 'd':
   case 'D':
      ActivateGadget (Gadgets[ID_DVIFILE], Window, NULL);
      break;

   case 'e':
      TeXDriver.act_PageType = ++TeXDriver.act_PageType % 3;
      GT_SetGadgetAttrs (Gadgets[ID_PAGETYPE], Window, NULL,
                         GTMX_Active, TeXDriver.act_PageType, TAG_END, NULL);
      break;

   case 'E':
      TeXDriver.act_PageType = (2 + TeXDriver.act_PageType) % 3;
      GT_SetGadgetAttrs (Gadgets[ID_PAGETYPE], Window, NULL,
                         GTMX_Active, TeXDriver.act_PageType, TAG_END, NULL);
      break;

   case 'f':
   case 'F':
      ActivateGadget (Gadgets[ID_FROM_PAGE], Window, NULL);
      break;

   case 'g':
   case 'G':
      if (FileRequester = (struct FileRequester *)AllocAslRequestTags (ASL_FileRequest, ASL_Window, Window, TAG_DONE))
         {
         if (AslRequestTags (FileRequester, ASL_Hail, "Select DVI File", TAG_DONE))
            {
            strmfp (Args.ArgStr[KW_FILE], FileRequester->rf_Dir, FileRequester->rf_File);
            GT_SetGadgetAttrs (Gadgets[ID_DVIFILE], Window, NULL,
                               GTST_String, Args.ArgStr[KW_FILE],
                               TAG_END, NULL);
            }
         FreeAslRequest (FileRequester);
         }
      break;

   case 'h':
   case 'H':
      ActivateGadget (Gadgets[ID_HOFFSET], Window, NULL);
      break;

   case 'o':
   case 'O':
      TeXDriver.act_Orientation = ++TeXDriver.act_Orientation % 2;
      GT_SetGadgetAttrs (Gadgets[ID_ORIENTATION], Window, NULL,
                         GTMX_Active, TeXDriver.act_Orientation, TAG_END, NULL);
      break;

   case 'p':
   case 'P':
      if (TeXPrtHost)
         {
         system (RexxPrintMacro);
         }
      else
         CallPrinterDriver (Gadgets, FALSE);
      break;

   case 'q':
   case 'Q':
      Status.Exit = TRUE;
      break;

   case 'r':
   case 'R':
      Toggle = ((Gadgets[ID_REVERSE]->Flags & GFLG_SELECTED) != GFLG_SELECTED);
      GT_SetGadgetAttrs (Gadgets[ID_REVERSE], Window, NULL,
                         GTCB_Checked, Toggle, TAG_END);
      break;

   case 's':
   case 'S':
      TeXDriver.act_PageSel = ++TeXDriver.act_PageSel % 2;
      GT_SetGadgetAttrs (Gadgets[ID_PAGESEL], Window, NULL,
                         GTMX_Active, TeXDriver.act_PageSel, TAG_END, NULL);
      break;

   case 't':
   case 'T':
      ActivateGadget (Gadgets[ID_TO_PAGE], Window, NULL);
      break;

   case 'v':
   case 'V':
      ActivateGadget (Gadgets[ID_VOFFSET], Window, NULL);
      break;
   }
}



/*---------------------------- END OF FILE --------------------------------*/



