'ShowGadgets 1.0'
                             ----------------
                             by PowerPeak '90

    This utility shows all gadgets in the active window. When you press
AMIGA-AMIGA-G the active window will be cleared and all gadgets are shown
as rectangles. The window will be restored when you press the left
mouse-button. Very useful for debugging your programs and checking for
hidden gadgets in other programs (preferences 1.2 :-) .
    This month again a C program. Compile with Lattice C 5.04 or it will
not work !



~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                                 ShowGadgets.c                               
-----------------------------------------------------------------------------

/*========================================================*/
/*							  */
/* Show gadgets in a window V1.0			  */
/* © J.Tyberghein					  */
/*    Mon Mar  5 09:16:17 1990 V1.0			  */
/*							  */
/*========================================================*/

#include <proto/exec.h>
#include <proto/dos.h>
#include <proto/graphics.h>
#include <proto/intuition.h>
#include <exec/interrupts.h>
#include <devices/inputevent.h>
#include <devices/input.h>
#include <intuition/intuition.h>
#include <intuition/intuitionbase.h>
#include <string.h>

/*=============================== Data =====================================*/

APTR SysBase;
struct DosLibrary *DOSBase;
struct IntuitionBase *IntuitionBase;
struct GfxBase *GfxBase;

void OpenStuff ();
void __regargs CloseStuff (int);
void Print (char *);


-----------------------------------------------------------------------------
  NewWindow structure for our dummy window                                   
-----------------------------------------------------------------------------
                                                                             
struct NewWindow nWin =
  {
    0,0,0,0,0,1,
    NULL,
    BORDERLESS,
    NULL,NULL,NULL,NULL,NULL,
    0,0,0,0,
    CUSTOMSCREEN
  };


-----------------------------------------------------------------------------
  Press AMIGA-AMIGA-G for view gadgets, and AMIGA-AMIGA-ESC to quit          
-----------------------------------------------------------------------------
                                                                             
#define GKEY	    0x24
#define ESCAPEKEY   0x45


-----------------------------------------------------------------------------
  The following structure is needed to pass information from our input       
  device handler to our task and vice versa                                  
-----------------------------------------------------------------------------
                                                                             
typedef struct
  {
    struct Task *TaskToSig;	  /* Pointer to our own task */
    ULONG QuitSig,QuitSigNum;	  /* Signal to quit ShowGadgets */
    ULONG ActionSig,ActionSigNum; /* Someone pressed AMIGA-AMIGA-G */
  } Global_Data;

Global_Data Global;


-----------------------------------------------------------------------------
  Our port and requestblock for the input device                             
-----------------------------------------------------------------------------
                                                                             
struct MsgPort *InputDevPort = NULL;
struct IOStdReq *InputRequestBlock = NULL;
struct Interrupt HandlerStuff;

/*=============================== Code =====================================*/


/*------------------------------ main program ------------------------------*/

void __saveds myMain ()
{
  struct Window *win,*myWin;
  int w,h,sig,xx,yy;
  struct RastPort *rp;
  struct Gadget *g;

  OpenStuff ();
  Print ("ShowGadgets 1.0  Written by J.Tyberghein 5 Mar 90\n");
  Print ("Press 'AMIGA-AMIGA-G' for gadget view ");
  Print ("(Left mouse button to stop view)\n");
  Print ("Press 'AMIGA-AMIGA-ESC' to quit\n");

-----------------------------------------------------------------------------
  Wait for signals from our input device                                     
-----------------------------------------------------------------------------
                                                                             
  for ( ; ; )
    {
      sig = Wait (Global.QuitSig | Global.ActionSig);
      if (sig & Global.QuitSig) break;
      if (sig & Global.ActionSig)

-----------------------------------------------------------------------------
  Now we show all gadgets for the active window                              
-----------------------------------------------------------------------------
                                                                             
	{
	  win = IntuitionBase->ActiveWindow;
	  nWin.LeftEdge = win->LeftEdge;
	  nWin.TopEdge = win->TopEdge;
	  w = nWin.Width = win->Width;
	  h = nWin.Height = win->Height;
	  nWin.Screen = win->WScreen;

-----------------------------------------------------------------------------
  Open our new window on top of the other window                             
-----------------------------------------------------------------------------
                                                                             
	  if (!(myWin = (struct Window *)OpenWindow (&nWin)))
	    {
	      Print ("Error opening window\n");
	      DisplayBeep (0L);
	    }
	  else
	    {
	      rp = myWin->RPort;

-----------------------------------------------------------------------------
  Forbid multitasking to prevent the other task from messing with its        
  gadgets                                                                    
-----------------------------------------------------------------------------
                                                                             
	      Forbid ();
	      SetRast (rp,0L);
	      SetAPen (rp,1L);

-----------------------------------------------------------------------------
  Scan all gadgets                                                           
-----------------------------------------------------------------------------
                                                                             
	      g = win->FirstGadget;
	      while (g)
		{
		  int x1,y1,x2,y2;


-----------------------------------------------------------------------------
  Compute the location for this gadget                                       
-----------------------------------------------------------------------------
                                                                             
		  x1 = g->LeftEdge; y1 = g->TopEdge;
		  if (g->Flags & GRELRIGHT) x1 += w;
		  if (g->Flags & GRELBOTTOM) y1 += h;
		  if (g->Flags & GRELWIDTH) xx = x2 = x1+g->Width+w-1;
		  else x2 = x1+g->Width-1;
		  if (g->Flags & GRELHEIGHT) yy = y2 = y1+g->Height+h-1;
		  else y2 = y1+g->Height-1;

-----------------------------------------------------------------------------
  Draw a box on our window representing the gadget on the other window       
-----------------------------------------------------------------------------
                                                                             
		  Move (rp,x1,y1);
		  Draw (rp,x2,y1);
		  Draw (rp,x2,y2);
		  Draw (rp,x1,y2);
		  Draw (rp,x1,y1);
		  g = g->NextGadget;
		}

-----------------------------------------------------------------------------
  Wait for the leftmousebutton                                               
-----------------------------------------------------------------------------
                                                                             
	      while ((*(BYTE *)0xbfe001)&64) ;
	      CloseWindow (myWin);
	      Permit ();
	    }
	}
    }
  Print ("Done !\n");
  CloseStuff (0);
}

/*-------------------------- Print something -------------------------------*/

void Print (char *str)
{
  Write (Output (),str,strlen (str));
}

/*------------------------ InputEvent handler ------------------------------*/

struct InputEvent * __saveds __asm MyHandler
      (register __a0 struct InputEvent *ev, register __a1 Global_Data *gdptr)
{
  register struct InputEvent *ep;


-----------------------------------------------------------------------------
  For each event...                                                          
-----------------------------------------------------------------------------
                                                                             
  for (ep=ev ; ep ; ep=ep->ie_NextEvent)
    if (ep->ie_Class == IECLASS_RAWKEY)
      if (ep->ie_Code == GKEY && (ep->ie_Qualifier &
	IEQUALIFIER_RCOMMAND) && (ep->ie_Qualifier & IEQUALIFIER_LCOMMAND))

-----------------------------------------------------------------------------
  The user pressed AMIGA-AMIGA-G, send a signal to the main task             
-----------------------------------------------------------------------------
                                                                             
	{
	  ep->ie_Class = IECLASS_NULL;
	  Signal (gdptr->TaskToSig,gdptr->ActionSig);
	}
      else if (ep->ie_Code == ESCAPEKEY && (ep->ie_Qualifier &
	IEQUALIFIER_RCOMMAND) && (ep->ie_Qualifier & IEQUALIFIER_LCOMMAND))

-----------------------------------------------------------------------------
  Tell the main task to quit                                                 
-----------------------------------------------------------------------------
                                                                             
	{
	  ep->ie_Class = IECLASS_NULL;
	  Signal (gdptr->TaskToSig,gdptr->QuitSig);
	}
  return (ev);
}

/*----------------------------- OpenStuff ----------------------------------*/

void OpenStuff ()
{

-----------------------------------------------------------------------------
  We must use SysBase because we don't use the standard startup code         
-----------------------------------------------------------------------------
                                                                             
  SysBase = (APTR)*(LONG *)4;

-----------------------------------------------------------------------------
  Open all libraries                                                         
-----------------------------------------------------------------------------
                                                                             
  DOSBase = (struct DosLibrary *)OpenLibrary ("dos.library",0L);
  IntuitionBase = (struct IntuitionBase *)
    OpenLibrary ("intuition.library",0L);
  GfxBase = (struct GfxBase *)OpenLibrary ("graphics.library",0L);

-----------------------------------------------------------------------------
  Allocate our signals                                                       
-----------------------------------------------------------------------------
                                                                             
  Global.QuitSigNum = Global.ActionSigNum = 0L;
  Global.TaskToSig = FindTask (0L);
  if ((Global.QuitSigNum = AllocSignal (-1L)) == -1L)
    {
      Print ("Error allocating signal\n");
      CloseStuff (4);
    }
  Global.QuitSig = 1L<<Global.QuitSigNum;
  if ((Global.ActionSigNum = AllocSignal (-1L)) == -1L)
    {
      Print ("Error allocating signal\n");
      CloseStuff (4);
    }
  Global.ActionSig = 1L<<Global.ActionSigNum;

-----------------------------------------------------------------------------
  Create the port and the StdIO for our input device                         
-----------------------------------------------------------------------------
                                                                             
  if (!(InputDevPort = CreatePort (0L,0L)))
    {
      Print ("Error creating InputDevPort\n");
      CloseStuff (1);
    }
  if (!(InputRequestBlock = CreateStdIO (InputDevPort)))
    {
      Print ("Error creating Standard IO\n");
      CloseStuff (2);
    }

-----------------------------------------------------------------------------
  Initialize the interrupt structure                                         
  We set our priority to 53. This is higher than the priority for the        
  intuition input device (50) so we are called before intuition              
-----------------------------------------------------------------------------
                                                                             
  HandlerStuff.is_Data = (APTR)&Global;
  HandlerStuff.is_Code = (VOID (*)())MyHandler;
  HandlerStuff.is_Node.ln_Pri = 53;
  if (OpenDevice ("input.device",0L,(struct IORequest *)InputRequestBlock,0L))
    {
      Print ("Error opening Input.device\n");
      CloseStuff (3);
    }

-----------------------------------------------------------------------------
  Add our handler                                                            
-----------------------------------------------------------------------------
                                                                             
  InputRequestBlock->io_Command = IND_ADDHANDLER;
  InputRequestBlock->io_Data = (APTR)&HandlerStuff;
  DoIO ((struct IORequest *)InputRequestBlock);
}

/*---------------------------- CloseStuff ----------------------------------*/

void __regargs CloseStuff (int Error)
{
  if (DOSBase) CloseLibrary ((struct Library *)DOSBase);
  if (IntuitionBase) CloseLibrary ((struct Library *)IntuitionBase);
  if (GfxBase) CloseLibrary ((struct Library *)GfxBase);
  if (Global.ActionSigNum) FreeSignal (Global.ActionSigNum);
  if (Global.QuitSigNum) FreeSignal (Global.QuitSigNum);
  if (InputRequestBlock)
    {
      InputRequestBlock->io_Command = IND_REMHANDLER;
      InputRequestBlock->io_Data = (APTR)&HandlerStuff;
      DoIO ((struct IORequest *)InputRequestBlock);
      CloseDevice ((struct IORequest *)InputRequestBlock);
      DeleteStdIO (InputRequestBlock);
    }
  if (InputDevPort) DeletePort (InputDevPort);
  Exit (Error);
}


-----------------------------------------------------------------------------
   The end.                                                 Jorrit Tyberghein
-----------------------------------------------------------------------------