|##########|
|#MAGIC   #|CLABLJDK
|#PROJECT #|"IMPORTALL"
|#PATHS   #|"StdProject"
|#FLAGS   #|xx---x-xx---xxx-----------------
|#USERSW  #|--------------------------------
|#USERMASK#|--------------------------------
|#SWITCHES#|xx---xxxxx------
|##########|
DEFINITION MODULE Intuition;
(* $A- *)

| von Thilo bekommen Anfang Mai
|
| WB 21 May 1992 kompilierbar gemacht
| WB  1 Jun 1992 typen besser
| WB 19 Aug 1992 Konflikte mit Exec beseitigt PaperType, GadgetType.

FROM Exec      IMPORT Interrupt,          IOStdReq,           Library,
		      List,               ListPtr,            MemReqSet,
		      Message,            MinNode,            MsgPortPtr,
		      Node,               SignalSemaphore,    TaskPtr,
		      TaskSignals,        TaskSignals;

FROM Graphics  IMPORT BitMap,             BitMapPtr,          ClipRect,
		      DisplayInfoPtr,     PenArrayPtr,
		      DrawModeSet,        GfxBasePtr,         jam2,
		      LayerInfo,          LayerPtr,           RastPort,
		      RastPortPtr,        RectanglePtr,       RegionPtr,
		      RegionRectanglePtr, SimpleSpritePtr,    TextAttr,
		      TextAttrPtr,        TextFontPtr,        TmpRas,
		      View,               ViewModeSet,        ViewModes,
		      ViewPort,           ViewPortPtr,        ViewPtr;

FROM Timer     IMPORT IOTimer,            TimeVal;

FROM System    IMPORT BITSET,             LONGSET,            PROC,
		      Regs,               SysStringPtr;

FROM Input     IMPORT InputEvent,         InputEventPtr,
		      lButton,            Qualifiers,         QualifierSet,
		      rButton,            upPrefix;

FROM Resources IMPORT ResHandles;

FROM Utility   IMPORT Hook,               HookPtr,            StdTags,
		      tagUser,            TagArrayPtr;


CONST
  wTB                   = tagUser + 99;  | $80000063    WindowTags base
  sTB                   = tagUser + 32;  | $80000020    ScreenTags base

TYPE

  BorderPtr             = POINTER TO Border;
  GadgetPtr             = POINTER TO Gadget;
  IBoxPtr               = POINTER TO IBox;
  ImagePtr              = POINTER TO Image;
  IntuiMessagePtr       = POINTER TO IntuiMessage;
  IntuiTextPtr          = POINTER TO IntuiText;
  MenuItemPtr           = POINTER TO MenuItem;
  PreferencesPtr        = POINTER TO Preferences;
  PropInfoPtr           = POINTER TO PropInfo;
  RememberPtr           = POINTER TO Remember;
  RequesterPtr          = POINTER TO Requester;
  ScreenPtr             = POINTER TO Screen;
  StringInfoPtr         = POINTER TO StringInfo;
  WindowPtr             = POINTER TO Window;

DEFINITION MODULE WinRes = Resources.ResHandles(WindowPtr);

DEFINITION MODULE ScreenRes = Resources.ResHandles(ScreenPtr);

TYPE
  MenuFlags    = ( menuEnabled,            | r/w this menu is enabled
		   miDrawn     = 8);       | r/o items are being drawn
  MenuFlagSet  = SET OF MenuFlags;

  MenuPtr      = POINTER TO Menu;
  Menu         = RECORD
		   nextMenu   : MenuPtr;
		   leftEdge   : INTEGER;
		   topEdge    : INTEGER;
		   width      : INTEGER;
		   height     : INTEGER;
		   flags      : MenuFlagSet;
		   menuName   : SysStringPtr;
		   firstItem  : MenuItemPtr;
		   jazzx      : INTEGER;
		   jazzy      : INTEGER;
		   beatx      : INTEGER;
		   beaty      : INTEGER;
		 END;

  MenuItemFlags   = (
		  checkIt,       | checkmarkable item
		  itemText,      | textual item, FALSE if graphical item
		  commSeq,       | command sequence
		  menuToggle,    | toggling checks (else mut. exclude)
		  itemEnabled,   | this item is enabled
		  mif5,          |
		  highComp,      | highlight by complementing the selectbox
		  highBox,       | highlight by "boxing" the selectbox
		  checked,       | state of the checkmark
		  mif9,          |
		  mif10,         |
		  mif11,         |
		  isDrawn,       | this item's subs are currently drawn
		  highItem,      | this item is currently highlighted
		  menuToggled ); | this item was already toggled

  MenuItemFlagSet = SET OF MenuItemFlags;

CONST
  highNone        = MenuItemFlagSet:{highBox,highComp};
  checkWidth      = 19;
  commWidth       = 27;
  lowCheckWidth   = 13;
  lowCommWidth    = 16;

TYPE

  MenuItem = RECORD
	       nextItem      : MenuItemPtr;
	       leftEdge      : INTEGER;
	       topEdge       : INTEGER;
	       width         : INTEGER;
	       height        : INTEGER;
	       flags         : MenuItemFlagSet;
	       mutualExclude : LONGSET;
	       itemFill      : ANYPTR;
	       selectFill    : ANYPTR;
	       command       : CHAR;
	       subItem       : MenuItemPtr;
	       nextSelect    : CARDINAL;
	     END;

  RequesterFlags  = (
		  pointRel,       | TopLeft is relative to pointer for
				  | DMRequester, relative to window
				  | center for Request()
		  preDrawn,       | imageBMap -> predrawn Requester imagery
		  noisReg,        | requester does not filter input
		  rf3,            |
		  simpleReq,      | to use SIMPLEREFRESH layer (recommended)
		  userEqImage,    | render-order BackFill, image, gadgets,
				  | text don't fill requester with
				  | backFill pen
		  noReqBackFill,  |
		  rf7,            |
		  rf8,            |
		  rf9,            |
		  rf10,           |
		  rf11,           |
		  reqOffWindow,   | r/o part of the Gadgets was offwindow
		  reqActive,      | r/o this requester is active
		  sysRequest,     | (unused) this requester caused by system
		  deferRefresh ); | this Requester stops a Refresh broadcast

  RequesterFlagSet= SET OF RequesterFlags;

  Requester= RECORD
	       olderRequest  : RequesterPtr;
	       leftEdge      : INTEGER;
	       topEdge       : INTEGER;
	       width         : INTEGER;
	       height        : INTEGER;
	       relLeft       : INTEGER;
	       relTop        : INTEGER;
	       gadgets       : GadgetPtr;
	       border        : BorderPtr;
	       text          : IntuiTextPtr;
	       flags         : RequesterFlagSet;
	       backFill      : SHORTCARD;                 | background pen
	       layer         : LayerPtr;
	       pad1          : ARRAY [0..31] OF SHORTINT;
	       imageBMap     : BitMapPtr;                 | if predrawn
	       rWindow       : WindowPtr;                 | our owner
	       image         : ImagePtr;                  | if userEqImage
	       reqPad2       : ARRAY [0..31] OF SHORTINT;
	     END;

  GadgetFlags       = (gadgHBox,gadgHImage,gadgImage,gRelBottom,gRelRight,
		       gRelWidth,gRelHeight,selected,gadgDisabled,
		       tabCycle,stringExtend,ggf11,labelString,labelImage);
  GadgetFlagSet     = SET OF GadgetFlags;

  ActivationFlags   = (relVerify,gadgImmediate,endGadget,followMouse,
		       rightBorder,leftBorger,topBorder,bottomBorder,
		       toggleSelect,stringCenter,stringRight,longint,
		       altKeyMap,extended,activeGadget,bordersniff);
  ActivationFlagSet = SET OF ActivationFlags;

CONST
  gadgHighbits = GadgetFlagSet:{gadgHBox,gadgHImage};
  gadgHNone    = GadgetFlagSet:{gadgHBox,gadgHImage};
  gadgHComp    = GadgetFlagSet:{};
  labelIText   = GadgetFlagSet:{};
  labelMask    = GadgetFlagSet:{labelString,labelImage};
  stringLeft   = ActivationFlagSet:{};

TYPE
  GadgetTypeBits = (gtb0,gtb1,gtb2,gtb3,
		    gtb4,gtb5,gtb6,gtb7,
		    gtb8,gtb9,gbtA,gtbB,
		    reqGadget,gzzGadget,scrGadget,sysGadget);
  GadgetType     = SET OF GadgetTypeBits;

CONST
  boolGadget     = GadgetType:{gtb0};
  propGadget     = GadgetType:{gtb0,gtb1};
  strGadget      = GadgetType:{gtb2};
  customGadget   = GadgetType:{gtb0,gtb2};

  wSizing        = GadgetType:{gtb4};
  wDragging      = GadgetType:{gtb5};
  sDragging      = GadgetType:{gtb4,gtb5};
  wUpFront       = GadgetType:{gtb6};
  sUpFront       = GadgetType:{gtb4,gtb6};
  wDownBack      = GadgetType:{gtb5,gtb6};
  sDownBack      = GadgetType:{gtb4,gtb5,gtb6};
  wClose         = GadgetType:{gtb7};

TYPE
  GadgInfoPtr = POINTER TO GadgInfo;
  GadgInfo    = RECORD END;

  Gadget = RECORD
	     nextGadget   : GadgetPtr;
	     leftEdge     : INTEGER;
	     topEdge      : INTEGER;
	     width        : INTEGER;
	     height       : INTEGER;
	     flags        : GadgetFlagSet;
	     activation   : ActivationFlagSet;
	     gadgetType   : GadgetType;
	     gadgetRender : ANYPTR;
	     selectRender : ANYPTR;
	     gadgetText   : IntuiTextPtr;
	     mutualExclude: LONGSET;
	     specialInfo  : GadgInfoPtr;
	     gadgetID     : INTEGER;
	     userData     : ANYPTR;
	   END;

CONST
  boolMask = 1;

TYPE
  BoolInfo = RECORD OF GadgInfo
	       flags      : BITSET;
	       mask       : ANYPTR;
	       reserved   : LONGCARD;
	     END;

  PropInfoFlags     = (autoKnob,freeHoriz,freeVert,propBorderless,
		       propNewLook,pf5,pf6,pf7,knobHit);
  PropInfoFlagSet   = SET OF PropInfoFlags;

CONST
  knobVmin = 4;
  knobHmin = 6;
  maxBody  = $FFFF;
  maxPot   = $FFFF;

TYPE
  PropInfo = RECORD OF GadgInfo
	       flags      : PropInfoFlagSet;
	       horizPot   : CARDINAL;
	       vertPot    : CARDINAL;
	       horizBody  : CARDINAL;
	       vertBody   : CARDINAL;
	       cWidth     : CARDINAL;
	       cHeight    : CARDINAL;
	       hPotRes    : CARDINAL;
	       vPotRes    : CARDINAL;
	       leftBorder : CARDINAL;
	       topBorder  : CARDINAL;
	     END;

  StringExtFlags   = (replace,fixedField,noFilter,noChange,
		      noWorkBuffer,control,longint,exitHelp,
		      makeMeLong = 31);
  StringExtFlagSet = SET OF StringExtFlags;

  StringExtendPtr = POINTER TO StringExtend;
  StringExtend    = RECORD
		      font       : TextFontPtr;
		      pens       : ARRAY [2] OF SHORTCARD;
		      activePens : ARRAY [2] OF SHORTCARD;
		      initModes  : StringExtFlagSet;
		      editHook   : HookPtr;
		      buffer     : SysStringPtr;
		      reserved   : ARRAY [4] OF LONGINT;
		    END;

  StringInfo = RECORD OF GadgInfo
		 buffer      : ANYPTR;
		 undoBuffer  : ANYPTR;
		 bufferPos   : INTEGER;
		 maxChars    : INTEGER;
		 dispPos     : INTEGER;
		 undoPos     : INTEGER;
		 numChars    : INTEGER;
		 dispcount   : INTEGER;
		 cLeft       : INTEGER;
		 cTop        : INTEGER;
		 extension   : StringExtendPtr;
		 longint     : LONGINT;
		 altKeyMap   : ANYPTR;
	       END;


CONST
  autoFrontPen   = 0;
  autoBackPen    = 1;
  autoDrawMode   = jam2;
  autoLeftEdge   = 6;
  autoTopEdge    = 3;
  autoITextFont  = NIL;
  autoNextText   = NIL;

TYPE
  IntuiText   = RECORD
		  frontPen    : SHORTCARD;
		  backPen     : SHORTCARD;
		  drawMode    : DrawModeSet;
		  leftEdge    : INTEGER;
		  topEdge     : INTEGER;
		  iTextFont   : TextAttrPtr;
		  iText       : SysStringPtr;
		  nextText    : IntuiTextPtr;
		END;

GROUP
  IntuiTextGrp = IntuiText,IntuiTextPtr,DrawModeSet,
		 Graphics.DrawModes,autoFrontPen,autoBackPen,autoDrawMode,
		 autoLeftEdge,autoTopEdge,autoITextFont,autoNextText;

TYPE
  BorderList   = ARRAY OF RECORD x,y : INTEGER END;
  Border       = RECORD
		  leftEdge,
		  topEdge     : INTEGER;
		  frontPen,
		  backPen     : SHORTCARD;
		  drawMode    : DrawModeSet;
		  count       : SHORTCARD;
		  xy          : POINTER TO BorderList;
		  nextBorder  : BorderPtr;
		END;

GROUP
  BorderGrp   = BorderPtr,Border,DrawModeSet,
		Graphics.DrawModes;


TYPE
  Image       = RECORD
		  leftEdge,
		  topEdge,
		  width,
		  height,
		  depth       : INTEGER;
		  imageData   : ANYPTR;
		  planePick,
		  planeOnOff  : SHORTCARD;
		  nextImage   : ImagePtr;
		END;


TYPE
  IDCMPFlags  = ( sizeVerify,         newSize,            refreshWindow,
		  mouseButtons,       mouseMove,          gadgetDown,
		  gadgetUp,           reqSet,             menuPick,
		  closeWindow,        rawKey,             reqVerify,
		  reqClear,           menuVerify,         newPrefs,
		  diskInserted,       diskRemoved,        wbenchMessage,
		  activeWindow,       inactiveWindow,     deltaMove,
		  vanillaKey,         intuiTicks,         idcmpUpdate,
		  menuHelp,           changeWindow,       c26,
		  c27,                c28,                c29,
		  c30,                lonelyMessage );
  IDCMPFlagSet  = SET OF IDCMPFlags;

  IDCMPFlagSetPtr  = POINTER TO IDCMPFlagSet;

CONST
  selectUp     = lButton+upPrefix;
  selectDown   = lButton;
  menuUp       = rButton+upPrefix;
  menuDown     = rButton;
  menuNull     = $FFFF;
  noMenu       = $1F;
  noItem       = $3F;
  noSub        = $1F;
  keyCodeQ     = $10;
  keyCodeX     = $32;
  keyCodeV     = $34;
  keyCodeB     = $35;
  keyCodeN     = $36;
  keyCodeM     = $37;
  cursorUp     = $4C;
  cursorDown   = $4D;
  cursorRight  = $4E;
  cursorLeft   = $4F;
  menuHot      = 1;
  menuCancel   = 2;
  menuWaiting  = 3;
  okOk         = menuHot;
  okAbort      = 4;
  okCancel     = menuCancel;
  wbenchOpen   = 1;
  wbenchClose  = 2;
  altLeft      = QualifierSet:{lAlt};
  altRight     = QualifierSet:{rAlt};
  amigaLeft    = QualifierSet:{lCommand};
  amigaRight   = QualifierSet:{rCommand};
  amigaKeys    = amigaLeft+amigaRight;

TYPE
  IntuiMessage = RECORD OF Message
		   class        : IDCMPFlagSet;
		   code         : CARDINAL;
		   qualifier    : QualifierSet;
		   iAddress     : ANYPTR;
		   mouseX,
		   mouseY       : INTEGER;
		   seconds,
		   micros       : LONGCARD;
		   idcmpWindow  : WindowPtr;
		   specialLink  : IntuiMessagePtr;
		 END;



GROUP
  IDCMPGrp   =  IDCMPFlags,         IDCMPFlagSet,
		selectUp,           selectDown,         menuUp,
		menuDown,           menuNull,           noMenu,
		noItem,             noSub,              keyCodeQ,
		keyCodeX,           keyCodeV,           keyCodeB,
		keyCodeN,           keyCodeM,           cursorUp,
		cursorDown,         cursorRight,        cursorLeft,
		menuHot,            menuCancel,         menuWaiting,
		okOk,               okAbort,            okCancel,
		wbenchOpen,         wbenchClose,        altLeft,
		altRight,           amigaLeft,          amigaRight,
		amigaKeys,          IntuiMessage,       IntuiMessagePtr;

TYPE
  WindowFlags   = (windowSizing,windowDrag,windowDepth,windowClose,
		   sizeBRight,sizeBBottom,simpleRefresh,superBitMap,
		   backDrop,reportMouse,gimmeZeroZero,borderless,
		   activate,windowActive,inRequest,menuState,rmbTrap,
		   noCareRefresh,nw_Extended,wf19,wf20,wf21,wf22,wf23,
		   windowRefresh,wbenchWindow,windowTicked,visitor,zoomed,
		   hasZoom,wf30,wf31);
  WindowFlagSet = SET OF WindowFlags;

  ScreenFlags   = (wbenchScreen,publicScreen,sf2,sf3,showTitle,beeping,
		   customBitMap,screenBehind,screenQuiet,screenHiRes,
		   sf10,sf11,nsExtended,sf13,autoScroll);
  ScreenFlagSet = SET OF ScreenFlags;


CONST
  defaultMouseQueue = 5;    | the default for WindowTags.mouseQueue
  otherRefresh      = WindowFlagSet:{simpleRefresh,superBitMap};
  refreshBits       = otherRefresh;
  stdScreenHeight   = -1;
  stdScreenWidth    = -1;
  customScreen      = ScreenFlagSet:{wbenchScreen..sf3};

TYPE
  NewWindowPtr = POINTER TO NewWindow;
  NewWindow    = RECORD
		   leftEdge,
		   topEdge,
		   width,
		   height      : INTEGER;
		   detailPen,
		   blockPen    : SHORTINT;
		   idcmpFlags  : IDCMPFlagSet;
		   flags       : WindowFlagSet;
		   firstGadget : GadgetPtr;
		   checkMark   : ImagePtr;
		   title       : SysStringPtr;
		   screen      : ScreenPtr;
		   bitMap      : BitMapPtr;
		   minWidth,
		   minHeight,
		   maxWidth,
		   maxHeight   : INTEGER;
		   type        : ScreenFlagSet;
		 END;

  ColorSpecPtr = POINTER TO ColorSpec;
  ColorSpec    = RECORD
		   colorIndex  : INTEGER;
		   red,
		   green,
		   blue        : CARDINAL;
		 END;
  ColorSpecs   = ARRAY OF ColorSpec;

  ColorPtr     =  POINTER TO ColorSpecs;

  EasyStructPtr = POINTER TO EasyStruct;
  EasyStruct    = RECORD
		    structSize  : LONGCARD;
		    flags       : LONGCARD;
		    title,
		    textFormat,
		    gadgetFormat: SysStringPtr;
		  END;

  WindowTags      =
    TAGS OF StdTags
      left              = wTB+$01 : LONGINT;
      top               = wTB+$02 : LONGINT;
      width             = wTB+$03 : LONGINT;
      height            = wTB+$04 : LONGINT;
      detailPen         = wTB+$05 : LONGCARD;       | SHORTCARD
      blockPen          = wTB+$06 : LONGCARD;       | SHORTCARD
      IDCMP             = wTB+$07 : IDCMPFlagSet;
      flags             = wTB+$08 : WindowFlagSet;
      gadgets           = wTB+$09 : GadgetPtr;
      checkmark         = wTB+$0A : ImagePtr;
      title             = wTB+$0B : SysStringPtr;
      screenTitle       = wTB+$0C : SysStringPtr;
      customScreen      = wTB+$0D : ScreenPtr;
      superBitMap       = wTB+$0E : BitMapPtr;
      minWidth          = wTB+$0F : LONGINT;        | INTEGER
      minHeight         = wTB+$10 : LONGINT;        | INTEGER
      maxWidth          = wTB+$11 : LONGCARD;       | CARDINAL
      maxHeight         = wTB+$12 : LONGCARD;       | CARDINAL
      innerWidth        = wTB+$13 : LONGINT;
      innerHeight       = wTB+$14 : LONGINT;

      pubScreenName     = wTB+$15 : SysStringPtr;
      pubScreen         = wTB+$16 : ScreenPtr;
      pubScreenFallBack = wTB+$17 : LONGBOOL;
      windowName        = wTB+$18 : SysStringPtr;
      colors            = wTB+$19 : ColorPtr;  | may not ever be implemented
      zoom              = wTB+$1A : IBoxPtr;
      mouseQueue        = wTB+$1B : LONGINT;  | def. defaultMouseQueue
      backFill          = wTB+$1C : HookPtr;   | see Layers.InstallLayerHook
      RPTQueue          = wTB+$1D : LONGINT;   | queue for events (see RKM)

      sizeGadget        = wTB+$1E : LONGBOOL;
      dragBar           = wTB+$1F : LONGBOOL;
      depthGadget       = wTB+$20 : LONGBOOL;
      closeGadget       = wTB+$21 : LONGBOOL;
      backDrop          = wTB+$22 : LONGBOOL;
      reportMouse       = wTB+$23 : LONGBOOL;
      noCareRefresh     = wTB+$24 : LONGBOOL;
      borderless        = wTB+$25 : LONGBOOL;
      activate          = wTB+$26 : LONGBOOL;
      RMBTrap           = wTB+$27 : LONGBOOL;
      wBenchWindow      = wTB+$28 : LONGBOOL;
      simpleRefresh     = wTB+$29 : LONGBOOL;
      smartRefresh      = wTB+$2A : LONGBOOL;
      sizeBRight        = wTB+$2B : LONGBOOL;  | SizeGadget in right border
      sizeBBottom       = wTB+$2C : LONGBOOL;  | SizeGadget in bottom Border
      autoAdjust        = wTB+$2D : LONGBOOL;
      gimmeZeroZero     = wTB+$2E : LONGBOOL;
      menuHelp          = wTB+$2F : LONGBOOL;  | see IDCMP.menuHelp
    END;

  WindowTagListPtr = POINTER TO WindowTagList;
  WindowTagList    = ARRAY OF WindowTags;

  ExtNewWindowPtr  = POINTER TO ExtNewWindow;
  ExtNewWindow     = RECORD OF NewWindow;
		       extension   : WindowTagListPtr;
		     END;

  NewScreenPtr     = POINTER TO NewScreen;
  NewScreen        = RECORD
		       leftEdge    : INTEGER;
		       topEdge     : INTEGER;
		       width       : INTEGER;
		       height      : INTEGER;
		       depth       : INTEGER;
		       detailPen   : SHORTINT;
		       blockPen    : SHORTINT;
		       viewModes   : ViewModeSet;
		       type        : ScreenFlagSet;
		       font        : TextAttrPtr;
		       defaultTitle: ANYPTR;
		       gadgets     : GadgetPtr;
		       customBitMap: BitMapPtr;
		     END;

  | Types for ScreenTags

  ErrorTypePtr     = POINTER TO ErrorType;
  ErrorType        = ( noMonitor,     noChips,       noMem,
		       noChipMem,     pubNotUnique,  unknownMode,
		       mmlong = $10000 );

  FontPrefs        = ( oldDefaultFont,    | The old fixed-width default
		       wbScreenFont,      | be font sensitive !!!
		       mmlong = $10000 );

  OScanType        = ( text,standard,max,video );

  ScreenTags       =
    TAGS OF StdTags
      left         = sTB + $01 : LONGINT;
      top          = sTB + $02 : LONGINT;
      width        = sTB + $03 : LONGINT;
      height       = sTB + $04 : LONGINT;
      depth        = sTB + $05 : LONGINT;
      detailPen    = sTB + $06 : LONGCARD;     | SHORTCARD
      blockPen     = sTB + $07 : LONGCARD;     | SHORTCARD
      title        = sTB + $08 : SysStringPtr;
      colors       = sTB + $09 : ColorPtr;     | initial Palette. Finish
					       | with -1.
      errorCode    = sTB + $0A : ErrorTypePtr;
      font         = sTB + $0B : TextAttrPtr;
      sysFont      = sTB + $0C : FontPrefs;
      type         = sTB + $0D : ScreenFlagSet;
      bitMap       = sTB + $0E : BitMapPtr;      | custom bitmap
      pubName      = sTB + $0F : SysStringPtr;   | state before the two
						 | below
      pubSig       = sTB + $10 : TaskSignals;    | signal for pubTask
      pubTask      = sTB + $11 : TaskPtr;        | the pubscreen task
      displayID    = sTB + $12 : LONGINT;        | a custom Display
      dClip        = sTB + $13 : RectanglePtr;   | better use overScan
      overScan     = sTB + $14 : OScanType;
      obsolete1    = sTB + $15 : SysStringPtr;   | used to be Monitorname
      showTitle    = sTB + $16 : LONGBOOL;
      behind       = sTB + $17 : LONGBOOL;
      quiet        = sTB + $18 : LONGBOOL;
      autoScroll   = sTB + $19 : LONGBOOL;
      pens         = sTB + $1A : PenArrayPtr; | init screen.drawInfo.pens
      fullPalette  = sTB + $1B : LONGBOOL;    | init all preferences colors
    END;

  ScreenTagListPtr = POINTER TO ScreenTagList;
  ScreenTagList    = ARRAY OF ScreenTags;

  ExtNewScreenPtr  = POINTER TO ExtNewScreen;
  ExtNewScreen     = RECORD OF NewScreen;
		       extension   : ScreenTagListPtr;
		     END;

  Window           = RECORD  OF WinRes.ResHandle
		       nextWindow  : WindowPtr;
		       leftEdge    : INTEGER;
		       topEdge     : INTEGER;
		       width       : INTEGER;
		       height      : INTEGER;
		       mouseY      : INTEGER;
		       mouseX      : INTEGER;
		       minWidth    : INTEGER;
		       minHeight   : INTEGER;
		       maxWidth    : INTEGER;
		       maxHeight   : INTEGER;
		       flags       : WindowFlagSet;
		       menuStrip   : MenuPtr;
		       title       : SysStringPtr;
		       firstRequest: RequesterPtr;
		       dmRequest   : RequesterPtr;
		       reqCount    : INTEGER;
		       wScreen     : ScreenPtr;
		       rPort       : RastPortPtr;
		       borderLeft  : SHORTINT;
		       borderTop   : SHORTINT;
		       borderRight : SHORTINT;
		       borderBottom: SHORTINT;
		       borderRPort : RastPortPtr;
		       firstGadget : GadgetPtr;
		       parent      : WindowPtr;
		       descendant  : WindowPtr;
		       pointer     : ANYPTR;
		       ptrHeight   : SHORTINT;
		       ptrWidth    : [0..16];
		       xOffset     : SHORTINT;
		       yOffset     : SHORTINT;
		       idcmpFlags  : IDCMPFlagSet;
		       userPort    : MsgPortPtr;
		       windowPort  : MsgPortPtr;
		       messageKey  : IntuiMessagePtr;
		       detailPen   : SHORTCARD;
		       blockPen    : SHORTCARD;
		       checkMark   : ImagePtr;
		       screenTitle : SysStringPtr;
		       gzzMouseX   : INTEGER;
		       gzzMouseY   : INTEGER;
		       gzzWidth    : INTEGER;
		       gzzHeight   : INTEGER;
		       extData     : ANYPTR;
		       userData    : ANYPTR;
		       wLayer      : LayerPtr;
		       iFont       : TextFontPtr;
		     END;

  Screen           = RECORD OF ScreenRes.ResHandle
		       nextScreen  : ScreenPtr;
		       firstWindow : WindowPtr;
		       leftEdge    : INTEGER;
		       topEdge     : INTEGER;
		       width       : INTEGER;
		       height      : INTEGER;
		       mouseY      : INTEGER;
		       mouseX      : INTEGER;
		       flags       : ScreenFlagSet;
		       title       : SysStringPtr;
		       defaultTitle: SysStringPtr;
		       barHeight   : SHORTINT;
		       barVBorder  : SHORTINT;
		       barHBorder  : SHORTINT;
		       menuVBorder : SHORTINT;
		       menuHBorder : SHORTINT;
		       wBorTop     : SHORTINT;
		       wBorLeft    : SHORTINT;
		       wBorRight   : SHORTINT;
		       wBorBottom  : SHORTINT;
		       font        : TextAttrPtr;
		       viewPort    : ViewPort;
		       rastPort    : RastPort;
		       bitMap      : BitMap;
		       layerInfo   : LayerInfo;
		       firstGadget : GadgetPtr;
		       detailPen   : SHORTCARD;
		       blockPen    : SHORTCARD;
		       saveColor0  : CARDINAL;
		       barLayer    : LayerPtr;
		       extData     : ANYPTR;
		       userData    : ANYPTR;
		     END;

CONST
  private          =  1;
  maxPubScreenName =  139;          (* names no longer *)

TYPE
  PBNFlags         = ( shanghai, popPubScreen, makeMeWord = 15 );
  PBNFlagSet       = SET OF PBNFlags;

  PubScreenNode    = RECORD OF Node;
		       screen        : ScreenPtr;
		       flags         : PBNFlagSet;
		       size          : INTEGER;
		       visitorCount  : INTEGER;
		       sigTask       : TaskPtr;
		       sigBit        : TaskSignals;
		     END;



CONST
  filenameSize  = 30;
  pointerSize   = (1+16+1)*2;
  topazEighty   = 8;
  topazSixty    = 9;

TYPE
  PrinterPort   = (parallelPrinter,serialPrinter);


(* PrinterTypes *)
CONST
  CustomName     = 0;
  AlphaP101      = 1;
  Brother15XL    = 2;
  CbmMps1000     = 3;
  Diab630        = 4;
  DiabAdvD25     = 5;
  DiabC150       = 6;
  Epson          = 7;
  EpsonJX80      = 8;
  Okimate20      = 9;
  QumeLP20       = 10;
  HpLaserjet     = 11;
  HpLaserjetPlus = 12;

TYPE
  SerParShk     =(shakeXon,shakeRts,shakeNone,sps3,parityNone,parityEven,
		  parityOdd);

  SerParShkSet  = SET OF SerParShk;

  Print         =(ignoreDimensions,correctRed,correctGreen,correctBlue,
		  centerImage,boundedDimensions,absoluteDimensions,
		  pixelDimensions,mulitplyDimensions,integerScaling,
		  halftoneDithering,floydDithering,antiAlias,greyScale2);

  PrintFlags    = SET OF Print;


CONST
  orderedDithering = ignoreDimensions;
  correctRgbMask   = PrintFlags :{correctRed..correctBlue};
  dimensionsMask   = PrintFlags :{boundedDimensions..pixelDimensions};
  ditheringMask    = PrintFlags :{halftoneDithering,floydDithering};

TYPE

  PaperType = ( fanfold       = $0,
		single        = $080 );

  Preferences   = RECORD
		    fontHeight        : SHORTCARD;
		    printerPort       : PrinterPort;
		    baudRate          : CARDINAL;
		    keyRptSpeed       : TimeVal;
		    keyRptDelay       : TimeVal;
		    doubleClick       : TimeVal;
		    pointerMatrix     : ARRAY [0..pointerSize-1] OF CARDINAL;
		    xOffset           : SHORTINT;
		    yOffset           : SHORTINT;
		    color17           : CARDINAL;
		    color18           : CARDINAL;
		    color19           : CARDINAL;
		    pointerTicks      : CARDINAL;
		    color0            : CARDINAL;
		    color1            : CARDINAL;
		    color2            : CARDINAL;
		    color3            : CARDINAL;
		    viewXOffset       : SHORTINT;
		    viewYOffset       : SHORTINT;
		    viewInitX         : INTEGER;
		    viewInitY         : INTEGER;
		    enableCLI         : BOOLEAN;
		    printerType       : CARDINAL;
		    printerFilename   : ARRAY [0..filenameSize-1] OF CHAR;
		    printPitch        : CARDINAL;
		    printQuality      : CARDINAL;
		    printSpacing      : CARDINAL;
		    printLeftMargin   : CARDINAL;
		    printRightMargin  : CARDINAL;
		    printImage        : CARDINAL;
		    printAspect       : CARDINAL;
		    printShade        : CARDINAL;
		    printTreshhold    : INTEGER;
		    paperSize         : CARDINAL;
		    paperLength       : CARDINAL;
		    paperType         : PaperType;
		    serRWBits         : SHORTCARD;
		    serStopBuf        : SHORTCARD;
		    serParShk         : SerParShkSet;
		    laceWB            : BOOLEAN;
		    workName          : ARRAY [0..filenameSize-1] OF CHAR;
		    padding           : ARRAY [0..15] OF SHORTINT;
		  END;


CONST
  baud110       = 0;
  baud300       = 1;
  baud1200      = 2;
  baud2400      = 3;
  baud4800      = 4;
  baud9600      = 5;
  baud19200     = 6;
  baudMidi      = 7;
  pica          = $0;
  elite         = $0400;
  fine          = $0800;
  draft         = $0;
  letter        = $0100;
  sixLPI        = $0;
  eightLPI      = $0200;
  imagePositive = 0;
  imageNegative = 1;
  aspectHoriz   = 0;
  aspectVert    = 1;
  shadeBW       = 0;
  shadeGreyscale= 1;
  shadeColor    = 2;
  usLetter      = $0;
  usLegal       = $010;
  nTractor      = $020;
  wTractor      = $030;
  custom        = $040;

  readBits      = $0F0;
  writeBits     = $0F;
  stopBits      = $0F0;
  bufSizeBits   = $0F;
  buf512        = 0;
  buf1024       = 1;
  buf2048       = 2;
  buf4096       = 3;
  buf8000       = 4;
  buf16000      = 5;

TYPE
  Remember      = RECORD
		    nextRemember : RememberPtr;
		    rememberSize : LONGCARD;
		    memory       : ANYPTR;
		  END;

CONST
  deadendAlert  = $80000000;
  recoveryAlert = 0;

TYPE
  DisplayMode   = (hiresPick,lowresPick);

CONST
  dMountCode    = LONGINT(DisplayMode'MAX)+1;
  eventMax      = 10;

TYPE
  Res           = (hiresGadget,lowresGadget);

CONST
  resCount      = LONGINT(Res'MAX)+1;

TYPE
  Gadgets       = (upFrontGadget,downBackGadget,sizeGadget,
		   closeGadget,dragGadget,
		   sUpFrontGadget,sDownBackGadget,sDragGadget);

CONST
  gadgetCount   = LONGINT(Gadgets'MAX)+1;

TYPE
  ILocks        = (iStateLock,layerInfoLock,gadgetsLock,layerRomLock,
		   viewLock,iBaseLock,rpLock);

CONST
  numILocks     = LONGINT(ILocks'MAX)+1;

TYPE
  FatIntuiMessagePtr = POINTER TO FatIntuiMessage;
  FatIntuiMessage    = RECORD OF IntuiMessage
			 prevKeys     : LONGCARD;
		       END;

  IBox            = RECORD
		      left          : INTEGER;
		      top           : INTEGER;
		      width         : INTEGER;
		      height        : INTEGER;
		    END;

  PointPtr        = POINTER TO Point;
  Point           = RECORD
		      x             : INTEGER;
		      y             : INTEGER;
		    END;

  PenPair         = RECORD
		      detailPen     : SHORTCARD;
		      blockPen      : SHORTCARD;
		    END;


  CoordinatesPtr  = POINTER TO Coordinates;
  Coordinates     = RECORD
		      x,
		      y   : CARDINAL;
		    END;



  DrawInfoFlags   = (newLook,makeMeLong=31);
  DrawInfoFlagSet = SET OF DrawInfoFlags;

  DrawInfoPenss   = (detailPen,
		     blockPen,
		     textPen,
		     shinePen,
		     shadowPen,
		     fillPen,
		     fillTextPen,
		     backgroundPen,
		     highlightTextPen);

  DrawInfoPtr     = POINTER TO DrawInfo;
  DrawInfo        = RECORD
		      version       : CARDINAL;
		      numPens       : CARDINAL;
		      pens          : ANYPTR;  | Pointer to Pen-Array ??
		      font          : TextFontPtr;
		      depth         : CARDINAL;
		      resolution    : Coordinates;
		      flags         : DrawInfoFlagSet;
		      reserved      : ARRAY [0..6] OF LONGCARD;
		    END;


(*
 * Package of information passed to custom and 'boopsi'
 * gadget "hook" functions.  This structure is READ ONLY.
 *)

  GadgetInfoPtr = POINTER TO GadgetInfo;
  GadgetInfo    = RECORD
		    screen    : ScreenPtr;
		    window    : WindowPtr;
		    requester : RequesterPtr;
		    |
		    | rendering information:
		    | don't use these without cloning/locking.
		    | Official way is to call ObtainRPort()
		    |
		    rastPort  : RastPortPtr;
		    layer     : LayerPtr;
		    |
		    | copy of dimensions of screen/window/g00/req(/group)
		    | that gadget resides in.  Left/Top of this box is
		    | offset from window mouse coordinates to gadget
		    | coordinates
		    |   screen gadgets           : 0,0 (from screen coords)
		    |   window gadgets (no g00)  : 0,0
		    |   gzzGadget (borderlayer)  : 0,0
		    |   gzz innerlayer gadget    : borderleft, bordertop
		    |   Requester gadgets        : reqleft, reqtop
		    |
		    domain    : IBox;
		    pens      : PenPair;
		    |
		    | the Detail and Block pens in drInfo.pens are
		    | for the screen.  Use the above for window-sensitive
		    | colors.
		    |
		    drInfo    : DrawInfo;
		    |
		    | reserved space: this structure is extensible anyway,
		    | but using these saves some recompilation
		    | (orig. CBM comment).
		    |
		    reserved  : ARRAY [0..5] OF LONGCARD;
		  END;


CONST
  numIEvents = 4;

TYPE
  PGX           = RECORD
		    container   : IBox;
		    newKnob     : IBox;
		  END;

  SGActionFlags   = (use,end,beep,reuese,redisplay,
		     nextActive,prevActive,makeMeLong=31);
  SGActionFlagSet = SET OF SGActionFlags;

  EditOperation   = (null,noOp,delBackward,delForward,
		     moveCursor,enter,reset,replaceChar,
		     insertChar,badFormat,bigChange,undo,
		     clear,special,
		     makeMeWord = $1000);

  SGWorkPtr       = POINTER TO SGWork;
  SGWork          = RECORD
		      gadget       : GadgetPtr;
		      strInfo      : StringInfoPtr;
		      workBuffer,
		      prevBuffer   : SysStringPtr;
		      modes        : StringExtFlagSet;
		      iEvent       : InputEventPtr;
		      code         : CARDINAL;
		      bufferPos,
		      numChars     : INTEGER;
		      actions      : SGActionFlagSet;
		      longInt      : LONGINT;
		      info         : GadgetInfoPtr;
		      editOp       : EditOperation;
		    END;





  IClassPtr  = POINTER TO IClass;
  ObjectPtr  = POINTER TO Object;
  Object     = RECORD OF MinNode;
		 class  :  IClassPtr;
	       END;

  | Dispatched method ID's
  | NOTE: Applications should use Intuition entry points, not direct
  | DoMethod() calls, for NewObject, DisposeObject, SetAttrs,
  | SetGadgetAttrs, and GetAttr.
  |
  | the following enum is for clean access for magic string values in
  | variant RECORD ClassId just below.

  MethodID = (dummy   = $100,  | to start us off
	      new,             | 'object' parameter is "true class"
	      dispose,         | delete self (no parameters)
	      set,             | set attributes (in tag list)
	      get,             | return single attribute value
	      addTail,         | add self to a List (let root do it)
	      remove,          | remove self from list
	      notify,          | send to self: notify dependents
	      update,          | notification message from somebody
	      addMember,       | used by various classes with lists
	      remMember,       | used by various classes with lists
	      ldummy = $10000);| dummy to make the enum a long value

  ClassId   = SysStringPtr;

  |
  | you can use this type to point to a "generic" message,
  | in the object-oriented programming parlance.  Based on
  | the value of 'MethodID', you dispatch to processing
  | for the various message types.  The meaningful parameter
  | packet structure definitions are defined below.
  |
  Msg      = POINTER TO MsgRoot;
  MsgRoot  = RECORD
	       methodId  : MethodID;
	       | method-specific data follows, some examples below
	     END;

CONST
  RootClass      = "rootclass";
  ImageClass     = "imageclass";
  FrameIClass    = "frameiclass";
  SysIClass      = "sysiclass";
  FillRectClass  = "fillrectclass";
  GadgetClass    = "gadgetclass";
  PropGClass     = "propgclass";
  StrGClass      = "strgclass";
  ButtonGClass   = "buttongclass";
  FRButtonGClass = "frbuttonclass";
  GroupGClass    = "groupgclass";
  ICClass        = "icclass";
  ModelClass     = "modelclass";

TYPE
  |
  | ´new´ and ´set´:
  |
  OpSetPtr  = POINTER TO OpSet;
  OpSet     = RECORD OF MsgRoot
		attrList  : ANYPTR;        | Taglist of any tags
		gInfo     : GadgetInfoPtr; | always there for gadgets,
	      END;                         | when SetGadgetAttrs() is used,
					   | but will be NULL for ´new´

  |
  | ´notify´ and ´update´:
  |
  | this flag (interim) means that the update message is being issued from
  | something like an active gadget, a la followMouse.  When  the gadget goes
  | inactive, it will issue a final update message with this bit cleared.
  | Examples of use are for followMouse equivalents for propgadclass, and
  | repeat strobes for buttons.
  |
  OpuFlags   =  (   interim,  opufmax = 31 );
  OpuFlagSet =  SET OF OpuFlags;
  |
  | Message for notify or update Methods
  |
  OpUpdatePtr = POINTER TO OpUpdate;
  OpUpdate    = RECORD OF MsgRoot
		  attrList  : ANYPTR;    | TagList of new attributes
		  gInfo     : GadgetPtr; | non-NULL when SetGadgetAttrs or
					 | notification resultingfrom gadget
					 | input occurs.
		  flags     : OpuFlagSet;
		END;


  |
  | Message for Method 'get'
  |
  OpGetPtr    = POINTER TO OpGet;
  OpGet       = RECORD OF MsgRoot
		  attrId    : LONGCARD;
		  storage   : ANYPTR; | may be other types, but
				      | "int" , types are all LONGCARD
		END;


  |
  | 'addTail' Message
  |
  OpAddTailPtr = POINTER TO OpAddTail;
  OpAddTail    = RECORD OF MsgRoot
		   list     : ListPtr;
		 END;

  |
  | ´addMember´ and ´remMember´ Message
  |
  OpMemberPtr = POINTER TO OpMember;
  OpMember    = RECORD OF MsgRoot
		  object   : ObjectPtr;
		END;

  IClassFlags     = ( inPublicList, icfmax=31 );
  IClassFlagSet   = SET OF IClassFlags;

  IClass    =  RECORD
		 dispatcher   :  Hook;
		 reserved     :  LONGCARD;
		 super        :  IClassPtr;
		 id           :  ClassId;

		 instOffset   :  CARDINAL;
		 instSize     :  CARDINAL;
		 userData     :  LONGCARD;
		 subClassCount:  LONGCARD;
		 objectCount  :  LONGCARD;
		 flags        :  LONGCARD;
	       END;

  Class = IClass;



|
|   GadgetClass
|


CONST
  |
  | Tag offsets
  |
  gaTB          = tagUser + $30000;  | OffSet GadgetClass attributeTags
  pgaTB         = gaTB    + $01000;  | Offset PropGClass attributeTags
  strgTB        = gaTB    + $02000;  | Offset STRGClass attributeTags
  layoTB        = gaTB    + $08000;  | Offset Gadget layout attributeTags

  defaultMaxChars   = 128;


TYPE
  GadgetTags        =
    TAGS OF StdTags
      dummy = tagUser + $30000;
      left           : LONGINT;
      relRight       : LONGINT;
      top            : LONGINT;
      relBottom      : LONGINT;
      width          : LONGINT;
      relWidth       : LONGINT;
      height         : LONGINT;
      relHeight      : LONGINT;
      text           : SysStringPtr;
      image          : ImagePtr;
      border         : BorderPtr;
      selectRender   : ANYPTR;
      highLight      : LONGINT; | ????
      disabled       : LONGBOOL;
      gzzGadget      : LONGBOOL;
      id             : LONGINT;
      userData       : ANYPTR;
      specialInfo    : GadgInfoPtr;
      selected       : LONGBOOL;
      endGadget      : LONGBOOL;
      immediate      : LONGBOOL;
      relVerify      : LONGBOOL;
      followMouse    : LONGBOOL;
      rightBorder    : LONGBOOL;
      leftBorder     : LONGBOOL;
      topBorder      : LONGBOOL;
      bottomBorder   : LONGBOOL;
      toggleSelect   : LONGBOOL;
      sysGadget      : LONGBOOL;
		     |
		     | bool, sets GTYP_SYSGADGET field in type
		     |
      sysGType       : GadgetType;     | internal use only
		     |
		     | e.g., wUpFront , ...
		     |
      previous       : GadgetPtr;
		     |
		     | previous gadget (or GadgetPtrPtr) in linked list
		     | This attribute CANNOT be used to link new gadgets
		     | to an open window or requester. Use AddGList().
		     |
      next           : GadgetPtr;      | not implemented
      drawInfo       : DrawInfoPtr;
		     |
		     | some fancy gadgets need to see a DrawInfo
		     | when created or for layout
		     |
      intuiText      : IntuiTextPtr;
		     |
		     | use at most ONE of text, intuiText, or labelImage
		     |
      labelImage     : ImagePtr;
		     |
		     | an Image object used in place of GadgetText
		     |
      tabCycle       : LONGBOOL;
		     |
		     | indicates that this gadget is to participate in
		     | cycling activation with Tab or Shift-Tab.
    END;

  GadgetTagListPtr  = POINTER TO GadgetTagList;
  GadgetTagList     = ARRAY OF GadgetTags;


  OrientationFlags   = (horizontal,vertical,makeMeLong = 31);
  OrientationFlagSet = SET OF OrientationFlags;

  PropGTags         = TAGS OF GadgetTags
			dummy = tagUser + $31000;

			freedom      : OrientationFlagSet;
			borderless   : LONGCARD;
			horizPot     : LONGCARD;
			horizBody    : LONGCARD;
			vertPot      : LONGCARD;
			vertBody     : LONGCARD;
			total        : LONGCARD;
			visible      : LONGCARD;
			top          : LONGCARD;
			newLook      : LONGBOOL;
		      END;

  TagStrgPtr        = POINTER TO StringTags;
  StringTags        = TAGS OF GadgetTags
			dummy = tagUser + $32000;

			maxChars         : LONGINT;
			buffer           : SysStringPtr;
			undoBuffer       : SysStringPtr;
			workBuffer       : SysStringPtr;
			bufferPos        : SysStringPtr;
			dispPos          : LONGINT;
			altKeyMap        : ANYPTR;
			font             : LONGINT;
			pens             : LONGINT;
			activePens       : LONGINT;
			editHook         : LONGINT;
			editModes        : LONGINT;

			replaceMode      : BOOLEAN;
			fixedFieldMode   : BOOLEAN;
			noFilterMode     : BOOLEAN;

			justification    : GadgetFlagSet;

			longVal          : LONGINT;
			textVal          : SysStringPtr;

			exitHelp         : LONGBOOL;
		      END;

  StringTagListPtr  = POINTER TO StringTagList;
  StringTagList     = ARRAY OF StringTags;


  TagLayoutPtr      = POINTER TO LayoutTags;
  LayoutTags        = TAGS OF GadgetTags
			dummy = tagUser + $38000;
			layoutObj       : LONGINT;
			spacing         : LONGINT;
			orientation     : OrientationFlagSet;
		      END;

  LayoutTagListPtr  = POINTER TO LayoutTagList;
  LayoutTagList     = ARRAY OF LayoutTags;

CONST
    hitTest     = MethodID(0); | return 'gadgetHit' if you are clicked on
			       | (whether or not you are disabled).
    render      = MethodID(1); | draw yourself, in the appropriate state
    goActive    = MethodID(2); | you are now going to be fed input
    handleInput = MethodID(3); | handle that input
    goInactive  = MethodID(4); | whether or not by choice, you are done

CONST
  | HitTest-Return Value :
  gadgetNotHit      =  0;
  gadgetHit         =  4;

TYPE
  |
  | Parameter "Messages" passed to gadget class methods
  |
  | 'hitTest' Message:
  |
  HitTest           = RECORD OF MsgRoot;
			gInfo       : GadgInfo;
			mouse       : Point;
		      END;

  | values for Render.redraw
  |
  RedrawType    = (toggle,reDraw,update,makemelong = 1000000 );

  |
  | 'render' message:
  |
  Render            = RECORD OF MsgRoot;
			gInfo       : GadgInfo;
			rPort       : RastPort;
			redraw      : RedrawType;
		      END;

TYPE
  |
  | 'goActive' and 'handleInput' messages:
  |
  GPInput           = RECORD OF MsgRoot;
			gInfo       : GadgInfo;
			iEvent      : InputEvent;
			termination : POINTER TO LONGINT;
			mouse       : Point;
		      END;


  InputGoActiveCodeFlags = (iga0,noReUse,reUse,verify,nextActive,
			    prevActive);
  IGoActFlagSet          = SET OF InputGoActiveCodeFlags;


  |
  | 'goInactive' message:
  |
  GoInactive        = RECORD OF MsgRoot;
			gInfo       : GadgInfo;
			abort       : LONGBOOL;
		      END;


(* IcClass starts here : *)

CONST
  ioCdummy      = MethodID($0401); | used for nothing
  setLoop       = MethodID($0402); | set/increment loop counter
  clearLoop     = MethodID($0403); | clear/decrement loop counter
  checkLoop     = MethodID($0404); | set/increment loop

  icaTB          = tagUser + $40000;
  icTargetIDCMP  = -1;   (* ? *)

TYPE

  |
  | InterConnection Attribute Tags
  |
  ICATags     = TAGS OF StdTags
		  dummy = tagUser + $40000;
		  target : LONGINT;
		  map    : LONGINT;
		  code   : LONGINT;
		END;

  ICATagListPtr = POINTER TO ICATagList;
  ICATagList    = ARRAY OF ICATags;


CONST
  customImageDepth    = -1;


TYPE
  SYSIAWichValues   = (depthImage=0,zoomImage,sizeImage,closeImage,
		       sDepthImage=5,leftImage=$A,upImage,rightImage,
		       downImage,checkImage,mxImage);

  SYSIASizeValues   = (medRes=0,lowRes,hiRes);


  ImageMessageId    = (draw=$202,
		       hitTest,   | return TRUE if click hits image
		       erase,     | erase yourself
		       move,      | draw new and erase old, smoothly
		       drawFrame, | draw with specified dimensions
		       frameBox,  | get recommended frame around some box
		       hitFrame,  | hittest with dimensions
		       eraseFrame | hittest with dimensions
		      );

(* image draw states or styles, for IM_DRAW *)
 ImageDrawStates    = (normal=0,
		       selected,        | for selected gadgets
		       disabled,        | for disabled gadgets
		       busy,            | for future functionality
		       indeterminant,   | for future functionality
		       inactiveNormal,  | normal, in inactive window border
		       inactiveSelected,| selected, in inactive border
		       inactiveDisabled | disabled, in inactive border
		       );

  TagImagePtr       = POINTER TO ImageTags;
  ImageTags         = TAGS OF StdTags
			dummy = tagUser + $20000;
			left         : LONGINT;
			top          : LONGINT;
			width        : LONGINT;
			height       : LONGINT;
			fgPen        : LONGINT;
			bgPen        : LONGINT;
			data         : LONGINT;
			lineWidth    : LONGINT;
			sysIAShadowPen     : LONGINT;
			sysIAHighLightPen  : LONGINT;
			size         : SYSIASizeValues;
			sysIADepth   : LONGINT;
			sysIAWich    : SYSIAWichValues;
			pens         : ANYPTR; (* ? Pointer to Pens[] *)
			resolution   : LONGCARD;
			aPattern     : LONGINT;
			aPatSize     : LONGINT;
			mode         : LONGINT;
			font         : LONGINT;
			outLine      : LONGINT;
			recessed     : LONGINT;
			doubleEmboss : LONGINT;
			edgesOnly    : LONGINT;
			sysIADrawInfo  : LONGINT;
		      END;

  ImageTagListPtr   = POINTER TO ImageTagList;
  ImageTagList      = ARRAY OF ImageTags;

  ImpFrameBox   = RECORD OF MsgRoot;
		    contentsBox   : IBoxPtr; | input: relative box
					     | of contents
		    frameBox      : IBoxPtr; | output: rel. box of
					     | encl frame
		    drInfo        : DrawInfo;
		    frameFlags    : LONGCARD;
		  END;

  (* es folgen seltsame Macros.... ? *)

  DimensionRec  = RECORD
		    width   : INTEGER;
		    height  : INTEGER;
		  END;

  ImpDraw       = RECORD
		    methodId    : LONGCARD;
		    rPort       : RastPort;
		    offset      : Point;
		    state       : LONGCARD;
		    drInfo      : DrawInfo;
		    (* this parameters only valid in DRAWFRAME *)
		    dimensions  : DimensionRec;
		  END;

(* IM_ERASE, IM_ERASEFRAME      *)
(* NOTE: This is a subset of impDraw    *)
  ImpErase      = RECORD
		    methodId    : LONGCARD;
		    rPort       : RastPort;
		    offset      : Point;
		    (* this parameters only valid in ERASEFRAME *)
		    dimensions  : DimensionRec;
		  END;

  ImpHitTest    = RECORD
		    methodId    : LONGCARD;
		    point       : Point;
		    (* this parameters only valid in HITFRAME *)
		    dimensions  : DimensionRec;
		  END;





(* ------------------ Procedures ----------------------- *)


TYPE
  IntuitionBasePtr  = POINTER TO IntuitionBaseType;
  IntuitionBaseType = RECORD OF Library
			viewLord      : View;
			activeWindow  : WindowPtr;
			activeScreen  : ScreenPtr;
			firstScreen   : ScreenPtr;
			flags         : LONGSET;
			mousey        : INTEGER;
			mousex        : INTEGER;
			seconds       : LONGCARD;
			micros        : LONGCARD;
		      END;




VAR
  IntuitionBase : IntuitionBasePtr;

LIBRARY IntuitionBase BY -30
  PROCEDURE OpenIntuition();

LIBRARY IntuitionBase BY -36
  PROCEDURE Intuition( iEvent IN A0: InputEventPtr );

LIBRARY IntuitionBase BY -42
  PROCEDURE AddGadget( window   IN A0: WindowPtr;
		       gadget   IN A1: GadgetPtr;
		       position IN D0: LONGCARD ): LONGCARD;

LIBRARY IntuitionBase BY -48
  PROCEDURE ClearDMRequest( window IN A0: WindowPtr ): LONGBOOL;

LIBRARY IntuitionBase BY -54
  PROCEDURE ClearMenuStrip( window IN A0: WindowPtr );

LIBRARY IntuitionBase BY -60
  PROCEDURE ClearPointer( window IN A0: WindowPtr );

LIBRARY IntuitionBase BY -66
  PROCEDURE CloseScreen( screen IN A0: ScreenPtr ): LONGBOOL;

LIBRARY IntuitionBase BY -72
  PROCEDURE CloseWindow( window IN A0: WindowPtr );


LIBRARY IntuitionBase BY -78
  PROCEDURE CloseWorkbench(): LONGBOOL;

LIBRARY IntuitionBase BY -78
  PROCEDURE CloseWorkBench(): LONGBOOL;

LIBRARY IntuitionBase BY -84
  PROCEDURE CurrentTime( VAR seconds IN A0: LONGCARD;
			 VAR micros  IN A1: LONGCARD );

LIBRARY IntuitionBase BY -90
  PROCEDURE DisplayAlert(     alertNumber IN D0: LONGCARD;
			  REF string      IN A0: STRING;
			      height      IN D1: LONGINT ): LONGBOOL;

LIBRARY IntuitionBase BY -96
  PROCEDURE DisplayBeep( screen IN A0: ScreenPtr );

LIBRARY IntuitionBase BY -102
  PROCEDURE DoubleClick( sSeconds IN D0 : LONGCARD;
			 sMicros  IN D1 : LONGCARD;
			 cSeconds IN D2 : LONGCARD;
			 cMicros  IN D3 : LONGCARD ): LONGBOOL;

LIBRARY IntuitionBase BY -108
  PROCEDURE DrawBorder( rp         IN A0: RastPortPtr;
			border     IN A1: BorderPtr;
			leftOffset IN D0: LONGINT;
			topOffset  IN D1: LONGINT );

LIBRARY IntuitionBase BY -114
  PROCEDURE DrawImage( rp         IN A0: RastPortPtr;
		       image      IN A1: ImagePtr;
		       leftOffset IN D0: LONGINT;
		       topOffset  IN D1: LONGINT );

LIBRARY IntuitionBase BY -120
  PROCEDURE EndRequest( requester IN A0: RequesterPtr;
			window    IN A1: WindowPtr );

LIBRARY IntuitionBase BY -126
  PROCEDURE GetDefPrefs( preferences IN A0: PreferencesPtr;
			 size        IN D0: LONGINT ): PreferencesPtr;

LIBRARY IntuitionBase BY -132
  PROCEDURE GetPrefs( preferences IN A0: PreferencesPtr;
		      size        IN D0: LONGINT ): PreferencesPtr;

LIBRARY IntuitionBase BY -138
  PROCEDURE InitRequester( requester IN A0: RequesterPtr );

LIBRARY IntuitionBase BY -144
  PROCEDURE ItemAddress( menuStrip  IN A0: MenuPtr;
			 menuNumber IN D0: LONGCARD ): MenuItemPtr;

LIBRARY IntuitionBase BY -150
  PROCEDURE ModifyIDCMP( window IN A0: WindowPtr;
			 flags  IN D0: IDCMPFlagSet ): LONGBOOL;

LIBRARY IntuitionBase BY -156
  PROCEDURE ModifyProp( gadget    IN A0: GadgetPtr;
			window    IN A1: WindowPtr;
			requester IN A2: RequesterPtr;
			flags     IN D0: LONGCARD;
			horizPot  IN D1: LONGCARD;
			vertPot   IN D2: LONGCARD;
			horizBody IN D3: LONGCARD;
			vertBody  IN D4: LONGCARD );

LIBRARY IntuitionBase BY -162
  PROCEDURE MoveScreen( screen IN A0: ScreenPtr;
			dx     IN D0: LONGINT;
			dy     IN D1: LONGINT );

LIBRARY IntuitionBase BY -168
  PROCEDURE MoveWindow( window IN A0: WindowPtr;
			dx     IN D0: LONGINT;
			dy     IN D1: LONGINT );

LIBRARY IntuitionBase BY -174
  PROCEDURE OffGadget( gadget    IN A0: GadgetPtr;
		       window    IN A1: WindowPtr;
		       requester IN A2: RequesterPtr );

LIBRARY IntuitionBase BY -180
  PROCEDURE OffMenu( window     IN A0: WindowPtr;
		     menuNumber IN D0: LONGCARD );

LIBRARY IntuitionBase BY -186
  PROCEDURE OnGadget( gadget    IN A0: GadgetPtr;
		      window    IN A1: WindowPtr;
		      requester IN A2: RequesterPtr );

LIBRARY IntuitionBase BY -192
  PROCEDURE OnMenu( window     IN A0: WindowPtr;
		    menuNumber IN D0: LONGCARD );

LIBRARY IntuitionBase BY -198
  PROCEDURE OpenScreen( REF newScreen IN A0: NewScreen ): ScreenPtr;

LIBRARY IntuitionBase BY -204
  PROCEDURE OpenWindow( REF newWindow IN A0: NewWindow ): WindowPtr;

LIBRARY IntuitionBase BY -210
  PROCEDURE OpenWorkbench(): LONGCARD;

LIBRARY IntuitionBase BY -210
  PROCEDURE OpenWorkBench(): LONGCARD;

LIBRARY IntuitionBase BY -216
  PROCEDURE PrintIText( rp    IN A0: RastPortPtr;
			iText IN A1: IntuiTextPtr;
			left  IN D0: LONGINT;
			top   IN D1: LONGINT );

LIBRARY IntuitionBase BY -222
  PROCEDURE RefreshGadgets( gadgets   IN A0: GadgetPtr;
			    window    IN A1: WindowPtr;
			    requester IN A2: RequesterPtr );

LIBRARY IntuitionBase BY -228
  PROCEDURE RemoveGadget( window IN A0: WindowPtr;
			  gadget IN A1: GadgetPtr ): LONGCARD;

LIBRARY IntuitionBase BY -234
  PROCEDURE ReportMouse( flag   IN D0: LONGBOOL;
			 window IN A0: WindowPtr );

LIBRARY IntuitionBase BY -240
  PROCEDURE Request( requester IN A0: RequesterPtr;
		     window    IN A1: WindowPtr ): LONGBOOL;

LIBRARY IntuitionBase BY -246
  PROCEDURE ScreenToBack( screen IN A0: ScreenPtr );

LIBRARY IntuitionBase BY -252
  PROCEDURE ScreenToFront( screen IN A0: ScreenPtr );

LIBRARY IntuitionBase BY -258
  PROCEDURE SetDMRequest( window    IN A0: WindowPtr;
			  requester IN A1: RequesterPtr ): LONGBOOL;

LIBRARY IntuitionBase BY -264
  PROCEDURE SetMenuStrip( window IN A0: WindowPtr;
			  menu   IN A1: MenuPtr ): LONGBOOL;

LIBRARY IntuitionBase BY -270
  PROCEDURE SetPointer( window  IN A0: WindowPtr;
			pointer IN A1: ANYPTR;
			height  IN D0: LONGINT;
			width   IN D1: LONGINT;
			xOffset IN D2: LONGINT;
			yOffset IN D3: LONGINT );

LIBRARY IntuitionBase BY -276
  PROCEDURE SetWindowTitles( window      IN A0: WindowPtr;
			     windowTitle IN A1: SysStringPtr;
			     screenTitle IN A2: SysStringPtr );

LIBRARY IntuitionBase BY -282
  PROCEDURE ShowTitle( screen IN A0: ScreenPtr;
		       showIt IN D0: LONGBOOL );

LIBRARY IntuitionBase BY -288
  PROCEDURE SizeWindow( window IN A0: WindowPtr;
			dx     IN D0: LONGINT;
			dy     IN D1: LONGINT );

LIBRARY IntuitionBase BY -294
  PROCEDURE ViewAddress(): ViewPtr;

LIBRARY IntuitionBase BY -300
  PROCEDURE ViewPortAddress( window IN A0: WindowPtr ): ViewPortPtr;

LIBRARY IntuitionBase BY -306
  PROCEDURE WindowToBack( window IN A0: WindowPtr );

LIBRARY IntuitionBase BY -312
  PROCEDURE WindowToFront( window IN A0: WindowPtr );

LIBRARY IntuitionBase BY -318
  PROCEDURE WindowLimits( window    IN A0: WindowPtr;
			  widthMin  IN D0: LONGINT;
			  heightMin IN D1: LONGINT;
			  widthMax  IN D2: LONGCARD;
			  heightMax IN D3: LONGCARD ): LONGBOOL;

LIBRARY IntuitionBase BY -324
  PROCEDURE SetPrefs( preferences IN A0: PreferencesPtr;
		      size        IN D0: LONGINT;
		      inform      IN D1: LONGBOOL ): PreferencesPtr;

LIBRARY IntuitionBase BY -330
  PROCEDURE IntuiTextLength( iText IN A0: IntuiTextPtr ): LONGINT;

LIBRARY IntuitionBase BY -336
  PROCEDURE WBenchToBack(): LONGBOOL;

LIBRARY IntuitionBase BY -342
  PROCEDURE WBenchToFront(): LONGBOOL;

LIBRARY IntuitionBase BY -348
  PROCEDURE AutoRequest( window  IN A0: WindowPtr;
			 body    IN A1: IntuiTextPtr;
			 posText IN A2: IntuiTextPtr;
			 negText IN A3: IntuiTextPtr;
			 pFlag   IN D0: LONGCARD;
			 nFlag   IN D1: LONGCARD;
			 width   IN D2: LONGINT;
			 height  IN D3: LONGINT ): LONGBOOL;

LIBRARY IntuitionBase BY -354
  PROCEDURE BeginRefresh( window IN A0: WindowPtr );

LIBRARY IntuitionBase BY -360
  PROCEDURE BuildSysRequest( window  IN A0: WindowPtr;
			     body    IN A1: IntuiTextPtr;
			     posText IN A2: IntuiTextPtr;
			     negText IN A3: IntuiTextPtr;
			     flags   IN D0: LONGCARD;
			     width   IN D1: LONGINT;
			     height  IN D2: LONGINT ): WindowPtr;

LIBRARY IntuitionBase BY -366
  PROCEDURE EndRefresh( window   IN A0: WindowPtr;
			complete IN D0: LONGBOOL );

LIBRARY IntuitionBase BY -372
  PROCEDURE FreeSysRequest( window IN A0: WindowPtr );

LIBRARY IntuitionBase BY -378
  PROCEDURE MakeScreen( screen IN A0: ScreenPtr );

LIBRARY IntuitionBase BY -384
  PROCEDURE RemakeDisplay();

LIBRARY IntuitionBase BY -390
  PROCEDURE RethinkDisplay();

LIBRARY IntuitionBase BY -396
  PROCEDURE AllocRemember( VAR rememberKey IN A0: RememberPtr;
			       size        IN D0: LONGCARD;
			       flags       IN D1: LONGCARD ): ANYPTR;

LIBRARY IntuitionBase BY -408
  PROCEDURE FreeRemember( VAR rememberKey  IN A0: RememberPtr;
			      reallyForget IN D0: LONGBOOL );

LIBRARY IntuitionBase BY -414
  PROCEDURE LockIBase( dontknow IN D0: LONGCARD ): LONGCARD;

LIBRARY IntuitionBase BY -420
  PROCEDURE UnlockIBase( ibLock IN A0: LONGCARD );

LIBRARY IntuitionBase BY -426
  PROCEDURE GetScreenData( buffer IN A0: ANYPTR;
			   size   IN D0: LONGCARD;
			   type   IN D1: LONGCARD;
			   screen IN A1: ScreenPtr ): LONGBOOL;

LIBRARY IntuitionBase BY -432
  PROCEDURE RefreshGList( gadgets   IN A0: GadgetPtr;
			  window    IN A1: WindowPtr;
			  requester IN A2: RequesterPtr;
			  numGad    IN D0: LONGINT );

LIBRARY IntuitionBase BY -438
  PROCEDURE AddGList( window    IN A0: WindowPtr;
		      gadget    IN A1: GadgetPtr;
		      position  IN D0: LONGCARD;
		      numGad    IN D1: LONGINT;
		      requester IN A2: RequesterPtr ): LONGCARD;

LIBRARY IntuitionBase BY -444
  PROCEDURE RemoveGList( window IN A0: WindowPtr;
			 gadget IN A1: GadgetPtr;
			 numGad IN D0: LONGINT ): LONGCARD;

LIBRARY IntuitionBase BY -450
  PROCEDURE ActivateWindow( window IN A0: WindowPtr ): LONGINT;

LIBRARY IntuitionBase BY -456
  PROCEDURE RefreshWindowFrame( window IN A0: WindowPtr );

LIBRARY IntuitionBase BY -462
  PROCEDURE ActivateGadget( gadgets   IN A0: GadgetPtr;
			    window    IN A1: WindowPtr;
			    requester IN A2: RequesterPtr ): LONGBOOL;

LIBRARY IntuitionBase BY -468
  PROCEDURE NewModifyProp( gadget    IN A0: GadgetPtr;
			   window    IN A1: WindowPtr;
			   requester IN A2: RequesterPtr;
			   flags     IN D0: LONGCARD;
			   horizPot  IN D1: LONGCARD;
			   vertPot   IN D2: LONGCARD;
			   horizBody IN D3: LONGCARD;
			   vertBody  IN D4: LONGCARD;
			   numGad    IN D5: LONGINT );

LIBRARY IntuitionBase BY -474
  PROCEDURE QueryOverscan( displayID IN A0: LONGCARD;
			   rect      IN A1: RectanglePtr;
			   oScanType IN D0: LONGINT ): LONGINT;

LIBRARY IntuitionBase BY -480
  PROCEDURE MoveWindowInFrontOf( window       IN A0: WindowPtr;
				 behindWindow IN A1: WindowPtr );

LIBRARY IntuitionBase BY -486
  PROCEDURE ChangeWindowBox( window IN A0: WindowPtr;
			     left   IN D0: LONGINT;
			     top    IN D1: LONGINT;
			     width  IN D2: LONGINT;
			     height IN D3: LONGINT );

LIBRARY IntuitionBase BY -492
  PROCEDURE SetEditHook( hook IN A0: HookPtr ): HookPtr;

LIBRARY IntuitionBase BY -498
  PROCEDURE SetMouseQueue( window      IN A0: WindowPtr;
			   queueLength IN D0: LONGCARD ): LONGINT;

LIBRARY IntuitionBase BY -504
  PROCEDURE ZipWindow( window IN A0: WindowPtr );

LIBRARY IntuitionBase BY -510
  PROCEDURE LockPubScreen( name IN A0: SysStringPtr ): ScreenPtr;

LIBRARY IntuitionBase BY -516
  PROCEDURE UnlockPubScreen( name   IN A0: SysStringPtr;
			     screen IN A1: ScreenPtr );

LIBRARY IntuitionBase BY -522
  PROCEDURE LockPubScreenList(): ListPtr;

LIBRARY IntuitionBase BY -528
  PROCEDURE UnlockPubScreenList();

LIBRARY IntuitionBase BY -534
  PROCEDURE NextPubScreen( screen  IN A0: ScreenPtr;
			   namebuf IN A1: SysStringPtr ): SysStringPtr;

LIBRARY IntuitionBase BY -540
  PROCEDURE SetDefaultPubScreen( name IN A0: SysStringPtr );

LIBRARY IntuitionBase BY -546
  PROCEDURE SetPubScreenModes( modes IN D0: LONGCARD ): LONGCARD;

LIBRARY IntuitionBase BY -552
  PROCEDURE PubScreenStatus( screen      IN A0: ScreenPtr;
			     statusFlags IN D0: LONGCARD ): LONGCARD;

LIBRARY IntuitionBase BY -558
  PROCEDURE ObtainGIRPort( gInfo IN A0: GadgetInfoPtr ): RastPortPtr;

LIBRARY IntuitionBase BY -564
  PROCEDURE ReleaseGIRPort( rp IN A0: RastPortPtr );

LIBRARY IntuitionBase BY -570
  PROCEDURE GadgetMouse( gadget     IN A0: GadgetPtr;
			 gInfo      IN A1: GadgetInfoPtr;
			 mousePoint IN A2: Point );


(* private *)
(*******
LIBRARY IntuitionBase BY -576
  PROCEDURE SetIPrefs( ptr  IN A0: PreferencesPtr;
		       size IN D0: LONGINT;
		       type IN D1: LONGBOOL ): PreferencesPtr;
****)

(* public *)

LIBRARY IntuitionBase BY -582
  PROCEDURE GetDefaultPubScreen( nameBuffer IN A0: SysStringPtr );

LIBRARY IntuitionBase BY -588
  PROCEDURE EasyRequest( window     IN A0: WindowPtr;
			 easyStruct IN A1: EasyStructPtr;
			 idcmpPtr   IN A2: IDCMPFlagSetPtr;
			 args       IN A3: LIST OF LONGINT ): LONGINT;

LIBRARY IntuitionBase BY -594
  PROCEDURE BuildEasyRequestArgs( window     IN A0: WindowPtr;
				  easyStruct IN A1: EasyStructPtr;
				  idcmp      IN D0: IDCMPFlagSet;
				  args       IN A3: ANYPTR ): WindowPtr;

LIBRARY IntuitionBase BY -594
  PROCEDURE BuildEasyRequest( window     IN A0: WindowPtr;
			      easyStruct IN A1: EasyStructPtr;
			      idcmp      IN D0: IDCMPFlagSet;
			      args       IN A3: LIST OF LONGINT):WindowPtr;

LIBRARY IntuitionBase BY -600
  PROCEDURE SysReqHandler( window    IN A0: WindowPtr;
			   idcmpPtr  IN A1: IDCMPFlagSetPtr;
			   waitInput IN D0: LONGBOOL ): LONGINT;

LIBRARY IntuitionBase BY -606
  PROCEDURE OpenWindowTags( newWindow IN A0: NewWindowPtr;
			    tagList   IN A1: LIST OF WindowTags):WindowPtr;

LIBRARY IntuitionBase BY -606
  PROCEDURE OpenWindowTagList(newWindow IN A0: NewWindowPtr;
			      tagList   IN A1: WindowTagListPtr):WindowPtr;

LIBRARY IntuitionBase BY -612
  PROCEDURE OpenScreenTags( newScreen IN A0: NewScreenPtr;
			    tagList   IN A1: LIST OF ScreenTags):ScreenPtr;

LIBRARY IntuitionBase BY -612
  PROCEDURE OpenScreenTagList(newScreen IN A0: NewScreenPtr;
			      tagList   IN A1: ScreenTagListPtr):ScreenPtr;

LIBRARY IntuitionBase BY -618
  PROCEDURE DrawImageState( rp         IN A0: RastPortPtr;
			    image      IN A1: ImagePtr;
			    leftOffset IN D0: LONGINT;
			    topOffset  IN D1: LONGINT;
			    state      IN D2: LONGCARD;
			    drawInfo   IN A2: DrawInfoPtr );

LIBRARY IntuitionBase BY -624
  PROCEDURE PointInImage( point IN D0: Point;
			  image IN A0: ImagePtr ): LONGBOOL;

LIBRARY IntuitionBase BY -630
  PROCEDURE EraseImage( rp         IN A0: RastPortPtr;
			image      IN A1: ImagePtr;
			leftOffset IN D0: LONGINT;
			topOffset  IN D1: LONGINT );

LIBRARY IntuitionBase BY -636
  PROCEDURE NewObjectA( class   IN A0: IClassPtr;
			classID IN A1: ClassId;  (* SysStringPtr *)
		      tagList IN A2: TagArrayPtr ): ANYPTR;

LIBRARY IntuitionBase BY -642
  PROCEDURE DisposeObject( object IN A0: ANYPTR );

LIBRARY IntuitionBase BY -648
  PROCEDURE SetAttrs( object  IN A0: ANYPTR;
		      tagList IN A1: LIST OF StdTags ): LONGCARD;

LIBRARY IntuitionBase BY -648
  PROCEDURE SetAttrsA( object  IN A0: ANYPTR;
		       tagList IN A1: TagArrayPtr ): LONGCARD;

LIBRARY IntuitionBase BY -654
  PROCEDURE GetAttr( attrID     IN D0: LONGCARD;
		     object     IN A0: ANYPTR;
		     storagePtr IN A1: ANYPTR ): LONGCARD;      (* ? *)

LIBRARY IntuitionBase BY -660
  PROCEDURE SetGadgetAttrs( gadget    IN A0: GadgetPtr;
			    window    IN A1: WindowPtr;
			    requester IN A2: RequesterPtr;
			    tagList   IN A3: LIST OF GadgetTags):LONGCARD;

LIBRARY IntuitionBase BY -660
  PROCEDURE SetGadgetAttrsA( gadget    IN A0: GadgetPtr;
			     window    IN A1: WindowPtr;
			     requester IN A2: RequesterPtr;
			     tagList   IN A3: GadgetTagListPtr): LONGCARD;

LIBRARY IntuitionBase BY -666
  PROCEDURE NextObject( objectPtrPtr IN A0: ANYPTR ): ANYPTR;


|*****
|
| private
|
|LIBRARY IntuitionBase BY -672 PROCEDURE FindClass( classID IN A0: #);
|
|******


LIBRARY IntuitionBase BY -678
  PROCEDURE MakeClass( classID       IN A0: SysStringPtr;
		       superClassID  IN A1: SysStringPtr;
		       superClassPtr IN A2: IClassPtr;
		       instanceSize  IN D0: LONGCARD;
		       flags         IN D1: IClassFlagSet ): IClassPtr;

LIBRARY IntuitionBase BY -684
  PROCEDURE AddClass( class IN A0: IClassPtr );

LIBRARY IntuitionBase BY -690
  PROCEDURE GetScreenDrawInfo( screen IN A0: ScreenPtr ): DrawInfoPtr;

LIBRARY IntuitionBase BY -696
  PROCEDURE FreeScreenDrawInfo( screen   IN A0: ScreenPtr;
				drawInfo IN A1: DrawInfoPtr );

LIBRARY IntuitionBase BY -702
  PROCEDURE ResetMenuStrip( window IN A0: WindowPtr;
			    menu   IN A1: MenuPtr ): LONGBOOL;

LIBRARY IntuitionBase BY -708
  PROCEDURE RemoveClass( classPtr IN A0: IClassPtr );

LIBRARY IntuitionBase BY -714
  PROCEDURE FreeClass( classPtr IN A0: IClassPtr ): LONGBOOL;


(* private *)

LIBRARY IntuitionBase BY -720
  PROCEDURE LockPubClass();

LIBRARY IntuitionBase BY -726
  PROCEDURE UnlockPubClass();




GROUP
  WindowGrp  =
       (* I *)    IDCMPGrp,
       (* T *)
		  ExtNewWindow,       ExtNewWindowPtr,    NewWindow,
		  NewWindowPtr,       RastPort ,          RastPortPtr,
		  Window,             WindowFlags,        WindowFlagSet,
		  WindowPtr,
       (* C *)    otherRefresh ,      refreshBits,
       (* P *)    ActivateWindow,     CloseWindow,        ClearMenuStrip,
		  ModifyIDCMP,        MoveWindow,         OpenWindow,
		  OpenWindowTagList,  OpenWindowTags,
		  RefreshWindowFrame,
		  ResetMenuStrip,     SetMenuStrip,       SetWindowTitles,
		  SizeWindow,         WindowLimits,       WindowToBack,
		  WindowToFront;


  GadgetProcGrp =
       (* P *)    ActivateGadget,     AddGadget,          AddGList,
		  ModifyProp,         NewModifyProp,      OffGadget,
		  OnGadget,           RefreshGadgets,     RefreshGList,
		  RemoveGadget,       RemoveGList;

  ImageGrp    =   ImagePtr, Image;

  GadgetGrp   =
	  (* I *) GadgetProcGrp,
		  GadgetPtr,          PropInfoPtr,      StringInfoPtr,
		  GadgetFlags,        GadgetFlagSet,    ActivationFlags,
		  ActivationFlagSet,  gadgHighbits,     gadgHNone,
		  gadgHComp,          GadgetType,       GadgInfoPtr,
		  GadgInfo,           Gadget,           boolMask,
		  BoolInfo,           PropInfoFlags,    PropInfoFlagSet,
		  knobVmin,           knobHmin,         maxBody,
		  maxPot,             PropInfo,         BITSET,
		  StringInfo,         BorderGrp,        ImageGrp,
		  IntuiTextGrp;

  MenuGrp  =
	  (* I *) BITSET,             LONGSET,
	  (* T *) Menu,               MenuItem,           MenuItemFlags,
		  MenuItemFlagSet,    MenuItemPtr,        MenuPtr,
	  (* C *) checkWidth,         commWidth,          highNone,
		  lowCheckWidth,      lowCommWidth,       menuEnabled,
		  miDrawn,
	  (* P *) ClearMenuStrip,     ItemAddress,        OffMenu,
		  OnMenu;


  ReqGrp        =
	  (* P *) AutoRequest,        BuildSysRequest,    ClearDMRequest,
		  DisplayAlert,       EndRequest,         FreeSysRequest,
		  InitRequester,      Request,            SetDMRequest,
		  Requester,          RequesterFlags,
		  RequesterFlagSet,   RequesterPtr,
	  (* C *) deadendAlert,       recoveryAlert;


  ScreenGrp     =
	  (* I *) ViewModeSet,        ViewModes,
	  (* T *) BitMap,             BitMapPtr,          ExtNewScreen,
		  ExtNewScreenPtr,    NewScreen,          NewScreenPtr,
		  RastPortPtr,        Screen,             ScreenFlags,
		  ScreenFlagSet,      ScreenPtr,          ViewPortPtr,
	  (* C *) stdScreenHeight,    customScreen,
	  (* P *) CloseScreen,        CloseWorkbench,     CloseWorkBench,
		  DisplayBeep,        GetScreenData,      LockPubScreen,
		  LockPubScreenList,
		  MakeScreen,         NextPubScreen,
		  MoveScreen,         OpenScreen,
		  OpenScreenTagList,
		  OpenScreenTags,     OpenWorkbench,
		  OpenWorkBench,      ScreenToBack,       ScreenToFront,
		  ShowTitle,          UnlockPubScreen,
		  UnlockPubScreenList,
		  WBenchToBack,
		  WBenchToFront;

  GfxGrp        =
	  (* I *) IntuiTextGrp,       BorderGrp,          ImageGrp,
	  (* P *) ClearPointer,       DrawBorder,         DrawImage,
		  IntuiTextLength,    PrintIText,         SetPointer;


  MemGrp        =
	  (* I *) Exec.MemReqSet,     Exec.MemReqs,
	  (* T *) Remember,           RememberPtr,
	  (* P *) AllocRemember,      FreeRemember;


  RefreshGrp    =
	  (* P *) BeginRefresh,       EndRefresh,         RemakeDisplay,
		  RethinkDisplay;


  TimeGrp       = CurrentTime,        DoubleClick;

  PrefGrp     = GetDefPrefs,        GetPrefs,           SetPrefs,
		filenameSize,       pointerSize,        topazEighty,
		topazSixty,         PrinterPort,        CustomName,
		AlphaP101,          Brother15XL,        CbmMps1000,
		Diab630,            DiabAdvD25,         DiabC150,
		Epson,              EpsonJX80,          Okimate20,
		QumeLP20,           HpLaserjet,         HpLaserjetPlus,
		SerParShk,          SerParShkSet,       Preferences,
		baud110,            baud300,            baud1200,
		baud2400,           baud4800,           baud9600,
		baud19200,          baudMidi,           pica,
		elite,              fine,               draft,
		letter,             sixLPI,             eightLPI,
		imagePositive,      imageNegative,      aspectHoriz,
		aspectVert,         shadeBW,            shadeGreyscale,
		shadeColor,         usLetter,           usLegal,
		nTractor,           wTractor,           custom,
		PaperType,          readBits,
		writeBits,          stopBits,           bufSizeBits,
		buf512,             buf1024,            buf2048,
		buf4096,            buf8000,            buf16000;

  ViewGrp     = ViewAddress, ViewPortAddress;

  LockGrp     = LockIBase, UnlockIBase;

  IntuiIOGrp  = ReportMouse,  IDCMPGrp, Exec.MsgGrp,  Input.EventGrp;

  RecordGrp   =   BoolInfo,           Border,             BorderList,
		  ColorSpec,          Coordinates,        DimensionRec,
		  DrawInfo,           EasyStruct,         ExtNewScreen,
		  ExtNewWindow,       FatIntuiMessage,    Gadget,
		  GadgetInfo,         GadgetInfo,         GadgInfo,
		  GoInactive,         GPInput,
		  HitTest,            IBox,               IClass,
		  Image,              ImpDraw,            ImpErase,
		  ImpFrameBox,        ImpHitTest,         IntuiMessage,
		  IntuiText,          IntuitionBaseType,  Menu,
		  MenuItem,           MsgRoot,            NewScreen,
		  NewWindow,          Object,             OpAddTail,
		  OpGet,              OpMember,           OpSet,
		  OpUpdate,           PenPair,            PGX,
		  Point,              Preferences,        PropInfo,
		  PubScreenNode,      Remember,           Render,
		  Requester,          Screen,             StringInfo,
		  Window;


  All           = IntuiTextGrp,       BorderGrp,          ImageGrp,
		  GadgetGrp,          IDCMPGrp,           WindowGrp,
		  GadgetProcGrp,      MemGrp,             GfxGrp,
		  ReqGrp,             MenuGrp,            ReqGrp,
		  GadgetProcGrp,      ScreenGrp,
		  RefreshGrp,         TimeGrp,            PrefGrp,
		  ViewGrp,            LockGrp,            IntuiIOGrp,
		  DisplayMode,        dMountCode,         eventMax,
		  Res,                resCount,           Gadgets,
		  gadgetCount,        ILocks,             numILocks,
		  FatIntuiMessage,    IBox,               Point,
		  PenPair,
		  GadgetInfo,         numIEvents,         IntuitionBase,
		  IntuitionBasePtr,   IntuitionBaseType;


END Intuition.