INTUITION Types Reference¶
Per-function autodoc pages link to these types via the type name (e.g., [List](types-intuition.md#list)).
Clickable inner types: inside each struct definition, field types that are themselves structs/unions/enums are clickable hyperlinks to their own definitions.
Contents¶
cghooks.h¶
struct GadgetInfo¶
Source: intuition/cghooks.h
struct GadgetInfo {
struct Screen *gi_Screen;
struct Window *gi_Window; /* null for screen gadgets */
struct Requester *gi_Requester; /* null if not GTYP_REQGADGET */
/* rendering information:
* don't use these without cloning/locking.
* Official way is to call ObtainRPort()
*/
struct RastPort *gi_RastPort;
struct Layer *gi_Layer;
/* 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
*/
struct IBox gi_Domain;
/* these are the pens for the window or screen */
struct {
UBYTE DetailPen;
UBYTE BlockPen;
} gi_Pens;
/* the Detail and Block pens in gi_DrInfo->dri_Pens[] are
* for the screen. Use the above for window-sensitive
* colors.
*/
struct DrawInfo *gi_DrInfo;
/* reserved space: this structure is extensible
* anyway, but using these saves some recompilation
*/
ULONG gi_Reserved[6];
};
struct PGX¶
Source: intuition/cghooks.h
struct PGX {
struct IBox pgx_Container;
struct IBox pgx_NewKnob;
};
classes.h¶
struct Class¶
Source: intuition/classes.h
typedef struct IClass
{
struct Hook cl_Dispatcher; /* Class dispatcher */
ULONG cl_Reserved; /* Must be 0 */
struct IClass *cl_Super; /* Pointer to superclass */
ClassID cl_ID; /* Class ID */
UWORD cl_InstOffset; /* Offset of instance data */
UWORD cl_InstSize; /* Size of instance data */
ULONG cl_UserData; /* Class global data */
ULONG cl_SubclassCount; /* Number of subclasses */
ULONG cl_ObjectCount; /* Number of objects */
ULONG cl_Flags;
} Class;
struct ClassLibrary¶
Source: intuition/classes.h
struct ClassLibrary
{
struct Library cl_Lib; /* Embedded library */
UWORD cl_Pad; /* Align the structure */
Class *cl_Class; /* Class pointer */
};
intuition.h¶
struct BoolInfostruct Borderstruct ColorSpecstruct EasyStructstruct ExtGadgetstruct ExtIntuiMessagestruct ExtNewWindowstruct Gadgetstruct IBoxstruct Imagestruct IntuiMessagestruct IntuiTextstruct IntuiWheelDatastruct Menustruct MenuItemstruct NewWindowstruct PropInfostruct Rememberstruct Requesterstruct StringInfostruct TabletDatastruct TabletHookDatastruct Window
struct BoolInfo¶
Source: intuition/intuition.h
struct BoolInfo
{
UWORD Flags; /* defined below */
UWORD *Mask; /* bit mask for highlighting and selecting
* mask must follow the same rules as an Image
* plane. Its width and height are determined
* by the width and height of the gadget's
* select box. (i.e. Gadget.Width and .Height).
*/
ULONG Reserved; /* set to 0 */
};
struct Border¶
Source: intuition/intuition.h
struct Border
{
WORD LeftEdge, TopEdge; /* initial offsets from the origin */
UBYTE FrontPen, BackPen; /* pens numbers for rendering */
UBYTE DrawMode; /* mode for rendering */
BYTE Count; /* number of XY pairs */
WORD *XY; /* vector coordinate pairs rel to LeftTop */
struct Border *NextBorder; /* pointer to any other Border too */
};
struct ColorSpec¶
Source: intuition/intuition.h
struct ColorSpec
{
WORD ColorIndex; /* -1 terminates an array of ColorSpec */
UWORD Red; /* only the _bottom_ 4 bits recognized */
UWORD Green; /* only the _bottom_ 4 bits recognized */
UWORD Blue; /* only the _bottom_ 4 bits recognized */
};
struct EasyStruct¶
Source: intuition/intuition.h
struct EasyStruct {
ULONG es_StructSize; /* should be sizeof (struct EasyStruct )*/
ULONG es_Flags; /* should be 0 for now */
CONST_STRPTR es_Title; /* title of requester window */
CONST_STRPTR es_TextFormat; /* 'printf' style formatting string */
CONST_STRPTR es_GadgetFormat; /* 'printf' style formatting string */
};
struct ExtGadget¶
Source: intuition/intuition.h
struct ExtGadget
{
/* The first fields match struct Gadget exactly */
struct ExtGadget *NextGadget; /* Matches struct Gadget */
WORD LeftEdge, TopEdge; /* Matches struct Gadget */
WORD Width, Height; /* Matches struct Gadget */
UWORD Flags; /* Matches struct Gadget */
UWORD Activation; /* Matches struct Gadget */
UWORD GadgetType; /* Matches struct Gadget */
APTR GadgetRender; /* Matches struct Gadget */
APTR SelectRender; /* Matches struct Gadget */
struct IntuiText *GadgetText; /* Matches struct Gadget */
LONG MutualExclude; /* Matches struct Gadget */
APTR SpecialInfo; /* Matches struct Gadget */
UWORD GadgetID; /* Matches struct Gadget */
APTR UserData; /* Matches struct Gadget */
/* These fields only exist under V39 and only if GFLG_EXTENDED is set */
ULONG MoreFlags; /* see GMORE_ flags below */
WORD BoundsLeftEdge; /* Bounding extent for gadget, valid */
WORD BoundsTopEdge; /* only if GMORE_BOUNDS is set. The */
WORD BoundsWidth; /* GFLG_RELxxx flags affect these */
WORD BoundsHeight; /* coordinates as well. */
};
struct ExtIntuiMessage¶
Source: intuition/intuition.h
struct ExtIntuiMessage
{
struct IntuiMessage eim_IntuiMessage;
struct TabletData *eim_TabletData;
};
struct ExtNewWindow¶
Source: intuition/intuition.h
struct ExtNewWindow
{
WORD LeftEdge, TopEdge;
WORD Width, Height;
UBYTE DetailPen, BlockPen;
ULONG IDCMPFlags;
ULONG Flags;
struct Gadget *FirstGadget;
struct Image *CheckMark;
STRPTR Title;
struct Screen *Screen;
struct BitMap *BitMap;
WORD MinWidth, MinHeight;
UWORD MaxWidth, MaxHeight;
/* 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.
*/
UWORD Type;
/* ------------------------------------------------------- *
* 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.
*/
struct TagItem *Extension;
};
struct Gadget¶
Source: intuition/intuition.h
struct Gadget
{
struct Gadget *NextGadget; /* next gadget in the list */
WORD LeftEdge, TopEdge; /* "hit box" of gadget */
WORD Width, Height; /* "hit box" of gadget */
UWORD Flags; /* see below for list of defines */
UWORD Activation; /* see below for list of defines */
UWORD GadgetType; /* 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)
*/
APTR GadgetRender;
/* appliprog can specify "highlighted" imagery rather than algorithmic
* this can point to either Border or Image data
*/
APTR SelectRender;
struct IntuiText *GadgetText; /* text for this gadget */
/* MutualExclude, never implemented, is now declared obsolete.
* There are published examples of implementing a more general
* and practical exclusion in your applications.
*
* Starting with V36, this field is used to point to a hook
* for a custom gadget.
*
* Programs using this field for their own processing will
* continue to work, as long as they don't try the
* trick with custom gadgets.
*/
LONG MutualExclude; /* obsolete */
/* pointer to a structure of special data required by Proportional,
* String and Integer Gadgets
*/
APTR SpecialInfo;
UWORD GadgetID; /* user-definable ID field */
APTR UserData; /* ptr to general purpose User data (ignored by In) */
};
struct IBox¶
Source: intuition/intuition.h
struct IBox
{
WORD Left;
WORD Top;
WORD Width;
WORD Height;
};
struct Image¶
Source: intuition/intuition.h
struct Image
{
WORD LeftEdge; /* starting offset relative to some origin */
WORD TopEdge; /* starting offsets relative to some origin */
WORD Width; /* pixel size (though data is word-aligned) */
WORD Height;
WORD Depth; /* >= 0, for images you create */
UWORD *ImageData; /* 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 one 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 avoids 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 = 0x02;
* Gadget.PlaneOnOff = 0x01;
* 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.
*
* NOTE: Intuition relies on PlanePick to know how many planes
* of data are found in ImageData. There should be no more
* '1'-bits in PlanePick than there are planes in ImageData.
*/
UBYTE PlanePick, PlaneOnOff;
/* if the NextImage variable is not NULL, Intuition presumes that
* it points to another Image structure with another Image to be
* rendered
*/
struct Image *NextImage;
};
struct IntuiMessage¶
Source: intuition/intuition.h
struct IntuiMessage
{
struct Message ExecMessage;
/* the Class bits correspond directly with the IDCMP Flags, except for the
* special bit IDCMP_LONELYMESSAGE (defined below)
*/
ULONG Class;
/* the Code field is for special values like MENU number */
UWORD Code;
/* the Qualifier field is a copy of the current InputEvent's Qualifier */
UWORD Qualifier;
/* IAddress contains particular addresses for Intuition functions, like
* the pointer to the Gadget or the Screen
*/
APTR IAddress;
/* 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 (WFLG_GIMMEZEROZERO
* notwithstanding). If IDCMP_DELTAMOVE is set, these values will
* be deltas from the last reported position.
*/
WORD MouseX, MouseY;
/* the time values are copies of the current system clock time. Micros
* are in units of microseconds, Seconds in seconds.
*/
ULONG Seconds, Micros;
/* the IDCMPWindow variable will always have the address of the Window of
* this IDCMP
*/
struct Window *IDCMPWindow;
/* system-use variable */
struct IntuiMessage *SpecialLink;
};
struct IntuiText¶
Source: intuition/intuition.h
struct IntuiText
{
UBYTE FrontPen, BackPen; /* the pen numbers for the rendering */
UBYTE DrawMode; /* the mode for rendering the text */
WORD LeftEdge; /* relative start location for the text */
WORD TopEdge; /* relative start location for the text */
CONST struct TextAttr *ITextFont; /* if NULL, you accept the default */
STRPTR IText; /* pointer to null-terminated text */
struct IntuiText *NextText; /* pointer to another IntuiText to render */
};
struct IntuiWheelData¶
Source: intuition/intuition.h
struct IntuiWheelData
{
UWORD Version; /* version of this structure (see below) */
UWORD Reserved; /* always 0, reserved for future use */
WORD WheelX; /* horizontal wheel movement delta */
WORD WheelY; /* vertical wheel movement delta */
struct Gadget *HoveredGadget; /* Version 2: pointer to gadget that is hovered */
};
struct Menu¶
Source: intuition/intuition.h
struct Menu
{
struct Menu *NextMenu; /* same level */
WORD LeftEdge, TopEdge; /* position of the select box */
WORD Width, Height; /* dimensions of the select box */
UWORD Flags; /* see flag definitions below */
CONST_STRPTR MenuName; /* text for this Menu Header */
struct MenuItem *FirstItem; /* pointer to first in chain */
/* these mysteriously-named variables are for internal use only */
WORD JazzX, JazzY, BeatX, BeatY;
};
struct MenuItem¶
Source: intuition/intuition.h
struct MenuItem
{
struct MenuItem *NextItem; /* pointer to next in chained list */
WORD LeftEdge, TopEdge; /* position of the select box */
WORD Width, Height; /* dimensions of the select box */
UWORD Flags; /* see the defines below */
LONG MutualExclude; /* set bits mean this item excludes that */
APTR ItemFill; /* 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
*/
APTR SelectFill; /* points to Image, IntuiText, or NULL */
BYTE Command; /* only if appliprog sets the COMMSEQ flag */
struct MenuItem *SubItem; /* if non-zero, points to MenuItem for submenu */
/* The NextSelect field represents the menu number of next selected
* item (when user has drag-selected several items)
*/
UWORD NextSelect;
};
struct NewWindow¶
Source: intuition/intuition.h
struct NewWindow
{
WORD LeftEdge, TopEdge; /* screen dimensions of window */
WORD Width, Height; /* screen dimensions of window */
UBYTE DetailPen, BlockPen; /* for bar/border/gadget rendering */
ULONG IDCMPFlags; /* User-selected IDCMP flags */
ULONG Flags; /* 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)
*/
struct Gadget *FirstGadget;
/* 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
*/
struct Image *CheckMark;
STRPTR Title; /* 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 address of the
* Custom Screen structure in this variable. Otherwise, this variable
* is ignored and doesn't have to be initialized.
*/
struct Screen *Screen;
/* WFLG_SUPER_BITMAP Window? If so, put the address of your BitMap
* structure in this variable. If not, this variable is ignored and
* doesn't have to be initialized
*/
struct BitMap *BitMap;
/* the values describe the minimum and maximum sizes of your Windows.
* these matter only if you've chosen the WFLG_SIZEGADGET 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.
*/
WORD MinWidth, MinHeight; /* minimums */
UWORD MaxWidth, MaxHeight; /* 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.
*/
UWORD Type;
};
struct PropInfo¶
Source: intuition/intuition.h
struct PropInfo
{
UWORD Flags; /* 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.
*/
UWORD HorizPot; /* 16-bit FixedPoint horizontal quantity percentage */
UWORD VertPot; /* 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();
*/
UWORD HorizBody; /* horizontal Body */
UWORD VertBody; /* vertical Body */
/* these are the variables that Intuition sets and maintains */
UWORD CWidth; /* Container width (with any relativity absoluted) */
UWORD CHeight; /* Container height (with any relativity absoluted) */
UWORD HPotRes, VPotRes; /* pot increments */
UWORD LeftBorder; /* Container borders */
UWORD TopBorder; /* Container borders */
};
struct Remember¶
Source: intuition/intuition.h
struct Remember
{
struct Remember *NextRemember;
ULONG RememberSize;
UBYTE *Memory;
};
struct Requester¶
Source: intuition/intuition.h
struct Requester
{
struct Requester *OlderRequest;
WORD LeftEdge, TopEdge; /* dimensions of the entire box */
WORD Width, Height; /* dimensions of the entire box */
WORD RelLeft, RelTop; /* for Pointer relativity offsets */
struct Gadget *ReqGadget; /* pointer to a list of Gadgets */
struct Border *ReqBorder; /* the box's border */
struct IntuiText *ReqText; /* the box's text */
UWORD Flags; /* see definitions below */
/* pen number for back-plane fill before draws */
UBYTE BackFill;
/* Layer in place of clip rect */
struct Layer *ReqLayer;
UBYTE ReqPad1[32];
/* If the BitMap plane pointers are non-zero, this tells the system
* that the image comes pre-drawn (if the appliprog wants to define
* its 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
*/
struct BitMap *ImageBMap; /* points to the BitMap of PREDRAWN imagery */
struct Window *RWindow; /* added. points back to Window */
struct Image *ReqImage; /* new for V36: drawn if USEREQIMAGE set */
UBYTE ReqPad2[32];
};
struct StringInfo¶
Source: intuition/intuition.h
struct StringInfo
{
/* you initialize these variables, and then Intuition maintains them */
STRPTR Buffer; /* the buffer containing the start and final string */
STRPTR UndoBuffer; /* optional buffer for undoing current entry */
WORD BufferPos; /* character position in Buffer */
WORD MaxChars; /* max number of chars in Buffer (including NULL) */
WORD DispPos; /* Buffer position of first displayed character */
/* Intuition initializes and maintains these variables for you */
WORD UndoPos; /* character position in the undo buffer */
WORD NumChars; /* number of characters currently in Buffer */
WORD DispCount; /* number of whole characters visible in Container */
WORD CLeft, CTop; /* topleft offset of the container */
/* This unused field is changed to allow extended specification
* of string gadget parameters. It is ignored unless the flag
* GACT_STRINGEXTEND is set in the Gadget's Activation field
* or the GFLG_STRINGEXTEND flag is set in the Gadget Flags field.
* (See GFLG_STRINGEXTEND for an important note)
*/
/* struct Layer *LayerPtr; --- obsolete --- */
struct StringExtend *Extension;
/* you can initialize this variable before the gadget is submitted to
* Intuition, and then examine it later to discover what integer
* the user has entered (if the user never plays with the gadget,
* the value will be unchanged from your initial setting)
*/
LONG LongInt;
/* If you want this Gadget to use your own Console keymapping, you
* set the GACT_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 GACT_ALTKEYMAP, you'll get the standard ASCII keymapping.
*/
struct KeyMap *AltKeyMap;
};
struct TabletData¶
Source: intuition/intuition.h
struct TabletData
{
/* Sub-pixel position of tablet, in screen coordinates,
* scaled to fill a UWORD fraction:
*/
UWORD td_XFraction, td_YFraction;
/* Current tablet coordinates along each axis: */
ULONG td_TabletX, td_TabletY;
/* Tablet range along each axis. For example, if td_TabletX
* can take values 0-999, td_RangeX should be 1000.
*/
ULONG td_RangeX, td_RangeY;
/* Pointer to tag-list of additional tablet attributes.
* See for the tag values.
*/
struct TagItem *td_TagList;
};
struct TabletHookData¶
Source: intuition/intuition.h
struct TabletHookData
{
/* 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 640x400
* screen. Please scale accordingly.
*/
struct Screen *thd_Screen;
/* The width and height (measured in pixels of the active screen)
* that your are to scale to:
*/
ULONG thd_Width;
ULONG thd_Height;
/* Non-zero if the screen or something about the screen
* changed since the last time you were invoked:
*/
LONG thd_ScreenChanged;
};
struct Window¶
Source: intuition/intuition.h
struct Window
{
struct Window *NextWindow; /* for the linked list in a screen */
WORD LeftEdge, TopEdge; /* screen dimensions of window */
WORD Width, Height; /* screen dimensions of window */
WORD MouseY, MouseX; /* relative to upper-left of window */
WORD MinWidth, MinHeight; /* minimum sizes */
UWORD MaxWidth, MaxHeight; /* maximum sizes */
ULONG Flags; /* see below for defines */
struct Menu *MenuStrip; /* the strip of Menu headers */
STRPTR Title; /* the title text for this window */
struct Requester *FirstRequest; /* all active Requesters */
struct Requester *DMRequest; /* double-click Requester */
WORD ReqCount; /* count of reqs blocking Window */
struct Screen *WScreen; /* this Window's Screen */
struct RastPort *RPort; /* this Window's very own RastPort */
/* the border variables describe the window border. If you specify
* WFLG_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
* WFLG_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
*/
BYTE BorderLeft, BorderTop, BorderRight, BorderBottom;
struct RastPort *BorderRPort;
/* 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)
*/
struct Gadget *FirstGadget;
/* these are for opening/closing the windows */
struct Window *Parent, *Descendant;
/* sprite data information for your own Pointer
* set these AFTER you Open the Window by calling SetPointer()
*/
UWORD *Pointer; /* sprite data */
BYTE PtrHeight; /* sprite height (not including sprite padding) */
BYTE PtrWidth; /* sprite width (must be less than or equal to 16) */
BYTE XOffset, YOffset; /* sprite offsets */
/* the IDCMP Flags and User's and Intuition's Message Ports */
ULONG IDCMPFlags; /* User-selected flags */
struct MsgPort *UserPort, *WindowPort;
struct IntuiMessage *MessageKey;
UBYTE DetailPen, BlockPen; /* 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
*/
struct Image *CheckMark;
STRPTR ScreenTitle; /* if non-null, Screen title when Window is active */
/* These variables have the mouse coordinates relative to the
* inner-Window of WFLG_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, WFLG_GIMMEZEROZERO
* notwithstanding
*/
WORD GZZMouseX;
WORD GZZMouseY;
/* these variables contain the width and height of the inner-Window of
* WFLG_GIMMEZEROZERO Windows
*/
WORD GZZWidth;
WORD GZZHeight;
UBYTE *ExtData;
BYTE *UserData; /* general-purpose pointer to User data extension */
/** 11/18/85: this pointer keeps a duplicate of what
* Window.RPort->Layer is _supposed_ to be pointing at
*/
struct Layer *WLayer;
/* NEW 1.2: need to keep track of the font that
* OpenWindow opened, in case user SetFont's into RastPort
*/
struct TextFont *IFont;
/* (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.
*/
ULONG MoreFlags;
/**** Data beyond this point are Intuition Private. DO NOT USE ****/
};
preferences.h¶
struct Preferences¶
Source: intuition/preferences.h
struct Preferences
{
/* the default font height */
BYTE FontHeight; /* height for system default font */
/* constant describing what's hooked up to the port */
UBYTE PrinterPort; /* printer port connection */
/* the baud rate of the port */
UWORD BaudRate; /* baud rate for the serial port */
/* various timing rates */
TimeVal_Type KeyRptSpeed; /* repeat speed for keyboard */
TimeVal_Type KeyRptDelay; /* Delay before keys repeat */
TimeVal_Type DoubleClick; /* Interval allowed between clicks */
/* Intuition Pointer data */
UWORD PointerMatrix[POINTERSIZE]; /* Definition of pointer sprite */
BYTE XOffset; /* X-Offset for active 'bit' */
BYTE YOffset; /* Y-Offset for active 'bit' */
UWORD color17; /***********************************/
UWORD color18; /* Colours for sprite pointer */
UWORD color19; /***********************************/
UWORD PointerTicks; /* Sensitivity of the pointer */
/* Workbench Screen colors */
UWORD color0; /***********************************/
UWORD color1; /* Standard default colours */
UWORD color2; /* Used in the Workbench */
UWORD color3; /***********************************/
/* positioning data for the Intuition View */
BYTE ViewXOffset; /* Offset for top lefthand corner */
BYTE ViewYOffset; /* X and Y dimensions */
WORD ViewInitX, ViewInitY; /* View initial offset values */
BOOL EnableCLI; /* CLI availability switch */
/* printer configurations */
UWORD PrinterType; /* printer type */
TEXT PrinterFilename[FILENAME_SIZE];/* file for printer */
/* print format and quality configurations */
UWORD PrintPitch; /* print pitch */
UWORD PrintQuality; /* print quality */
UWORD PrintSpacing; /* number of lines per inch */
UWORD PrintLeftMargin; /* left margin in characters */
UWORD PrintRightMargin; /* right margin in characters */
UWORD PrintImage; /* positive or negative */
UWORD PrintAspect; /* horizontal or vertical */
UWORD PrintShade; /* b&w, half-tone, or color */
WORD PrintThreshold; /* darkness ctrl for b/w dumps */
/* print paper descriptors */
UWORD PaperSize; /* paper size */
UWORD PaperLength; /* paper length in number of lines */
UWORD PaperType; /* 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) */
UBYTE SerRWBits; /* upper nibble = (8-number of read bits) */
/* lower nibble = (8-number of write bits) */
UBYTE SerStopBuf; /* upper nibble = (number of stop bits - 1) */
/* lower nibble = (table value for BufSize) */
UBYTE SerParShk; /* upper nibble = (value for Parity setting) */
/* lower nibble = (value for Handshake mode) */
UBYTE LaceWB; /* if workbench is to be interlaced */
UBYTE Pad[ 12 ];
TEXT PrtDevName[DEVNAME_SIZE]; /* device used by printer.device
* (omit the ".device")
*/
UBYTE DefaultPrtUnit; /* default unit opened by printer.device */
UBYTE DefaultSerUnit; /* default serial unit */
BYTE RowSizeChange; /* affect NormalDisplayRows/Columns */
BYTE ColumnSizeChange;
UWORD PrintFlags; /* user preference flags */
UWORD PrintMaxWidth; /* max width of printed picture in 10ths/in */
UWORD PrintMaxHeight; /* max height of printed picture in 10ths/in */
UBYTE PrintDensity; /* print density */
UBYTE PrintXOffset; /* offset of printed picture in 10ths/inch */
UWORD wb_Width; /* override default workbench width */
UWORD wb_Height; /* override default workbench height */
UBYTE wb_Depth; /* override default workbench depth */
UBYTE ext_size; /* extension information -- do not touch! */
/* extension size in blocks of 64 bytes */
};
screens.h¶
struct DrawInfostruct ExtNewScreenstruct NewScreenstruct PubScreenNodestruct Screenstruct ScreenBuffer
struct DrawInfo¶
Source: intuition/screens.h
struct DrawInfo
{
UWORD dri_Version; /* will be DRI_VERSION */
UWORD dri_NumPens; /* guaranteed to be >= 9 */
UWORD *dri_Pens; /* pointer to pen array */
struct TextFont *dri_Font; /* screen default font */
UWORD dri_Depth; /* (initial) depth of screen bitmap */
struct { /* from DisplayInfo database for initial display mode */
UWORD X;
UWORD Y;
} dri_Resolution;
ULONG dri_Flags; /* defined below */
/* New for V39: dri_CheckMark, dri_AmigaKey. */
struct Image *dri_CheckMark; /* pointer to scaled checkmark image
* Will be NULL if DRI_VERSION < 2
*/
struct Image *dri_AmigaKey; /* pointer to scaled Amiga-key image
* Will be NULL if DRI_VERSION < 2
*/
/* New for V47: dri_Screen. */
struct Screen *dri_Screen; /* pointer to associated screen
* Will be NULL if DRI_VERSION < 3
*/
ULONG dri_Reserved[4]; /* avoid recompilation ;^) */
};
struct ExtNewScreen¶
Source: intuition/screens.h
struct ExtNewScreen
{
WORD LeftEdge, TopEdge, Width, Height, Depth;
UBYTE DetailPen, BlockPen;
UWORD ViewModes;
UWORD Type;
struct TextAttr *Font;
STRPTR DefaultTitle;
struct Gadget *Gadgets;
struct BitMap *CustomBitMap;
struct TagItem *Extension;
/* more specification data, scanned if
* NS_EXTENDED is set in NewScreen.Type
*/
};
struct NewScreen¶
Source: intuition/screens.h
struct NewScreen
{
WORD LeftEdge, TopEdge, Width, Height, Depth; /* screen dimensions */
UBYTE DetailPen, BlockPen; /* for bar/border/gadget rendering */
UWORD ViewModes; /* the Modes for the ViewPort (and View) */
UWORD Type; /* the Screen type (see defines above) */
struct TextAttr *Font; /* this Screen's default text attributes */
STRPTR DefaultTitle; /* the default title for this Screen */
struct Gadget *Gadgets; /* UNUSED: Leave this NULL */
/* 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
*/
struct BitMap *CustomBitMap;
};
struct PubScreenNode¶
Source: intuition/screens.h
struct PubScreenNode {
struct Node psn_Node; /* ln_Name is screen name */
struct Screen *psn_Screen;
UWORD psn_Flags; /* below */
WORD psn_Size; /* includes name buffer */
WORD psn_VisitorCount; /* how many visitor windows */
struct Task *psn_SigTask; /* who to signal when visitors gone */
UBYTE psn_SigBit; /* which signal */
};
struct Screen¶
Source: intuition/screens.h
struct Screen
{
struct Screen *NextScreen; /* linked list of screens */
struct Window *FirstWindow; /* linked list Screen's Windows */
WORD LeftEdge, TopEdge; /* parameters of the screen */
WORD Width, Height; /* parameters of the screen */
WORD MouseY, MouseX; /* position relative to upper-left */
UWORD Flags; /* see definitions below */
STRPTR Title; /* null-terminated Title text */
STRPTR DefaultTitle; /* for Windows without ScreenTitle */
/* Bar sizes for this Screen and all Window's in this Screen */
/* Note that BarHeight is one less than the actual menu bar
* height. We're going to keep this in V36 for compatibility,
* although V36 artwork might use that extra pixel
*
* Also, the title bar height of a window is calculated from the
* screen's WBorTop field, plus the font height, plus one.
*/
BYTE BarHeight, BarVBorder, BarHBorder, MenuVBorder, MenuHBorder;
BYTE WBorTop, WBorLeft, WBorRight, WBorBottom;
struct TextAttr *Font; /* this screen's default font */
/* the display data structures for this Screen */
struct ViewPort ViewPort; /* describing the Screen's display */
struct RastPort RastPort; /* describing Screen rendering */
struct BitMap BitMap; /* SEE WARNING ABOVE! */
struct Layer_Info LayerInfo; /* each screen gets a LayerInfo */
/* Only system gadgets may be attached to a screen.
* You get the standard system Screen Gadgets automatically
*/
struct Gadget *FirstGadget;
UBYTE DetailPen, BlockPen; /* for bar/border/gadget rendering */
/* the following variable(s) are maintained by Intuition to support the
* DisplayBeep() color flashing technique
*/
UWORD SaveColor0;
/* This layer is for the Screen and Menu bars */
struct Layer *BarLayer;
UBYTE *ExtData;
UBYTE *UserData; /* general-purpose pointer to User data extension */
/**** Data below this point are SYSTEM PRIVATE ****/
};
struct ScreenBuffer¶
Source: intuition/screens.h
struct ScreenBuffer
{
struct BitMap *sb_BitMap; /* BitMap of this buffer */
struct DBufInfo *sb_DBufInfo; /* DBufInfo for this buffer */
};
sghooks.h¶
struct SGWork¶
Source: intuition/sghooks.h
struct SGWork {
/* set up when gadget is first activated */
struct Gadget *Gadget; /* the contestant itself */
struct StringInfo *StringInfo; /* easy access to sinfo */
STRPTR WorkBuffer; /* intuition's planned result */
STRPTR PrevBuffer; /* what was there before */
ULONG Modes; /* current mode */
/* modified for each input event */
struct InputEvent *IEvent; /* actual event: do not change */
UWORD Code; /* character code, if one byte */
WORD BufferPos; /* cursor position */
WORD NumChars;
ULONG Actions; /* what Intuition will do */
LONG LongInt; /* temp storage for longint */
struct GadgetInfo *GadgetInfo; /* see cghooks.h */
UWORD EditOp; /* from constants below */
};
struct StringExtend¶
Source: intuition/sghooks.h
struct StringExtend {
/* display specifications */
struct TextFont *Font; /* must be an open Font (not TextAttr) */
UBYTE Pens[2]; /* color of text/backgroun */
UBYTE ActivePens[2]; /* colors when gadget is active */
/* edit specifications */
ULONG InitialModes; /* initial mode flags, below */
struct Hook *EditHook; /* if non-NULL, must supply WorkBuffer */
STRPTR WorkBuffer; /* must be as large as StringInfo.Buffer*/
ULONG Reserved[4]; /* set to 0 */
};