/*************************************************************************/
/* Autor      : RTA                                                      */
/* Computer   : Amiga                                                    */
/* Sprache    : Ansi C                                                   */
/* Compiler   : SAS C-Compiler Version 5.1a                              */
/* Dateiname  : waiting.c                                                */
/* Projekt    : OnlineHelp                                               */
/* Erstellt am: 09 Nov 1991,18:40                                        */
/*************************************************************************/

#include "online.h"

static struct IntuiText Render_text = {
  1,0,JAM1,0,0,NULL,NULL,NULL };

static struct Gadget Render = {
  NULL,117,13,1,1,GADGHNONE,NULL,BOOLGADGET,
  NULL,NULL,&Render_text,NULL,NULL,NULL,NULL };

static UBYTE Gadget0_buf[256];

static struct StringInfo Gadget0_info = {
  (UBYTE *)&Gadget0_buf,NULL,0,256,0,0,0,0,0,0,NULL,NULL,NULL };

static SHORT Gadget0_pairs0[] = {
  -2,-1,-2,9,-1,9,-1,-1,408,-1 };

static SHORT Gadget0_pairs1[] = {
  -1,9,408,9,408,0,409,-1,409,9 };

static struct Border Gadget0_bord[] = {
  0,0,1,0,JAM1,5,(SHORT *)&Gadget0_pairs0,&Gadget0_bord[1],
  0,0,2,0,JAM1,5,(SHORT *)&Gadget0_pairs1,NULL };

#define Gadget0_ID    0

static struct Gadget Gadget0 = {
  &Render,61,29,408,9,
  GADGHCOMP,
  RELVERIFY,
  STRGADGET,
  (APTR)&Gadget0_bord[0],NULL,
  NULL,NULL,(APTR)&Gadget0_info,Gadget0_ID,NULL };

#define FIRSTGADGET Gadget0

/**********************************************************************/
/* Liest ein Suchmuster mit Hilfe eines Stringgadgets ein             */
/* Gibt NULL zurück falls abgebrochen oder Fehler                     */
/**********************************************************************/
BYTE *getpattern(void)
{
      BYTE *p;

		if(!mywindow)return(NULL);
		gotoxy(0,0);
		clrscr();
      Gadget0.LeftEdge=(USHORT)(mywindow->Width-Gadget0.Width)/2.0;
      Render.GadgetText->IText=errortext.pattern;
      Render.LeftEdge=(USHORT)Gadget0.LeftEdge+60;
      AddGList(mywindow,&Gadget0,-1,2,NULL);
      RefreshGadgets(&FIRSTGADGET,mywindow,NULL);
      Delay(10);
      ActivateGadget(&FIRSTGADGET,mywindow,NULL);
      if(!waiting1())  return(NULL);
      RemoveGList(mywindow,&Gadget0,2);
      p=Gadget0_buf;
      return(p);
}

/**********************************************************************/
/* Warten auf eine Aktion vom User bei der Eingabe des Suchmusters    */
/* Gibt TRUE zurück, falls alles gut gegangen sit. FALSE falls der    */
/* Benutzer abgebrochen hat.                                          */
/**********************************************************************/
BOOL waiting1()
{
   struct IntuiMessage *message;
   ULONG    class;
   USHORT   code;
   BOOL     quit=FALSE,ende=FALSE;

   do
   {
      if ((message = (struct IntuiMessage *)GetMsg(mywindow->UserPort)) == 0L)
         {
          Wait(1L<<mywindow->UserPort->mp_SigBit);
          continue;
         }
      class     = message->Class;
      code      = message->Code;
      ReplyMsg((struct Message *)message);
      switch (class)
         {
           case NEWSIZE     : getxy();
	                           break;
           case RAWKEY      : if(code==ESC) quit=ende=TRUE;
                              break;
           case GADGETUP    : ende=TRUE;
                              break;
           case CLOSEWINDOW : quit=ende=TRUE;
                              break;
        }
   }while(!ende);
   if(quit) return(FALSE);
   else     return(TRUE);
}
/*************************************************************************/
/*       Warten auf eine Aktion vom User während er sich den Text        */
/*        anschaut. Dabei wird in Anhängigkeit von der Aktion ein        */
/*        DEFINE Wert zurückgegeben, der dann in Online.c weiter-        */
/*                           verarbeitet wird.                           */
/*************************************************************************/
SHORT waiting2()
{
   struct IntuiMessage *message=NULL;
	struct RexxMsg      *rexxmessage = NULL;
   ULONG               class,waitmask=0;
   USHORT              code,qual;
   BOOL                ende=FALSE;
   struct Gadget       *temp;
   SHORT               id;
	
	rexxmessage=NULL;
	quit=FALSE;
	
   do
   {
		if(mywindow)  waitmask=1<<mywindow->UserPort->mp_SigBit;
		if(rexx_port) waitmask|=1<<rexx_port->mp_SigBit;
		if(!waitmask)return(QUIT);

	   if(mywindow)message = (struct IntuiMessage *)GetMsg(mywindow->UserPort);
   	if(rexx_port)rexxmessage = (struct RexxMsg *)GetMsg(rexx_port);

	   if(!message && !rexxmessage)
   		{
			Wait(waitmask);
			continue;
			}

	if(mywindow)
	   if(message)
		{
      class     = message->Class;
      code      = message->Code;
      qual      = message->Qualifier;
      ReplyMsg((struct Message *)message);
      switch (class)
         {
           case NEWSIZE     : id=SIZE; ende=TRUE;
                              break;
           case RAWKEY      : switch(code)
                              {
                              case ESC:    if(noarexx)id=QUIT;
                              				 else 
                              				 	{
                              				 	if(qual&(IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT))
																{id=QUIT;DisplayBeep(myscreen);}
															else id=SLEEP;	
															}
                                           ende=TRUE;
                                           break;
                              case RETURN: ende=TRUE;
                                           id=WEITER;
                                           break;
                              case ENTER : ende=TRUE;
                                           id=NEXTDOC;
                                           break;
                              case UP: 	 if(qual&(IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT))id=BACK;
													    else 
															{
										   			 	if(qual&IEQUALIFIER_CONTROL)id=BEGIN;
															else id=ZBACK;
															}
														 ende=TRUE;	
													    break;
                              case DOWN:   if(qual&(IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT))id=FOR;
                                           else
                                           	{
                                           	if(qual&IEQUALIFIER_CONTROL) id=END;
															else id=ZFOR;
															}
														 ende=TRUE;	
                                           break;
                              }
                              while (message = (struct IntuiMessage *)GetMsg(mywindow->UserPort))
									      {ReplyMsg((struct Message *)message);}
                              break;
           case GADGETUP    : temp=(struct Gadget *)message->IAddress;
                              id=temp->GadgetID;
                              ende=TRUE;
                              break;
           case CLOSEWINDOW : if(noarexx)id=QUIT;
           							else id=SLEEP;
                              ende=TRUE;
                              break;
        }
      }
   if(rexx_port && rexxmessage)
		if(rexxmessage->rm_Node.mn_Node.ln_Type == NT_REPLYMSG)
			{
			if(rexxmessage->rm_Result1!=0 || rexxmessage->rm_Result2!=0)
				{
				SimpleRequest("%s Code: %d/%d",
							 errortext.arexxerror,
					       rexxmessage->rm_Result1,
					       rexxmessage->rm_Result2);
				}
			free_rexx_command(rexxmessage);
			}
		else
			execute_command(rexxmessage);
   }while(!ende && !quit);
   return(id);
}