{
    This file is part of the Free Pascal run time library.
    Copyright (c) 2004 Karoly Balogh for Genesi S.a.r.l. <www.genesi.lu>

    intuition.library interface unit for MorphOS/PowerPC

    Based on work of Nils Sjoholm member of the Amiga RTL
    development team.

    MorphOS port was done on a free Pegasos II/G4 machine
    provided by Genesi S.a.r.l. <www.genesi.lu>

    See the file COPYING.FPC, included in this distribution,
    for details about the copyright.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

 **********************************************************************}
{$PACKRECORDS 2}

unit intuition;

interface

uses
  exec, graphics, utility, inputevent, timer, layers;


{
 * NOTE:  intuition/iobsolete.h is included at the END of this file!
 }

{ ======================================================================== }
{ === IntuiText ========================================================== }
{ ================================= ======================================= }
{ IntuiText is a series of strings that start with a screen location
 *  (always relative to the upper-left corner of something) and then the
 *  text of the string.  The text is null-terminated.
 }
Type
    pIntuiText = ^tIntuiText;
    tIntuiText = record
        FrontPen,
        BackPen         : Byte;         { the pen numbers for the rendering }
        DrawMode        : Byte;         { the mode for rendering the text }
        LeftEdge        : smallint;        { relative start location for the text }
        TopEdge         : smallint;        { relative start location for the text }
        ITextFont       : pTextAttr;  { if NULL, you accept the default }
        IText           : PChar;       { pointer to null-terminated text }
        NextText        : pIntuiText;   { continuation to TxWrite another text }
    end;



{ ======================================================================== }
{ === Border ============================================================= }
{ ======================================================================== }
{ Data type Border, used for drawing a series of lines which is intended for
 *  use as a border drawing, but which may, in fact, be used to render any
 *  arbitrary vector shape.
 *  The routine DrawBorder sets up the RastPort with the appropriate
 *  variables, then does a Move to the first coordinate, then does Draws
 *  to the subsequent coordinates.
 *  After all the Draws are done, if NextBorder is non-zero we call DrawBorder
 *  recursively
 }
Type
    pBorder = ^tBorder;
    tBorder = record
        LeftEdge,
        TopEdge         : smallint;        { initial offsets from the origin }
        FrontPen,
        BackPen         : Byte;         { pens numbers for rendering }
        DrawMode        : Byte;         { mode for rendering }
        Count           : Shortint;         { number of XY pairs }
        XY              : Pointer;      { vector coordinate pairs rel to LeftTop}
        NextBorder      : pBorder;      { pointer to any other Border too }
    end;

{ ======================================================================== }
{ === MenuItem =========================================================== }
{ ======================================================================== }

Type

    pMenuItem = ^tMenuItem;
    tMenuItem = record
        NextItem        : pMenuItem;    { pointer to next in chained list }
        LeftEdge,
        TopEdge         : smallint;        { position of the select box }
        Width,
        Height          : smallint;        { dimensions of the select box }
        Flags           : Word;        { see the defines below }

        MutualExclude   : Longint;      { set bits mean this item excludes that }

        ItemFill        : Pointer;      { points to Image, IntuiText, or NULL }

    { when this item is pointed to by the cursor and the items highlight
     *  mode HIGHIMAGE is selected, this alternate image will be displayed
     }

        SelectFill      : Pointer;      { points to Image, IntuiText, or NULL }

        Command         : Char;         { only if appliprog sets the COMMSEQ flag }

        SubItem         : pMenuItem;    { if non-zero, DrawMenu shows "->" }

    { The NextSelect field represents the menu number of next selected
     *  item (when user has drag-selected several items)
     }

        NextSelect      : Word;
    end;


Const

{ FLAGS SET BY THE APPLIPROG }
    CHECKIT     = $0001;        { whether to check this item if selected }
    ITEMTEXT    = $0002;        { set if textual, clear if graphical item }
    COMMSEQ     = $0004;        { set if there's an command sequence }
    MENUTOGGLE  = $0008;        { set to toggle the check of a menu item }
    ITEMENABLED = $0010;        { set if this item is enabled }

{ these are the SPECIAL HIGHLIGHT FLAG state meanings }
    HIGHFLAGS   = $00C0;        { see definitions below for these bits }
    HIGHIMAGE   = $0000;        { use the user's "select image" }
    HIGHCOMP    = $0040;        { highlight by complementing the selectbox }
    HIGHBOX     = $0080;        { highlight by "boxing" the selectbox }
    HIGHNONE    = $00C0;        { don't highlight }

{ FLAGS SET BY BOTH APPLIPROG AND INTUITION }
    CHECKED     = $0100;        { if CHECKIT, then set this when selected }

{ FLAGS SET BY INTUITION }
    ISDRAWN     = $1000;        { this item's subs are currently drawn }
    HIGHITEM    = $2000;        { this item is currently highlighted }
    MENUTOGGLED = $4000;        { this item was already toggled }


{ ======================================================================== }
{ === Menu =============================================================== }
{ ======================================================================== }
Type

    pMenu = ^tMenu;
    tMenu = record
        NextMenu        : pMenu;        { same level }
        LeftEdge,
        TopEdge         : smallint;        { position of the select box }
        Width,
        Height          : smallint;        { dimensions of the select box }
        Flags           : Word;        { see flag definitions below }
        MenuName        : PChar;       { text for this Menu Header }
        FirstItem       : pMenuItem;  { pointer to first in chain }

    { these mysteriously-named variables are for internal use only }

        JazzX,
        JazzY,
        BeatX,
        BeatY           : smallint;
    end;

CONST
{ FLAGS SET BY BOTH THE APPLIPROG AND INTUITION }
    MENUENABLED = $0001;        { whether or not this menu is enabled }

{ FLAGS SET BY INTUITION }
    MIDRAWN     = $0100;        { this menu's items are currently drawn }




{ ======================================================================== }
{ === Gadget ============================================================= }
{ ======================================================================== }

Type

    pGadget = ^tGadget;
    tGadget = record
        NextGadget      : pGadget;      { next gadget in the list }

        LeftEdge,
        TopEdge         : smallint;        { "hit box" of gadget }
        Width,
        Height          : smallint;        { "hit box" of gadget }

        Flags           : Word;        { see below for list of defines }

        Activation      : Word;        { see below for list of defines }

        GadgetType      : Word;        { see below for defines }

    { appliprog can specify that the Gadget be rendered as either as Border
     * or an Image.  This variable points to which (or equals NULL if there's
     * nothing to be rendered about this Gadget)
     }

        GadgetRender    : Pointer;

    { appliprog can specify "highlighted" imagery rather than algorithmic
     * this can point to either Border or Image data
     }

        SelectRender    : Pointer;

        GadgetText      : pIntuiText; { text for this gadget }

    { by using the MutualExclude word, the appliprog can describe
     * which gadgets mutually-exclude which other ones.  The bits
     * in MutualExclude correspond to the gadgets in object containing
     * the gadget list.  If this gadget is selected and a bit is set
     * in this gadget's MutualExclude and the gadget corresponding to
     * that bit is currently selected (e.g. bit 2 set and gadget 2
     * is currently selected) that gadget must be unselected.
     * Intuition does the visual unselecting (with checkmarks) and
     * leaves it up to the program to unselect internally
     }

        MutualExclude   : Longint;      { set bits mean this gadget excludes that gadget }

    { pointer to a structure of special data required by Proportional,
     * String and Longint Gadgets
     }

        SpecialInfo     : Pointer;

        GadgetID        : Word;        { user-definable ID field }
        UserData        : Pointer;      { ptr to general purpose User data (ignored by In) }
    end;

 pExtGadget = ^tExtGadget;
 tExtGadget = record
    { The first fields match struct Gadget exactly }
    NextGadget     : pExtGadget;  { Matches struct Gadget }
    LeftEdge, TopEdge,            { Matches struct Gadget }
    Width, Height  : smallint;     { Matches struct Gadget }
    Flags,                        { Matches struct Gadget }
    Activation,                   { Matches struct Gadget }
    GadgetType     : WORD;        { Matches struct Gadget }
    GadgetRender,                 { Matches struct Gadget }
    SelectRender   : Pointer;     { Matches struct Gadget }
    GadgetText     : pIntuiText;  { Matches struct Gadget }
    MutualExclude  : Longint;     { Matches struct Gadget }
    SpecialInfo    : Pointer;     { Matches struct Gadget }
    GadgetID       : WORD;        { Matches struct Gadget }
    UserData       : Pointer;     { Matches struct Gadget }

    { These fields only exist under V39 and only if GFLG_EXTENDED is set }
    MoreFlags      : Cardinal;     { see GMORE_ flags below }
    BoundsLeftEdge,             { Bounding extent for gadget, valid   }
    BoundsTopEdge,              { only if GMORE_BOUNDS is set.  The   }
    BoundsWidth,                { GFLG_RELxxx flags affect these      }
    BoundsHeight   : smallint;      { coordinates as well.        }
 end;


CONST
{ --- Gadget.Flags values      --- }
{ combinations in these bits describe the highlight technique to be used }
 GFLG_GADGHIGHBITS  = $0003;
 GFLG_GADGHCOMP     = $0000;  { Complement the select box }
 GFLG_GADGHBOX      = $0001;  { Draw a box around the image }
 GFLG_GADGHIMAGE    = $0002;  { Blast in this alternate image }
 GFLG_GADGHNONE     = $0003;  { don't highlight }

 GFLG_GADGIMAGE     = $0004;  { set IF GadgetRender AND SelectRender
                                   * point to an Image structure, clear
                                   * if they point to Border structures
                                   }

{ combinations in these next two bits specify to which corner the gadget's
 *  Left & Top coordinates are relative.  If relative to Top/Left,
 *  these are "normal" coordinates (everything is relative to something in
 *  this universe).
 *
 * Gadget positions and dimensions are relative to the window or
 * requester which contains the gadget
 }
 GFLG_RELBOTTOM   = $0008;  { vert. pos. is relative to bottom edge }
 GFLG_RELRIGHT    = $0010;  { horiz. pos. is relative to right edge }
 GFLG_RELWIDTH    = $0020;  { width is relative to req/window    }
 GFLG_RELHEIGHT   = $0040;  { height is relative to req/window   }

{ New for V39: GFLG_RELSPECIAL allows custom gadget implementors to
 * make gadgets whose position and size depend in an arbitrary way
 * on their window's dimensions.  The GM_LAYOUT method will be invoked
 * for such a gadget (or any other GREL_xxx gadget) at suitable times,
 * such as when the window opens or the window's size changes.
 }
 GFLG_RELSPECIAL  = $4000;  { custom gadget has special relativity.
                                   * Gadget box values are absolutes, but
                                   * can be changed via the GM_LAYOUT method.
                                   }

 GFLG_SELECTED    = $0080;  { you may initialize AND look at this        }

{ the GFLG_DISABLED flag is initialized by you and later set by Intuition
 * according to your calls to On/OffGadget().  It specifies whether or not
 * this Gadget is currently disabled from being selected
 }
 GFLG_DISABLED    = $0100;

{ These flags specify the type of text field that Gadget.GadgetText
 * points to.  In all normal (pre-V36) gadgets which you initialize
 * this field should always be zero.  Some types of gadget objects
 * created from classes will use these fields to keep track of
 * types of labels/contents that different from IntuiText, but are
 * stashed in GadgetText.
 }

 GFLG_LABELMASK   = $3000;
 GFLG_LABELITEXT  = $0000;  { GadgetText points to IntuiText     }
 GFLG_LABELSTRING = $1000;  { GadgetText points to (UBYTE *)     }
 GFLG_LABELIMAGE  = $2000;  { GadgetText points to Image (object)        }

{ New for V37: GFLG_TABCYCLE }
 GFLG_TABCYCLE    = $0200;  { (string OR custom) gadget participates in
                                   * cycling activation with Tab or Shift-Tab
                                   }
{ New for V37: GFLG_STRINGEXTEND.  We discovered that V34 doesn't properly
 * ignore the value we had chosen for the Gadget->Activation flag
 * GACT_STRINGEXTEND.  NEVER SET THAT FLAG WHEN RUNNING UNDER V34.
 * The Gadget->Flags bit GFLG_STRINGEXTEND is provided as a synonym which is
 * safe under V34, and equivalent to GACT_STRINGEXTEND under V37.
 * (Note that the two flags are not numerically equal)
 }
 GFLG_STRINGEXTEND = $0400;  { this String Gadget has StringExtend        }

{ New for V39: GFLG_IMAGEDISABLE.  This flag is automatically set if
 * the custom image of this gadget knows how to do disabled rendering
 * (more specifically, if its IA_SupportsDisable attribute is TRUE).
 * Intuition uses this to defer the ghosting to the image-class,
 * instead of doing it itself (the old compatible way).
 * Do not set this flag yourself - Intuition will do it for you.
 }

 GFLG_IMAGEDISABLE = $0800;  { Gadget's image knows how to do disabled
                                   * rendering
                                   }

{ New for V39:  If set, this bit means that the Gadget is actually
 * a struct ExtGadget, with new fields and flags.  All V39 boopsi
 * gadgets are ExtGadgets.  Never ever attempt to read the extended
 * fields of a gadget if this flag is not set.
 }
 GFLG_EXTENDED    = $8000;  { Gadget is extended }

{ ---  Gadget.Activation flag values   --- }
{ Set GACT_RELVERIFY if you want to verify that the pointer was still over
 * the gadget when the select button was released.  Will cause
 * an IDCMP_GADGETUP message to be sent if so.
 }
 GACT_RELVERIFY    = $0001;

{ the flag GACT_IMMEDIATE, when set, informs the caller that the gadget
 *  was activated when it was activated.  This flag works in conjunction with
 *  the GACT_RELVERIFY flag
 }
 GACT_IMMEDIATE    = $0002;

{ the flag GACT_ENDGADGET, when set, tells the system that this gadget,
 * when selected, causes the Requester to be ended.  Requesters
 * that are ended are erased and unlinked from the system.
 }
 GACT_ENDGADGET    = $0004;

{ the GACT_FOLLOWMOUSE flag, when set, specifies that you want to receive
 * reports on mouse movements while this gadget is active.
 * You probably want to set the GACT_IMMEDIATE flag when using
 * GACT_FOLLOWMOUSE, since that's the only reasonable way you have of
 * learning why Intuition is suddenly sending you a stream of mouse
 * movement events.  If you don't set GACT_RELVERIFY, you'll get at
 * least one Mouse Position event.
 }
 GACT_FOLLOWMOUSE = $0008;

{ if any of the BORDER flags are set in a Gadget that's included in the
 * Gadget list when a Window is opened, the corresponding Border will
 * be adjusted to make room for the Gadget
 }
 GACT_RIGHTBORDER = $0010;
 GACT_LEFTBORDER  = $0020;
 GACT_TOPBORDER   = $0040;
 GACT_BOTTOMBORDER= $0080;
 GACT_BORDERSNIFF = $8000;  { neither set nor rely on this bit   }

 GACT_TOGGLESELECT= $0100;  { this bit for toggle-select mode }
 GACT_BOOLEXTEND  = $2000;  { this Boolean Gadget has a BoolInfo }

{ should properly be in StringInfo, but aren't }
 GACT_STRINGLEFT  = $0000;  { NOTE WELL: that this has value zero        }
 GACT_STRINGCENTER= $0200;
 GACT_STRINGRIGHT = $0400;
 GACT_LONGINT     = $0800;  { this String Gadget is for Long Ints        }
 GACT_ALTKEYMAP   = $1000;  { this String has an alternate keymap        }
 GACT_STRINGEXTEND= $2000;  { this String Gadget has StringExtend        }
                                  { NOTE: NEVER SET GACT_STRINGEXTEND IF YOU
                                   * ARE RUNNING ON LESS THAN V36!  SEE
                                   * GFLG_STRINGEXTEND (ABOVE) INSTEAD
                                   }

 GACT_ACTIVEGADGET = $4000;  { this gadget is "active".  This flag
                                   * is maintained by Intuition, and you
                                   * cannot count on its value persisting
                                   * while you do something on your program's
                                   * task.  It can only be trusted by
                                   * people implementing custom gadgets
                                   }

{ note $8000 is used above (GACT_BORDERSNIFF);
 * all Activation flags defined }

{ --- GADGET TYPES ------------------------------------------------------- }
{ These are the Gadget Type definitions for the variable GadgetType
 * gadget number type MUST start from one.  NO TYPES OF ZERO ALLOWED.
 * first comes the mask for Gadget flags reserved for Gadget typing
 }
 GTYP_GADGETTYPE = $FC00;  { all Gadget Global Type flags (padded) }
 GTYP_SYSGADGET  = $8000;  { 1 = Allocated by the system, 0 = by app. }
 GTYP_SCRGADGET  = $4000;  { 1 = ScreenGadget, 0 = WindowGadget }
 GTYP_GZZGADGET  = $2000;  { 1 = for WFLG_GIMMEZEROZERO borders }
 GTYP_REQGADGET  = $1000;  { 1 = this is a Requester Gadget }
{ system gadgets }
 GTYP_SIZING     = $0010;
 GTYP_WDRAGGING  = $0020;
 GTYP_SDRAGGING  = $0030;
 GTYP_WUPFRONT   = $0040;
 GTYP_SUPFRONT   = $0050;
 GTYP_WDOWNBACK  = $0060;
 GTYP_SDOWNBACK  = $0070;
 GTYP_CLOSE      = $0080;
{ application gadgets }
 GTYP_BOOLGADGET = $0001;
 GTYP_GADGET0002 = $0002;
 GTYP_PROPGADGET = $0003;
 GTYP_STRGADGET  = $0004;
 GTYP_CUSTOMGADGET    =   $0005;


{* GTYP_GTYPEMASK is a mask you can apply to tell what class
 * of gadget this is.  The possible classes follow.
 *}
 GTYP_GTYPEMASK        =  $0007;

{ This bit in GadgetType is reserved for undocumented internal use
 * by the Gadget Toolkit, and cannot be used nor relied on by
 * applications:        $0100;
 }

{ New for V39.  Gadgets which have the GFLG_EXTENDED flag set are
 * actually ExtGadgets, which have more flags.  The GMORE_xxx
 * identifiers describe those flags.  For GMORE_SCROLLRASTER, see
 * important information in the ScrollWindowRaster() autodoc.
 * NB: GMORE_SCROLLRASTER must be set before the gadget is
 * added to a window.
 }
 GMORE_BOUNDS       = $00000001; { ExtGadget has valid Bounds }
 GMORE_GADGETHELP   = $00000002; { This gadget responds to gadget help }
 GMORE_SCROLLRASTER = $00000004; { This (custom) gadget uses ScrollRaster }

{ ======================================================================== }
{ === BoolInfo======================================================= }
{ ======================================================================== }
{ This is the special data needed by an Extended Boolean Gadget
 * Typically this structure will be pointed to by the Gadget field SpecialInfo
 }
Type
    pBoolInfo = ^tBoolInfo;
    tBoolInfo = record
        Flags   : Word;        { defined below }
        Mask    : Pointer; { bit mask for highlighting and selecting
                         * mask must follow the same rules as an Image
                         * plane.  It's width and height are determined
                         * by the width and height of the gadget's
                         * select box. (i.e. Gadget.Width and .Height).
                         }
        Reserved : Cardinal;     { set to 0      }
    end;

Const

{ set BoolInfo.Flags to this flag bit.
 * in the future, additional bits might mean more stuff hanging
 * off of BoolInfo.Reserved.
}
    BOOLMASK    = $0001;        { extension is for masked gadget }

{ ======================================================================== }
{ === PropInfo =========================================================== }
{ ======================================================================== }
{ this is the special data required by the proportional Gadget
 * typically, this data will be pointed to by the Gadget variable SpecialInfo
 }

Type

    pPropInfo = ^tPropInfo;
    tPropInfo = record
        Flags   : Word;        { general purpose flag bits (see defines below) }

    { You initialize the Pot variables before the Gadget is added to
     * the system.  Then you can look here for the current settings
     * any time, even while User is playing with this Gadget.  To
     * adjust these after the Gadget is added to the System, use
     * ModifyProp();  The Pots are the actual proportional settings,
     * where a value of zero means zero and a value of MAXPOT means
     * that the Gadget is set to its maximum setting.
     }

        HorizPot        : WORD; { 16-bit FixedPoint horizontal quantity percentage }
        VertPot         : WORD; { 16-bit FixedPoint vertical quantity percentage }

    { the 16-bit FixedPoint Body variables describe what percentage of
     * the entire body of stuff referred to by this Gadget is actually
     * shown at one time.  This is used with the AUTOKNOB routines,
     * to adjust the size of the AUTOKNOB according to how much of
     * the data can be seen.  This is also used to decide how far
     * to advance the Pots when User hits the Container of the Gadget.
     * For instance, if you were controlling the display of a 5-line
     * Window of text with this Gadget, and there was a total of 15
     * lines that could be displayed, you would set the VertBody value to
     *     (MAXBODY / (TotalLines / DisplayLines)) = MAXBODY / 3.
     * Therefore, the AUTOKNOB would fill 1/3 of the container, and
     * if User hits the Cotainer outside of the knob, the pot would
     * advance 1/3 (plus or minus) If there's no body to show, or
     * the total amount of displayable info is less than the display area,
     * set the Body variables to the MAX.  To adjust these after the
     * Gadget is added to the System, use ModifyProp();
     }

        HorizBody       : Word;        { horizontal Body }
        VertBody        : Word;        { vertical Body }

    { these are the variables that Intuition sets and maintains }

        CWidth          : Word;        { Container width (with any relativity absoluted) }
        CHeight         : Word;        { Container height (with any relativity absoluted) }
        HPotRes,
        VPotRes         : Word;        { pot increments }
        LeftBorder      : Word;        { Container borders }
        TopBorder       : Word;        { Container borders }
    end;

CONST
{ --- FLAG BITS ---------------------------------------------------------- }
 AUTOKNOB     =   $0001;  { this flag sez:  gimme that old auto-knob }
{ NOTE: if you do not use an AUTOKNOB for a proportional gadget,
 * you are currently limited to using a single Image of your own
 * design: Intuition won't handle a linked list of images as
 * a proportional gadget knob.
 }

 FREEHORIZ     =  $0002;  { IF set, the knob can move horizontally }
 FREEVERT      =  $0004;  { IF set, the knob can move vertically }
 PROPBORDERLESS =  $0008;  { IF set, no border will be rendered }
 KNOBHIT       =  $0100;  { set when this Knob is hit }
 PROPNEWLOOK   =  $0010;  { set this IF you want to get the new
                                 * V36 look
                                 }

 KNOBHMIN      =  6;       { minimum horizontal size of the Knob }
 KNOBVMIN      =  4;       { minimum vertical size of the Knob }
 MAXBODY       =  $FFFF;  { maximum body value }
 MAXPOT        =  $FFFF;  { maximum pot value }

{ ======================================================================== }
{ === StringInfo ========================================================= }
{ ======================================================================== }
{ this is the special data required by the string Gadget
 * typically, this data will be pointed to by the Gadget variable SpecialInfo
 }

Type

    pStringInfo = ^tStringInfo;
    tStringInfo = record
    { you initialize these variables, and then Intuition maintains them }
        Buffer          : PChar;       { the buffer containing the start and final string }
        UndoBuffer      : PChar;       { optional buffer for undoing current entry }
        BufferPos       : smallint;        { character position in Buffer }
        MaxChars        : smallint;        { max number of chars in Buffer (including NULL) }
        DispPos         : smallint;        { Buffer position of first displayed character }

    { Intuition initializes and maintains these variables for you }

        UndoPos         : smallint;        { character position in the undo buffer }
        NumChars        : smallint;        { number of characters currently in Buffer }
        DispCount       : smallint;        { number of whole characters visible in Container }
        CLeft,
        CTop            : smallint;        { topleft offset of the container }

    { you can initialize this variable before the gadget is submitted to
     * Intuition, and then examine it later to discover what Longint
     * the user has entered (if the user never plays with the gadget,
     * the value will be unchanged from your initial setting)
     }
        Extension       : Pointer;
        _LongInt         : Longint;

    { If you want this Gadget to use your own Console keymapping, you
     * set the ALTKEYMAP bit in the Activation flags of the Gadget, and then
     * set this variable to point to your keymap.  If you don't set the
     * ALTKEYMAP, you'll get the standard ASCII keymapping.
     }

        AltKeyMap       : Pointer;
    end;


{ ======================================================================== }
{ === Requester ========================================================== }
{ ======================================================================== }

Type

    pRequester = ^tRequester;
    tRequester = record
    { the ClipRect and BitMap and used for rendering the requester }
        OlderRequest    : pRequester;
        LeftEdge,
        TopEdge         : smallint;        { dimensions of the entire box }
        Width,
        Height          : smallint;        { dimensions of the entire box }
        RelLeft,
        RelTop          : smallint;        { for Pointer relativity offsets }

        ReqGadget       : pGadget;    { pointer to a list of Gadgets }
        ReqBorder       : pBorder;    { the box's border }
        ReqText         : pIntuiText; { the box's text }
        Flags           : Word;        { see definitions below }

    { pen number for back-plane fill before draws }

        BackFill        : Byte;

    { Layer in place of clip rect       }

        ReqLayer        : pLayer;

        ReqPad1         : Array [0..31] of Byte;

    { If the BitMap plane pointers are non-zero, this tells the system
     * that the image comes pre-drawn (if the appliprog wants to define
     * it's own box, in any shape or size it wants!);  this is OK by
     * Intuition as long as there's a good correspondence between
     * the image and the specified Gadgets
     }

        ImageBMap       : pBitMap;    { points to the BitMap of PREDRAWN imagery }
        RWindow         : Pointer;      { added.  points back to Window }
        ReqImage        : Pointer;
        ReqPad2         : Array [0..31] of Shortint;
    end;


Const

{ FLAGS SET BY THE APPLIPROG }
    POINTREL            = $0001;    { if POINTREL set, TopLeft is relative to pointer}
    PREDRAWN            = $0002;    { if ReqBMap points to predrawn Requester imagery }
    NOISYREQ            = $0004;    { if you don't want requester to filter input          }

    SIMPLEREQ           = $0010;
        { to use SIMPLEREFRESH layer (recommended)     }

    { New for V36          }
    USEREQIMAGE         = $0020;
         {  render linked list ReqImage after BackFill
         * but before gadgets and text
         }
    NOREQBACKFILL       = $0040;
        { don't bother filling requester with Requester.BackFill pen   }


{ FLAGS SET BY INTUITION }
    REQOFFWINDOW        = $1000;        { part of one of the Gadgets was offwindow }
    REQACTIVE           = $2000;        { this requester is active }
    SYSREQUEST          = $4000;        { this requester caused by system }
    DEFERREFRESH        = $8000;        { this Requester stops a Refresh broadcast }




{ ======================================================================== }
{ === Image ============================================================== }
{ ======================================================================== }
{ This is a brief image structure for very simple transfers of
 * image data to a RastPort
 }

Type
    pImage = ^tImage;
    tImage = record
        LeftEdge        : smallint;        { starting offset relative to some origin }
        TopEdge         : smallint;        { starting offsets relative to some origin }
        Width           : smallint;        { pixel size (though data is word-aligned) }
        Height,
        Depth           : smallint;        { pixel sizes }
        ImageData       : Pointer;      { pointer to the actual word-aligned bits }

    { the PlanePick and PlaneOnOff variables work much the same way as the
     * equivalent GELS Bob variables.  It's a space-saving
     * mechanism for image data.  Rather than defining the image data
     * for every plane of the RastPort, you need define data only
     * for the planes that are not entirely zero or one.  As you
     * define your Imagery, you will often find that most of the planes
     * ARE just as color selectors.  For instance, if you're designing
     * a two-color Gadget to use colors two and three, and the Gadget
     * will reside in a five-plane display, bit plane zero of your
     * imagery would be all ones, bit plane one would have data that
     * describes the imagery, and bit planes two through four would be
     * all zeroes.  Using these flags allows you to avoid wasting all
     * that memory in this way:  first, you specify which planes you
     * want your data to appear in using the PlanePick variable.  For
     * each bit set in the variable, the next "plane" of your image
     * data is blitted to the display.  For each bit clear in this
     * variable, the corresponding bit in PlaneOnOff is examined.
     * If that bit is clear, a "plane" of zeroes will be used.
     * If the bit is set, ones will go out instead.  So, for our example:
     *   Gadget.PlanePick = $02;
     *   Gadget.PlaneOnOff = $01;
     * Note that this also allows for generic Gadgets, like the
     * System Gadgets, which will work in any number of bit planes.
     * Note also that if you want an Image that is only a filled
     * rectangle, you can get this by setting PlanePick to zero
     * (pick no planes of data) and set PlaneOnOff to describe the pen
     * color of the rectangle.
     }

        PlanePick,
        PlaneOnOff      : Byte;

    { if the NextImage variable is not NULL, Intuition presumes that
     * it points to another Image structure with another Image to be
     * rendered
     }

        NextImage       : pImage;
    end;


{ New for V39, Intuition supports the IESUBCLASS_NEWTABLET subclass
 * of the IECLASS_NEWPOINTERPOS event.  The ie_EventAddress of such
 * an event points to a TabletData structure (see below).
 *
 * The TabletData structure contains certain elements including a taglist.
 * The taglist can be used for special tablet parameters.  A tablet driver
 * should include only those tag-items the tablet supports.  An application
 * can listen for any tag-items that interest it.  Note: an application
 * must set the WA_TabletMessages attribute to TRUE to receive this
 * extended information in its IntuiMessages.
 *
 * The definitions given here MUST be followed.  Pay careful attention
 * to normalization and the interpretation of signs.
 *
 * TABLETA_TabletZ:  the current value of the tablet in the Z direction.
 * This unsigned value should typically be in the natural units of the
 * tablet.  You should also provide TABLETA_RangeZ.
 *
 * TABLETA_RangeZ:  the maximum value of the tablet in the Z direction.
 * Normally specified along with TABLETA_TabletZ, this allows the
 * application to scale the actual Z value across its range.
 *
 * TABLETA_AngleX:  the angle of rotation or tilt about the X-axis.  This
 * number should be normalized to fill a signed long Longint.  Positive
 * values imply a clockwise rotation about the X-axis when viewing
 * from +X towards the origin.
 *
 * TABLETA_AngleY:  the angle of rotation or tilt about the Y-axis.  This
 * number should be normalized to fill a signed long Longint.  Positive
 * values imply a clockwise rotation about the Y-axis when viewing
 * from +Y towards the origin.
 *
 * TABLETA_AngleZ:  the angle of rotation or tilt about the Z axis.  This
 * number should be normalized to fill a signed long Longint.  Positive
 * values imply a clockwise rotation about the Z-axis when viewing
 * from +Z towards the origin.
 *
 *      Note: a stylus that supports tilt should use the TABLETA_AngleX
 *      and TABLETA_AngleY attributes.  Tilting the stylus so the tip
 *      points towards increasing or decreasing X is actually a rotation
 *      around the Y-axis.  Thus, if the stylus tip points towards
 *      positive X, then that tilt is represented as a negative
 *      TABLETA_AngleY.  Likewise, if the stylus tip points towards
 *      positive Y, that tilt is represented by positive TABLETA_AngleX.
 *
 * TABLETA_Pressure:  the pressure reading of the stylus.  The pressure
 * should be normalized to fill a signed long Longint.  Typical devices
 * won't generate negative pressure, but the possibility is not precluded.
 * The pressure threshold which is considered to cause a button-click is
 * expected to be set in a Preferences program supplied by the tablet
 * vendor.  The tablet driver would send IECODE_LBUTTON-type events as
 * the pressure crossed that threshold.
 *
 * TABLETA_ButtonBits:  ti_Data is a long Longint whose bits are to
 * be interpreted at the state of the first 32 buttons of the tablet.
 *
 * TABLETA_InProximity:  ti_Data is a boolean.  For tablets that support
 * proximity, they should send the (TABLETA_InProximity,FALSE) tag item
 * when the stylus is out of proximity.  One possible use we can forsee
 * is a mouse-blanking commodity which keys off this to blank the
 * mouse.  When this tag is absent, the stylus is assumed to be
 * in proximity.
 *
 * TABLETA_ResolutionX:  ti_Data is an unsigned long Longint which
 * is the x-axis resolution in dots per inch.
 *
 * TABLETA_ResolutionY:  ti_Data is an unsigned long Longint which
 * is the y-axis resolution in dots per inch.
 }

const
 TABLETA_Dummy          = (TAG_USER + $3A000)  ;
 TABLETA_TabletZ        = (TABLETA_Dummy + $01);
 TABLETA_RangeZ         = (TABLETA_Dummy + $02);
 TABLETA_AngleX         = (TABLETA_Dummy + $03);
 TABLETA_AngleY         = (TABLETA_Dummy + $04);
 TABLETA_AngleZ         = (TABLETA_Dummy + $05);
 TABLETA_Pressure       = (TABLETA_Dummy + $06);
 TABLETA_ButtonBits     = (TABLETA_Dummy + $07);
 TABLETA_InProximity    = (TABLETA_Dummy + $08);
 TABLETA_ResolutionX    = (TABLETA_Dummy + $09);
 TABLETA_ResolutionY    = (TABLETA_Dummy + $0A);

{ If your window sets WA_TabletMessages to TRUE, then it will receive
 * extended IntuiMessages (struct ExtIntuiMessage) whose eim_TabletData
 * field points at a TabletData structure.  This structure contains
 * additional information about the input event.
 }

Type
 pTabletData = ^tTabletData;
 tTabletData = record
    { Sub-pixel position of tablet, in screen coordinates,
     * scaled to fill a UWORD fraction:
     }
    td_XFraction, td_YFraction  : WORD;

    { Current tablet coordinates along each axis: }
    td_TabletX, td_TabletY      : Cardinal;

    { Tablet range along each axis.  For example, if td_TabletX
     * can take values 0-999, td_RangeX should be 1000.
     }
    td_RangeX, td_RangeY        : Cardinal;

    { Pointer to tag-list of additional tablet attributes.
     * See <intuition/intuition.h> for the tag values.
     }
    td_TagList                  : pTagItem;
 end;

{ If a tablet driver supplies a hook for ient_CallBack, it will be
 * invoked in the standard hook manner.  A0 will point to the Hook
 * itself, A2 will point to the InputEvent that was sent, and
 * A1 will point to a TabletHookData structure.  The InputEvent's
 * ie_EventAddress field points at the IENewTablet structure that
 * the driver supplied.
 *
 * Based on the thd_Screen, thd_Width, and thd_Height fields, the driver
 * should scale the ient_TabletX and ient_TabletY fields and store the
 * result in ient_ScaledX, ient_ScaledY, ient_ScaledXFraction, and
 * ient_ScaledYFraction.
 *
 * The tablet hook must currently return NULL.  This is the only
 * acceptable return-value under V39.
 }

 pTabletHookData = ^tTabletHookData;
 tTabletHookData = record
    { Pointer to the active screen:
     * Note: if there are no open screens, thd_Screen will be NULL.
     * thd_Width and thd_Height will then describe an NTSC 64$400
     * screen.  Please scale accordingly.
     }
    thd_Screen      : Pointer;

    { The width and height (measured in pixels of the active screen)
     * that your are to scale to:
     }
    thd_Width,
    thd_Height      : Cardinal;

    { Non-zero if the screen or something about the screen
     * changed since the last time you were invoked:
     }
    thd_ScreenChanged   : Longint;
 end;


{ ======================================================================== }
{ === IntuiMessage ======================================================= }
{ ======================================================================== }

Type

    pIntuiMessage = ^tIntuiMessage;
    tIntuiMessage = record
        ExecMessage     : tMessage;

    { the Class bits correspond directly with the IDCMP Flags, except for the
     * special bit LONELYMESSAGE (defined below)
     }

        IClass           : Cardinal;

    { the Code field is for special values like MENU number }

        Code            : Word;

    { the Qualifier field is a copy of the current InputEvent's Qualifier }

        Qualifier       : Word;

    { IAddress contains particular addresses for Intuition functions, like
     * the pointer to the Gadget or the Screen
     }

        IAddress        : Pointer;

    { when getting mouse movement reports, any event you get will have the
     * the mouse coordinates in these variables.  the coordinates are relative
     * to the upper-left corner of your Window (GIMMEZEROZERO notwithstanding)
     }

        MouseX,
        MouseY          : smallint;

    { the time values are copies of the current system clock time.  Micros
     * are in units of microseconds, Seconds in seconds.
     }

        Seconds,
        Micros          : Cardinal;

    { the IDCMPWindow variable will always have the Pointer of the Window of
     * this IDCMP
     }

        IDCMPWindow     : Pointer;

    { system-use variable }

        SpecialLink     : pIntuiMessage;
    end;

{ New for V39:
 * All IntuiMessages are now slightly extended.  The ExtIntuiMessage
 * structure has an additional field for tablet data, which is usually
 * NULL.  If a tablet driver which is sending IESUBCLASS_NEWTABLET
 * events is installed in the system, windows with the WA_TabletMessages
 * property set will find that eim_TabletData points to the TabletData
 * structure.  Applications must first check that this field is non-NULL;
 * it will be NULL for certain kinds of message, including mouse activity
 * generated from other than the tablet (i.e. the keyboard equivalents
 * or the mouse itself).
 *
 * NEVER EVER examine any extended fields when running under pre-V39!
 *
 * NOTE: This structure is subject to grow in the future.  Making
 * assumptions about its size is A BAD IDEA.
 }

 pExtIntuiMessage = ^tExtIntuiMessage;
 tExtIntuiMessage = record
    eim_IntuiMessage  : tIntuiMessage;
    eim_TabletData    : pTabletData;
 end;


CONST

{ --- IDCMP Classes ------------------------------------------------------ }
{ Please refer to the Autodoc for OpenWindow() and to the Rom Kernel
 * Manual for full details on the IDCMP classes.
 }
 IDCMP_SIZEVERIFY      =  $00000001;
 IDCMP_NEWSIZE         =  $00000002;
 IDCMP_REFRESHWINDOW   =  $00000004;
 IDCMP_MOUSEBUTTONS    =  $00000008;
 IDCMP_MOUSEMOVE       =  $00000010;
 IDCMP_GADGETDOWN      =  $00000020;
 IDCMP_GADGETUP        =  $00000040;
 IDCMP_REQSET          =  $00000080;
 IDCMP_MENUPICK        =  $00000100;
 IDCMP_CLOSEWINDOW     =  $00000200;
 IDCMP_RAWKEY          =  $00000400;
 IDCMP_REQVERIFY       =  $00000800;
 IDCMP_REQCLEAR        =  $00001000;
 IDCMP_MENUVERIFY      =  $00002000;
 IDCMP_NEWPREFS        =  $00004000;
 IDCMP_DISKINSERTED    =  $00008000;
 IDCMP_DISKREMOVED     =  $00010000;
 IDCMP_WBENCHMESSAGE   =  $00020000;  {  System use only         }
 IDCMP_ACTIVEWINDOW    =  $00040000;
 IDCMP_INACTIVEWINDOW  =  $00080000;
 IDCMP_DELTAMOVE       =  $00100000;
 IDCMP_VANILLAKEY      =  $00200000;
 IDCMP_INTUITICKS      =  $00400000;
{  for notifications from "boopsi" gadgets               }
 IDCMP_IDCMPUPDATE     =  $00800000;  { new for V36      }
{ for getting help key report during menu session        }
 IDCMP_MENUHELP        =  $01000000;  { new for V36      }
{ for notification of any move/size/zoom/change window   }
 IDCMP_CHANGEWINDOW    =  $02000000;  { new for V36      }
 IDCMP_GADGETHELP      =  $04000000;  { new for V39      }

{ NOTEZ-BIEN:                          $80000000 is reserved for internal use   }

{ the IDCMP Flags do not use this special bit, which is cleared when
 * Intuition sends its special message to the Task, and set when Intuition
 * gets its Message back from the Task.  Therefore, I can check here to
 * find out fast whether or not this Message is available for me to send
 }
 IDCMP_LONELYMESSAGE   =  $80000000;


{ --- IDCMP Codes -------------------------------------------------------- }
{ This group of codes is for the IDCMP_CHANGEWINDOW message }
 CWCODE_MOVESIZE = $0000;  { Window was moved and/or sized }
 CWCODE_DEPTH    = $0001;  { Window was depth-arranged (new for V39) }

{ This group of codes is for the IDCMP_MENUVERIFY function }
 MENUHOT       =  $0001;  { IntuiWants verification OR MENUCANCEL    }
 MENUCANCEL    =  $0002;  { HOT Reply of this cancels Menu operation }
 MENUWAITING   =  $0003;  { Intuition simply wants a ReplyMsg() ASAP }

{ These are internal tokens to represent state of verification attempts
 * shown here as a clue.
 }
 OKOK          =  MENUHOT; { guy didn't care                      }
 OKABORT       =  $0004;  { window rendered question moot        }
 OKCANCEL      =  MENUCANCEL; { window sent cancel reply          }

{ This group of codes is for the IDCMP_WBENCHMESSAGE messages }
 WBENCHOPEN    =  $0001;
 WBENCHCLOSE   =  $0002;


{ A data structure common in V36 Intuition processing  }
Type
   pIBox = ^tIBox;
   tIBox = record
    Left,
    Top,
    Width,
    Height : smallint;
   END;


{ ======================================================================== }
{ === Window ============================================================= }
{ ======================================================================== }

Type

    pWindow = ^tWindow;
    tWindow = record
        NextWindow      : pWindow;      { for the linked list in a screen }

        LeftEdge,
        TopEdge         : smallint;        { screen dimensions of window }
        Width,
        Height          : smallint;        { screen dimensions of window }

        MouseY,
        MouseX          : smallint;        { relative to upper-left of window }

        MinWidth,
        MinHeight       : smallint;        { minimum sizes }
        MaxWidth,
        MaxHeight       : smallint;        { maximum sizes }

        Flags           : Cardinal;      { see below for defines }

        MenuStrip       : pMenu;      { the strip of Menu headers }

        Title           : PChar;       { the title text for this window }

        FirstRequest    : pRequester; { all active Requesters }

        DMRequest       : pRequester; { double-click Requester }

        ReqCount        : smallint;        { count of reqs blocking Window }

        WScreen         : Pointer;      { this Window's Screen }
        RPort           : pRastPort;  { this Window's very own RastPort }

    { the border variables describe the window border.   If you specify
     * GIMMEZEROZERO when you open the window, then the upper-left of the
     * ClipRect for this window will be upper-left of the BitMap (with correct
     * offsets when in SuperBitMap mode; you MUST select GIMMEZEROZERO when
     * using SuperBitMap).  If you don't specify ZeroZero, then you save
     * memory (no allocation of RastPort, Layer, ClipRect and associated
     * Bitmaps), but you also must offset all your writes by BorderTop,
     * BorderLeft and do your own mini-clipping to prevent writing over the
     * system gadgets
     }

        BorderLeft,
        BorderTop,
        BorderRight,
        BorderBottom    : Shortint;
        BorderRPort     : pRastPort;


    { You supply a linked-list of Gadgets for your Window.
     * This list DOES NOT include system gadgets.  You get the standard
     * window system gadgets by setting flag-bits in the variable Flags (see
     * the bit definitions below)
     }

        FirstGadget     : pGadget;

    { these are for opening/closing the windows }

        Parent,
        Descendant      : pWindow;

    { sprite data information for your own Pointer
     * set these AFTER you Open the Window by calling SetPointer()
     }

        _Pointer         : Pointer;      { sprite data }
        PtrHeight       : Shortint;         { sprite height (not including sprite padding) }
        PtrWidth        : Shortint;         { sprite width (must be less than or equal to 16) }
        XOffset,
        YOffset         : Shortint;         { sprite offsets }

    { the IDCMP Flags and User's and Intuition's Message Ports }
        IDCMPFlags      : Cardinal;      { User-selected flags }
        UserPort,
        WindowPort      : pMsgPort;
        MessageKey      : pIntuiMessage;

        DetailPen,
        BlockPen        : Byte; { for bar/border/gadget rendering }

    { the CheckMark is a pointer to the imagery that will be used when
     * rendering MenuItems of this Window that want to be checkmarked
     * if this is equal to NULL, you'll get the default imagery
     }

        CheckMark       : pImage;

        ScreenTitle     : PChar; { if non-null, Screen title when Window is active }

    { These variables have the mouse coordinates relative to the
     * inner-Window of GIMMEZEROZERO Windows.  This is compared with the
     * MouseX and MouseY variables, which contain the mouse coordinates
     * relative to the upper-left corner of the Window, GIMMEZEROZERO
     * notwithstanding
     }

        GZZMouseX       : smallint;
        GZZMouseY       : smallint;

    { these variables contain the width and height of the inner-Window of
     * GIMMEZEROZERO Windows
     }

        GZZWidth        : smallint;
        GZZHeight       : smallint;

        ExtData         : Pointer;

        UserData        : Pointer;      { general-purpose pointer to User data extension }

    {* jimm: NEW: 11/18/85: this pointer keeps a duplicate of what
     * Window.RPort->Layer is _supposed_ to be pointing at
     }

        WLayer          : pLayer;

    { jimm: NEW 1.2: need to keep track of the font that
     * OpenWindow opened, in case user SetFont's into RastPort
     }

        IFont           : pTextFont;
    {* (V36) another flag word (the Flags field is used up).
     * At present, all flag values are system private.
     * Until further notice, you may not change nor use this field.
     *}
        MoreFlags       : Cardinal;

    {**** Data beyond this point are Intuition Private.  DO NOT USE ****}

    end;

CONST
{ --- Flags requested at OpenWindow() time by the application --------- }
 WFLG_SIZEGADGET   =  $00000001;  { include sizing system-gadget? }
 WFLG_DRAGBAR      =  $00000002;  { include dragging system-gadget? }
 WFLG_DEPTHGADGET  =  $00000004;  { include depth arrangement gadget? }
 WFLG_CLOSEGADGET  =  $00000008;  { include close-box system-gadget? }

 WFLG_SIZEBRIGHT   =  $00000010;  { size gadget uses right border }
 WFLG_SIZEBBOTTOM  =  $00000020;  { size gadget uses bottom border }

{ --- refresh modes ------------------------------------------------------ }
{ combinations of the WFLG_REFRESHBITS select the refresh type }
 WFLG_REFRESHBITS   = $000000C0;
 WFLG_SMART_REFRESH = $00000000;
 WFLG_SIMPLE_REFRESH= $00000040;
 WFLG_SUPER_BITMAP  = $00000080;
 WFLG_OTHER_REFRESH = $000000C0;

 WFLG_BACKDROP      = $00000100;  { this is a backdrop window }

 WFLG_REPORTMOUSE   = $00000200;  { to hear about every mouse move }

 WFLG_GIMMEZEROZERO = $00000400;  { a GimmeZeroZero window       }

 WFLG_BORDERLESS    = $00000800;  { to get a Window sans border }

 WFLG_ACTIVATE      = $00001000;  { when Window opens, it's Active }


{ --- Other User Flags --------------------------------------------------- }
 WFLG_RMBTRAP       = $00010000;  { Catch RMB events for your own }
 WFLG_NOCAREREFRESH = $00020000;  { not to be bothered with REFRESH }

{ - V36 new Flags which the programmer may specify in NewWindow.Flags  }
 WFLG_NW_EXTENDED   = $00040000;  { extension data provided      }
                                        { see struct ExtNewWindow      }

{ - V39 new Flags which the programmer may specify in NewWindow.Flags  }
 WFLG_NEWLOOKMENUS  = $00200000;  { window has NewLook menus     }

{ These flags are set only by Intuition.  YOU MAY NOT SET THEM YOURSELF! }
 WFLG_WINDOWACTIVE  = $00002000;  { this window is the active one }
 WFLG_INREQUEST     = $00004000;  { this window is in request mode }
 WFLG_MENUSTATE     = $00008000;  { Window is active with Menus on }
 WFLG_WINDOWREFRESH = $01000000;  { Window is currently refreshing }
 WFLG_WBENCHWINDOW  = $02000000;  { WorkBench tool ONLY Window }
 WFLG_WINDOWTICKED  = $04000000;  { only one timer tick at a time }

{ --- V36 Flags to be set only by Intuition -------------------------  }
 WFLG_VISITOR       = $08000000;  { visitor window               }
 WFLG_ZOOMED        = $10000000;  { identifies "zoom state"      }
 WFLG_HASZOOM       = $20000000;  { windowhas a zoom gadget      }

{ --- Other Window Values ---------------------------------------------- }
 DEFAULTMOUSEQUEUE  =     (5);     { no more mouse messages       }

{ --- see struct IntuiMessage for the IDCMP Flag definitions ------------- }


{ ======================================================================== }
{ === NewWindow ========================================================== }
{ ======================================================================== }

Type

    pNewWindow = ^tNewWindow;
    tNewWindow = record
        LeftEdge,
        TopEdge         : smallint;        { screen dimensions of window }
        Width,
        Height          : smallint;        { screen dimensions of window }

        DetailPen,
        BlockPen        : Byte;         { for bar/border/gadget rendering }

        IDCMPFlags      : Cardinal;      { User-selected IDCMP flags }

        Flags           : Cardinal;      { see Window struct for defines }

    { You supply a linked-list of Gadgets for your Window.
     *  This list DOES NOT include system Gadgets.  You get the standard
     *  system Window Gadgets by setting flag-bits in the variable Flags (see
     *  the bit definitions under the Window structure definition)
     }

        FirstGadget     : pGadget;

    { the CheckMark is a pointer to the imagery that will be used when
     * rendering MenuItems of this Window that want to be checkmarked
     * if this is equal to NULL, you'll get the default imagery
     }

        CheckMark       : pImage;

        Title           : PChar;  { the title text for this window }

    { the Screen pointer is used only if you've defined a CUSTOMSCREEN and
     * want this Window to open in it.  If so, you pass the Pointer of the
     * Custom Screen structure in this variable.  Otherwise, this variable
     * is ignored and doesn't have to be initialized.
     }

        Screen          : Pointer;

    { SUPER_BITMAP Window?  If so, put the Pointer of your BitMap structure
     * in this variable.  If not, this variable is ignored and doesn't have
     * to be initialized
     }

        BitMap          : pBitMap;

    { the values describe the minimum and maximum sizes of your Windows.
     * these matter only if you've chosen the WINDOWSIZING Gadget option,
     * which means that you want to let the User to change the size of
     * this Window.  You describe the minimum and maximum sizes that the
     * Window can grow by setting these variables.  You can initialize
     * any one these to zero, which will mean that you want to duplicate
     * the setting for that dimension (if MinWidth == 0, MinWidth will be
     * set to the opening Width of the Window).
     * You can change these settings later using SetWindowLimits().
     * If you haven't asked for a SIZING Gadget, you don't have to
     * initialize any of these variables.
     }

        MinWidth,
        MinHeight       : smallint;        { minimums }
        MaxWidth,
        MaxHeight       : smallint;        { maximums }

    { the type variable describes the Screen in which you want this Window to
     * open.  The type value can either be CUSTOMSCREEN or one of the
     * system standard Screen Types such as WBENCHSCREEN.  See the
     * type definitions under the Screen structure
     }

        WType           : Word;        { is "Type" in C includes }
    end;


{ The following structure is the future NewWindow.  Compatibility
 * issues require that the size of NewWindow not change.
 * Data in the common part (NewWindow) indicates the the extension
 * fields are being used.
 * NOTE WELL: This structure may be subject to future extension.
 * Writing code depending on its size is not allowed.
 }
   pExtNewWindow = ^tExtNewWindow;
   tExtNewWindow = record
    LeftEdge, TopEdge : smallint;
    Width, Height : smallint;

    DetailPen, BlockPen : Byte;
    IDCMPFlags    : Cardinal;
    Flags         : Cardinal;
    FirstGadget   : pGadget;

    CheckMark     : pImage;

    Title         : PChar;
    WScreen       : Pointer;
    WBitMap       : pBitMap;

    MinWidth, MinHeight : smallint;
    MaxWidth, MaxHeight : Word;

    { the type variable describes the Screen in which you want this Window to
     * open.  The type value can either be CUSTOMSCREEN or one of the
     * system standard Screen Types such as WBENCHSCREEN.  See the
     * type definitions under the Screen structure.
     * A new possible value for this field is PUBLICSCREEN, which
     * defines the window as a 'visitor' window.  See below for
     * additional information provided.
     }
    WType  : Word;

    { ------------------------------------------------------- *
     * extensions for V36
     * if the NewWindow Flag value WFLG_NW_EXTENDED is set, then
     * this field is assumed to point to an array ( or chain of arrays)
     * of TagItem structures.  See also ExtNewScreen for another
     * use of TagItems to pass optional data.
     *
     * see below for tag values and the corresponding data.
     }
    Extension : pTagItem;
  END;

{
 * The TagItem ID's (ti_Tag values) for OpenWindowTagList() follow.
 * They are values in a TagItem array passed as extension/replacement
 * values for the data in NewWindow.  OpenWindowTagList() can actually
 * work well with a NULL NewWindow pointer.
 }
CONST
 WA_Dummy     =   (TAG_USER + 99); { $80000063   }

{ these tags simply override NewWindow parameters }
 WA_Left               =  (WA_Dummy + $01);
 WA_Top                =  (WA_Dummy + $02);
 WA_Width              =  (WA_Dummy + $03);
 WA_Height             =  (WA_Dummy + $04);
 WA_DetailPen          =  (WA_Dummy + $05);
 WA_BlockPen           =  (WA_Dummy + $06);
 WA_IDCMP              =  (WA_Dummy + $07);
                        { "bulk" initialization of NewWindow.Flags }
 WA_Flags              =  (WA_Dummy + $08);
 WA_Gadgets            =  (WA_Dummy + $09);
 WA_Checkmark          =  (WA_Dummy + $0A);
 WA_Title              =  (WA_Dummy + $0B);
                        { means you don't have to call SetWindowTitles
                         * after you open your window
                         }
 WA_ScreenTitle        =  (WA_Dummy + $0C);
 WA_CustomScreen       =  (WA_Dummy + $0D);
 WA_SuperBitMap        =  (WA_Dummy + $0E);
                        { also implies WFLG_SUPER_BITMAP property      }
 WA_MinWidth           =  (WA_Dummy + $0F);
 WA_MinHeight          =  (WA_Dummy + $10);
 WA_MaxWidth           =  (WA_Dummy + $11);
 WA_MaxHeight          =  (WA_Dummy + $12);

{ The following are specifications for new features    }

 WA_InnerWidth         =  (WA_Dummy + $13);
 WA_InnerHeight        =  (WA_Dummy + $14);
                        { You can specify the dimensions of the interior
                         * region of your window, independent of what
                         * the border widths will be.  You probably want
                         * to also specify WA_AutoAdjust to allow
                         * Intuition to move your window or even
                         * shrink it so that it is completely on screen.
                         }

 WA_PubScreenName      =  (WA_Dummy + $15);
                        { declares that you want the window to open as
                         * a visitor on the public screen whose name is
                         * pointed to by (UBYTE *) ti_Data
                         }
 WA_PubScreen          =  (WA_Dummy + $16);
                        { open as a visitor window on the public screen
                         * whose Pointer is in (struct Screen *) ti_Data.
                         * To ensure that this screen remains open, you
                         * should either be the screen's owner, have a
                         * window open on the screen, or use LockPubScreen().
                         }
 WA_PubScreenFallBack  =  (WA_Dummy + $17);
                        { A Boolean, specifies whether a visitor window
                         * should "fall back" to the default public screen
                         * (or Workbench) if the named public screen isn't
                         * available
                         }
 WA_WindowName         =  (WA_Dummy + $18);
                        { not implemented      }
 WA_Colors             =  (WA_Dummy + $19);
                        { a ColorSpec array for colors to be set
                         * when this window is active.  This is not
                         * implemented, and may not be, since the default
                         * values to restore would be hard to track.
                         * We'd like to at least support per-window colors
                         * for the mouse pointer sprite.
                         }
 WA_Zoom       =  (WA_Dummy + $1A);
                        { ti_Data points to an array of four WORD's,
                         * the initial Left/Top/Width/Height values of
                         * the "alternate" zoom position/dimensions.
                         * It also specifies that you want a Zoom gadget
                         * for your window, whether or not you have a
                         * sizing gadget.
                         }
 WA_MouseQueue         =  (WA_Dummy + $1B);
                        { ti_Data contains initial value for the mouse
                         * message backlog limit for this window.
                         }
 WA_BackFill           =  (WA_Dummy + $1C);
                        { unimplemented at present: provides a "backfill
                         * hook" for your window's layer.
                         }
 WA_RptQueue           =  (WA_Dummy + $1D);
                        { initial value of repeat key backlog limit    }

    { These Boolean tag items are alternatives to the NewWindow.Flags
     * boolean flags with similar names.
     }
 WA_SizeGadget         =  (WA_Dummy + $1E);
 WA_DragBar            =  (WA_Dummy + $1F);
 WA_DepthGadget        =  (WA_Dummy + $20);
 WA_CloseGadget        =  (WA_Dummy + $21);
 WA_Backdrop           =  (WA_Dummy + $22);
 WA_ReportMouse        =  (WA_Dummy + $23);
 WA_NoCareRefresh      =  (WA_Dummy + $24);
 WA_Borderless         =  (WA_Dummy + $25);
 WA_Activate           =  (WA_Dummy + $26);
 WA_RMBTrap            =  (WA_Dummy + $27);
 WA_WBenchWindow       =  (WA_Dummy + $28);       { PRIVATE!! }
 WA_SimpleRefresh      =  (WA_Dummy + $29);
                        { only specify if TRUE }
 WA_SmartRefresh       =  (WA_Dummy + $2A);
                        { only specify if TRUE }
 WA_SizeBRight         =  (WA_Dummy + $2B);
 WA_SizeBBottom        =  (WA_Dummy + $2C);

    { New Boolean properties   }
 WA_AutoAdjust         =  (WA_Dummy + $2D);
                        { shift or squeeze the window's position and
                         * dimensions to fit it on screen.
                         }

 WA_GimmeZeroZero      =  (WA_Dummy + $2E);
                        { equiv. to NewWindow.Flags WFLG_GIMMEZEROZERO }

{ New for V37: WA_MenuHelp (ignored by V36) }
 WA_MenuHelp           =  (WA_Dummy + $2F);
                        { Enables IDCMP_MENUHELP:  Pressing HELP during menus
                         * will return IDCMP_MENUHELP message.
                         }

{ New for V39:  (ignored by V37 and earlier) }
 WA_NewLookMenus       =  (WA_Dummy + $30);
                        { Set to TRUE if you want NewLook menus }
 WA_AmigaKey           =  (WA_Dummy + $31);
                        { Pointer to image for Amiga-key equiv in menus }
 WA_NotifyDepth        =  (WA_Dummy + $32);
                        { Requests IDCMP_CHANGEWINDOW message when
                         * window is depth arranged
                         * (imsg->Code = CWCODE_DEPTH)
                         }

{ WA_Dummy + $33 is obsolete }

 WA_Pointer            =  (WA_Dummy + $34);
                        { Allows you to specify a custom pointer
                         * for your window.  ti_Data points to a
                         * pointer object you obtained via
                         * "pointerclass". NULL signifies the
                         * default pointer.
                         * This tag may be passed to OpenWindowTags()
                         * or SetWindowPointer().
                         }

 WA_BusyPointer        =  (WA_Dummy + $35);
                        { ti_Data is boolean.  Set to TRUE to
                         * request the standard busy pointer.
                         * This tag may be passed to OpenWindowTags()
                         * or SetWindowPointer().
                         }

 WA_PointerDelay       =  (WA_Dummy + $36);
                        { ti_Data is boolean.  Set to TRUE to
                         * request that the changing of the
                         * pointer be slightly delayed.  The change
                         * will be called off if you call NewSetPointer()
                         * before the delay expires.  This allows
                         * you to post a busy-pointer even if you think
                         * the busy-time may be very Word, without
                         * fear of a flashing pointer.
                         * This tag may be passed to OpenWindowTags()
                         * or SetWindowPointer().
                         }

 WA_TabletMessages     =  (WA_Dummy + $37);
                        { ti_Data is a boolean.  Set to TRUE to
                         * request that tablet information be included
                         * in IntuiMessages sent to your window.
                         * Requires that something (i.e. a tablet driver)
                         * feed IESUBCLASS_NEWTABLET InputEvents into
                         * the system.  For a pointer to the TabletData,
                         * examine the ExtIntuiMessage->eim_TabletData
                         * field.  It is UNSAFE to check this field
                         * when running on pre-V39 systems.  It's always
                         * safe to check this field under V39 and up,
                         * though it may be NULL.
                         }

 WA_HelpGroup          =  (WA_Dummy + $38);
                        { When the active window has gadget help enabled,
                         * other windows of the same HelpGroup number
                         * will also get GadgetHelp.  This allows GadgetHelp
                         * to work for multi-windowed applications.
                         * Use GetGroupID() to get an ID number.  Pass
                         * this number as ti_Data to all your windows.
                         * See also the HelpControl() function.
                         }

 WA_HelpGroupWindow    =  (WA_Dummy + $39);
                        { When the active window has gadget help enabled,
                         * other windows of the same HelpGroup will also get
                         * GadgetHelp.  This allows GadgetHelp to work
                         * for multi-windowed applications.  As an alternative
                         * to WA_HelpGroup, you can pass a pointer to any
                         * other window of the same group to join its help
                         * group.  Defaults to NULL, which has no effect.
                         * See also the HelpControl() function.
                         }


{ HelpControl() flags:
 *
 * HC_GADGETHELP - Set this flag to enable Gadget-Help for one or more
 * windows.
 }

 HC_GADGETHELP  = 1;


{ ======================================================================== }
{ === Remember =========================================================== }
{ ======================================================================== }
{ this structure is used for remembering what memory has been allocated to
 * date by a given routine, so that a premature abort or systematic exit
 * can deallocate memory cleanly, easily, and completely
 }

Type

    pRemember = ^tRemember;
    tRemember = record
        NextRemember    : pRemember;
        RememberSize    : Cardinal;
        Memory          : Pointer;
    end;


{ === Color Spec ====================================================== }
{ How to tell Intuition about RGB values for a color table entry. }

  pColorSpec = ^tColorSpec;
  tColorSpec = record
    ColorIndex  : smallint;     { -1 terminates an array of ColorSpec  }
    Red         : Word;     { only the _bottom_ 4 bits recognized }
    Green       : Word;     { only the _bottom_ 4 bits recognized }
    Blue        : Word;     { only the _bottom_ 4 bits recognized }
  END;

{ === Easy Requester Specification ======================================= }
{ see also autodocs for EasyRequest and BuildEasyRequest       }
{ NOTE: This structure may grow in size in the future          }

   pEasyStruct = ^tEasyStruct;
   tEasyStruct = record
    es_StructSize   : Cardinal;  { should be sizeof (struct EasyStruct )}
    es_Flags        : Cardinal;  { should be 0 for now                  }
    es_Title        : PChar;   { title of requester window            }
    es_TextFormat   : PChar;   { 'printf' style formatting string     }
    es_GadgetFormat : PChar;   { 'printf' style formatting string   }
   END;



{ ======================================================================== }
{ === Miscellaneous ====================================================== }
{ ======================================================================== }
CONST
{ = MENU STUFF =========================================================== }
    NOMENU      = $001F;
    NOITEM      = $003F;
    NOSUB       = $001F;
    MENUNULL    = -1;


{ = =RJ='s peculiarities ================================================= }

{ these defines are for the COMMSEQ and CHECKIT menu stuff.  If CHECKIT,
 * I'll use a generic Width (for all resolutions) for the CheckMark.
 * If COMMSEQ, likewise I'll use this generic stuff
 }

    CHECKWIDTH          = 19;
    COMMWIDTH           = 27;
    LOWCHECKWIDTH       = 13;
    LOWCOMMWIDTH        = 16;

{ these are the AlertNumber defines.  if you are calling DisplayAlert()
 * the AlertNumber you supply must have the ALERT_TYPE bits set to one
 * of these patterns
 }

    ALERT_TYPE          = $80000000;
    RECOVERY_ALERT      = $00000000;    { the system can recover from this }
    DEADEND_ALERT       = $80000000;    { no recovery possible, this is it }


{ When you're defining IntuiText for the Positive and Negative Gadgets
 * created by a call to AutoRequest(), these defines will get you
 * reasonable-looking text.  The only field without a define is the IText
 * field; you decide what text goes with the Gadget
 }

    AUTOFRONTPEN        = 0;
    AUTOBACKPEN         = 1;
    AUTODRAWMODE        = JAM2;
    AUTOLEFTEDGE        = 6;
    AUTOTOPEDGE         = 3;

{ -
    AUTOITEXTFONT       = Nil;
    AUTONEXTTEXT        = Nil;
- }


{ --- RAWMOUSE Codes and Qualifiers (Console OR IDCMP) ------------------- }


    SELECTUP            = IECODE_LBUTTON + IECODE_UP_PREFIX;
    SELECTDOWN          = IECODE_LBUTTON;
    MENUUP              = IECODE_RBUTTON + IECODE_UP_PREFIX;
    MENUDOWN            = IECODE_RBUTTON;
    ALTLEFT             = IEQUALIFIER_LALT;
    ALTRIGHT            = IEQUALIFIER_RALT;
    AMIGALEFT           = IEQUALIFIER_LCOMMAND;
    AMIGARIGHT          = IEQUALIFIER_RCOMMAND;
    AMIGAKEYS           = AMIGALEFT + AMIGARIGHT;

    CURSORUP            = $4C;
    CURSORLEFT          = $4F;
    CURSORRIGHT         = $4E;
    CURSORDOWN          = $4D;
    KEYCODE_Q           = $10;
    KEYCODE_X           = $32;
    KEYCODE_N           = $36;
    KEYCODE_M           = $37;
    KEYCODE_V           = $34;
    KEYCODE_B           = $35;
    KEYCODE_LESS        = $38;
    KEYCODE_GREATER     = $39;

{ these are the display modes for which we have corresponding parameter
 *  settings in the config arrays
 }
CONST
 DMODECOUNT    =  $0002;  { how many modes there are }
 HIRESPICK     =  $0000;
 LOWRESPICK    =  $0001;

 EVENTMAX = 10;             { size of event array }

{ these are the system Gadget defines }
 RESCOUNT       = 2;
 HIRESGADGET    = 0;
 LOWRESGADGET   = 1;

 GADGETCOUNT    = 8;
 UPFRONTGADGET  = 0;
 DOWNBACKGADGET = 1;
 SIZEGADGET     = 2;
 CLOSEGADGET    = 3;
 DRAGGADGET     = 4;
 SUPFRONTGADGET = 5;
 SDOWNBACKGADGET= 6;
 SDRAGGADGET    = 7;


{ ======================================================================== }
{ === DrawInfo ========================================================= }
{ ======================================================================== }

{ This is a packet of information for graphics rendering.  It originates
 * with a Screen, and is gotten using GetScreenDrawInfo( screen );
 }

{ If you find dri_Version >= DRI_VERSION, you know this structure
 * has at least the fields defined in this version of the include file
 }
CONST
 RI_VERSION  =    (1);     { obsolete, will be removed            }
 DRI_VERSION =    (1);

Type

 pDrawInfo = ^tDrawInfo;
 tDrawInfo = record
    dri_Version : Word;    { will be  DRI_VERSION                 }
    dri_NumPens : Word;    { guaranteed to be >= numDrIPens       }
    dri_Pens    : Pointer;  { pointer to pen array                 }

    dri_Font    : pTextFont;      { screen default font          }
    dri_Depth   : Word;            { (initial) depth of screen bitmap     }

    dri_Resolution : record      { from DisplayInfo database for initial display mode }
                   x : word;
                   y : word;
                   end;

    dri_Flags : Cardinal;              { defined below                }
{ New for V39: dri_CheckMark, dri_AmigaKey. }
    dri_CheckMark : pImage; { ImagePtr }         { pointer to scaled checkmark image
                                                  * Will be NULL if DRI_VERSION < 2
                                                  }
    dri_AmigaKey  : pImage; { ImagePtr }    { pointer to scaled Amiga-key image
                                             * Will be NULL if DRI_VERSION < 2
                                             }

    dri_Reserved : Array[0..4] of Cardinal;        { avoid recompilation ;^)      }
 END;

CONST
 DRIF_NEWLOOK =   $00000001;      { specified SA_Pens, full treatment }

{ rendering pen number indexes into DrawInfo.dri_Pens[]        }
 DETAILPEN    =    ($0000);       { compatible Intuition rendering pens  }
 BLOCKPEN     =    ($0001);       { compatible Intuition rendering pens  }
 TEXTPEN      =    ($0002);       { text on background                   }
 SHINEPEN     =    ($0003);       { bright edge on 3D objects            }
 SHADOWPEN    =    ($0004);       { dark edge on 3D objects              }
 FILLPEN      =    ($0005);       { active-window/selected-gadget fill   }
 FILLTEXTPEN  =    ($0006);       { text over FILLPEN                    }
 BACKGROUNDPEN =   ($0007);       { always color 0                       }
 HIGHLIGHTTEXTPEN = ($0008);       { special color text, on background    }
{ New for V39, only present if DRI_VERSION >= 2: }
 BARDETAILPEN   =  ($0009);       { text/detail in screen-bar/menus }
 BARBLOCKPEN    =  ($000A);       { screen-bar/menus fill }
 BARTRIMPEN     =  ($000B);       { trim under screen-bar }

 NUMDRIPENS   =    ($0009);

{ New for V39:  It is sometimes useful to specify that a pen value
 * is to be the complement of color zero to three.  The "magic" numbers
 * serve that purpose:
 }
 PEN_C3        =  $FEFC;          { Complement of color 3 }
 PEN_C2        =  $FEFD;          { Complement of color 2 }
 PEN_C1        =  $FEFE;          { Complement of color 1 }
 PEN_C0        =  $FEFF;          { Complement of color 0 }

{ ======================================================================== }
{ === Screen ============================================================= }
{ ======================================================================== }

Type

    pScreen = ^tScreen;
    tScreen = record
        NextScreen      : pScreen;      { linked list of screens }
        FirstWindow     : pWindow;      { linked list Screen's Windows }

        LeftEdge,
        TopEdge         : smallint;        { parameters of the screen }
        Width,
        Height          : smallint;        { parameters of the screen }

        MouseY,
        MouseX          : smallint;        { position relative to upper-left }

        Flags           : Word;        { see definitions below }

        Title           : PChar;       { null-terminated Title text }
        DefaultTitle    : PChar;       { for Windows without ScreenTitle }

    { Bar sizes for this Screen and all Window's in this Screen }
        BarHeight,
        BarVBorder,
        BarHBorder,
        MenuVBorder,
        MenuHBorder     : Shortint;
        WBorTop,
        WBorLeft,
        WBorRight,
        WBorBottom      : Shortint;

        Font            : pTextAttr;  { this screen's default font       }

    { the display data structures for this Screen (note the prefix S)}
        ViewPort        : tViewPort;     { describing the Screen's display }
        RastPort        : tRastPort;     { describing Screen rendering      }
        BitMap          : tBitMap;       { extra copy of RastPort BitMap   }
        LayerInfo       : tLayer_Info;   { each screen gets a LayerInfo     }

    { You supply a linked-list of Gadgets for your Screen.
     *  This list DOES NOT include system Gadgets.  You get the standard
     *  system Screen Gadgets by default
     }

        FirstGadget     : pGadget;

        DetailPen,
        BlockPen        : Byte;         { for bar/border/gadget rendering }

    { the following variable(s) are maintained by Intuition to support the
     * DisplayBeep() color flashing technique
     }
        SaveColor0      : Word;

    { This layer is for the Screen and Menu bars }
        BarLayer        : pLayer;

        ExtData         : Pointer;
        UserData        : Pointer;
                        { general-purpose pointer to User data extension }
    {**** Data below this point are SYSTEM PRIVATE ****}

    end;

Const

{ The screen flags have the suffix "_f" added to avoid conflicts with
  routine names. }

{ --- FLAGS SET BY INTUITION --------------------------------------------- }
{ The SCREENTYPE bits are reserved for describing various Screen types
 * available under Intuition.
 }
    SCREENTYPE_f        = $000F;        { all the screens types available       }
{ --- the definitions for the Screen Type ------------------------------- }
    WBENCHSCREEN_f      = $0001;        { Ta Da!  The Workbench         }
    CUSTOMSCREEN_f      = $000F;        { for that special look         }

    SHOWTITLE_f         = $0010;        { this gets set by a call to ShowTitle() }

    BEEPING_f           = $0020;        { set when Screen is beeping            }

    CUSTOMBITMAP_f      = $0040;        { if you are supplying your own BitMap }

    SCREENBEHIND_f      = $0080;        { if you want your screen to open behind
                                         * already open screens
                                         }
    SCREENQUIET_f       = $0100;        { if you do not want Intuition to render
                                         * into your screen (gadgets, title)     }
    SCREENHIRES         = $0200;        { do no use lowres gadgets (private)       }

    NS_EXTENDED         = $1000;          { ExtNewScreen.Extension is valid      }
    { V36 applications can use OpenScreenTagList() instead of NS_EXTENDED  }

{ New for V39: }
    PENSHARED           = $0400;  { Screen opener set (SA_SharePens,TRUE) }


    AUTOSCROLL          = $4000;  { screen is to autoscoll               }

    STDSCREENHEIGHT     = -1;           { supply in NewScreen.Height            }
    STDSCREENWIDTH      = -1;           { supply in NewScreen.Width             }



{
 * Screen attribute tag ID's.  These are used in the ti_Tag field of
 * TagItem arrays passed to OpenScreenTagList() (or in the
 * ExtNewScreen.Extension field).
 }

{ Screen attribute tags.  Please use these versions, not those in
 * iobsolete.h.
 }
CONST
  SA_Dummy    =    (TAG_USER + 32);
{
 * these items specify items equivalent to fields in NewScreen
 }
 SA_Left     =    (SA_Dummy + $0001);
 SA_Top      =    (SA_Dummy + $0002);
 SA_Width    =    (SA_Dummy + $0003);
 SA_Height   =    (SA_Dummy + $0004);
                        { traditional screen positions and dimensions  }
 SA_Depth    =    (SA_Dummy + $0005);
                        { screen bitmap depth                          }
 SA_DetailPen=    (SA_Dummy + $0006);
                        { serves as default for windows, too           }
 SA_BlockPen =    (SA_Dummy + $0007);
 SA_Title    =    (SA_Dummy + $0008);
                        { default screen title                         }
 SA_Colors   =    (SA_Dummy + $0009);
                        { ti_Data is an array of struct ColorSpec,
                         * terminated by ColorIndex = -1.  Specifies
                         * initial screen palette colors.
                         }
 SA_ErrorCode=    (SA_Dummy + $000A);
                        { ti_Data points to LONG error code (values below)}
 SA_Font     =    (SA_Dummy + $000B);
                        { equiv. to NewScreen.Font                     }
 SA_SysFont  =    (SA_Dummy + $000C);
                        { Selects one of the preferences system fonts:
                         *      0 - old DefaultFont, fixed-width
                         *      1 - WB Screen preferred font
                         }
 SA_Type     =    (SA_Dummy + $000D);
                        { equiv. to NewScreen.Type                     }
 SA_BitMap   =    (SA_Dummy + $000E);
                        { ti_Data is pointer to custom BitMap.  This
                         * implies type of CUSTOMBITMAP
                         }
 SA_PubName  =    (SA_Dummy + $000F);
                        { presence of this tag means that the screen
                         * is to be a public screen.  Please specify
                         * BEFORE the two tags below
                         }
 SA_PubSig   =    (SA_Dummy + $0010);
 SA_PubTask  =    (SA_Dummy + $0011);
                        { Task ID and signal for being notified that
                         * the last window has closed on a public screen.
                         }
 SA_DisplayID=    (SA_Dummy + $0012);
                        { ti_Data is new extended display ID from
                         * <graphics/displayinfo.h>.
                         }
 SA_DClip    =    (SA_Dummy + $0013);
                        { ti_Data points to a rectangle which defines
                         * screen display clip region
                         }
 SA_Overscan =    (SA_Dummy + $0014);
                        { was S_STDDCLIP.  Set to one of the OSCAN_
                         * specifiers below to get a system standard
                         * overscan region for your display clip,
                         * screen dimensions (unless otherwise specified),
                         * and automatically centered position (partial
                         * support only so far).
                         * If you use this, you shouldn't specify
                         * SA_DClip.  SA_Overscan is for "standard"
                         * overscan dimensions, SA_DClip is for
                         * your custom numeric specifications.
                         }
 SA_Obsolete1=    (SA_Dummy + $0015);
                        { obsolete S_MONITORNAME                       }

{* booleans *}
 SA_ShowTitle  =  (SA_Dummy + $0016);
                        { boolean equivalent to flag SHOWTITLE         }
 SA_Behind     =  (SA_Dummy + $0017);
                        { boolean equivalent to flag SCREENBEHIND      }
 SA_Quiet      =  (SA_Dummy + $0018);
                        { boolean equivalent to flag SCREENQUIET       }
 SA_AutoScroll =  (SA_Dummy + $0019);
                        { boolean equivalent to flag AUTOSCROLL        }
 SA_Pens       =  (SA_Dummy + $001A);
                        { pointer to ~0 terminated UWORD array, as
                         * found in struct DrawInfo
                         }
 SA_FullPalette=  (SA_Dummy + $001B);
                        { boolean: initialize color table to entire
                         *  preferences palette (32 for V36), rather
                         * than compatible pens 0-3, 17-19, with
                         * remaining palette as returned by GetColorMap()
                         }

 SA_ColorMapEntries = (SA_Dummy + $001C);
                        { New for V39:
                         * Allows you to override the number of entries
                         * in the ColorMap for your screen.  Intuition
                         * normally allocates (1<<depth) or 32, whichever
                         * is more, but you may require even more if you
                         * use certain V39 graphics.library features
                         * (eg. palette-banking).
                         }

 SA_Parent      = (SA_Dummy + $001D);
                        { New for V39:
                         * ti_Data is a pointer to a "parent" screen to
                         * attach this one to.  Attached screens slide
                         * and depth-arrange together.
                         }

 SA_Draggable   = (SA_Dummy + $001E);
                        { New for V39:
                         * Boolean tag allowing non-draggable screens.
                         * Do not use without good reason!
                         * (Defaults to TRUE).
                         }

 SA_Exclusive   = (SA_Dummy + $001F);
                        { New for V39:
                         * Boolean tag allowing screens that won't share
                         * the display.  Use sparingly!  Starting with 3.01,
                         * attached screens may be SA_Exclusive.  Setting
                         * SA_Exclusive for each screen will produce an
                         * exclusive family.   (Defaults to FALSE).
                         }

 SA_SharePens   = (SA_Dummy + $0020);
                        { New for V39:
                         * For those pens in the screen's DrawInfo->dri_Pens,
                         * Intuition obtains them in shared mode (see
                         * graphics.library/ObtainPen()).  For compatibility,
                         * Intuition obtains the other pens of a public
                         * screen as PEN_EXCLUSIVE.  Screens that wish to
                         * manage the pens themselves should generally set
                         * this tag to TRUE.  This instructs Intuition to
                         * leave the other pens unallocated.
                         }

 SA_BackFill    = (SA_Dummy + $0021);
                        { New for V39:
                         * provides a "backfill hook" for your screen's
                         * Layer_Info.
                         * See layers.library/InstallLayerInfoHook()
                         }

 SA_Interleaved = (SA_Dummy + $0022);
                        { New for V39:
                         * Boolean tag requesting that the bitmap
                         * allocated for you be interleaved.
                         * (Defaults to FALSE).
                         }

 SA_Colors32    = (SA_Dummy + $0023);
                        { New for V39:
                         * Tag to set the screen's initial palette colors
                         * at 32 bits-per-gun.  ti_Data is a pointer
                         * to a table to be passed to the
                         * graphics.library/LoadRGB32() function.
                         * This format supports both runs of color
                         * registers and sparse registers.  See the
                         * autodoc for that function for full details.
                         * Any color set here has precedence over
                         * the same register set by SA_Colors.
                         }

 SA_VideoControl = (SA_Dummy + $0024);
                        { New for V39:
                         * ti_Data is a pointer to a taglist that Intuition
                         * will pass to graphics.library/VideoControl(),
                         * upon opening the screen.
                         }

 SA_FrontChild  = (SA_Dummy + $0025);
                        { New for V39:
                         * ti_Data is a pointer to an already open screen
                         * that is to be the child of the screen being
                         * opened.  The child screen will be moved to the
                         * front of its family.
                         }

 SA_BackChild   = (SA_Dummy + $0026);
                        { New for V39:
                         * ti_Data is a pointer to an already open screen
                         * that is to be the child of the screen being
                         * opened.  The child screen will be moved to the
                         * back of its family.
                         }

 SA_LikeWorkbench     =   (SA_Dummy + $0027);
                        { New for V39:
                         * Set ti_Data to 1 to request a screen which
                         * is just like the Workbench.  This gives
                         * you the same screen mode, depth, size,
                         * colors, etc., as the Workbench screen.
                         }

 SA_Reserved          =   (SA_Dummy + $0028);
                        { Reserved for private Intuition use }

 SA_MinimizeISG       =   (SA_Dummy + $0029);
                        { New for V40:
                         * For compatibility, Intuition always ensures
                         * that the inter-screen gap is at least three
                         * non-interlaced lines.  If your application
                         * would look best with the smallest possible
                         * inter-screen gap, set ti_Data to TRUE.
                         * If you use the new graphics VideoControl()
                         * VC_NoColorPaletteLoad tag for your screen's
                         * ViewPort, you should also set this tag.
                          }


{ this is an obsolete tag included only for compatibility with V35
 * interim release for the A2024 and Viking monitors
 }
 NSTAG_EXT_VPMODE = (TAG_USER + 1);


{ OpenScreen error codes, which are returned in the (optional) LONG
 * pointed to by ti_Data for the SA_ErrorCode tag item
 }
 OSERR_NOMONITOR   = (1);     { named monitor spec not available     }
 OSERR_NOCHIPS     = (2);     { you need newer custom chips          }
 OSERR_NOMEM       = (3);     { couldn't get normal memory           }
 OSERR_NOCHIPMEM   = (4);     { couldn't get chipmem                 }
 OSERR_PUBNOTUNIQUE= (5);     { public screen name already used      }
 OSERR_UNKNOWNMODE = (6);     { don't recognize mode asked for       }

{ ======================================================================== }
{ === NewScreen ========================================================== }
{ ======================================================================== }

Type

    pNewScreen = ^tNewScreen;
    tNewScreen = record
        LeftEdge,
        TopEdge,
        Width,
        Height,
        Depth           : smallint;        { screen dimensions }

        DetailPen,
        BlockPen        : Byte;         { for bar/border/gadget rendering }

        ViewModes       : Word;        { the Modes for the ViewPort (and View) }

        SType           : Word;        { the Screen type (see defines above) }

        Font            : pTextAttr;  { this Screen's default text attributes }

        DefaultTitle    : PChar;       { the default title for this Screen }

        Gadgets         : pGadget;      { your own Gadgets for this Screen }

    { if you are opening a CUSTOMSCREEN and already have a BitMap
     * that you want used for your Screen, you set the flags CUSTOMBITMAP in
     * the Type field and you set this variable to point to your BitMap
     * structure.  The structure will be copied into your Screen structure,
     * after which you may discard your own BitMap if you want
     }

        CustomBitMap    : pBitMap;
    end;


type

 pExtNewScreen = ^tExtNewScreen;
 tExtNewScreen = record
  LeftEdge, TopEdge, Width, Height, Depth : smallint;
  DetailPen, BlockPen : Byte;
  ViewModes : Word;
  ens_Type : Word;     { Type in C-Includes }
  Font : pTextAttr;
  DefaultTitle : PChar;
  Gadgets : pGadget;
  CustomBitMap : pBitMap;
  Extension : pTagItem;
 END;


CONST
{ === Overscan Types ===       }
 OSCAN_TEXT     = (1);     { entirely visible     }
 OSCAN_STANDARD = (2);     { just past edges      }
 OSCAN_MAX      = (3);     { as much as possible  }
 OSCAN_VIDEO    = (4);     { even more than is possible   }


{ === Public Shared Screen Node ===    }

{ This is the representative of a public shared screen.
 * This is an internal data structure, but some functions may
 * present a copy of it to the calling application.  In that case,
 * be aware that the screen pointer of the structure can NOT be
 * used safely, since there is no guarantee that the referenced
 * screen will remain open and a valid data structure.
 *
 * Never change one of these.
 }

Type
   pPubScreenNode = ^tPubScreenNode;
   tPubScreenNode = record
    psn_Node    : tNode;       { ln_Name is screen name }
    psn_Screen  : pScreen;
    psn_Flags   : Word;      { below                }
    psn_Size    : smallint;      { includes name buffer }
    psn_VisitorCount  : smallint; { how many visitor windows }
    psn_SigTask : pTask;    { who to signal when visitors gone }
    psn_SigBit  : Byte;     { which signal }
   END;

CONST
 PSNF_PRIVATE  =  ($0001);

 MAXPUBSCREENNAME  =      (139);   { names no longer, please      }

{ pub screen modes     }
 SHANGHAI      =  $0001;  { put workbench windows on pub screen }
 POPPUBSCREEN  =  $0002;  { pop pub screen to front when visitor opens }

{ New for V39:  Intuition has new screen depth-arrangement and movement
 * functions called ScreenDepth() and ScreenPosition() respectively.
 * These functions permit the old behavior of ScreenToFront(),
 * ScreenToBack(), and MoveScreen().  ScreenDepth() also allows
 * independent depth control of attached screens.  ScreenPosition()
 * optionally allows positioning screens even though they were opened
 * (SA_Draggable,FALSE).
 }

{ For ScreenDepth(), specify one of SDEPTH_TOFRONT or SDEPTH_TOBACK,
 * and optionally also SDEPTH_INFAMILY.
 *
 * NOTE: ONLY THE OWNER OF THE SCREEN should ever specify
 * SDEPTH_INFAMILY.  Commodities, "input helper" programs,
 * or any other program that did not open a screen should never
 * use that flag.  (Note that this is a style-behavior
 * requirement;  there is no technical requirement that the
 * task calling this function need be the task which opened
 * the screen).
 }

 SDEPTH_TOFRONT        =  (0);     { Bring screen to front }
 SDEPTH_TOBACK         =  (1);     { Send screen to back }
 SDEPTH_INFAMILY       =  (2);     { Move an attached screen with
                                         * respect to other screens of
                                         * its family
                                         }

{ Here's an obsolete name equivalent to SDEPTH_INFAMILY: }
 SDEPTH_CHILDONLY      =  SDEPTH_INFAMILY;


{ For ScreenPosition(), specify one of SPOS_RELATIVE, SPOS_ABSOLUTE,
 * or SPOS_MAKEVISIBLE to describe the kind of screen positioning you
 * wish to perform:
 *
 * SPOS_RELATIVE: The x1 and y1 parameters to ScreenPosition() describe
 *      the offset in coordinates you wish to move the screen by.
 * SPOS_ABSOLUTE: The x1 and y1 parameters to ScreenPosition() describe
 *      the absolute coordinates you wish to move the screen to.
 * SPOS_MAKEVISIBLE: (x1,y1)-(x2,y2) describes a rectangle on the
 *      screen which you would like autoscrolled into view.
 *
 * You may additionally set SPOS_FORCEDRAG along with any of the
 * above.  Set this if you wish to reposition an (SA_Draggable,FALSE)
 * screen that you opened.
 *
 * NOTE: ONLY THE OWNER OF THE SCREEN should ever specify
 * SPOS_FORCEDRAG.  Commodities, "input helper" programs,
 * or any other program that did not open a screen should never
 * use that flag.
 }

 SPOS_RELATIVE         =  (0);     { Coordinates are relative }

 SPOS_ABSOLUTE         =  (1);     { Coordinates are expressed as
                                         * absolutes, not relatives.
                                         }

 SPOS_MAKEVISIBLE      =  (2);     { Coordinates describe a box on
                                         * the screen you wish to be
                                         * made visible by autoscrolling
                                         }

 SPOS_FORCEDRAG        =  (4);     { Move non-draggable screen }

{ New for V39: Intuition supports double-buffering in screens,
 * with friendly interaction with menus and certain gadgets.
 * For each buffer, you need to get one of these structures
 * from the AllocScreenBuffer() call.  Never allocate your
 * own ScreenBuffer structures!
 *
 * The sb_DBufInfo field is for your use.  See the graphics.library
 * AllocDBufInfo() autodoc for details.
 }
Type

 pScreenBuffer = ^tScreenBuffer;
 tScreenBuffer = record
    sb_BitMap  : pBitMap;           { BitMap of this buffer }
    sb_DBufInfo : pDBufInfo;       { DBufInfo for this buffer }
 end;

const
{ These are the flags that may be passed to AllocScreenBuffer().
 }
 SB_SCREEN_BITMAP      =  1;
 SB_COPY_BITMAP        =  2;


{ ======================================================================== }
{ === Preferences ======================================================== }
{ ======================================================================== }

Const

{ these are the definitions for the printer configurations }
    FILENAME_SIZE       = 30;           { Filename size }

    POINTERSIZE         = (1 + 16 + 1) * 2;     { Size of Pointer data buffer }

{ These defines are for the default font size.   These actually describe the
 * height of the defaults fonts.  The default font type is the topaz
 * font, which is a fixed width font that can be used in either
 * eighty-column or sixty-column mode.  The Preferences structure reflects
 * which is currently selected by the value found in the variable FontSize,
 * which may have either of the values defined below.  These values actually
 * are used to select the height of the default font.  By changing the
 * height, the resolution of the font changes as well.
 }
    TOPAZ_EIGHTY        = 8;
    TOPAZ_SIXTY         = 9;

Type

    pPreferences = ^tPreferences;
    tPreferences = record
    { the default font height }
        FontHeight      : Shortint;         { height for system default font  }

    { constant describing what's hooked up to the port }
        PrinterPort     : Byte;         { printer port connection     }

    { the baud rate of the port }
        BaudRate        : Word;        { baud rate for the serial port   }

    { various timing rates }
        KeyRptSpeed     : ttimeval;      { repeat speed for keyboard       }
        KeyRptDelay     : ttimeval;      { Delay before keys repeat             }
        DoubleClick     : ttimeval;      { Interval allowed between clicks }

    { Intuition Pointer data }
        PointerMatrix   : Array [0..POINTERSIZE-1] of Word;
                                        { Definition of pointer sprite     }
        XOffset         : Shortint;         { X-Offset for active 'bit'       }
        YOffset         : Shortint;         { Y-Offset for active 'bit'       }
        color17         : Word;        {*********************************}
        color18         : Word;        { Colours for sprite pointer      }
        color19         : Word;        {*********************************}
        PointerTicks    : Word;        { Sensitivity of the pointer       }

    { Workbench Screen colors }
        color0          : Word;        {*********************************}
        color1          : Word;        {   Standard default colours      }
        color2          : Word;        {   Used in the Workbench         }
        color3          : Word;        {*********************************}

    { positioning data for the Intuition View }
        ViewXOffset     : Shortint;         { Offset for top lefthand corner  }
        ViewYOffset     : Shortint;         { X and Y dimensions           }
        ViewInitX,
        ViewInitY       : smallint;        { View initial offset values      }

        EnableCLI       : Boolean;      { CLI availability switch }

    { printer configurations }
        PrinterType     : Word;        { printer type                     }
        PrinterFilename : Array [0..FILENAME_SIZE-1] of Char;
                                        { file for printer         }

    { print format and quality configurations }
        PrintPitch      : Word;        { print pitch              }
        PrintQuality    : Word;        { print quality    }
        PrintSpacing    : Word;        { number of lines per inch    }
        PrintLeftMargin : Word;        { left margin in characters        }
        PrintRightMargin : Word;       { right margin in characters       }
        PrintImage      : Word;        { positive or negative         }
        PrintAspect     : Word;        { horizontal or vertical      }
        PrintShade      : Word;        { b&w, half-tone, or color    }
        PrintThreshold  : smallint;        { darkness ctrl for b/w dumps      }

    { print paper descriptors }
        PaperSize       : Word;        { paper size               }
        PaperLength     : Word;        { paper length in number of lines }
        PaperType       : Word;        { continuous or single sheet       }

    { Serial device settings: These are six nibble-fields in three bytes }
    { (these look a little strange so the defaults will map out to zero) }
        SerRWBits       : Byte;
                             { upper nibble = (8-number of read bits)     }
                             { lower nibble = (8-number of write bits)    }
        SerStopBuf      : Byte;
                             { upper nibble = (number of stop bits - 1)  }
                             { lower nibble = (table value for BufSize)  }
        SerParShk       : Byte;
                             { upper nibble = (value for Parity setting) }
                             { lower nibble = (value for Handshake mode) }
        LaceWB          : Byte;         { if workbench is to be interlaced      }

        WorkName        : Array [0..FILENAME_SIZE-1] of Char;
                                        { temp file for printer         }

        RowSizeChange   : Shortint;
        ColumnSizeChange : Shortint;

        PrintFlags      : Word;        { user preference flags }
        PrintMaxWidth   : Word;        { max width of printed picture in 10ths/inch }
        PrintMaxHeight  : Word;        { max height of printed picture in 10ths/inch }
        PrintDensity    : Byte;         { print density }
        PrintXOffset    : Byte;         { offset of printed picture in 10ths/inch }

        wb_Width        : Word;        { override default workbench width       }
        wb_Height       : Word;        { override default workbench height }
        wb_Depth        : Byte;         { override default workbench depth       }

        ext_size        : Byte;         { extension information -- do not touch! }
                            { extension size in blocks of 64 bytes }
    end;

Const

{ Workbench Interlace (use one bit) }
    LACEWB              = $01;
    LW_RESERVED         = 1;     { internal use only }

{ PrinterPort }
    PARALLEL_PRINTER    = $00;
    SERIAL_PRINTER      = $01;

{ BaudRate }
    BAUD_110            = $00;
    BAUD_300            = $01;
    BAUD_1200           = $02;
    BAUD_2400           = $03;
    BAUD_4800           = $04;
    BAUD_9600           = $05;
    BAUD_19200          = $06;
    BAUD_MIDI           = $07;

{ PaperType }
    FANFOLD             = $00;
    SINGLE              = $80;

{ PrintPitch }
    PICA                = $000;
    ELITE               = $400;
    FINE                = $800;

{ PrintQuality }
    DRAFT               = $000;
    LETTER              = $100;

{ PrintSpacing }
    SIX_LPI             = $000;
    EIGHT_LPI           = $200;

{ Print Image }
    IMAGE_POSITIVE      = $00;
    IMAGE_NEGATIVE      = $01;

{ PrintAspect }
    ASPECT_HORIZ        = $00;
    ASPECT_VERT         = $01;

{ PrintShade }
    SHADE_BW            = $00;
    SHADE_GREYSCALE     = $01;
    SHADE_COLOR         = $02;

{ PaperSize }
    US_LETTER           = $00;
    US_LEGAL            = $10;
    N_TRACTOR           = $20;
    W_TRACTOR           = $30;
    CUSTOM_PAPER        = $40;

{ New PaperSizes for V36: }
 EURO_A0 = $50;            { European size A0: 841 x 1189 }
 EURO_A1 = $60;            { European size A1: 594 x 841 }
 EURO_A2 = $70;            { European size A2: 420 x 594 }
 EURO_A3 = $80;            { European size A3: 297 x 420 }
 EURO_A4 = $90;            { European size A4: 210 x 297 }
 EURO_A5 = $A0;            { European size A5: 148 x 210 }
 EURO_A6 = $B0;            { European size A6: 105 x 148 }
 EURO_A7 = $C0;            { European size A7: 74 x 105 }
 EURO_A8 = $D0;            { European size A8: 52 x 74 }

{ PrinterType }
    CUSTOM_NAME         = $00;
    ALPHA_P_101         = $01;
    BROTHER_15XL        = $02;
    CBM_MPS1000         = $03;
    DIAB_630            = $04;
    DIAB_ADV_D25        = $05;
    DIAB_C_150          = $06;
    EPSON               = $07;
    EPSON_JX_80         = $08;
    OKIMATE_20          = $09;
    QUME_LP_20          = $0A;
{ new printer entries, 3 October 1985 }
    HP_LASERJET         = $0B;
    HP_LASERJET_PLUS    = $0C;

{ Serial Input Buffer Sizes }
    SBUF_512            = $00;
    SBUF_1024           = $01;
    SBUF_2048           = $02;
    SBUF_4096           = $03;
    SBUF_8000           = $04;
    SBUF_16000          = $05;

{ Serial Bit Masks }
    SREAD_BITS          = $F0;          { for SerRWBits   }
    SWRITE_BITS         = $0F;

    SSTOP_BITS          = $F0;          { for SerStopBuf  }
    SBUFSIZE_BITS       = $0F;

    SPARITY_BITS        = $F0;          { for SerParShk }
    SHSHAKE_BITS        = $0F;

{ Serial Parity (upper nibble, after being shifted by
 * macro SPARNUM() )
 }
    SPARITY_NONE        = 0;
    SPARITY_EVEN        = 1;
    SPARITY_ODD         = 2;

{ Serial Handshake Mode (lower nibble, after masking using
 * macro SHANKNUM() )
 }
    SHSHAKE_XON         = 0;
    SHSHAKE_RTS         = 1;
    SHSHAKE_NONE        = 2;

{ new defines for PrintFlags }

    CORRECT_RED         = $0001;        { color correct red shades }
    CORRECT_GREEN       = $0002;        { color correct green shades }
    CORRECT_BLUE        = $0004;        { color correct blue shades }

    CENTER_IMAGE        = $0008;        { center image on paper }

    IGNORE_DIMENSIONS   = $0000;        { ignore max width/height settings }
    BOUNDED_DIMENSIONS  = $0010;        { use max width/height as boundaries }
    ABSOLUTE_DIMENSIONS = $0020;        { use max width/height as absolutes }
    PIXEL_DIMENSIONS    = $0040;        { use max width/height as prt pixels }
    MULTIPLY_DIMENSIONS = $0080;        { use max width/height as multipliers }

    INTEGER_SCALING     = $0100;        { force integer scaling }

    ORDERED_DITHERING   = $0000;        { ordered dithering }
    HALFTONE_DITHERING  = $0200;        { halftone dithering }
    FLOYD_DITHERING     = $0400;        { Floyd-Steinberg dithering }

    ANTI_ALIAS          = $0800;        { anti-alias image }
    GREY_SCALE2         = $1000;        { for use with hi-res monitor }

{ masks used for checking bits }

    CORRECT_RGB_MASK    = CORRECT_RED + CORRECT_GREEN + CORRECT_BLUE;
    DIMENSIONS_MASK     = BOUNDED_DIMENSIONS + ABSOLUTE_DIMENSIONS +
                                PIXEL_DIMENSIONS + MULTIPLY_DIMENSIONS;
    DITHERING_MASK      = HALFTONE_DITHERING + FLOYD_DITHERING;






{ ======================================================================== }
{ === IntuitionBase ====================================================== }
{ ======================================================================== }
{
 * Be sure to protect yourself against someone modifying these data as
 * you look at them.  This is done by calling:
 *
 * lock = LockIBase(0), which returns an Integer.  When done call
 * UnlockIBase(lock) where lock is what LockIBase() returned.
 }

Type

    pIntuitionBase = ^tIntuitionBase;
    tIntuitionBase = record
{ IntuitionBase should never be directly modified by programs   }
{ even a little bit, guys/gals; do you hear me? }

        LibNode         : tLibrary;

        ViewLord        : tView;

        ActiveWindow    : pWindow;
        ActiveScreen    : pScreen;

    { the FirstScreen variable points to the frontmost Screen.   Screens are
     * then maintained in a front to back order using Screen.NextScreen
     }

        FirstScreen     : pScreen;    { for linked list of all screens }

        Flags           : Cardinal;      { see definitions below }
        MouseY,
        MouseX          : smallint;        { mouse position relative to View }

        Seconds         : Cardinal;      { timestamp of most current input event }
        Micros          : Cardinal;      { timestamp of most current input event }

    { I told you this was private.
     * The data beyond this point has changed, is changing, and
     * will continue to change.
     }

    end;


{
 * Package of information passed to custom and 'boopsi'
 * gadget 'hook' functions.  This structure is READ ONLY.
 }
Type

   pGadgetInfo = ^tGadgetInfo;
   tGadgetInfo = record
    gi_Screen                   : pScreen;       { ScreenPtr }
    gi_Window                   : pWindow;       { null for screen gadgets }    { WindowPtr }
    gi_Requester                : pRequester;    { null IF not GTYP_REQGADGET } { RequesterPtr }

    { rendering information:
     * don't use these without cloning/locking.
     * Official way is to call ObtainRPort()
     }
    gi_RastPort                 : pRastPort;     { RastPortPtr }
    gi_Layer                    : pLayer;        { 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
     *  GTYP_GZZGADGETs (borderlayer):          0,0
     *  GZZ innerlayer gadget:          borderleft, bordertop
     *  Requester gadgets:              reqleft, reqtop
     }
    gi_Domain                   : tIBox;

    gi_Pens                     : record
                      DetailPen : Byte;
                      BlockPen  : Byte;
                                  end;

    { the Detail and Block pens in gi_DrInfo->dri_Pens[] are
     * for the screen.  Use the above for window-sensitive
     * colors.
     }
    gi_DrInfo                   : pDrawInfo;  { DrawInfoPtr }

    { reserved space: this structure is extensible
     * anyway, but using these saves some recompilation
     }
    gi_Reserved                 : Array[0..5] of Cardinal;
   END;

{** system private data structure for now **}
{ prop gadget extra info       }

   pPGX = ^tPGX;
   tPGX = record
    pgx_Container : tIBox;
    pgx_NewKnob   : tIBox;
   END;

{ this casts MutualExclude for easy assignment of a hook
 * pointer to the unused MutualExclude field of a custom gadget
 }

{** User visible handles on objects, classes, messages **}
Type
 Object_ = Cardinal;
 pObject_ = ^Object_;
 ClassID = ^Byte;

{
 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.

typedef struct
    Cardinal MethodID;
     method-specific data follows, some examples below
               *Msg; }

  pMsg = ^tMsg;
  tMsg = record
     MethodID : Cardinal;
  end;

{
 * Class id strings for Intuition classes.
 * There's no real reason to use the uppercase constants
 * over the lowercase strings, but this makes a good place
 * to list the names of the built-in classes.
 }
CONST
 ROOTCLASS      : PChar = 'rootclass'    ;         { classusr.h   }
 IMAGECLASS     : PChar = 'imageclass'   ;         { imageclass.h }
 FRAMEICLASS    : PChar = 'frameiclass'  ;
 SYSICLASS      : PChar = 'sysiclass'    ;
 FILLRECTCLASS  : PChar = 'fillrectclass';
 GADGETCLASS    : PChar = 'gadgetclass'  ;         { gadgetclass.h }
 PROPGCLASS     : PChar = 'propgclass'   ;
 STRGCLASS      : PChar = 'strgclass'    ;
 BUTTONGCLASS   : PChar = 'buttongclass' ;
 FRBUTTONCLASS  : PChar = 'frbuttonclass';
 GROUPGCLASS    : PChar = 'groupgclass'  ;
 ICCLASS        : PChar = 'icclass'      ;         { icclass.h    }
 MODELCLASS     : PChar = 'modelclass'   ;
 ITEXTICLASS    : PChar = 'itexticlass'  ;
 POINTERCLASS   : PChar = 'pointerclass' ;         { pointerclass.h }


{ Dispatched method ID's
 * NOTE: Applications should use Intuition entry points, not direct
 * DoMethod() calls, for NewObject, DisposeObject, SetAttrs,
 * SetGadgetAttrs, and GetAttr.
 }

 OM_Dummy       = ($100);
 OM_NEW         = ($101); { 'object' parameter is 'true class'   }
 OM_DISPOSE     = ($102); { delete self (no parameters)          }
 OM_SET         = ($103); { set attributes (in tag list)         }
 OM_GET         = ($104); { return single attribute value        }
 OM_ADDTAIL     = ($105); { add self to a List (let root do it)  }
 OM_REMOVE      = ($106); { remove self from list                }
 OM_NOTIFY      = ($107); { send to self: notify dependents      }
 OM_UPDATE      = ($108); { notification message from somebody   }
 OM_ADDMEMBER   = ($109); { used by various classes with lists   }
 OM_REMMEMBER   = ($10A); { used by various classes with lists   }

{ Parameter 'Messages' passed to methods       }

{ OM_NEW and OM_SET    }
Type
   popSet = ^topSet;
   topSet = record
    MethodID            : Cardinal;
    ops_AttrList        : pTagItem;    { new attributes       }
    ops_GInfo           : pGadgetInfo; { always there for gadgets,
                                         * when SetGadgetAttrs() is used,
                                         * but will be NULL for OM_NEW
                                         }
   END;

{ OM_NOTIFY, and OM_UPDATE     }

  popUpdate = ^topUpdate;
  topUpdate = record
    MethodID            : Cardinal;
    opu_AttrList        : pTagItem;     { new attributes       }
    opu_GInfo           : pGadgetInfo;  { non-NULL when SetGadgetAttrs OR
                                         * notification resulting from gadget
                                         * input occurs.
                                         }
    opu_Flags           : Cardinal;        { defined below        }
  END;

{ this flag means that the update message is being issued from
 * something like an active gadget, a la GACT_FOLLOWMOUSE.  When
 * the gadget goes inactive, it will issue a final update
 * message with this bit cleared.  Examples of use are for
 * GACT_FOLLOWMOUSE equivalents for propgadclass, and repeat strobes
 * for buttons.
 }
CONST
 OPUF_INTERIM   = 1;

{ OM_GET       }
Type

  popGet = ^topGet;
  topGet = record
    MethodID,
    opg_AttrID          : Cardinal;
    opg_Storage         : Pointer;   { may be other types, but 'int'
                                         * types are all Cardinal
                                         }
  END;

{ OM_ADDTAIL   }

  popAddTail = ^topAddTail;
  topAddTail = record
    MethodID  : Cardinal;
    opat_List : pList;
  END;

{ OM_ADDMEMBER, OM_REMMEMBER   }
Type

   popMember = ^topMember;
   topMember = record
    MethodID   : Cardinal;
    opam_Object : pObject_;
   END;



{*****************************************}
{** 'White box' access to struct IClass **}
{*****************************************}

{ This structure is READ-ONLY, and allocated only by Intuition }
TYPE

   pIClass = ^tIClass;
   tIClass = record
    cl_Dispatcher       : tHook;
    cl_Reserved         : Cardinal;    { must be 0  }
    cl_Super            : pIClass;
    cl_ID               : ClassID;

    { where within an object is the instance data for this class? }
    cl_InstOffset       : Word;
    cl_InstSize         : Word;

    cl_UserData         : Cardinal;    { per-class data of your choice }
    cl_SubclassCount    : Cardinal;
                                        { how many direct subclasses?  }
    cl_ObjectCount      : Cardinal;
                                { how many objects created of this class? }
    cl_Flags            : Cardinal;
   END;

CONST
 CLF_INLIST    =  $00000001;      { class is in public class list }



{************************************************}
{** 'White box' access to struct _Object       **}
{************************************************}

{
 * We have this, the instance data of the root class, PRECEDING
 * the 'object'.  This is so that Gadget objects are Gadget pointers,
 * and so on.  If this structure grows, it will always have o_Class
 * at the end, so the macro OCLASS(o) will always have the same
 * offset back from the pointer returned from NewObject().
 *
 * This data structure is subject to change.  Do not use the o_Node
 * embedded structure.
 }
Type
  p_Object = ^t_Object;
  t_Object = record
    o_Node    : tMinNode;
    o_Class   : pIClass;
  END;

{ BOOPSI class libraries should use this structure as the base for their
 * library data.  This allows developers to obtain the class pointer for
 * performing object-less inquiries. }


       PClassLibrary = ^tClassLibrary;
       tClassLibrary = record
            cl_Lib : tLibrary;    { Embedded library }
            cl_Pad : Word;       { Align the structure }
            cl_Class : PIClass;   { Class pointer }
         end;

{
 * NOTE:  <intuition/iobsolete.h> is included at the END of this file!
 }

{ Gadget Class attributes      }
CONST
    GA_Dummy           =  (TAG_USER +$30000);

    { (LONG) Left edge of the gadget relative to the left edge of
     * the window }
    GA_Left            =  (GA_Dummy + $0001);

    { (LONG) Left edge of the gadget relative to the right edge of
     * the window }
    GA_RelRight        =  (GA_Dummy + $0002);

    { (LONG) Top edge of the gadget relative to the top edge of
     * the window }
    GA_Top             =  (GA_Dummy + $0003);

    { (LONG) Top edge of the gadget relative to the bottom edge
     * of the window }
    GA_RelBottom       =  (GA_Dummy + $0004);

    { (LONG) Width of the gadget }
    GA_Width           =  (GA_Dummy + $0005);

    { (LONG) Width of the gadget relative to the width of the
     * window }
    GA_RelWidth        =  (GA_Dummy + $0006);

    { (LONG) Height of the gadget }
    GA_Height          =  (GA_Dummy + $0007);

    { (LONG) Height of the gadget relative to the height of
     * the window }
    GA_RelHeight       =  (GA_Dummy + $0008);

    { (PChar) Gadget imagry is NULL terminated string }
    GA_Text            =  (GA_Dummy + $0009); { ti_Data is (UBYTE *) }

    { (struct Image *) Gadget imagry is an image }
    GA_Image           =  (GA_Dummy + $000A);

    { (struct Border *) Gadget imagry is a border }
    GA_Border          =  (GA_Dummy + $000B);

    { (struct Image *) Selected gadget imagry }
    GA_SelectRender    =  (GA_Dummy + $000C);

    { (UWORD) One of GFLG_GADGHNONE, GFLG_GADGHBOX, GFLG_GADGHCOMP,
     * or GFLG_GADGHIMAGE }
    GA_Highlight       =  (GA_Dummy + $000D);

    { (BOOL) Indicate whether gadget is disabled or not.
     * Defaults to FALSE. }
    GA_Disabled        =  (GA_Dummy + $000E);

    { (BOOL) Indicate whether the gadget is for
     * WFLG_GIMMEZEROZERO window borders or not.  Defaults
     * to FALSE. }
    GA_GZZGadget       =  (GA_Dummy + $000F);

    { (UWORD) Gadget ID assigned by the application }
    GA_ID              =  (GA_Dummy + $0010);

    { (APTR) Application specific data }
    GA_UserData        =  (GA_Dummy + $0011);

    { (APTR) Gadget specific data }
    GA_SpecialInfo     =  (GA_Dummy + $0012);

    { (BOOL) Indicate whether the gadget is selected or not.
     * Defaults to FALSE }
    GA_Selected        =  (GA_Dummy + $0013);

    { (BOOL) When set tells the system that when this gadget
     * is selected causes the requester that it is in to be
     * ended.  Defaults to FALSE. }
    GA_EndGadget       =  (GA_Dummy + $0014);

    { (BOOL) When set indicates that the gadget is to
     * notify the application when it becomes active.  Defaults
     * to FALSE. }
    GA_Immediate       =  (GA_Dummy + $0015);

    { (BOOL) When set indicates that the application wants to
     * verify that the pointer was still over the gadget when
     * the select button is released.  Defaults to FALSE. }
    GA_RelVerify       =  (GA_Dummy + $0016);

    { (BOOL) When set indicates that the application wants to
     * be notified of mouse movements while the gadget is active.
     * It is recommmended that GA_Immediate and GA_RelVerify are
     * also used so that the active gadget can be tracked by the
     * application.  Defaults to FALSE. }
    GA_FollowMouse     =  (GA_Dummy + $0017);

    { (BOOL) Indicate whether the gadget is in the right border
     * or not.  Defaults to FALSE. }
    GA_RightBorder     =  (GA_Dummy + $0018);

    { (BOOL) Indicate whether the gadget is in the left border
     * or not.  Defaults to FALSE. }
    GA_LeftBorder      =  (GA_Dummy + $0019);

    { (BOOL) Indicate whether the gadget is in the top border
     * or not.  Defaults to FALSE. }
    GA_TopBorder       =  (GA_Dummy + $001A);

    { (BOOL) Indicate whether the gadget is in the bottom border
     * or not.  Defaults to FALSE. }
    GA_BottomBorder    =  (GA_Dummy + $001B);

    { (BOOL) Indicate whether the gadget is toggle-selected
     * or not.  Defaults to FALSE. }
    GA_ToggleSelect    =  (GA_Dummy + $001C);

    { (BOOL) Reserved for system use to indicate that the
     * gadget belongs to the system.  Defaults to FALSE. }
    GA_SysGadget       =  (GA_Dummy + $001D);

    { (UWORD) Reserved for system use to indicate the
     * gadget type. }
    GA_SysGType        =  (GA_Dummy + $001E);

    { (struct Gadget *) Previous gadget in the linked list.
     * NOTE: This attribute CANNOT be used to link new gadgets
     * into the gadget list of an open window or requester.
     * You must use AddGList(). }
    GA_Previous        =  (GA_Dummy + $001F);

    { (struct Gadget *) Next gadget in the linked list. }
    GA_Next            =  (GA_Dummy + $0020);

    { (struct DrawInfo *) Some gadgets need a DrawInfo at creation time }
    GA_DrawInfo        =  (GA_Dummy + $0021);

    { You should use at most ONE of GA_Text, GA_IntuiText, and GA_LabelImage }
    { (struct IntuiText *) Label is an IntuiText. }
    GA_IntuiText          =  (GA_Dummy + $0022);

    { (Object *) Label is an image object. }
    GA_LabelImage         =  (GA_Dummy + $0023);

    { New for V37:
         * Boolean indicates that this gadget is to participate in
         * cycling activation with Tab or Shift-Tab.
    }
    GA_TabCycle           =  (GA_Dummy + $0024);

    { New for V39:
         * Boolean indicates that this gadget sends gadget-help
    }
    GA_GadgetHelp         =  (GA_Dummy + $0025);

    { New for V39:
         * ti_Data is a pointer to an IBox structure which is
         * to be copied into the extended gadget's bounds.
    }
    GA_Bounds             =  (GA_Dummy + $0026);

    { New for V39:
         * Boolean indicates that this gadget has the "special relativity"
         * property, which is useful for certain fancy relativity
         * operations through the GM_LAYOUT method.
    }
    GA_RelSpecial         =  (GA_Dummy + $0027);


     GA_TextAttr = GA_Dummy + 40;
  { (struct TextAttr  ) Indicate the font to use for the gadget.
         New for V42.  }

     GA_ReadOnly = GA_Dummy + 41;
  { (BOOL) Indicate that the gadget is read-only (non-selectable).
         Defaults to FALSE. New for V42.  }

     GA_Underscore = GA_Dummy + 42;
  { (UBYTE) Underscore/escape character for keyboard shortcuts.
         Defaults to '_' . New for V44.  }

     GA_ActivateKey = GA_Dummy + 43;
  { (PChar) Set/Get the gadgets shortcut/activation key(s)
         Defaults to NULL. New for V44.  }

     GA_BackFill = GA_Dummy + 44;
  { (struct Hook  ) Backfill pattern hook.
         Defaults to NULL. New for V44.  }

     GA_GadgetHelpText = GA_Dummy + 45;
  { (PChar)   RESERVERD/PRIVATE DO NOT USE
         Defaults to NULL. New for V44.  }

     GA_UserInput = GA_Dummy + 46;
  { (BOOL) Notification tag indicates this notification is from the activite
           gadget receiving user input - an attempt to make IDCMPUPDATE more efficient.
         Defaults to FALSE. New for V44.  }
{ PROPGCLASS attributes }

 PGA_Dummy      = (TAG_USER + $31000);
 PGA_Freedom    = (PGA_Dummy + $0001);
        { only one of FREEVERT or FREEHORIZ }
 PGA_Borderless = (PGA_Dummy + $0002);
 PGA_HorizPot   = (PGA_Dummy + $0003);
 PGA_HorizBody  = (PGA_Dummy + $0004);
 PGA_VertPot    = (PGA_Dummy + $0005);
 PGA_VertBody   = (PGA_Dummy + $0006);
 PGA_Total      = (PGA_Dummy + $0007);
 PGA_Visible    = (PGA_Dummy + $0008);
 PGA_Top        = (PGA_Dummy + $0009);
{ New for V37: }
 PGA_NewLook    = (PGA_Dummy + $000A);

{ STRGCLASS attributes }

 STRINGA_Dummy         =  (TAG_USER      +$32000);
 STRINGA_MaxChars      =  (STRINGA_Dummy + $0001);
 STRINGA_Buffer        =  (STRINGA_Dummy + $0002);
 STRINGA_UndoBuffer    =  (STRINGA_Dummy + $0003);
 STRINGA_WorkBuffer    =  (STRINGA_Dummy + $0004);
 STRINGA_BufferPos     =  (STRINGA_Dummy + $0005);
 STRINGA_DispPos       =  (STRINGA_Dummy + $0006);
 STRINGA_AltKeyMap     =  (STRINGA_Dummy + $0007);
 STRINGA_Font          =  (STRINGA_Dummy + $0008);
 STRINGA_Pens          =  (STRINGA_Dummy + $0009);
 STRINGA_ActivePens    =  (STRINGA_Dummy + $000A);
 STRINGA_EditHook      =  (STRINGA_Dummy + $000B);
 STRINGA_EditModes     =  (STRINGA_Dummy + $000C);

{ booleans }
 STRINGA_ReplaceMode    = (STRINGA_Dummy + $000D);
 STRINGA_FixedFieldMode = (STRINGA_Dummy + $000E);
 STRINGA_NoFilterMode   = (STRINGA_Dummy + $000F);

 STRINGA_Justification  = (STRINGA_Dummy + $0010);
        { GACT_STRINGCENTER, GACT_STRINGLEFT, GACT_STRINGRIGHT }
 STRINGA_LongVal        = (STRINGA_Dummy + $0011);
 STRINGA_TextVal        = (STRINGA_Dummy + $0012);

 STRINGA_ExitHelp       = (STRINGA_Dummy + $0013);
        { STRINGA_ExitHelp is new for V37, and ignored by V36.
         * Set this if you want the gadget to exit when Help is
         * pressed.  Look for a code of $5F, the rawkey code for Help
         }

 SG_DEFAULTMAXCHARS     = (128);

{ Gadget Layout related attributes     }

 LAYOUTA_Dummy          = (TAG_USER  + $38000);
 LAYOUTA_LayoutObj      = (LAYOUTA_Dummy + $0001);
 LAYOUTA_Spacing        = (LAYOUTA_Dummy + $0002);
 LAYOUTA_Orientation    = (LAYOUTA_Dummy + $0003);

 LAYOUTA_ChildMaxWidth = LAYOUTA_Dummy + $0004;
  { (BOOL) Child objects are of equal width.  Should default to TRUE for
         gadgets with a horizontal orientation.  New for V42.  }

 LAYOUTA_ChildMaxHeight = LAYOUTA_Dummy + $0005;
  { (BOOL) Child objects are of equal height.  Should default to TRUE for
         gadgets with a vertical orientation.  New for V42.  }

{ orientation values   }
 LORIENT_NONE   = 0;
 LORIENT_HORIZ  = 1;
 LORIENT_VERT   = 2;


{ Gadget Method ID's   }

 GM_Dummy      =  (-1);    { not used for anything                }
 GM_HITTEST    =  (0);     { return GMR_GADGETHIT IF you are clicked on
                                 * (whether or not you are disabled).
                                 }
 GM_RENDER      = (1);     { draw yourself, in the appropriate state }
 GM_GOACTIVE    = (2);     { you are now going to be fed input    }
 GM_HANDLEINPUT = (3);     { handle that input                    }
 GM_GOINACTIVE  = (4);     { whether or not by choice, you are done  }
 GM_HELPTEST    = (5);     { Will you send gadget help if the mouse is
                                 * at the specified coordinates?  See below
                                 * for possible GMR_ values.
                                 }
 GM_LAYOUT      = (6);     { re-evaluate your size based on the GadgetInfo
                                 * Domain.  Do NOT re-render yourself yet, you
                                 * will be called when it is time...
                                 }

{ Parameter "Messages" passed to gadget class methods  }

{ GM_HITTEST   }
type

  pgpHitTest = ^tgpHitTest;
  tgpHitTest = record
    MethodID  : Cardinal;
    gpht_GInfo : pGadgetInfo;
    gpht_Mouse : record
             x : smallint;
             y : smallint;
                 end;
  END;

const
{ For GM_HITTEST, return GMR_GADGETHIT if you were indeed hit,
 * otherwise return zero.
 *
 * For GM_HELPTEST, return GMR_NOHELPHIT (zero) if you were not hit.
 * Typically, return GMR_HELPHIT if you were hit.
 * It is possible to pass a UWORD to the application via the Code field
 * of the IDCMP_GADGETHELP message.  Return GMR_HELPCODE or'd with
 * the UWORD-sized result you wish to return.
 *
 * GMR_HELPHIT yields a Code value of ((UWORD) ~0), which should
 * mean "nothing particular" to the application.
 }

 GMR_GADGETHIT  = ($00000004);    { GM_HITTEST hit }

 GMR_NOHELPHIT  = ($00000000);    { GM_HELPTEST didn't hit }
 GMR_HELPHIT    = ($FFFFFFFF);    { GM_HELPTEST hit, return code = ~0 }
 GMR_HELPCODE   = ($00010000);    { GM_HELPTEST hit, return low word as code }


{ GM_RENDER    }
Type
   pgpRender = ^tgpRender;
   tgpRender = record
    MethodID  : Cardinal;
    gpr_GInfo : pGadgetInfo;      { gadget context               }
    gpr_RPort : pRastPort;        { all ready for use            }
    gpr_Redraw : Longint;           { might be a "highlight pass"  }
   END;

{ values of gpr_Redraw }
CONST
 GREDRAW_UPDATE = (2);     { incremental update, e.g. prop slider }
 GREDRAW_REDRAW = (1);     { redraw gadget        }
 GREDRAW_TOGGLE = (0);     { toggle highlight, IF applicable      }

{ GM_GOACTIVE, GM_HANDLEINPUT  }
Type

  pgpInput = ^tgpInput;
  tgpInput = record
    MethodID : Cardinal;
    gpi_GInfo : pGadgetInfo;
    gpi_IEvent : pInputEvent;
    gpi_Termination : Pointer;
    gpi_Mouse : record
            x : smallint;
            y : smallint;
                end;
    {* (V39) Pointer to TabletData structure, if this event originated
     * from a tablet which sends IESUBCLASS_NEWTABLET events, or NULL if
     * not.
     *
     * DO NOT ATTEMPT TO READ THIS FIELD UNDER INTUITION PRIOR TO V39!
     * IT WILL BE INVALID!
     *}
   gpi_TabletData  : pTabletData;
  END;

{ GM_HANDLEINPUT and GM_GOACTIVE  return code flags    }
{ return GMR_MEACTIVE (0) alone if you want more input.
 * Otherwise, return ONE of GMR_NOREUSE and GMR_REUSE, and optionally
 * GMR_VERIFY.
 }
CONST
 GMR_MEACTIVE  =  (0);
 GMR_NOREUSE   =  (2);
 GMR_REUSE     =  (4);
 GMR_VERIFY    =  (8);        { you MUST set cgp_Termination }

{ New for V37:
 * You can end activation with one of GMR_NEXTACTIVE and GMR_PREVACTIVE,
 * which instructs Intuition to activate the next or previous gadget
 * that has GFLG_TABCYCLE set.
 }
 GMR_NEXTACTIVE = (16);
 GMR_PREVACTIVE = (32);

{ GM_GOINACTIVE }
Type

   pgpGoInactive = ^tgpGoInactive;
   tgpGoInactive = record
    MethodID    : Cardinal;
    gpgi_GInfo  : pGadgetInfo;

    { V37 field only!  DO NOT attempt to read under V36! }
    gpgi_Abort  : Cardinal;               { gpgi_Abort=1 IF gadget was aborted
                                         * by Intuition and 0 if gadget went
                                         * inactive at its own request
                                         }
   END;

{* New for V39: Intuition sends GM_LAYOUT to any GREL_ gadget when
 * the gadget is added to the window (or when the window opens, if
 * the gadget was part of the NewWindow.FirstGadget or the WA_Gadgets
 * list), or when the window is resized.  Your gadget can set the
 * GA_RelSpecial property to get GM_LAYOUT events without Intuition
 * changing the interpretation of your gadget select box.  This
 * allows for completely arbitrary resizing/repositioning based on
 * window size.
 *}
{* GM_LAYOUT *}
Type

 pgpLayout = ^tgpLayout;
 tgpLayout = record
    MethodID            : Cardinal;
    gpl_GInfo           : pGadgetInfo;
    gpl_Initial         : Cardinal;      {* non-zero if this method was invoked
                                         * during AddGList() or OpenWindow()
                                         * time.  zero if this method was invoked
                                         * during window resizing.
                                         *}
 end;

{***************************************************************************}

{ The GM_DOMAIN method is used to obtain the sizing requirements of an
 * object for a class before ever creating an object. }

{ GM_DOMAIN }

    PgpDomain = ^tgpDomain;
     tgpDomain = record
          MethodID : Cardinal;
          gpd_GInfo : PGadgetInfo;
          gpd_RPort : PRastPort;    { RastPort to layout for }
          gpd_Which : LongInt;
          gpd_Domain : tIBox;       { Resulting domain }
          gpd_Attrs : PTagItem;     { Additional attributes }
       end;


  const
     GDOMAIN_MINIMUM = 0;
  { Minimum size  }

     GDOMAIN_NOMINAL = 1;
  { Nominal size  }

     GDOMAIN_MAXIMUM = 2;
  { Maximum size  }

{***************************************************************************}

{ The GM_KEYTEST method is used to determin if a key press matches an
 * object's activation key(s). }

{ GM_KEYTEST send this message.
 }

  type
     PgpKeyTest = ^tgpKeyTest;
     tgpKeyTest = record
          MethodID : Cardinal;
          gpkt_GInfo : PGadgetInfo;
          gpkt_IMsg : PIntuiMessage;   { The IntuiMessage that triggered this }
          gpkt_VanillaKey : Cardinal;
       end;

{***************************************************************************}

{ The GM_KEYGOACTIVE method is called to "simulate" a gadget going down.
 * A gadget should render itself in a selected state when receiving
 * this message. If the class supports this method, it must return
 * GMR_KEYACTIVE.
 *
 * If a gadget returns zero for this method, it will subsequently be
 * activated via ActivateGadget() with a NULL IEvent.
 }

     PgpKeyInput = ^tgpKeyInput;
     tgpKeyInput = record
          MethodID : Cardinal;        { GM_KEYGOACTIVE }
          gpk_GInfo : PGadgetInfo;
          gpk_IEvent : PInputEvent;
          gpk_Termination : ^LongInt;
       end;


  const
     GMR_KEYACTIVE = 1 shl 4;

  { you MUST set gpk_Termination  }
     GMR_KEYVERIFY = 1 shl 5;

{ The GM_KEYGOINACTIVE method is called to simulate the gadget release.
 * Upon receiving this message, the gadget should do everything a
 * normal gadget release would do.
 }

  type
     PgpKeyGoInactive = ^tgpKeyGoInactive;
     tgpKeyGoInactive = record
          MethodID : Cardinal;
          gpki_GInfo : PGadgetInfo;
          gpki_Abort : Cardinal;
       end;

CONST
 ICM_Dummy      = ($0401);       { used for nothing             }
 ICM_SETLOOP    = ($0402);       { set/increment loop counter   }
 ICM_CLEARLOOP  = ($0403);       { clear/decrement loop counter }
 ICM_CHECKLOOP  = ($0404);       { set/increment loop           }

{ no parameters for ICM_SETLOOP, ICM_CLEARLOOP, ICM_CHECKLOOP  }

{ interconnection attributes used by icclass, modelclass, and gadgetclass }
 ICA_Dummy      = (TAG_USER+$40000);
 ICA_TARGET     = (ICA_Dummy + 1);
        { interconnection target               }
 ICA_MAP        = (ICA_Dummy + 2);
        { interconnection map tagitem list     }
 ICSPECIAL_CODE = (ICA_Dummy + 3);
        { a "pseudo-attribute", see below.     }

{ Normally, the value for ICA_TARGET is some object pointer,
 * but if you specify the special value ICTARGET_IDCMP, notification
 * will be send as an IDCMP_IDCMPUPDATE message to the appropriate window's
 * IDCMP port.  See the definition of IDCMP_IDCMPUPDATE.
 *
 * When you specify ICTARGET_IDCMP for ICA_TARGET, the map you
 * specify will be applied to derive the attribute list that is
 * sent with the IDCMP_IDCMPUPDATE message.  If you specify a map list
 * which results in the attribute tag id ICSPECIAL_CODE, the
 * lower sixteen bits of the corresponding ti_Data value will
 * be copied into the Code field of the IDCMP_IDCMPUPDATE IntuiMessage.
 }
 ICTARGET_IDCMP = (NOT 0);


CONST
 CUSTOMIMAGEDEPTH     =   (-1);
{ if image.Depth is this, it's a new Image class object }


{****************************************************}
CONST
 IA_Dummy             =   (TAG_USER + $20000);
 IA_Left              =   (IA_Dummy + $01);
 IA_Top               =   (IA_Dummy + $02);
 IA_Width             =   (IA_Dummy + $03);
 IA_Height            =   (IA_Dummy + $04);
 IA_FGPen             =   (IA_Dummy + $05);
                    { IA_FGPen also means "PlanePick"  }
 IA_BGPen             =   (IA_Dummy + $06);
                    { IA_BGPen also means "PlaneOnOff" }
 IA_Data              =   (IA_Dummy + $07);
                    { bitplanes, for classic image,
                     * other image classes may use it for other things
                     }
 IA_LineWidth         =   (IA_Dummy + $08);
 IA_Pens              =   (IA_Dummy + $0E);
                    { pointer to UWORD pens[],
                     * ala DrawInfo.Pens, MUST be
                     * terminated by ~0.  Some classes can
                     * choose to have this, or SYSIA_DrawInfo,
                     * or both.
                     }
 IA_Resolution        =   (IA_Dummy + $0F);
                    { packed uwords for x/y resolution into a longword
                     * ala DrawInfo.Resolution
                     }

{*** see class documentation to learn which    ****}
{*** classes recognize these                   ****}
 IA_APattern           =  (IA_Dummy + $10);
 IA_APatSize           =  (IA_Dummy + $11);
 IA_Mode               =  (IA_Dummy + $12);
 IA_Font               =  (IA_Dummy + $13);
 IA_Outline            =  (IA_Dummy + $14);
 IA_Recessed           =  (IA_Dummy + $15);
 IA_DoubleEmboss       =  (IA_Dummy + $16);
 IA_EdgesOnly          =  (IA_Dummy + $17);

{*** "sysiclass" attributes                    ****}
 SYSIA_Size            =  (IA_Dummy + $0B);
                    { 's below          }
 SYSIA_Depth           =  (IA_Dummy + $0C);
                    { this is unused by Intuition.  SYSIA_DrawInfo
                     * is used instead for V36
                     }
 SYSIA_Which           =  (IA_Dummy + $0D);
                    { see 's below      }
 SYSIA_DrawInfo        =  (IA_Dummy + $18);
                    { pass to sysiclass, please }

{****  obsolete: don't use these, use IA_Pens  ****}
 SYSIA_Pens            =  IA_Pens;
 IA_ShadowPen          =  (IA_Dummy + $09);
 IA_HighlightPen       =  (IA_Dummy + $0A);

{ New for V39: }
 SYSIA_ReferenceFont   =  (IA_Dummy + $19);
                    { Font to use as reference for scaling
                     * certain sysiclass images
                     }
 IA_SupportsDisable    =  (IA_Dummy + $1a);
                    { By default, Intuition ghosts gadgets itself,
                     * instead of relying on IDS_DISABLED or
                     * IDS_SELECTEDDISABLED.  An imageclass that
                     * supports these states should return this attribute
                     * as TRUE.  You cannot set or clear this attribute,
                     * however.
                     }

 IA_FrameType          =  (IA_Dummy + $1b);
                    { Starting with V39, FrameIClass recognizes
                     * several standard types of frame.  Use one
                     * of the FRAME_ specifiers below.  Defaults
                     * to FRAME_DEFAULT.
                     }

     IA_Underscore = IA_Dummy + $1c;
  { V44, Indicate underscore keyboard shortcut for image labels.
                       (UBYTE) Defaults to '_'
                      }

     IA_Scalable = IA_Dummy + $1d;
  { V44, Attribute indicates this image is allowed
                           to/can scale its rendering.
                       (BOOL) Defaults to FALSE.
                      }

     IA_ActivateKey = IA_Dummy + $1e;
  { V44, Used to get an underscored label shortcut.
                       Useful for labels attached to string gadgets.
                       (UBYTE) Defaults to NULL.
                      }

     IA_Screen = IA_Dummy + $1f;
  { V44 Screen pointer, may be useful/required by certain classes.
                       (struct Screen  )
                      }

     IA_Precision = IA_Dummy + $20;
  { V44 Precision value, typically pen precision but may be
                       used for similar custom purposes.
                       (Cardinal)
                      }

{* next attribute: (IA_Dummy + $1c)   *}

{***********************************************}

{ data values for SYSIA_Size   }
 SYSISIZE_MEDRES = (0);
 SYSISIZE_LOWRES = (1);
 SYSISIZE_HIRES  = (2);

{
 * SYSIA_Which tag data values:
 * Specifies which system gadget you want an image for.
 * Some numbers correspond to internal Intuition s
 }
 DEPTHIMAGE     = ($00);
 ZOOMIMAGE      = ($01);
 SIZEIMAGE      = ($02);
 CLOSEIMAGE     = ($03);
 SDEPTHIMAGE    = ($05); { screen depth gadget }
 LEFTIMAGE      = ($0A);
 UPIMAGE        = ($0B);
 RIGHTIMAGE     = ($0C);
 DOWNIMAGE      = ($0D);
 CHECKIMAGE     = ($0E);
 MXIMAGE        = ($0F); { mutual exclude "button" }
{* New for V39: *}
 MENUCHECK      = ($10); { Menu checkmark image }
 AMIGAKEY       = ($11); { Menu Amiga-key image }

{ Data values for IA_FrameType (recognized by FrameIClass)
 *
 * FRAME_DEFAULT:  The standard V37-type frame, which has
 *      thin edges.
 * FRAME_BUTTON:  Standard button gadget frames, having thicker
 *      sides and nicely edged corners.
 * FRAME_RIDGE:  A ridge such as used by standard string gadgets.
 *      You can recess the ridge to get a groove image.
 * FRAME_ICONDROPBOX: A broad ridge which is the standard imagery
 *      for areas in AppWindows where icons may be dropped.
 }

     FRAME_DEFAULT = 0;
     FRAME_BUTTON = 1;
     FRAME_RIDGE = 2;
     FRAME_ICONDROPBOX = 3;

{ image message id's   }
    IM_DRAW     = $202;  { draw yourself, with "state"          }
    IM_HITTEST  = $203;  { return TRUE IF click hits image      }
    IM_ERASE    = $204;  { erase yourself                       }
    IM_MOVE     = $205;  { draw new AND erase old, smoothly     }

    IM_DRAWFRAME= $206;  { draw with specified dimensions       }
    IM_FRAMEBOX = $207;  { get recommended frame around some box}
    IM_HITFRAME = $208;  { hittest with dimensions              }
    IM_ERASEFRAME= $209; { hittest with dimensions              }
    IM_DOMAINFRAME = $20A;{ query image for its domain info (V44)  }

{ image draw states or styles, for IM_DRAW }
    IDS_NORMAL          = (0);
    IDS_SELECTED        = (1);    { for selected gadgets     }
    IDS_DISABLED        = (2);    { for disabled gadgets     }
    IDS_BUSY            = (3);    { for future functionality }
    IDS_INDETERMINATE   = (4);    { for future functionality }
    IDS_INACTIVENORMAL  = (5);    { normal, in inactive window border }
    IDS_INACTIVESELECTED= (6);    { selected, in inactive border }
    IDS_INACTIVEDISABLED= (7);    { disabled, in inactive border }
    IDS_SELECTEDDISABLED = 8;     { disabled and selected     }

{ oops, please forgive spelling error by jimm }
 IDS_INDETERMINANT = IDS_INDETERMINATE;

{ IM_FRAMEBOX  }
Type

  pimpFrameBox = ^timpFrameBox;
  timpFrameBox = record
    MethodID   : Cardinal;
    imp_ContentsBox  : pIBox;       { input: relative box of contents }
    imp_FrameBox     : pIBox;          { output: rel. box of encl frame  }
    imp_DrInfo       : pDrawInfo;
    imp_FrameFlags   : Cardinal;
  END;

CONST
 FRAMEF_SPECIFY = (1);  { Make do with the dimensions of FrameBox
                                 * provided.
                                 }

{ IM_DRAW, IM_DRAWFRAME        }
Type

   pimpDraw = ^timpDraw;
   timpDraw = record
    MethodID    : Cardinal;
    imp_RPort   : pRastPort;
    imp_Offset  : record
              x : Word;
              y : Word;
                  end;
    imp_State   : Cardinal;
    imp_DrInfo  : pDrawInfo;

    { these parameters only valid for IM_DRAWFRAME }
    imp_Dimensions : record
             Width : Word;
            Height : Word;
                     end;
   END;

{ IM_ERASE, IM_ERASEFRAME      }
{ NOTE: This is a subset of impDraw    }

   pimpErase = ^timpErase;
   timpErase = record
    MethodID       : Cardinal;
    imp_RPort      : pRastPort;
    imp_Offset     : record
                 x : Word;
                 y : Word;
                     end;

    { these parameters only valid for IM_ERASEFRAME }
    imp_Dimensions : record
             Width : Word;
            Height : Word;
                     end;
   END;

{ IM_HITTEST, IM_HITFRAME      }

   pimpHitTest = ^timpHitTest;
   timpHitTest = record
    MethodID   : Cardinal;
    imp_Point  : record
             x : Word;
             y : Word;
                 end;

    { these parameters only valid for IM_HITFRAME }
    imp_Dimensions : record
               Width : Word;
               Height : Word;
               end;
   END;


{ The IM_DOMAINFRAME method is used to obtain the sizing
 * requirements of an image object within a layout group.
 }

{ IM_DOMAINFRAME }
     PimpDomainFrame = ^timpDomainFrame;
     timpDomainFrame = record
          MethodID : Cardinal;
          imp_DrInfo : PDrawInfo;
          imp_RPort : PRastPort;
          imp_Which : LongInt;
          imp_Domain : tIBox;
          imp_Attrs : PTagItem;
       end;

  { Accepted vales for imp_Which.
    }

  const
     IDOMAIN_MINIMUM = 0;
     IDOMAIN_NOMINAL = 1;
     IDOMAIN_MAXIMUM = 2;

 { **  'boopsi' pointer class interface }

const
{ The following tags are recognized at NewObject() time by
 * pointerclass:
 *
 * POINTERA_BitMap (struct BitMap *) - Pointer to bitmap to
 *      get pointer imagery from.  Bitplane data need not be
 *      in chip RAM.
 * POINTERA_XOffset (LONG) - X-offset of the pointer hotspot.
 * POINTERA_YOffset (LONG) - Y-offset of the pointer hotspot.
 * POINTERA_WordWidth (Cardinal) - designed width of the pointer in words
 * POINTERA_XResolution (Cardinal) - one of the POINTERXRESN_ flags below
 * POINTERA_YResolution (Cardinal) - one of the POINTERYRESN_ flags below
 *
 }

 POINTERA_Dummy = (TAG_USER + $39000);

 POINTERA_BitMap        = (POINTERA_Dummy + $01);
 POINTERA_XOffset       = (POINTERA_Dummy + $02);
 POINTERA_YOffset       = (POINTERA_Dummy + $03);
 POINTERA_WordWidth     = (POINTERA_Dummy + $04);
 POINTERA_XResolution   = (POINTERA_Dummy + $05);
 POINTERA_YResolution   = (POINTERA_Dummy + $06);

{ These are the choices for the POINTERA_XResolution attribute which
 * will determine what resolution pixels are used for this pointer.
 *
 * POINTERXRESN_DEFAULT (ECS-compatible pointer width)
 *      = 70 ns if SUPERHIRES-type mode, 140 ns if not
 *
 * POINTERXRESN_SCREENRES
 *      = Same as pixel speed of screen
 *
 * POINTERXRESN_LORES (pointer always in lores-like pixels)
 *      = 140 ns in 15kHz modes, 70 ns in 31kHz modes
 *
 * POINTERXRESN_HIRES (pointer always in hires-like pixels)
 *      = 70 ns in 15kHz modes, 35 ns in 31kHz modes
 *
 * POINTERXRESN_140NS (pointer always in 140 ns pixels)
 *      = 140 ns always
 *
 * POINTERXRESN_70NS (pointer always in 70 ns pixels)
 *      = 70 ns always
 *
 * POINTERXRESN_35NS (pointer always in 35 ns pixels)
 *      = 35 ns always
 }

 POINTERXRESN_DEFAULT   = 0;
 POINTERXRESN_140NS     = 1;
 POINTERXRESN_70NS      = 2;
 POINTERXRESN_35NS      = 3;

 POINTERXRESN_SCREENRES = 4;
 POINTERXRESN_LORES     = 5;
 POINTERXRESN_HIRES     = 6;

{ These are the choices for the POINTERA_YResolution attribute which
 * will determine what vertical resolution is used for this pointer.
 *
 * POINTERYRESN_DEFAULT
 *      = In 15 kHz modes, the pointer resolution will be the same
 *        as a non-interlaced screen.  In 31 kHz modes, the pointer
 *        will be doubled vertically.  This means there will be about
 *        200-256 pointer lines per screen.
 *
 * POINTERYRESN_HIGH
 * POINTERYRESN_HIGHASPECT
 *      = Where the hardware/software supports it, the pointer resolution
 *        will be high.  This means there will be about 400-480 pointer
 *        lines per screen.  POINTERYRESN_HIGHASPECT also means that
 *        when the pointer comes out double-height due to hardware/software
 *        restrictions, its width would be doubled as well, if possible
 *        (to preserve aspect).
 *
 * POINTERYRESN_SCREENRES
 * POINTERYRESN_SCREENRESASPECT
 *      = Will attempt to match the vertical resolution of the pointer
 *        to the screen's vertical resolution.  POINTERYRESN_SCREENASPECT also
 *        means that when the pointer comes out double-height due to
 *        hardware/software restrictions, its width would be doubled as well,
 *        if possible (to preserve aspect).
 *
 }

 POINTERYRESN_DEFAULT          =  0;
 POINTERYRESN_HIGH             =  2;
 POINTERYRESN_HIGHASPECT       =  3;
 POINTERYRESN_SCREENRES        =  4;
 POINTERYRESN_SCREENRESASPECT  =  5;

{ Compatibility note:
 *
 * The AA chipset supports variable sprite width and resolution, but
 * the setting of width and resolution is global for all sprites.
 * When no other sprites are in use, Intuition controls the sprite
 * width and sprite resolution for correctness based on pointerclass
 * attributes specified by the creator of the pointer.  Intuition
 * controls sprite resolution with the VTAG_DEFSPRITERESN_SET tag
 * to VideoControl().  Applications can override this on a per-viewport
 * basis with the VTAG_SPRITERESN_SET tag to VideoControl().
 *
 * If an application uses a sprite other than the pointer sprite,
 * Intuition will automatically regenerate the pointer sprite's image in
 * a compatible width.  This might involve BitMap scaling of the imagery
 * you supply.
 *
 * If any sprites other than the pointer sprite were obtained with the
 * old GetSprite() call, Intuition assumes that the owner of those
 * sprites is unaware of sprite resolution, hence Intuition will set the
 * default sprite resolution (VTAG_DEFSPRITERESN_SET) to ECS-compatible,
 * instead of as requested by the various pointerclass attributes.
 *
 * No resolution fallback occurs when applications use ExtSprites.
 * Such applications are expected to use VTAG_SPRITERESN_SET tag if
 * necessary.
 *
 * NB:  Under release V39, only sprite width compatibility is implemented.
 * Sprite resolution compatibility was added for V40.
 }


Type

   pStringExtend = ^tStringExtend;
   tStringExtend = record
    { display specifications   }
    Font        : pTextFont;      { must be an open Font (not TextAttr)  }
    Pens        : Array[0..1] of Byte;        { color of text/backgroun              }
    ActivePens  : Array[0..1] of Byte;  { colors when gadget is active         }

    { edit specifications      }
    InitialModes : Cardinal;   { initial mode flags, below            }
    EditHook     : pHook;      { IF non-NULL, must supply WorkBuffer  }
    WorkBuffer   : PChar;    { must be as large as StringInfo.Buffer}

    Reserved     : Array[0..3] of Cardinal;    { set to 0                             }
   END;

   pSGWork = ^tSGWork;
   tSGWork = record
    { set up when gadget is first activated    }
    Gad       : pGadget;         { the contestant itself        }   { Gadget in C-Includes }
    StrInfo   : pStringInfo;     { easy access to sinfo         }   { StrInfo in C-Includes }
    WorkBuffer : PChar;           { intuition's planned result   }
    PrevBuffer : PChar;           { what was there before        }
    Modes      : Cardinal;          { current mode                 }

    { modified for each input event    }
    IEvent     : pInputEvent;    { actual event: do not change  }
    Code       : Word;            { character code, IF one byte  }
    BufferPos  : smallint;            { cursor position              }
    NumChars   : smallint;
    Actions    : Cardinal;          { what Intuition will do       }
    LongInt_   : Longint;          { temp storage for longint     }

    GInfo      : pGadgetInfo;    { see cghooks.h                }   { GadgetInfo in C-Includes }
    EditOp     : Word;            { from constants below         }
   END;

{ SGWork.EditOp -
 * These values indicate what basic type of operation the global
 * editing hook has performed on the string before your gadget's custom
 * editing hook gets called.  You do not have to be concerned with the
 * value your custom hook leaves in the EditOp field, only if you
 * write a global editing hook.
 *
 * For most of these general edit operations, you'll want to compare
 * the BufferPos and NumChars of the StringInfo (before global editing)
 * and SGWork (after global editing).
 }

CONST
 EO_NOOP       =  ($0001);
        { did nothing                                                  }
 EO_DELBACKWARD=  ($0002);
        { deleted some chars (maybe 0).                                }
 EO_DELFORWARD =  ($0003);
        { deleted some characters under and in front of the cursor     }
 EO_MOVECURSOR =  ($0004);
        { moved the cursor                                             }
 EO_ENTER      =  ($0005);
        { "enter" or "return" key, terminate                           }
 EO_RESET      =  ($0006);
        { current Intuition-style undo                                 }
 EO_REPLACECHAR=  ($0007);
        { replaced one character and (maybe) advanced cursor           }
 EO_INSERTCHAR =  ($0008);
        { inserted one char into string or added one at end            }
 EO_BADFORMAT  =  ($0009);
        { didn't like the text data, e.g., Bad LONGINT                 }
 EO_BIGCHANGE  =  ($000A);        { unused by Intuition  }
        { complete or major change to the text, e.g. new string        }
 EO_UNDO       =  ($000B);        { unused by Intuition  }
        { some other style of undo                                     }
 EO_CLEAR      =  ($000C);
        { clear the string                                             }
 EO_SPECIAL    =  ($000D);        { unused by Intuition  }
        { some operation that doesn't fit into the categories here     }


{ Mode Flags definitions (ONLY first group allowed as InitialModes)    }
 SGM_REPLACE   =  (1);       { replace mode                 }
{ please initialize StringInfo with in-range value of BufferPos
 * if you are using SGM_REPLACE mode.
 }

 SGM_FIXEDFIELD = (2);       { fixed length buffer          }
                                        { always set SGM_REPLACE, too  }
 SGM_NOFILTER   = (4);       { don't filter control chars   }

{ SGM_EXITHELP is new for V37, and ignored by V36: }
 SGM_EXITHELP   = (128);       { exit with code = $5F IF HELP hit }


{ These Mode Flags are for internal use only                           }
 SGM_NOCHANGE   = (8);       { no edit changes yet          }
 SGM_NOWORKB    = (16);       { Buffer == PrevBuffer         }
 SGM_CONTROL    = (32);       { control char escape mode     }
 SGM_LONGINT    = (64);       { an intuition longint gadget  }

{ String Gadget Action Flags (put in SGWork.Actions by EditHook)       }
 SGA_USE        = ($1);  { use contents of SGWork               }
 SGA_END        = ($2);  { terminate gadget, code in Code field }
 SGA_BEEP       = ($4);  { flash the screen for the user        }
 SGA_REUSE      = ($8);  { reuse input event                    }
 SGA_REDISPLAY  = ($10); { gadget visuals changed               }

{ New for V37: }
 SGA_NEXTACTIVE = ($20); { Make next possible gadget active.    }
 SGA_PREVACTIVE = ($40); { Make previous possible gadget active.}

{ function id for only existing custom string gadget edit hook }

 SGH_KEY        = (1);    { process editing keystroke            }
 SGH_CLICK      = (2);    { process mouse click cursor position  }

{ Here's a brief summary of how the custom string gadget edit hook works:
 *      You provide a hook in StringInfo.Extension.EditHook.
 *      The hook is called in the standard way with the 'object'
 *      a pointer to SGWork, and the 'message' a pointer to a command
 *      block, starting either with (longword) SGH_KEY, SGH_CLICK,
 *      or something new.
 *
 *      You return 0 if you don't understand the command (SGH_KEY is
 *      required and assumed).  Return non-zero if you implement the
 *      command.
 *
 *   SGH_KEY:
 *      There are no parameters following the command longword.
 *
 *      Intuition will put its idea of proper values in the SGWork
 *      before calling you, and if you leave SGA_USE set in the
 *      SGWork.Actions field, Intuition will use the values
 *      found in SGWork fields WorkBuffer, NumChars, BufferPos,
 *      and LongInt, copying the WorkBuffer back to the StringInfo
 *      Buffer.
 *
 *      NOTE WELL: You may NOT change other SGWork fields.
 *
 *      If you clear SGA_USE, the string gadget will be unchanged.
 *
 *      If you set SGA_END, Intuition will terminate the activation
 *      of the string gadget.  If you also set SGA_REUSE, Intuition
 *      will reuse the input event after it deactivates your gadget.
 *
 *      In this case, Intuition will put the value found in SGWork.Code
 *      into the IntuiMessage.Code field of the IDCMP_GADGETUP message it
 *      sends to the application.
 *
 *      If you set SGA_BEEP, Intuition will call DisplayBeep(); use
 *      this if the user has typed in error, or buffer is full.
 *
 *      Set SGA_REDISPLAY if the changes to the gadget warrant a
 *      gadget redisplay.  Note: cursor movement requires a redisplay.
 *
 *      Starting in V37, you may set SGA_PREVACTIVE or SGA_NEXTACTIVE
 *      when you set SGA_END.  This tells Intuition that you want
 *      the next or previous gadget with GFLG_TABCYCLE to be activated.
 *
 *   SGH_CLICK:
 *      This hook command is called when Intuition wants to position
 *      the cursor in response to a mouse click in the string gadget.
 *
 *      Again, here are no parameters following the command longword.
 *
 *      This time, Intuition has already calculated the mouse position
 *      character cell and put it in SGWork.BufferPos.  The previous
 *      BufferPos value remains in the SGWork.StringInfo.BufferPos.
 *
 *      Intuition will again use the SGWork fields listed above for
 *      SGH_KEY.  One restriction is that you are NOT allowed to set
 *      SGA_END or SGA_REUSE for this command.  Intuition will not
 *      stand for a gadget which goes inactive when you click in it.
 *
 *      You should always leave the SGA_REDISPLAY flag set, since Intuition
 *      uses this processing when activating a string gadget.
 }

const
  INTUITIONNAME : PChar = 'intuition.library';

var
  intuitionbase : PIntuitionBase;


procedure OpenIntuition;
SysCall IntuitionBase 030;

procedure Intuition(iEvent : pInputEvent location 'a0');
SysCall IntuitionBase 036;

function AddGadget(window : pWindow location 'a0'; gadget : pGadget location 'a1'; position : CARDINAL location 'd0') : Word;
SysCall IntuitionBase 042;

function ClearDMRequest(window : pWindow location 'a0') : BOOLEAN;
SysCall IntuitionBase 048;

procedure ClearMenuStrip(window : pWindow location 'a0');
SysCall IntuitionBase 054;

procedure ClearPointer(window : pWindow location 'a0');
SysCall IntuitionBase 060;

function CloseScreen(screen : pScreen location 'a0') : BOOLEAN;
SysCall IntuitionBase 066;

procedure CloseWindow(window : pWindow location 'a0');
SysCall IntuitionBase 072;

function CloseWorkBench : LongInt;
SysCall IntuitionBase 078;

procedure CurrentTime(VAR seconds : CARDINAL location 'a0'; VAR micros : CARDINAL location 'a1');
SysCall IntuitionBase 084;

function DisplayAlert(alertNumber : CARDINAL location 'd0'; string1 : PChar location 'a0'; height : CARDINAL location 'd1') : BOOLEAN;
SysCall IntuitionBase 090;

procedure DisplayBeep(screen : pScreen location 'a0');
SysCall IntuitionBase 096;

function DoubleClick(sSeconds : CARDINAL location 'd0'; sMicros : CARDINAL location 'd1'; cSeconds : CARDINAL location 'd2'; cMicros : CARDINAL location 'd3') : BOOLEAN;
SysCall IntuitionBase 102;

procedure DrawBorder(rp : pRastPort location 'a0'; border : pBorder location 'a1'; leftOffset : LongInt location 'd0'; topOffset : LongInt location 'd1');
SysCall IntuitionBase 108;

procedure DrawImage(rp : pRastPort location 'a0'; image : pImage location 'a1'; leftOffset : LongInt location 'd0'; topOffset : LongInt location 'd1');
SysCall IntuitionBase 114;

procedure EndRequest(requester : pRequester location 'a0'; window : pWindow location 'a1');
SysCall IntuitionBase 120;

function GetDefPrefs(preferences : pPreferences location 'a0'; size : LongInt location 'd0') : pPreferences;
SysCall IntuitionBase 126;

function GetPrefs(preferences : pPreferences location 'a0'; size : LongInt location 'd0') : pPreferences;
SysCall IntuitionBase 132;

procedure InitRequester(requester : pRequester location 'a0');
SysCall IntuitionBase 138;

function ItemAddress(menuStrip : pMenu location 'a0'; menuNumber : CARDINAL location 'd0') : pMenuItem;
SysCall IntuitionBase 144;

function ModifyIDCMP(window : pWindow location 'a0'; flags : CARDINAL location 'd0') : BOOLEAN;
SysCall IntuitionBase 150;

procedure ModifyProp(gadget : pGadget location 'a0'; window : pWindow location 'a1'; requester : pRequester location 'a2'; flags : CARDINAL location 'd0'; horizPot : CARDINAL location 'd1'; vertPot : CARDINAL location 'd2'; horizBody : CARDINAL location 'd3'; vertBody : CARDINAL location 'd4');
SysCall IntuitionBase 156;

procedure MoveScreen(screen : pScreen location 'a0'; dx : LongInt location 'd0'; dy : LongInt location 'd1');
SysCall IntuitionBase 162;

procedure MoveWindow(window : pWindow location 'a0'; dx : LongInt location 'd0'; dy : LongInt location 'd1');
SysCall IntuitionBase 168;

procedure OffGadget(gadget : pGadget location 'a0'; window : pWindow location 'a1'; requester : pRequester location 'a2');
SysCall IntuitionBase 174;

procedure OffMenu(window : pWindow location 'a0'; menuNumber : CARDINAL location 'd0');
SysCall IntuitionBase 180;

procedure OnGadget(gadget : pGadget location 'a0'; window : pWindow location 'a1'; requester : pRequester location 'a2');
SysCall IntuitionBase 186;

procedure OnMenu(window : pWindow location 'a0'; menuNumber : CARDINAL location 'd0');
SysCall IntuitionBase 192;

function OpenScreen(newScreen : pNewScreen location 'a0') : pScreen;
SysCall IntuitionBase 198;

function OpenWindow(newWindow : pNewWindow location 'a0') : pWindow;
SysCall IntuitionBase 204;

function OpenWorkBench : CARDINAL;
SysCall IntuitionBase 210;

procedure PrintIText(rp : pRastPort location 'a0'; iText : pIntuiText location 'a1'; left : LongInt location 'd0'; top : LongInt location 'd1');
SysCall IntuitionBase 216;

procedure RefreshGadgets(gadgets : pGadget location 'a0'; window : pWindow location 'a1'; requester : pRequester location 'a2');
SysCall IntuitionBase 222;

function RemoveGadget(window : pWindow location 'a0'; gadget : pGadget location 'a1') : Word;
SysCall IntuitionBase 228;

procedure ReportMouse(flag : LongInt location 'd0'; window : pWindow location 'a0');
SysCall IntuitionBase 234;

function Request(requester : pRequester location 'a0'; window : pWindow location 'a1') : BOOLEAN;
SysCall IntuitionBase 240;

procedure ScreenToBack(screen : pScreen location 'a0');
SysCall IntuitionBase 246;

procedure ScreenToFront(screen : pScreen location 'a0');
SysCall IntuitionBase 252;

function SetDMRequest(window : pWindow location 'a0'; requester : pRequester location 'a1') : BOOLEAN;
SysCall IntuitionBase 258;

function SetMenuStrip(window : pWindow location 'a0'; menu : pMenu location 'a1') : BOOLEAN;
SysCall IntuitionBase 264;

procedure SetPointer(window : pWindow location 'a0'; VAR pointer : Word location 'a1'; height : LongInt location 'd0'; width : LongInt location 'd1'; xOffset : LongInt location 'd2'; yOffset : LongInt location 'd3');
SysCall IntuitionBase 270;

procedure SetWindowTitles(window : pWindow location 'a0'; windowTitle : PChar location 'a1'; screenTitle : PChar location 'a2');
SysCall IntuitionBase 276;

procedure ShowTitle(screen : pScreen location 'a0'; showIt : LongInt location 'd0');
SysCall IntuitionBase 282;

procedure SizeWindow(window : pWindow location 'a0'; dx : LongInt location 'd0'; dy : LongInt location 'd1');
SysCall IntuitionBase 288;

function ViewAddress : pView;
SysCall IntuitionBase 294;

function ViewPortAddress(window : pWindow location 'a0') : pViewPort;
SysCall IntuitionBase 300;

procedure WindowToBack(window : pWindow location 'a0');
SysCall IntuitionBase 306;

procedure WindowToFront(window : pWindow location 'a0');
SysCall IntuitionBase 312;

function WindowLimits(window : pWindow location 'a0'; widthMin : LongInt location 'd0'; heightMin : LongInt location 'd1'; widthMax : CARDINAL location 'd2'; heightMax : CARDINAL location 'd3') : BOOLEAN;
SysCall IntuitionBase 318;

function SetPrefs(preferences : pPreferences location 'a0'; size : LongInt location 'd0'; inform : LongInt location 'd1') : pPreferences;
SysCall IntuitionBase 324;

function IntuiTextLength(iText : pIntuiText location 'a0') : LongInt;
SysCall IntuitionBase 330;

function WBenchToBack : BOOLEAN;
SysCall IntuitionBase 336;

function WBenchToFront : BOOLEAN;
SysCall IntuitionBase 342;

function AutoRequest(window : pWindow location 'a0'; body : pIntuiText location 'a1'; posText : pIntuiText location 'a2'; negText : pIntuiText location 'a3'; pFlag : CARDINAL location 'd0'; nFlag : CARDINAL location 'd1'; width : CARDINAL location 'd2'; height : CARDINAL location 'd3') : BOOLEAN;
SysCall IntuitionBase 348;

procedure BeginRefresh(window : pWindow location 'a0');
SysCall IntuitionBase 354;

function BuildSysRequest(window : pWindow location 'a0'; body : pIntuiText location 'a1'; posText : pIntuiText location 'a2'; negText : pIntuiText location 'a3'; flags : CARDINAL location 'd0'; width : CARDINAL location 'd1'; height : CARDINAL location 'd2') : pWindow;
SysCall IntuitionBase 360;

procedure EndRefresh(window : pWindow location 'a0'; complete : LongInt location 'd0');
SysCall IntuitionBase 366;

procedure FreeSysRequest(window : pWindow location 'a0');
SysCall IntuitionBase 372;

function MakeScreen(screen : pScreen location 'a0') : LongInt;
SysCall IntuitionBase 378;

function RemakeDisplay : LongInt;
SysCall IntuitionBase 384;

function RethinkDisplay : LongInt;
SysCall IntuitionBase 390;

function AllocRemember(var rememberKey : pRemember location 'a0'; size : CARDINAL location 'd0'; flags : CARDINAL location 'd1') : POINTER;
SysCall IntuitionBase 396;

procedure FreeRemember(var rememberKey : pRemember location 'a0'; reallyForget : LongInt location 'd0');
SysCall IntuitionBase 408;

function LockIBase(dontknow : CARDINAL location 'd0') : CARDINAL;
SysCall IntuitionBase 414;

procedure UnlockIBase(ibLock : CARDINAL location 'a0');
SysCall IntuitionBase 420;

function GetScreenData(buffer : POINTER location 'a0'; size : CARDINAL location 'd0'; type1 : CARDINAL location 'd1'; screen : pScreen location 'a1') : LongInt;
SysCall IntuitionBase 426;

procedure RefreshGList(gadgets : pGadget location 'a0'; window : pWindow location 'a1'; requester : pRequester location 'a2'; numGad : LongInt location 'd0');
SysCall IntuitionBase 432;

function AddGList(window : pWindow location 'a0'; gadget : pGadget location 'a1'; position : CARDINAL location 'd0'; numGad : LongInt location 'd1'; requester : pRequester location 'a2') : Word;
SysCall IntuitionBase 438;

function RemoveGList(remPtr : pWindow location 'a0'; gadget : pGadget location 'a1'; numGad : LongInt location 'd0') : Word;
SysCall IntuitionBase 444;

procedure ActivateWindow(window : pWindow location 'a0');
SysCall IntuitionBase 450;

procedure RefreshWindowFrame(window : pWindow location 'a0');
SysCall IntuitionBase 456;

function ActivateGadget(gadgets : pGadget location 'a0'; window : pWindow location 'a1'; requester : pRequester location 'a2') : BOOLEAN;
SysCall IntuitionBase 462;

procedure NewModifyProp(gadget : pGadget location 'a0'; window : pWindow location 'a1'; requester : pRequester location 'a2'; flags : CARDINAL location 'd0'; horizPot : CARDINAL location 'd1'; vertPot : CARDINAL location 'd2'; horizBody : CARDINAL location 'd3'; vertBody : CARDINAL location 'd4'; numGad : LongInt location 'd5');
SysCall IntuitionBase 468;

function QueryOverscan(displayID : CARDINAL location 'a0'; rect : pRectangle location 'a1'; oScanType : LongInt location 'd0') : LongInt;
SysCall IntuitionBase 474;

procedure MoveWindowInFrontOf(window : pWindow location 'a0'; behindWindow : pWindow location 'a1');
SysCall IntuitionBase 480;

procedure ChangeWindowBox(window : pWindow location 'a0'; left : LongInt location 'd0'; top : LongInt location 'd1'; width : LongInt location 'd2'; height : LongInt location 'd3');
SysCall IntuitionBase 486;

function SetEditHook(hook : pHook location 'a0') : pHook;
SysCall IntuitionBase 492;

function SetMouseQueue(window : pWindow location 'a0'; queueLength : CARDINAL location 'd0') : LongInt;
SysCall IntuitionBase 498;

procedure ZipWindow(window : pWindow location 'a0');
SysCall IntuitionBase 504;

function LockPubScreen(name : PChar location 'a0') : pScreen;
SysCall IntuitionBase 510;

procedure UnlockPubScreen(name : PChar location 'a0'; screen : pScreen location 'a1');
SysCall IntuitionBase 516;

function LockPubScreenList : pList;
SysCall IntuitionBase 522;

procedure UnlockPubScreenList;
SysCall IntuitionBase 528;

function NextPubScreen(screen : pScreen location 'a0'; namebuf : PChar location 'a1') : PChar;
SysCall IntuitionBase 534;

procedure SetDefaultPubScreen(name : PChar location 'a0');
SysCall IntuitionBase 540;

function SetPubScreenModes(modes : CARDINAL location 'd0') : Word;
SysCall IntuitionBase 546;

function PubScreenStatus(screen : pScreen location 'a0'; statusFlags : CARDINAL location 'd0') : Word;
SysCall IntuitionBase 552;

function ObtainGIRPort(gInfo : pGadgetInfo location 'a0') : pRastPort;
SysCall IntuitionBase 558;

procedure ReleaseGIRPort(rp : pRastPort location 'a0');
SysCall IntuitionBase 564;

procedure GadgetMouse(gadget : pGadget location 'a0'; gInfo : pGadgetInfo location 'a1'; VAR mousePoint : INTEGER location 'a2');
SysCall IntuitionBase 570;

procedure GetDefaultPubScreen(nameBuffer : PChar location 'a0');
SysCall IntuitionBase 582;

function EasyRequestArgs(window : pWindow location 'a0'; easyStruct : pEasyStruct location 'a1'; idcmpPtr : Pointer location 'a2'; args : POINTER location 'a3') : LongInt;
SysCall IntuitionBase 588;

function BuildEasyRequestArgs(window : pWindow location 'a0'; easyStruct : pEasyStruct location 'a1'; idcmp : CARDINAL location 'd0'; args : POINTER location 'a3') : pWindow;
SysCall IntuitionBase 594;

function SysReqHandler(window : pWindow location 'a0'; VAR idcmpPtr : CARDINAL location 'a1'; waitInput : LongInt location 'd0') : LongInt;
SysCall IntuitionBase 600;

function OpenWindowTagList(newWindow : pNewWindow location 'a0'; tagList : pTagItem location 'a1') : pWindow;
SysCall IntuitionBase 606;

function OpenWindowTags(newWindow : pNewWindow; tagList : array of DWord) : pWindow; Inline;

function OpenScreenTagList(newScreen : pNewScreen location 'a0'; tagList : pTagItem location 'a1') : pScreen;
SysCall IntuitionBase 612;

function OpenScreenTags(newScreen : pNewScreen; tagList : array of DWord) : pScreen; Inline;

procedure DrawImageState(rp : pRastPort location 'a0'; image : pImage location 'a1'; leftOffset : LongInt location 'd0'; topOffset : LongInt location 'd1'; state : CARDINAL location 'd2'; drawInfo : pDrawInfo location 'a2');
SysCall IntuitionBase 618;

function PointInImage(point : CARDINAL location 'd0'; image : pImage location 'a0') : BOOLEAN;
SysCall IntuitionBase 624;

procedure EraseImage(rp : pRastPort location 'a0'; image : pImage location 'a1'; leftOffset : LongInt location 'd0'; topOffset : LongInt location 'd1');
SysCall IntuitionBase 630;

function NewObjectA(classPtr : pIClass location 'a0'; classID : PChar location 'a1'; tagList : pTagItem location 'a2') : POINTER;
SysCall IntuitionBase 636;

function NewObject(classPtr : pIClass; classID : PChar; tags: array of LongWord) : POINTER;

procedure DisposeObject(object1 : POINTER location 'a0');
SysCall IntuitionBase 642;

function SetAttrsA(object1 : POINTER location 'a0'; tagList : pTagItem location 'a1') : CARDINAL;
SysCall IntuitionBase 648;

function GetAttr(attrID : CARDINAL location 'd0'; object1 : POINTER location 'a0'; VAR storagePtr : CARDINAL location 'a1') : CARDINAL;
SysCall IntuitionBase 654;

function SetGadgetAttrsA(gadget : pGadget location 'a0'; window : pWindow location 'a1'; requester : pRequester location 'a2'; tagList : pTagItem location 'a3') : CARDINAL;
SysCall IntuitionBase 660;

function NextObject(objectPtrPtr : POINTER location 'a0') : POINTER;
SysCall IntuitionBase 666;

function MakeClass(classID : PChar location 'a0'; superClassID : PChar location 'a1'; superClassPtr : pIClass location 'a2'; instanceSize : CARDINAL location 'd0'; flags : CARDINAL location 'd1') : pIClass;
SysCall IntuitionBase 678;

procedure AddClass(classPtr : pIClass location 'a0');
SysCall IntuitionBase 684;

function GetScreenDrawInfo(screen : pScreen location 'a0') : pDrawInfo;
SysCall IntuitionBase 690;

procedure FreeScreenDrawInfo(screen : pScreen location 'a0'; drawInfo : pDrawInfo location 'a1');
SysCall IntuitionBase 696;

function ResetMenuStrip(window : pWindow location 'a0'; menu : pMenu location 'a1') : BOOLEAN;
SysCall IntuitionBase 702;

procedure RemoveClass(classPtr : pIClass location 'a0');
SysCall IntuitionBase 708;

function FreeClass(classPtr : pIClass location 'a0') : BOOLEAN;
SysCall IntuitionBase 714;

function AllocScreenBuffer(sc : pScreen location 'a0'; bm : pBitMap location 'a1'; flags : CARDINAL location 'd0') : pScreenBuffer;
SysCall IntuitionBase 768;

procedure FreeScreenBuffer(sc : pScreen location 'a0'; sb : pScreenBuffer location 'a1');
SysCall IntuitionBase 774;

function ChangeScreenBuffer(sc : pScreen location 'a0'; sb : pScreenBuffer location 'a1') : CARDINAL;
SysCall IntuitionBase 780;

procedure ScreenDepth(screen : pScreen location 'a0'; flags : CARDINAL location 'd0'; reserved : POINTER location 'a1');
SysCall IntuitionBase 786;

procedure ScreenPosition(screen : pScreen location 'a0'; flags : CARDINAL location 'd0'; x1 : LongInt location 'd1'; y1 : LongInt location 'd2'; x2 : LongInt location 'd3'; y2 : LongInt location 'd4');
SysCall IntuitionBase 792;

procedure ScrollWindowRaster(win : pWindow location 'a1'; dx : LongInt location 'd0'; dy : LongInt location 'd1'; xMin : LongInt location 'd2'; yMin : LongInt location 'd3'; xMax : LongInt location 'd4'; yMax : LongInt location 'd5');
SysCall IntuitionBase 798;

procedure LendMenus(fromwindow : pWindow location 'a0'; towindow : pWindow location 'a1');
SysCall IntuitionBase 804;

function DoGadgetMethodA(gad : pGadget location 'a0'; win : pWindow location 'a1'; req : pRequester location 'a2'; message : pLongInt location 'a3') : CARDINAL;
SysCall IntuitionBase 810;

procedure SetWindowPointerA(win : pWindow location 'a0'; taglist : pTagItem location 'a1');
SysCall IntuitionBase 816;

function TimedDisplayAlert(alertNumber : CARDINAL location 'd0'; string1 : PChar location 'a0'; height : CARDINAL location 'd1'; time : CARDINAL location 'a1') : BOOLEAN;
SysCall IntuitionBase 822;

procedure HelpControl(win : pWindow location 'a0'; flags : CARDINAL location 'd0');
SysCall IntuitionBase 828;

procedure ShowWindow(win : pWindow location 'a0');
SysCall IntuitionBase 840;

procedure HideWindow(win : pWindow location 'a0');
SysCall IntuitionBase 846;

function GetSkinInfoAttrA(drawinfo : pDrawInfo location 'a0'; attr : CARDINAL location 'd0'; taglist : pTagItem location 'a1') : CARDINAL;
SysCall IntuitionBase 918;

function GetDrawInfoAttr(drawinfo : pDrawInfo location 'a0'; attr : CARDINAL location 'd0'; VAR errorPtr : CARDINAL location 'a1') : CARDINAL;
SysCall IntuitionBase 936;

procedure WindowAction(window : pWindow location 'a0'; action : CARDINAL location 'd0'; tags : pTagItem location 'a1');
SysCall IntuitionBase 942;

function TransparencyControl(window : pWindow location 'a0'; method : CARDINAL location 'd0'; tags : pTagItem location 'a1') : BOOLEAN;
SysCall IntuitionBase 948;

procedure ScrollWindowRasterNoFill(win : pWindow location 'a1'; dx : LongInt location 'd0'; dy : LongInt location 'd1'; xMin : LongInt location 'd2'; yMin : LongInt location 'd3'; xMax : LongInt location 'd4'; yMax : LongInt location 'd5');
SysCall IntuitionBase 954;


{ Intuition macros }
function INST_DATA (cl: pIClass; o: p_Object): Pointer;
function SIZEOF_INSTANCE (cl: pIClass): Longint;
function BASEOBJECT (o: p_Object): Pointer;
function _OBJ(o: p_Object): p_Object;
function __OBJECT (o: Pointer): p_Object;
function OCLASS (o: Pointer): pIClass;
function SHIFTITEM (n: smallint): word;
function SHIFTMENU (n: smallint): word;
function SHIFTSUB (n: smallint): word;
function FULLMENUNUM (menu, item, sub: smallint): word;
function IM_BGPEN (im: pImage): byte;
function IM_BOX (im: pImage): pIBox;
function IM_FGPEN (im: pImage): byte;
function GADGET_BOX (g: pGadget): pIBox;
function CUSTOM_HOOK (gadget: pGadget): pHook;
function ITEMNUM( n : Word): Word;
function MENUNUM( n : Word): Word;
function SUBNUM( n : Word): Word;

{
FUNCTION DisplayAlert(alertNumber : Cardinal;string_ : string; height : Cardinal) : BOOLEAN;
FUNCTION LockPubScreen(name : string) : pScreen;
FUNCTION MakeClass(classID : string;superClassID : pCHAR;superClassPtr : pIClass; instanceSize : Cardinal; flags : Cardinal) : pIClass;
FUNCTION MakeClass(classID : pCHAR;superClassID : string;superClassPtr : pIClass; instanceSize : Cardinal; flags : Cardinal) : pIClass;
FUNCTION MakeClass(classID : string;superClassID : string;superClassPtr : pIClass; instanceSize : Cardinal; flags : Cardinal) : pIClass;
FUNCTION NewObjectA(classPtr : pIClass;classID : string;tagList : pTagItem) : POINTER;
PROCEDURE SetDefaultPubScreen(name : string);
PROCEDURE SetWindowTitles(window : pWindow;windowTitle : string;screenTitle : pCHAR);
PROCEDURE SetWindowTitles(window : pWindow;windowTitle : pCHAR;screenTitle : string);
PROCEDURE SetWindowTitles(window : pWindow;windowTitle : string;screenTitle : string);
FUNCTION TimedDisplayAlert(alertNumber : Cardinal;string_ : string; height : Cardinal; time : Cardinal) : BOOLEAN;
PROCEDURE UnlockPubScreen(name : string; screen : pScreen);
}

{ Helper calls }
function InitIntuitionLibrary : boolean;


implementation

{$WARNING Ugly workaround, this still needs support in the compiler}
function OpenScreenTags(newScreen : pNewScreen; tagList : array of DWord) : pScreen; Inline;
begin
  OpenScreenTags:=OpenScreenTagList(newScreen,@tagList);
end;

function OpenWindowTags(newWindow : pNewWindow; tagList : array of DWord) : pWindow; Inline;
begin
  OpenWindowTags:=OpenWindowTagList(newWindow,@tagList);
end;

function NewObject(classPtr : pIClass; classID : PChar; tags: array of LongWord) : POINTER; inline;
begin
  NewObject:=NewObjectA(classPtr, classID, @tags);
end;


function INST_DATA (cl: pIClass; o: p_Object): Pointer;
begin
    INST_DATA := Pointer(Longint(o) + cl^.cl_InstOffset);
end;

function SIZEOF_INSTANCE (cl: pIClass): Longint;
begin
    SIZEOF_INSTANCE := cl^.cl_InstOffset + cl^.cl_InstSize + sizeof(t_Object);
end;

function BASEOBJECT (o: p_Object): Pointer;
begin
    BASEOBJECT := Pointer(Longint(o) + sizeof(t_Object));
end;

function _OBJ(o: p_Object): p_Object;
begin
     _OBJ := p_Object(o);
END;

function __OBJECT (o: Pointer): p_Object;
begin
    __OBJECT := p_Object(Longint(o) - sizeof(t_Object))
end;

function OCLASS (o: Pointer): pIClass;
var
    obj: p_Object;
begin
    obj := p_Object(Longint(o) - sizeof(t_Object));
    OCLASS := obj^.o_Class;
end;

function SHIFTITEM (n: smallint): word;
begin
    SHIFTITEM := (n and $3f) shl 5
end;

function SHIFTMENU (n: smallint): word;
begin
    SHIFTMENU := n and $1f
end;

function SHIFTSUB (n: smallint): word;
begin
    SHIFTSUB := (n and $1f) shl 11
end;

function FULLMENUNUM (menu, item, sub: smallint): word;
begin
    FULLMENUNUM := ((sub and $1f) shl 11) or
                    ((item and $3f) shl 5) or
                      (menu and $1f)
end;


{ The next functons _BGPEN AND _FGPEN aren't a full replacement of the
  C macros because the C preprocessor makes it possible to set the
  A/BPen values of the image class objects as well. This can't work
  in pascal, of course! }

function IM_BGPEN (im: pImage): byte;
begin
    IM_BGPEN := im^.PlaneOnOff;
end;

function IM_BOX (im: pImage): pIBox;
begin
    IM_BOX := pIBox(@im^.LeftEdge);
END;

function IM_FGPEN (im: pImage): byte;
begin
    IM_FGPEN := im^.PlanePick;
end;

function GADGET_BOX (g: pGadget): pIBox;
begin
    GADGET_BOX := pIBox(@g^.LeftEdge);
end;

function CUSTOM_HOOK (gadget: pGadget): pHook;
begin
    CUSTOM_HOOK := pHook(gadget^.MutualExclude);
end;

function ITEMNUM( n : Word): Word;
begin
    ITEMNUM := (n shr 5) and $3F
end;

function MENUNUM( n : Word): Word;
begin
    MENUNUM := n and $1f
end;

function SUBNUM( n : Word): Word;
begin
    SUBNUM := (n shr 11) and $1f
end;

{
FUNCTION DisplayAlert(alertNumber : Cardinal;string_ : string; height : Cardinal) : BOOLEAN;
begin
      DisplayAlert := DisplayAlert(alertNumber,pas2c(string_),height);
end;

FUNCTION LockPubScreen(name : string) : pScreen;
begin
      LockPubScreen := LockPubScreen(pas2c(name));
end;

FUNCTION MakeClass(classID : string;superClassID : pCHAR;superClassPtr : pIClass; instanceSize : Cardinal; flags : Cardinal) : pIClass;
begin
      MakeClass := MakeClass(pas2c(classID),superClassID,superClassPtr,instanceSize,flags);
end;

FUNCTION MakeClass(classID : pCHAR;superClassID : string;superClassPtr : pIClass; instanceSize : Cardinal; flags : Cardinal) : pIClass;
begin
      MakeClass := MakeClass(classID,pas2c(superClassID),superClassPtr,instanceSize,flags);
end;

FUNCTION MakeClass(classID : string;superClassID : string;superClassPtr : pIClass; instanceSize : Cardinal; flags : Cardinal) : pIClass;
begin
      MakeClass := MakeClass(pas2c(classID),pas2c(superClassID),superClassPtr,instanceSize,flags);
end;

FUNCTION NewObjectA(classPtr : pIClass;classID : string;tagList : pTagItem) : POINTER;
begin
      NewObjectA := NewObjectA(classPtr,pas2c(classID),taglist);
end;

PROCEDURE SetDefaultPubScreen(name : string);
begin
      SetDefaultPubScreen(pas2c(name));
end;

PROCEDURE SetWindowTitles(window : pWindow;windowTitle : string;screenTitle : pCHAR);
begin
      SetWindowTitles(window,pas2c(windowTitle),screenTitle);
end;

PROCEDURE SetWindowTitles(window : pWindow;windowTitle : pCHAR;screenTitle : string);
begin
      SetWindowTitles(window,windowTitle,pas2c(screenTitle));
end;

PROCEDURE SetWindowTitles(window : pWindow;windowTitle : string;screenTitle : string);
begin
      SetWindowTitles(window,pas2c(windowTitle),pas2c(screenTitle));
end;

FUNCTION TimedDisplayAlert(alertNumber : Cardinal;string_ : string; height : Cardinal; time : Cardinal) : BOOLEAN;
begin
      TimedDisplayAlert := TimedDisplayAlert(alertNumber,pas2c(string_),height,time);
end;

PROCEDURE UnlockPubScreen(name : string; screen : pScreen);
begin
      UnlockPubScreen(pas2c(name),screen);
end;
}


const
  { Change VERSION and LIBVERSION to proper values }
  VERSION : string[2] = '50';
  LIBVERSION : longword = 50;

var
  intuition_exit : Pointer;

procedure CloseIntuitionLibrary;
begin
  ExitProc := intuition_exit;
  if IntuitionBase <> nil then begin
    CloseLibrary(PLibrary(IntuitionBase));
    IntuitionBase := nil;
  end;
end;

function InitIntuitionLibrary : boolean;
begin
  IntuitionBase := nil;
  IntuitionBase := OpenLibrary(INTUITIONNAME,LIBVERSION);
  if IntuitionBase <> nil then begin
    intuition_exit := ExitProc;
    ExitProc := @CloseIntuitionLibrary;
    InitIntuitionLibrary:=True;
  end else begin
    InitIntuitionLibrary:=False;
  end;
end;


end. (* UNIT INTUITION *)

