Frozen Fish 1: Amiga

home *** CD-ROM | disk | FTP | other *** search

/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / alib / d9xx / d911 / gadoutline.lha / GadOutline / Programmer / programmer.lha / Includes / libraries / gadoutline.h

Wrap

C/C++ Source or Header | 1993-07-28 | 128KB | 3,016 lines

#ifndef LIBRARIES_GADOUTLINE_H #define LIBRARIES_GADOUTLINE_H #ifndef EXEC_MEMORY_H #include <exec/memory.h> #endif #ifndef INTUITION_GADGETCLASS_H #include <intuition/gadgetclass.h> #endif #ifndef LIBRARIES_GADTOOLS_H #include <libraries/gadtools.h> #endif /** ** Command ID bit definitions. **/ typedef unsigned long CMDID; #define STDID_STARTBIT (0) // Standard ID code for command / gadget #define STDID_NUMBITS (10) #define GRPID_STARTBIT (12) // Group ID code #define GRPID_NUMBITS (20) // Bit allocation: // // 3 2 2 2 1 1 0 0 0 // 1 8 4 0 6 2 8 4 0 // GGGG GGGG GGGG GGGG GGGG xxSS SSSS SSSS // // G = Group ID bits // S = Standard ID bits // x = reserved. always set to 0. #define GETSTDID(cmdid) ((ULONG)( ( ((CMDID)(cmdid)) >> STDID_STARTBIT ) \ & ((1<<STDID_NUMBITS)-1) )) #define GETGRPID(cmdid) ((ULONG)( ( ((CMDID)(cmdid)) >> GRPID_STARTBIT ) \ & ((1<<GRPID_NUMBITS)-1) )) #define GO_CMDID(grpid,stdid) \ ((CMDID)( (((ULONG)(grpid)&((1<<GRPID_NUMBITS)-1))<<GRPID_STARTBIT) \ | (((ULONG)(stdid)&((1<<STDID_NUMBITS)-1))<<STDID_STARTBIT) \ )) #define GO_GRPID_A 0x00100 #define GO_GRPID_B 0x00200 #define GO_GRPID_C 0x00400 #define GO_GRPID_D 0x00800 #define GO_GRPID_E 0x01000 #define GO_GRPID_F 0x02000 #define GO_GRPID_G 0x04000 #define GO_GRPID_H 0x08000 #define GO_GRPID_I 0x10000 #define GO_GRPID_J 0x20000 #define GO_GRPID_K 0x40000 #define GO_GRPID_L 0x80000 #define GO_GRPID_MASK 0xFFF00 #define GO_GRPID_CODE 0x000FF /** ** Definition for a standard weight distribution; used below. **/ typedef unsigned short WDIST; #define LEFTDIST_STARTBIT (0) // All leftover weight that's not used below: #define LEFTDIST_NUMBITS (2) #define SPCLDIST_STARTBIT (2) // Weight of the last [below/right] space. #define SPCLDIST_NUMBITS (2) #define TXTLDIST_STARTBIT (4) // Weight of the last [below/right] text. #define TXTLDIST_NUMBITS (2) #define BODYDIST_STARTBIT (6) // Weight of the body. #define BODYDIST_NUMBITS (2) #define TXTFDIST_STARTBIT (8) // Weight of the first [above/left] text. #define TXTFDIST_NUMBITS (2) #define SPCFDIST_STARTBIT (10) // Weight of the first [above/left] space. #define SPCFDIST_NUMBITS (2) // Bit allocation: // // 1 1 0 0 0 // 5 2 8 4 0 // xxxx SSTT bbtt ssLL // // S = Space above/left weight // T = Text above/left weight // B = Body weight // t = Text below/right weight // s = Space below/right weight // L = left over space [all space not used above.] // x = reserved. always set to 0. #define GETLEFTDIST(wdist) ((UBYTE)( ( ((WDIST)(wdist)) >> LEFTDIST_STARTBIT ) \ & ((1<<LEFTDIST_NUMBITS)-1) )) #define GETSPCLDIST(wdist) ((UBYTE)( ( ((WDIST)(wdist)) >> SPCLDIST_STARTBIT ) \ & ((1<<SPCLDIST_NUMBITS)-1) )) #define GETTXTLDIST(wdist) ((UBYTE)( ( ((WDIST)(wdist)) >> TXTLDIST_STARTBIT ) \ & ((1<<TXTLDIST_NUMBITS)-1) )) #define GETBODYDIST(wdist) ((UBYTE)( ( ((WDIST)(wdist)) >> BODYDIST_STARTBIT ) \ & ((1<<BODYDIST_NUMBITS)-1) )) #define GETTXTFDIST(wdist) ((UBYTE)( ( ((WDIST)(wdist)) >> TXTFDIST_STARTBIT ) \ & ((1<<TXTFDIST_NUMBITS)-1) )) #define GETSPCFDIST(wdist) ((UBYTE)( ( ((WDIST)(wdist)) >> SPCFDIST_STARTBIT ) \ & ((1<<SPCFDIST_NUMBITS)-1) )) #define GO_WDIST(spcf,txtf,body,spcl,txtl,left) \ ((WDIST)( (((UWORD)(spcf)&((1<<SPCFDIST_NUMBITS)-1))<<SPCFDIST_STARTBIT) \ | (((UWORD)(txtf)&((1<<TXTFDIST_NUMBITS)-1))<<TXTFDIST_STARTBIT) \ | (((UWORD)(body)&((1<<BODYDIST_NUMBITS)-1))<<BODYDIST_STARTBIT) \ | (((UWORD)(txtl)&((1<<TXTLDIST_NUMBITS)-1))<<TXTLDIST_STARTBIT) \ | (((UWORD)(spcl)&((1<<SPCLDIST_NUMBITS)-1))<<SPCLDIST_STARTBIT) \ | (((UWORD)(left)&((1<<LEFTDIST_NUMBITS)-1))<<LEFTDIST_STARTBIT) \ )) /** ** Definition for how much weight an object gets in a group. **/ typedef unsigned long WEIGHT; #define BOXWGT_STARTBIT (0) // Weight of this entire box. #define BOXWGT_NUMBITS (8) #define VERWGT_STARTBIT (8) // Vertical distribution of weight. #define VERWGT_NUMBITS (12) #define HORWGT_STARTBIT (20) // Horizontal distribution of weight. #define HORWGT_NUMBITS (12) // Bit allocation: // // 3 2 2 2 1 1 0 0 0 // 1 8 4 0 6 2 8 4 0 // HHHH HHHH HHHH VVVV VVVV VVVV BBBB BBBB // // H = Horizonal weight distribution within box. [Type WDIST] // V = Vertical weight distribution within box. [Type WDIST] // B = Weight of entire box within its group. // x = reserved. always set to 0. #define GETBOXWGT(weight) ((ULONG)( ( ((WEIGHT)(weight)) >> BOXWGT_STARTBIT ) \ & ((1<<BOXWGT_NUMBITS)-1) )) #define GETVERWGT(weight) ((WDIST)( ( ((WEIGHT)(weight)) >> VERWGT_STARTBIT ) \ & ((1<<VERWGT_NUMBITS)-1) )) #define GETHORWGT(weight) ((WDIST)( ( ((WEIGHT)(weight)) >> HORWGT_STARTBIT ) \ & ((1<<HORWGT_NUMBITS)-1) )) #define GO_WEIGHT(horiz,vert,box) \ ((WEIGHT)( (((ULONG)(horiz)&((1<<HORWGT_NUMBITS)-1))<<HORWGT_STARTBIT) \ | (((WDIST)(vert)&((1<<VERWGT_NUMBITS)-1))<<VERWGT_STARTBIT) \ | (((WDIST)(box)&((1<<BOXWGT_NUMBITS)-1))<<BOXWGT_STARTBIT) \ )) /** ** Outline command definitions **/ typedef unsigned long OUTCMD; #define CMDSUBC_STARTBIT (0) #define CMDSUBC_NUMBITS (16) #define CMDCODE_STARTBIT (16) #define CMDCODE_NUMBITS (4) #define CMDKIND_STARTBIT (20) #define CMDKIND_NUMBITS (4) #define CMDTAGS_STARTBIT (24) #define CMDTAGS_NUMBITS (2) #define CMDPARS_STARTBIT (28) #define CMDPARS_NUMBITS (3) // Bit allocation: // // 3 2 2 2 1 1 0 0 0 // 1 8 4 0 6 2 8 4 0 // xPPP xxTT KKKK CCCC SSSS SSSS SSSS SSSS // // P = Command's number of parameters // T = Command's number of tag lists // K = Command's kind bits // C = Command's code bits // S = Command's sub-code bits // x = reserved. always set to 0. #define GETCMDPARS(outcmd) ((ULONG)( ( ((OUTCMD)(outcmd)) >> CMDPARS_STARTBIT ) \ & ((1<<CMDPARS_NUMBITS)-1) )) #define GETCMDTAGS(outcmd) ((ULONG)( ( ((OUTCMD)(outcmd)) >> CMDTAGS_STARTBIT ) \ & ((1<<CMDTAGS_NUMBITS)-1) )) #define GETCMDKIND(outcmd) ((ULONG)( ( ((OUTCMD)(outcmd)) >> CMDKIND_STARTBIT ) \ & ((1<<CMDKIND_NUMBITS)-1) )) #define GETCMDCODE(outcmd) ((ULONG)( ( ((OUTCMD)(outcmd)) >> CMDCODE_STARTBIT ) \ & ((1<<CMDCODE_NUMBITS)-1) )) #define GETCMDSUBC(outcmd) ((ULONG)( ( ((OUTCMD)(outcmd)) >> CMDSUBC_STARTBIT ) \ & ((1<<CMDSUBC_NUMBITS)-1) )) #define GO_OUTCMD(par,tag,kind,code,subc) \ ((OUTCMD) ( (((ULONG)(par)&((1<<CMDPARS_NUMBITS)-1))<<CMDPARS_STARTBIT) \ | (((ULONG)(tag)&((1<<CMDTAGS_NUMBITS)-1))<<CMDTAGS_STARTBIT) \ | (((ULONG)(kind)&((1<<CMDKIND_NUMBITS)-1))<<CMDKIND_STARTBIT) \ | (((ULONG)(code)&((1<<CMDCODE_NUMBITS)-1))<<CMDCODE_STARTBIT) \ | (((ULONG)(subc)&((1<<CMDSUBC_NUMBITS)-1))<<CMDSUBC_STARTBIT) \ )) // Bits describing major kinds. The command kind determines what ci_CmdData // points to and the general meaning of the parameters and tag lists. #define GOK_Illegal 0x0 // Illegal kind #define GOK_Box 0x1 // This is an actual box on the display. // ci_CmdData points to a BoxAttr structure. // The first two parameters are the same for all // codes; the rest are context sensitive to the // actual kind of object that is being created. // Parameters: // 1: CmdID - ID number; standard ID used in gadget. // 2: BoxWeight - How much extra space box gets. // 3: Text - GadTools text / Boopsi public class // name / Custom parameter. // 4: Value - GadTools flags / Boopsi private class // code / Custom parameter. // Tag Lists: // 1: Standard command tags applied to box. // 2: GadTools / Boopsi / Custom / Drawing tags. #define GOK_Image 0x2 // This is an image drawn on to the display. // ci_CmdData points to a BoxAttr structure. // The first two parameters are the same for all // codes; the rest are context sensitive to the // actual kind of object that is being created. // Parameters: // 1: CmdID - ID number; standard ID used in gadget. // 2: Reserved - Always set to 0. // 3: Text - GadTools text / Boopsi public class // name / Custom parameter. // 4: Value - GadTools flags / Boopsi private class // code / Custom parameter. // Tag Lists: // 1: Standard command tags applied to image. // 2: GadTools / Boopsi / Custom / Drawing tags. #define GOK_Object 0x3 // This is an object that is not a direct part of the // display. ci_CmdData is currently NULL. // The first two parameters are the same for all // codes; the rest are context sensitive to the // actual kind of object that is being created. // Parameters: // 1: CmdID - ID number; standard ID used in gadget. // 2: Reserved - Always set to 0. // 3: Text - GadTools text / Boopsi public class // name / Custom parameter. // 4: Value - GadTools flags / Boopsi private class // code / Custom parameter. // Tag Lists: // 1: Standard command tags applied to image. // 2: GadTools / Boopsi / Custom / Drawing tags. #define GOK_Group 0x4 // Group control commands. ci_CmdData points to // a standard BoxAttr structure. // Parameters: // 1: CmdID - ID number. // 2: GrpWeight - How much extra space grp box gets. // Tag Lists: // 1: Standard command tags // 2: (optional) List of drawing commands for group. #define GOK_Sys 0x5 // System control commands. // Parameters: // 1: CmdID - ID number. Usually 0. // Tag Lists: // None. #define GOK_Global 0x6 // Global settings commands. // Parameters: // 1: CmdID - ID number. // Tag Lists: // Global tags to change. #define GOK_User 0x7 // User command. // Parameters: // 1: CmdID - ID number. // 2-: Anything. // Tag Lists: // Anything. #define GOK_LastDef 0x8 // Last outline kind that is defined. // Bits descibing codes for box/image/object kind - GOK_Box/GOK_Image/GOK_Object. #define GOKB_Resv 0x0 // Reserved - do not use. #define GOKB_GadTools 0x1 // This is a standard gadtools gadget. // The 3rd parameter points to the gadget's label // text, the 4th contains the standard NewGadget // flags. The SubCode field in the command is // the actual GadTools gadget kind to create. #define GOKB_Boopsi 0x2 // This is a BOOPSI object. // The 3rd parameter is a public class name, the // 4th is the ID for a private class. These // parameters are directly associated with the // NewObject() call; one of them must be NULL. // See subcode definitions - GOSB_* - below. #define GOKB_Custom 0x3 // This is a custom object. // Everything after the first 2 parameters and // first tag list are available for whatever the // user wants. #define GOKB_Empty 0x4 // This is a an empty box. #define GOKB_Drawing 0x5 // This is a GadOutline drawing. See subcode // definitions - GOSD_* - below. // Bits descibing command codes for the group kind - GOK_Group. #define GOKG_Resvgrp 0x0 // Reserved - do not use. #define GOKG_Vertical 0x1 // Start a vertical group #define GOKG_Horizontal 0x2 // Start a horizontal group // Bits descibing command codes for the system kind - GOK_System. #define GOKS_Resv 0x0 // Reserved - do not use. #define GOKS_EndGroup 0x1 // End the current group. #define GOKS_EndOutline 0x2 // End the entire outline. // Bits descibing command codes for the global kind - GOK_Global. #define GOKG_Resvglb 0x0 // Reserved - do not use. #define GOKG_Outline 0x1 // Set global outline tags. [ie GOA_*] #define GOKG_Command 0x2 // Set global command tags. [ie GOCT_*] #define GOKG_Object 0x3 // Set global object tags. [object dependant] // NOT IMPLEMENTED ^^ #define GOKG_Screen 0x4 // Set standard screen tags. [ie SA_*] #define GOKG_Window 0x5 // Set standard window tags. [ie WA_*] // Bits describing subcode for drawing code. #define GOSD_Normal 0x1 // Just a normal drawing. #define GOSD_Button 0x2 // Drawing with a highlight button. #define GOSD_BoopsiIm 0x3 // Create a BOOPSI image object. #define GOSD_BoopsiGad 0x4 // Create a full BOOPSI gadget. // Bits describing subcode for BOOPSI code. #define GOSB_Object 0x1 // A generic object #define GOSB_Image 0x2 // A type of image class. #define GOSB_Gadget 0x3 // A type of gadget class. #define GOSB_AddGad 0x3 // A type of gadget class, added to go_BoopsiGList. // --------------------------------- // Standard box creation commands // --------------------------------- #define GO_GTBOX(gadkind,grpid,stdid,weight,name,flags) \ GO_OUTCMD(4,2,GOK_Box,GOKB_GadTools,gadkind), \ GO_CMDID(grpid,stdid),weight,name,flags // 4 arguents; 2 tag lists #define GO_DRAWBOX(type,grpid,stdid,weight) \ GO_OUTCMD(2,2,GOK_Box,GOKB_Drawing,type), \ GO_CMDID(grpid,stdid),weight // 2 arguents; 2 tag lists #define GO_BOOPSIBOX(type,grpid,stdid,weight,classname,classid) \ GO_OUTCMD(4,2,GOK_Box,GOKB_Boopsi,type), \ GO_CMDID(grpid,stdid),weight,classname,classid // 4 arguents; 2 tag lists #define GO_CUSTBOX(numparam,numtags,subcode,grpid,stdid,weight) \ GO_OUTCMD(numparam-2,numtags,GOK_Box,GOKB_Custom,subcode), \ GO_CMDID(grpid,stdid),weight #define GO_EMPTYBOX(grpid,stdid,weight) \ GO_OUTCMD(2,1,GOK_Box,GOKB_Empty,0),GO_CMDID(grpid,stdid),weight // 2 arguents; 1 tag list // --------------------------------- // Standard image creation commands // --------------------------------- #define GO_GTIMAGE(gadkind,grpid,stdid,name,flags) \ GO_OUTCMD(4,2,GOK_Image,GOKB_GadTools,gadkind), \ GO_CMDID(grpid,stdid),0,name,flags // 4 arguents; 2 tag lists #define GO_DRAWIMAGE(type,grpid,stdid) \ GO_OUTCMD(2,2,GOK_Image,GOKB_Drawing,type), \ GO_CMDID(grpid,stdid),0 // 2 arguents; 2 tag lists #define GO_BOOPSIIMAGE(type,grpid,stdid,classname,classid) \ GO_OUTCMD(4,2,GOK_Image,GOKB_Boopsi,type), \ GO_CMDID(grpid,stdid),0,classname,classid // 4 arguents; 2 tag lists #define GO_CUSTIMAGE(numparam,numtags,subcode,grpid,stdid) \ GO_OUTCMD(numparam-2,numtags,GOK_Image,GOKB_Custom,subcode), \ GO_CMDID(grpid,stdid),0 #define GO_EMPTYIMAGE(grpid,stdid) \ GO_OUTCMD(2,1,GOK_Image,GOKB_Empty,0),GO_CMDID(grpid,stdid),0 // 2 arguents; 1 tag list // --------------------------------- // Standard object creation commands // --------------------------------- #define GO_BOOPSIOBJ(type,grpid,stdid,classname,classid) \ GO_OUTCMD(3,2,GOK_Object,GOKB_Boopsi,type), \ GO_CMDID(grpid,stdid),classname,classid // 3 arguents; 2 tag lists // --------------------------------- // Standard group creation commands // --------------------------------- #define GO_HORIZGRP(grpid,stdid,weight) \ GO_OUTCMD(2,1,GOK_Group,GOKG_Horizontal,0),GO_CMDID(grpid,stdid),weight // 2 arguents; 1 tag list #define GO_VERTGRP(grpid,stdid,weight) \ GO_OUTCMD(2,1,GOK_Group,GOKG_Vertical,0),GO_CMDID(grpid,stdid),weight // 2 arguents; 1 tag list #define GO_HDRAWGRP(grpid,stdid,weight) \ GO_OUTCMD(2,2,GOK_Group,GOKG_Horizontal,GOSD_Normal), \ GO_CMDID(grpid,stdid),weight // 2 arguents; 2 tag lists #define GO_VDRAWGRP(grpid,stdid,weight) \ GO_OUTCMD(2,2,GOK_Group,GOKG_Vertical,GOSD_Normal), \ GO_CMDID(grpid,stdid),weight // 2 arguents; 2 tag lists // --------------------------------- // Standard system commands // --------------------------------- #define GO_ENDGRP() GO_OUTCMD(0,0,GOK_Sys,GOKS_EndGroup,0) #define GO_ENDOUTLINE() GO_OUTCMD(0,0,GOK_Sys,GOKS_EndOutline,0) // --------------------------------- // Standard global commands // --------------------------------- #define GO_OUTLINETAGS(grpid,stdid) \ GO_OUTCMD(1,2,GOK_Global,GOKG_Outline,0),GO_CMDID(grpid,stdid) // 1 arguent; 2 tag lists #define GO_COMMANDTAGS(grpid,stdid) \ GO_OUTCMD(1,2,GOK_Global,GOKG_Command,0),GO_CMDID(grpid,stdid) // 1 arguent; 2 tag lists #define GO_OBJECTTAGS(grpid,stdid) \ GO_OUTCMD(1,2,GOK_Global,GOKG_Object,0),GO_CMDID(grpid,stdid) // 1 arguent; 2 tag lists #define GO_SCREENTAGS(grpid,stdid) \ GO_OUTCMD(1,2,GOK_Global,GOKG_Screen,0),GO_CMDID(grpid,stdid) // 1 arguent; 2 tag lists #define GO_WINDOWTAGS(grpid,stdid) \ GO_OUTCMD(1,2,GOK_Global,GOKG_Window,0),GO_CMDID(grpid,stdid) // 1 arguent; 2 tag lists /** ** This is the main structure which is created for every command in the ** outline. **/ struct CmdInfo { struct Node ci_Node; // Private linking. DO NOT TOUCH. UWORD pad0; // LONG-align. DO NOT TOUCH. // These fields should only be looked at. struct GadOutline *ci_GadOutline; // Link back to global data. OUTCMD ci_Command; // Actual command code; see outline // command definitions. CMDID ci_CmdID; // Standard and Group ID codes for this command. // Always the first command parameter. // These fields should only be looked at by the application and may be // looked at and modified by the command's hook. void *ci_Object; // Command's created object. (ie, a Gadget) // Set to NULL when the object has not // been created yet or failed creation. ULONG ci_ObjIDCMP; // The IDCMP messages this object needs. // All of the following fields should only be looked at. union { // More detailed data for specific commands. void *ci_CmdData; // Generic data. struct BoxAttr *ci_BoxAttr; // Created by GOK_Box kind. }; union { // Parameters copied from outline. ULONG ci_Params[7]; // Generic view of parameters. struct { // GOK_Box ULONG ci_BoxWeight; // Raw weight for extra space box uses UBYTE *ci_BoxText; // Text label / boopsi class name for the box ULONG ci_BoxValue; // GadTools NewGadget flags / boopsi class id } ci_BoxParams; struct { // GOK_Image ULONG ci_ImageResv; // Currently unused. Always set to 0. UBYTE *ci_ImageText; // Boopsi class name for the image ULONG ci_ImageValue; // Boopsi class id for the image } ci_ImageParams; struct { // GOK_Object ULONG ci_ObjectResv; // Currently unused. Always set to 0. UBYTE *ci_ObjectText; // Boopsi class name for the object ULONG ci_ObjectValue; // Boopsi class id for the object } ci_ObjectParams; struct { // GOK_Group ULONG ci_GrpWeight; // Raw weight for extra space group uses } ci_GroupParams; }; // These tag lists are copied from the outline. They should only be // modified by the command's hook, and only individual elements of // the tag array may be modified. struct TagItem *ci_CmdTags; // Command tags supplied in the outline. union { struct TagItem *ci_Tags[3]; // Generic view of tag lists struct TagItem *ci_GadToolsTags;// GadTools standard tags struct TagItem *ci_BoopsiTags; // Boopsi class tags struct TagItem *ci_DrawingTags; // Drawing class tags struct TagItem *ci_GlobalTags; // Global tags set with GOK_Global }; void *ci_UserHookData; // For any use by user hook. ULONG ci_UserHookState; // Likewise. }; /* There is private data after this structure */ struct BoxAttr { struct Node ba_Node; // Private linking. DO NOT TOUCH. UWORD pad0; // LONG-align. DO NOT TOUCH. // The rest of these fields are 100% read-only. struct CmdInfo *ba_CmdInfo; // The command that created this box. struct BoxPosInfo *ba_BoxPosInfo; // If requested, the full box dimens. WORD ba_BoxLeft,ba_BoxTop; // Absolute LeftEdge and TopEdge of box. WORD ba_BoxWidth,ba_BoxHeight; // Total Width and Height of box. WORD ba_BodyLeft,ba_BodyTop; // Absolute LeftEdge and TopEdge of body. WORD ba_SpaceLeft,ba_TextLeft; // Final x dimensions of box WORD ba_BodyWidth; WORD ba_TextRight,ba_SpaceRight; WORD ba_SpaceAbove,ba_TextAbove; // Final y dimensions of box WORD ba_BodyHeight; WORD ba_TextBelow,ba_SpaceBelow; }; /* There is private data after this structure */ // The ExecMessage structure within the standard IntuiMessage is // reserved for use by the library. Do not touch in any way, shape or form. :) struct GOIMsg { struct IntuiMessage StdIMsg; // Standard Intuition message. UBYTE KeyPress[8]; // Translated RAWKEY event. ULONG UserData; // For any use by user. }; /* There is private data after this structure */ /** ** These are the messages that can be sent to the command's call back. Most ** of the gadget operations are implemented in the callback, including ** all of the code to create and destroy gadgets, change their attributes, ** implement hot keys, and keeping track of their state. The hook is ** passed the CmdInfo structure as its object, and a CmdHookMsg structure ** as its parameters. The function should always return 0 unless otherwise ** indicated. **/ #define CHM_INITIALIZE TAG_USER+1 // Initalizing object - allocate resources #define CHM_INITCMDATTR TAG_USER+2 // Parse initial command attributes // arg 1 = startup command tag list #define CHM_INITOBJATTR TAG_USER+3 // Parse initial object attributes // arg 1 = startup object tag list #define CHM_TERMINATE TAG_USER+4 // Terminating - free resources #define CHM_GETMINDIMENS TAG_USER+5 // Ask object its minimum size // arg 1 = pointer to GODimensInfo // which is to be filled in. #define CHM_CREATEOBJ TAG_USER+6 // Allocating a new object, restore state // arg 1 = Initialized NewGadget struct #define CHM_MADELINK TAG_USER+7 // A object was just created which // has a link to this object. // arg 1 = CmdInfo * to linker. // arg 2 = tag which points to us. #define CHM_DESTROYOBJ TAG_USER+8 // Free current object, save state. Be // prepared to recieve this without a // matching CHM_CREATEOBJ. #define CHM_HOOKOBJ TAG_USER+9 // Added object to window. #define CHM_UNHOOKOBJ TAG_USER+10 // Removing object from window. Be // prepared to recieve this without a // matching CHM_HOOKOBJ. #define CHM_PRERESIZE TAG_USER+11 // Set up to resize object. For GadTools // gadgets, this involves setting // ci_Object to NULL because the library // will free the gadtools list. Other // object may need to deallocate here // too, if they can't resize. #define CHM_RESIZEOBJ TAG_USER+12 // Resizing current object. // arg 1 = Initialized NewGadget struct #define CHM_DRAWSELF TAG_USER+13 // Redraw object imagery. #define CHM_UPDATESTATE TAG_USER+14 // Update state from IntuiMessage // arg 1 = COPY of GOIMsg received #define CHM_SETCMDATTR TAG_USER+15 // User changing command attributes // arg 1 = TagList with new values #define CHM_GETCMDATTR TAG_USER+16 // User request for current cmd state // arg 1 = TagList to fill in #define CHM_SETOBJATTR TAG_USER+17 // User changing object attributes // arg 1 = TagList with new values #define CHM_GETOBJATTR TAG_USER+18 // User request for current obj state // arg 1 = TagList to fill in #define CHM_HOTKEY TAG_USER+19 // Perform hotkey operation // arg 1 = COPY of GOIMsg received // These are the translation commands. The default is to just return // the same code that is sent -- ie, the original code was already an // actual string address. // The ULONG code to translate is passed as the first message argument // for most of these. #define CHM_TRANSCMDHOOK TAG_USER+50 // Translate a hook pointer supplied // with GOCT_SetUserHook tag. Should // return the address of a hook struct. #define CHM_TRANSEDITHOOK TAG_USER+51 // Translate a hook pointer supplied // as a gadget's edit hook. Should // return the address of a hook struct. #define CHM_TRANSTEXTPTR TAG_USER+52 // Translate a text string code // supplied in outline. Should // return the address of a string. #define CHM_TRANSTEXTARRAY TAG_USER+53 // Translate a text array code // supplied in outline. Should // return the address of a NULL // terminated array of string pointers. #define CHM_TRANSTEXTFMT TAG_USER+54 // Translate a text level format code // supplied in outline. Should // return the address of a standard // C-Style formatting string as used // in GadTools slides, etc. #define CHM_TRANSPUBCLASS TAG_USER+55 // Translate a BOOPSI public class // name. Should return a pointer // to a string with the class's name. #define CHM_TRANSPRIVCLASS TAG_USER+56 // Translate a BOOPSI private class // code. Should return a pointer // to a private BOOPSI class. #define CHM_TRANSHOTKEY TAG_USER+57 // Translate a hotkey code into the // actual key event. You will be // given a ULONG hotkey code, which // the builtin translation hook // interprets as an ASCII character // in the lower byte and various flags // in the high bits. You should return // an ASCII character for the hotkey; // the library will continue querrying // you for hotkeys until you return 0. // You are free to use the upper word // of the result for state information, // however always make sure the lower // word is an actual ASCII value. // [Ie, the upper byte is zero.] // Every number after this is for private use by the caller's custom hook. #define CHM_USER (TAG_USER+0x4000) struct CmdHookMsg { ULONG chm_Message; // Actual message code; one of above ULONG chm_NumArgs; // For future expansion. Always set // to zero. union { // Parameters struct { // CHM_GETMINDIMENS struct GODimensInfo*chm_MinDim; // to be filled in by the hook // all values start at zero } chm_GetMinDimens; struct { // CHM_CREATEOBJ struct NewGadget*chm_NewGadget; // Filled in NewGadget, ready to go. } chm_CreateObj; struct { // CHM_MADELINK struct CmdInfo *chm_LinkCmd; // Command which contains link struct TagItem *chm_LinkTag; // The tag which points to us. } chm_MadeLink; struct { // CHM_RESIZEOBJ struct NewGadget*chm_ResGadget; // Filled in NewGadget, ready to go. } chm_ResizeObj; struct { // CHM_UPDATESTATE struct GOIMsg *chm_StateGOIMsg; // message to update from } chm_UpdateState; struct { // CHM_SETCMDATTR/CHM_INITCMDATTR struct TagItem *chm_SetCmdTags; // New values for ci_CmdTags } chm_SetCmdAttr; struct { // CHM_GETCMDATTR struct TagItem *chm_GetCmdTags; // Tags to fill in ti_Data of } chm_GetCmdAttr; struct { // CHM_SETOBJATTR/CHM_INITOBJATTR struct TagItem *chm_SetObjTags; // New values for ci_ObjectTags } chm_SetObjAttr; struct { // CHM_GETOBJATTR struct TagItem *chm_GetObjTags; // Tags to fill in ti_Data of } chm_GetObjAttr; struct { // CHM_HOTKEY struct GOIMsg *chm_KeyGOIMsg; // message that triggered call } chm_HotKey; struct { // CHM_TRANS* messages ULONG chm_TransCode; // code to translate struct CmdInfo *chm_TransCmd; // If not NULL, the command // generating this event. } chm_Translate; struct { // CHM_TRANSHOTKEY message ULONG chm_HotKeyCode; // code to translate ULONG chm_PrevHotKey; // previous value you returned, or // 0 if this is the first time. } chm_TransHotKey; }; }; struct GODimensInfo { // Bare minimum values we can take. WORD gdi_StdSpaceLeft; // Pixels of space on left WORD gdi_StdTextLeft; // Pixels to left of body WORD gdi_StdBodyWidth; // Pixels for width of body WORD gdi_StdTextRight; // Pixels to right of body WORD gdi_StdSpaceRight; // Pixels of space on right WORD gdi_StdSpaceAbove; // Pixels of space above WORD gdi_StdTextAbove; // Pixels above body WORD gdi_StdBodyHeight; // Pixels for height of body WORD gdi_StdTextBelow; // Pixels below body WORD gdi_StdSpaceBelow; // Pixels of space below // Any extra spacing we would prefer to have. WORD gdi_PadSpaceLeft; // Pixels of padding space on left WORD gdi_PadTextLeft; // Pixels to left of body WORD gdi_PadBodyWidth; // Pixels for width of body WORD gdi_PadTextRight; // Pixels to right of body WORD gdi_PadSpaceRight; // Pixels of padding space on left UWORD gdi_PadSpaceAbove; // Pixels of padding space above UWORD gdi_PadTextAbove; // Pixels above body UWORD gdi_PadBodyHeight; // Pixels for height of body UWORD gdi_PadTextBelow; // Pixels below body UWORD gdi_PadSpaceBelow; // Pixels of padding space below }; struct GadOutline { struct Node go_Node; // Reserved for future use. DO NOT TOUCH. UWORD pad0; // LONG-align. DO NOT TOUCH. void *go_OutlineBase; // Also reserved. DO NOT TOUCH. // The following are read-only. struct Window *go_Window; // Window attached to the gadoutline. struct Window *go_HookedWin; // Window objects are attached to; NULL if // not attached. Use this and not // go_Window with SetGadgetAttrs(), etc. struct Screen *go_Screen; // Screen layout is on. struct Menu *go_MenuStrip; // Menu strip to attach to window. struct DrawInfo *go_DrI; // Used to get the screen font, etc. struct VisualInfo *go_VI; // Screen's VisualInfo. struct MsgPort *go_MsgPort; // Our message port, or the current window's // Handles on gadget lists. You should never need to look at these. struct Gadget *go_GToolsList; // The GadTools list of gadgets struct Gadget *go_BoopsiList; // The Boopsi list of gadgets struct Gadget *go_BorderList; // Currently unused. // Associated with current gadget held down by user. May be set to // NULL by the command's user hook if it really needs to. struct CmdInfo *go_ActCmdInfo; // Current CmdInfo accepting events // These may be modified by a user hook to reflect the addition of // a new gadget. They must always point to a valid gadget. struct Gadget *go_LastGTools; // Last GadTools gadget created struct Gadget *go_LastBoopsi; // Last Boopsi gadget created struct Gadget *go_LastBorder; // Currently unused. // Layout dimension information. Read only. UWORD go_Width,go_Height; // Size of window needed UWORD go_InnerWidth, // Size of window inside its frame go_InnerHeight; UWORD go_MinWidth, // Minimum window size the outline will fit in go_MinHeight; UWORD go_MinInnerWidth, // Minimum size of window inside its frame go_MinInnerHeight; // Last return code from requester. May be written by application. UWORD go_LastReqReturn; // Return value from last error report UWORD reserved0; // Current font information. Read only. struct TextFont *go_TextFont; // The opened TTextAttr below. struct TTextAttr go_TextAttr; // The actual font that is used by the // layout. All of the gadgets use this as // their TextAttr. struct TTextAttr go_TargetTA; // The desired font requested by the caller. // These may be used however you see fit. void *go_UserData; // For any use by user. void *go_UserHandler; // User's IDCMP handler or anything else. void *go_TransHookData; // For any use by user translation hook. }; /* There is private data after this structure */ // This structure is not created... yet... struct OutlineBase { struct Node ob_Node; // Private linking. UWORD pad0; // LONG-align. UBYTE *ob_ProgBaseName; // User program's base name. struct GadOutline *ob_Primary; // Primary outline. }; /* There is private data after this structure */ /** ** This structure is used to describe the full positioning information of ** a box on the screen. To be filled in, a pointer to this structure is ** passed using the GOCT_BoxPosInfo tag in the relevant box definition in the ** outline. The structure will be updated any time that the layout is ** recomputed. **/ struct BoxPosInfo { WORD bpi_BoxLeftEdge; // Left side of box; # pixels from left window edge WORD bpi_BoxTopEdge; // Top side of box; # pixels from top window edge WORD bpi_BoxRightEdge; // Right side of box; # pixels from left window edge WORD bpi_BoxBottomEdge; // Bottom side of box; # pixels from top window edge WORD bpi_BodyLeftEdge; // Left side of body; # pixels from left window edge WORD bpi_BodyTopEdge; // Top side of body; # pixels from top window edge WORD bpi_BodyRightEdge; // Right side of body; # pixels from left window edge WORD bpi_BodyBottomEdge; // Bottom side of body; # pixels from top window edge WORD bpi_SpaceLeft; // Number of pixels the left space width is WORD bpi_TextLeft; // Number of pixels the left text width is WORD bpi_BodyWidth; // Number of pixels the body width is WORD bpi_TextRight; // Number of pixels the right text width is WORD bpi_SpaceRight; // Number of pixels the right space width is WORD bpi_SpaceAbove; // Number of pixels space from TopEdge to text WORD bpi_TextAbove; // Number of pixels high the above text is WORD bpi_BodyHeight; // Number of pixels high body is WORD bpi_TextBelow; // Number of pixels high the below text is WORD bpi_SpaceBelow; // Number of pixels space from text to BottomEdge }; /** ** This is the type used by most of the tags that describe some kind of ** size (ie line height, body width, etc). The lower 16 bits tell the ** size (as a SIGNED value) and the upper 16 bits tell what this is relative to ** (ie, pixels, percent of a character width, etc) and the operation to ** perform (ie, add it to previous value). **/ typedef unsigned long TYPEDSIZE; #define SIZE_STARTBIT (0) #define SIZE_NUMBITS (16) #define TYPE_STARTBIT (16) #define TYPE_NUMBITS (8) #define MODE_STARTBIT (24) #define MODE_NUMBITS (7) // Bit allocation: // // 3 2 2 2 1 1 0 0 0 // 1 8 4 0 6 2 8 4 0 // 0MMM MMMM TTTT TTTT SSSS SSSS SSSS SSSS // // M = Mode bits // T = Type bits // S = Size bits // 0 = must be set to 0 // 1 = must be set to 1 // x = reserved. always set to 0. #define GETSIZE(tsize) (( WORD)( ( ((TYPEDSIZE)(tsize)) >> SIZE_STARTBIT ) \ & ((1<<SIZE_NUMBITS)-1) )) #define GETTYPE(tsize) ((ULONG)( ( ((TYPEDSIZE)(tsize)) >> TYPE_STARTBIT ) \ & ((1<<TYPE_NUMBITS)-1) )) #define GETMODE(tsize) ((ULONG)( ( ((TYPEDSIZE)(tsize)) >> MODE_STARTBIT ) \ & ((1<<MODE_NUMBITS)-1) )) #define GO_TSIZE(mode,size,type) \ ((TYPEDSIZE)( (((ULONG)(mode)&((1<<MODE_NUMBITS)-1))<<MODE_STARTBIT) \ | (((UWORD)(size)&((1<<SIZE_NUMBITS)-1))<<SIZE_STARTBIT) \ | (((ULONG)(type)&((1<<TYPE_NUMBITS)-1))<<TYPE_STARTBIT) \ )) // Bits descibing size modes #define GOM_Std 0x10 // Bit values describing 'standard' size mode // This is the minimum required size. #define GOM_Pad 0x20 // Bit values describing 'padding' size mode // This is space to remove if there is not enough room. #define GOM_Var 0x40 // Bit values describing 'variable' size mode // This is space to add if there is extra room. #define GOM_Base 0x30 // Bit values describing base size. // This is both the padding and standard sizes. #define GOM_All 0x70 // Bit values describing all sizes. // This is the combination of all three sizes. #define GOM_MdMask 0x70 // All bits used to describe size mode // Bits descibing size functions #define GOM_Set 0x0 // Bit values for 'set' function // Unconditionally sets the current value to this value. #define GOM_Max 0x1 // Bit values for 'maximum' function // Sets to the maximum of the current value and this value. #define GOM_Min 0x2 // Bit values for 'minimum' function // Sets to the minimum of the current value and this value. #define GOM_Add 0x3 // Bit values for 'add' function // Adds this value to the current value. #define GOM_Mul 0x4 // Bit values for 'mul' function // Multiplies this value with the current value. #define GOM_Div 0x5 // Bit values for 'div' function // Divides the current value by this value. #define GOM_FnMask 0xF // All bits used to describe size function #define GOM_StdSet (GOM_Set|GOM_Std) // Make the size this value #define GOM_StdMax (GOM_Max|GOM_Std) // Final size can't be less than this #define GOM_StdMin (GOM_Min|GOM_Std) // Final size can't be greater than this #define GOM_StdAdd (GOM_Add|GOM_Std) // Add this value to total size #define GOM_StdMul (GOM_Mul|GOM_Std) // Multiply this value with it #define GOM_StdDiv (GOM_Div|GOM_Std) // Divide current value by this #define GOM_PadSet (GOM_Set|GOM_Pad) // Make the padding size this value #define GOM_PadMax (GOM_Max|GOM_Pad) // Final padding size can't be < this #define GOM_PadMin (GOM_Min|GOM_Pad) // Final size can't be greater than this #define GOM_PadAdd (GOM_Add|GOM_Pad) // Add this value to total padding size #define GOM_PadMul (GOM_Mul|GOM_Pad) // Multiply this value with it #define GOM_PadDiv (GOM_Div|GOM_Pad) // Divide current value by this #define GOM_VarSet (GOM_Set|GOM_Var) // Make the variable size this value #define GOM_VarMax (GOM_Max|GOM_Var) // Final variable size can't be < this #define GOM_VarMin (GOM_Min|GOM_Var) // Final size can't be greater than this #define GOM_VarAdd (GOM_Add|GOM_Var) // Add this value to total variable size #define GOM_VarMul (GOM_Mul|GOM_Var) // Multiply this value with it #define GOM_VarDiv (GOM_Div|GOM_Var) // Divide current value by this #define GOM_BaseSet (GOM_Set|GOM_Base) // Make the padding size this value #define GOM_BaseMax (GOM_Max|GOM_Base) // Final padding size can't be < this #define GOM_BaseMin (GOM_Min|GOM_Base) // Final size can't be greater than this #define GOM_BaseAdd (GOM_Add|GOM_Base) // Add this value to total padding size #define GOM_BaseMul (GOM_Mul|GOM_Base) // Multiply this value with it #define GOM_BaseDiv (GOM_Div|GOM_Base) // Divide current value by this #define GOM_AllSet (GOM_Set|GOM_All) // Make the padding size this value #define GOM_AllMax (GOM_Max|GOM_All) // Final padding size can't be < this #define GOM_AllMin (GOM_Min|GOM_All) // Final size can't be greater than this #define GOM_AllAdd (GOM_Add|GOM_All) // Add this value to total padding size #define GOM_AllMul (GOM_Mul|GOM_All) // Multiply this value with it #define GOM_AllDiv (GOM_Div|GOM_All) // Divide current value by this // Types of unit the supplied size is in. // BASIC UNITS: Have same value for GOM_Std, GOM_Pad, GOM_Var. // These are the most basic of the basic units. #define GOT_Pixels 0 // Absolute # pixels #define GOT_PercCharW 1 // Percent of 1 character width #define GOT_PercChar0 2 // Percent of 1 numeric character width #define GOT_PercCharH 3 // Percent of 1 character height #define GOT_PercScale 4 // Percent to scale current value // These are basic units based on the limits on the outline size. #define GOT_PercMinW 5 // Percentage of the minimum layout width #define GOT_PercMinH 6 // Percentage of the minimum layout height #define GOT_PercMaxW 7 // Percentage of the maximum layout width #define GOT_PercMaxH 8 // Percentage of the maximum layout height // NUMBERS 9 TO 19 RESERVED HERE // These are basic units based on the data obtained from a tag that precedes // this one which contains one or more text strings. #define GOT_PercTextMinW 20 // Percentage of the smallest computed width // of all the text strings using the current font #define GOT_PercTextMinH 21 // Percentage of the smallest computed height // of all the text strings using the current font #define GOT_PercTextMaxW 22 // Percentage of the largest computed width // of all the text strings using the current font #define GOT_PercTextMaxH 23 // Percentage of the largest computed height // of all the text strings using the current font #define GOT_PercTextAddW 24 // Percentage of the addition of all the computed // widths of the text strings using the current font #define GOT_PercTextAddH 25 // Percentage of the addition of all the computed // heights of the text strings using the current font #define GOT_PercTextMinC 26 // Percentage of smallest number of chars in strs #define GOT_PercTextMaxC 27 // Percentage of largest number of chars in strs #define GOT_PercTextAddC 28 // Percentage of addition of number of chars in strs #define GOT_PercTextAddL 29 // Percentage of total number of lines supplied // NUMBERS 30 TO 39 RESERVED HERE // These are basic units based on pixels available to the box from the // group's minimum size. (Ie, the difference between the box's minimum sizes // and the minimum sizes that the box's parent group is using.) // These are the values that are used to fill in a box's extra space when // in GOCT_AutoDistExtra mode. If GOCT_FitToGroup is on, these will always // be zero. #define GOT_PercFlSpaceL 40 // Percentage of fill space left #define GOT_PercFlTextL 41 // Percentage of fill text left #define GOT_PercFlBodyW 42 // Percentage of fill body width #define GOT_PercFlTextR 43 // Percentage of fill text right #define GOT_PercFlSpaceR 44 // Percentage of fill space right #define GOT_PercFlBoxW 45 // Percentage of total fill width in box #define GOT_PercFlSpaceA 46 // Percentage of fill space above #define GOT_PercFlTextA 47 // Percentage of fill text above #define GOT_PercFlBodyH 48 // Percentage of fill body height #define GOT_PercFlTextB 49 // Percentage of fill text below #define GOT_PercFlSpaceB 50 // Percentage of fill space below #define GOT_PercFlBoxH 51 // Percentage of total fill height in box // NUMBERS 52 TO 59 RESERVED HERE // These are basic units based how much extra space has been allocated by // the layout to the current box. The individual parts are how the box's // parent group wants to distribute the space. #define GOT_PercExSpaceL 60 // Percentage of extra space left #define GOT_PercExTextL 61 // Percentage of extra text left #define GOT_PercExBodyW 62 // Percentage of extra body width #define GOT_PercExTextR 63 // Percentage of extra text right #define GOT_PercExSpaceR 64 // Percentage of extra space right #define GOT_PercExBoxW 65 // Percentage of total extra width in box #define GOT_PercExSpaceA 66 // Percentage of extra space above #define GOT_PercExTextA 67 // Percentage of extra text above #define GOT_PercExBodyH 68 // Percentage of extra body height #define GOT_PercExTextB 69 // Percentage of extra text below #define GOT_PercExSpaceB 70 // Percentage of extra space below #define GOT_PercExBoxH 71 // Percentage of total extra height in box // These are basic units which are the total amount of extra space // allocated to the box which has not been used yet. #define GOT_PercUnusedW 72 // Percentage of unused extra width #define GOT_PercUnusedH 73 // Percentage of unused extra height // NUMBERS 74 TO 89 RESERVED HERE // These are basic units based on the total current values of the box. // Each of these is the current sum of the std, pad and var modes. #define GOT_PercSpaceL 90 // Percentage of space left width #define GOT_PercTextL 91 // Percentage of text left width #define GOT_PercBodyW 92 // Percentage of body width #define GOT_PercTextR 93 // Percentage of text right width #define GOT_PercSpaceR 94 // Percentage of space right width #define GOT_PercSpaceA 95 // Percentage of space above height #define GOT_PercTextA 96 // Percentage of text above height #define GOT_PercBodyH 97 // Percentage of body height #define GOT_PercTextB 98 // Percentage of text below height #define GOT_PercSpaceB 99 // Percentage of space below height #define GOT_PercUser1 100 // Percentage of the value in user variable 1 #define GOT_PercUser2 101 // Percentage of the value in user variable 2 // NUMBERS 102 TO 107 RESERVED HERE #define GOT_PercBoxW 108 // Percentage of total box width #define GOT_PercBoxH 109 // Percentage of total box width // These are basic units based on the total current std mode values of the box. #define GOT_PercStSpaceL 110 // Percentage of space left width #define GOT_PercStTextL 111 // Percentage of text left width #define GOT_PercStBodyW 112 // Percentage of body width #define GOT_PercStTextR 113 // Percentage of text right width #define GOT_PercStSpaceR 114 // Percentage of space right width #define GOT_PercStSpaceA 115 // Percentage of space above height #define GOT_PercStTextA 116 // Percentage of text above height #define GOT_PercStBodyH 117 // Percentage of body height #define GOT_PercStTextB 118 // Percentage of text below height #define GOT_PercStSpaceB 119 // Percentage of space below height #define GOT_PercStUser1 120 // Percentage of the value in user variable 1 #define GOT_PercStUser2 121 // Percentage of the value in user variable 2 // NUMBERS 122 TO 127 RESERVED HERE #define GOT_PercStBoxW 128 // Percentage of total box width #define GOT_PercStBoxH 129 // Percentage of total box width // These are basic units based on the total current pad mode values of the box. #define GOT_PercPdSpaceL 130 // Percentage of space left width #define GOT_PercPdTextL 131 // Percentage of text left width #define GOT_PercPdBodyW 132 // Percentage of body width #define GOT_PercPdTextR 133 // Percentage of text right width #define GOT_PercPdSpaceR 134 // Percentage of space right width #define GOT_PercPdSpaceA 135 // Percentage of space above height #define GOT_PercPdTextA 136 // Percentage of text above height #define GOT_PercPdBodyH 137 // Percentage of body height #define GOT_PercPdTextB 138 // Percentage of text below height #define GOT_PercPdSpaceB 139 // Percentage of space below height #define GOT_PercPdUser1 140 // Percentage of the value in user variable 1 #define GOT_PercPdUser2 141 // Percentage of the value in user variable 2 // NUMBERS 142 TO 147 RESERVED HERE #define GOT_PercPdBoxW 148 // Percentage of total box width #define GOT_PercPdBoxH 149 // Percentage of total box width // These are basic units based on the total current var mode values of the box. #define GOT_PercVrSpaceL 150 // Percentage of space left width #define GOT_PercVrTextL 151 // Percentage of text left width #define GOT_PercVrBodyW 152 // Percentage of body width #define GOT_PercVrTextR 153 // Percentage of text right width #define GOT_PercVrSpaceR 154 // Percentage of space right width #define GOT_PercVrSpaceA 155 // Percentage of space above height #define GOT_PercVrTextA 156 // Percentage of text above height #define GOT_PercVrBodyH 157 // Percentage of body height #define GOT_PercVrTextB 158 // Percentage of text below height #define GOT_PercVrSpaceB 159 // Percentage of space below height #define GOT_PercVrUser1 160 // Percentage of the value in user variable 1 #define GOT_PercVrUser2 161 // Percentage of the value in user variable 2 // NUMBERS 162 TO 167 RESERVED HERE #define GOT_PercVrBoxW 168 // Percentage of total box width #define GOT_PercVrBoxH 169 // Percentage of total box width // NUMBERS 170 TO 219 RESERVED HERE // COMPLEX UNITS: Have different values for GOM_Std, GOM_Pad, GOM_Var. // These are complex units based on the current values of the box. #define GOT_PercMdSpaceL 220 // Percentage of space left width #define GOT_PercMdTextL 221 // Percentage of text left width #define GOT_PercMdBodyW 222 // Percentage of body width #define GOT_PercMdTextR 223 // Percentage of text right width #define GOT_PercMdSpaceR 224 // Percentage of space right width #define GOT_PercMdSpaceA 225 // Percentage of space above height #define GOT_PercMdTextA 226 // Percentage of text above height #define GOT_PercMdBodyH 227 // Percentage of body height #define GOT_PercMdTextB 228 // Percentage of text below height #define GOT_PercMdSpaceB 229 // Percentage of space below height #define GOT_PercMdUser1 230 // Percentage of the value in user variable 1 #define GOT_PercMdUser2 231 // Percentage of the value in user variable 2 // NUMBERS 232 TO 237 RESERVED HERE #define GOT_PercMdBoxW 238 // Percentage of total box width #define GOT_PercMdBoxH 239 // Percentage of total box width // These are complex units based on the default values for the box. #define GOT_PercDfSpaceL 240 // Percentage of space left width #define GOT_PercDfTextL 241 // Percentage of text left width #define GOT_PercDfBodyW 242 // Percentage of body width #define GOT_PercDfTextR 243 // Percentage of text right width #define GOT_PercDfSpaceR 244 // Percentage of space right width #define GOT_PercDfSpaceA 245 // Percentage of space above height #define GOT_PercDfTextA 246 // Percentage of text above height #define GOT_PercDfBodyH 247 // Percentage of body height #define GOT_PercDfTextB 248 // Percentage of text below height #define GOT_PercDfSpaceB 249 // Percentage of space below height // This is a special type which is used to find the size of another // box. The 'value' part of the typed size is divided into two parts; // the lower 12 bits are the StdID of the box to get the size from, // and the upper 4 bits area one of the following sizes. // Note that these sizes are not computed until after all of the groups // and boxes have been sized, so they are not available when setting // the size of a box or group during layout. #define GOT_BoxSize 255 // All of these return the actual number of pixels. #define GOTB_BoxLeft 0x0000 // Get the box's absolute left position. #define GOTB_BoxTop 0x1000 // Get the box's absolute top position. #define GOTB_BoxWidth 0x2000 // Get the box's absolute width. #define GOTB_BoxHeight 0x3000 // Get the box's absolute height. #define GOTB_BodyLeft 0x4000 // Get the box's absolute body left pos. #define GOTB_BodyTop 0x5000 // Get the box's absolute body top pos. #define GOTB_SpaceLeft 0x6000 // Get the box's absolute spc left size. #define GOTB_TextLeft 0x7000 // Get the box's absolute txt left size. #define GOTB_BodyWidth 0x8000 // Get the box's absolute body width. #define GOTB_TextRight 0x9000 // Get the box's absolute txt rgt size. #define GOTB_SpaceRight 0xA000 // Get the box's absolute spc rgt size. #define GOTB_SpaceAbove 0xB000 // Get the box's absolute spc abv size. #define GOTB_TextAbove 0xC000 // Get the box's absolute txt abv size. #define GOTB_BodyHeight 0xD000 // Get the box's absolute body height. #define GOTB_TextBelow 0xE000 // Get the box's absolute txt blw size. #define GOTB_SpaceBelow 0xF000 // Get the box's absolute spc blw size. #define GO_BSIZE(mode,stdid,which) GO_TSIZE(mode,(which&0xF000)|GETSTDID(stdid),GOT_BoxSize) /** ** Special type for defining a tag which links one gadget to another **/ typedef unsigned long TAGLINK; #define LNKCMD_STARTBIT (0) // ID of command object to create link to. #define LNKCMD_NUMBITS (12) #define LNKTAG_STARTBIT (12) // Lower 20 bits of link tag. #define LNKTAG_NUMBITS (20) // Bit allocation: // // 3 2 2 2 1 1 0 0 0 // 1 8 4 0 6 2 8 4 0 // TTTT TTTT TTTT TTTT TTTT CCCC CCCC CCCC // // T = Tag ID type bits // C = Command ID bits // x = reserved. always set to 0. #define GETLNKCMD(tlink) ((ULONG)( ( ((TAGLINK)(tlink)) >> LNKCMD_STARTBIT ) \ & ((1<<LNKCMD_NUMBITS)-1) )) #define GETLNKTAG(tlink) ((ULONG)( ( ( ((TAGLINK)(tlink)) >> LNKTAG_STARTBIT ) \ & ((1<<LNKTAG_NUMBITS)-1) \ ) | TAG_USER )) #define GO_MAKELINK(tag,cmd) \ ((TAGLINK)( (((ULONG)(tag)&((1<<LNKTAG_NUMBITS)-1))<<LNKTAG_STARTBIT) \ | (((ULONG)(cmd)&((1<<LNKCMD_NUMBITS)-1))<<LNKCMD_STARTBIT) \ )) /*** *** Tags after this number are free for use by the user to pass data *** to custom hook code through the main tag list. ***/ #define GOCT_User (TAG_USER+0xC000) /*** *** These are the GadgetOutline Command Tags that are used in the *** main (first) tag list of an outline command. ***/ #define TAG_OUTLINE_CMDBASE (TAG_USER+0x9000) #define TAG_OUTLINE_TYPEDSIZE (TAG_OUTLINE_CMDBASE+0x100) // These are the position-dependant typed size command tags. They are // sequentially parsed when computing typed sizes. #define GOCT_TextArray (TAG_OUTLINE_TYPEDSIZE+1) /* UBYTE ** * Takes the NULL-terminated array of string pointers (as supplied * to GadTools' Cycle and MX kinds), examines their width and height * in the current font, and sets the GOT_PercText* variables for use * in size tags following this one. * * Default: All values 0 */ #define GOCT_TextList (TAG_OUTLINE_TYPEDSIZE+2) /* struct List * * Takes the list of nodes with ln_Name filled in (as supplied * to GadTools' ListView kind), examines their width and height * in the current font, and sets the GOT_PercText* variables for use * in size tags following this one. * * Default: 0 */ #define GOCT_TextPtr (TAG_OUTLINE_TYPEDSIZE+3) /* UBYTE * * Takes the text string, examines its width and height in the current * font, and sets the GOT_PercText* variables for use in size tags * following this one. * * Default: 0 */ #define GOCT_MoreTextArray (TAG_OUTLINE_TYPEDSIZE+4) /* UBYTE ** * Same as GOCT_TextArray, but continues with dimensions from * the previous time. */ #define GOCT_MoreTextList (TAG_OUTLINE_TYPEDSIZE+5) /* struct List * * Same as GOCT_TextList, but continues with dimensions from * the previous time. */ #define GOCT_MoreTextPtr (TAG_OUTLINE_TYPEDSIZE+6) /* UBYTE * * Same as GOCT_TextPtr, but continues with dimensions from * the previous time. */ #define GOCT_TextArrayTag (TAG_OUTLINE_TYPEDSIZE+7) #define GOCT_TextListTag (TAG_OUTLINE_TYPEDSIZE+8) #define GOCT_TextPtrTag (TAG_OUTLINE_TYPEDSIZE+9) #define GOCT_MoreTextArrayTag (TAG_OUTLINE_TYPEDSIZE+10) #define GOCT_MoreTextListTag (TAG_OUTLINE_TYPEDSIZE+11) #define GOCT_MoreTextPtrTag (TAG_OUTLINE_TYPEDSIZE+12) /* Tag * These work identically to the previous tags, except they get their * pointer to the text/array/list from the specified tag in the * object tag list. Ie, ..., GOCT_TextPtrTag, GTST_String, ... * would get the pointer to a string from the first tag of type * GTST_String in the GadTools tag list. */ #define GOCT_SizeParse (TAG_OUTLINE_TYPEDSIZE+13) /* TYPEDSIZE * Special TypedSize tag used in the ParseTypedSizeList() taglist. */ // TAG NUMBERS 14 TO 29 RESERVED HERE #define GOCT_SizeSpaceLeft (TAG_OUTLINE_TYPEDSIZE+30) /* TYPEDSIZE * Set the amount of space to put between this box and box to the left. * * Default: GO_TSIZE(GOM_AllSet,100,GOT_PercDfSpaceL) */ #define GOCT_SizeTextLeft (TAG_OUTLINE_TYPEDSIZE+31) /* TYPEDSIZE * Set the width of the left text area. * * Default: GO_TSIZE(GOM_AllSet,100,GOT_PercDfTextL) */ #define GOCT_SizeBodyWidth (TAG_OUTLINE_TYPEDSIZE+32) /* TYPEDSIZE * Set the width of the box's body. * * Default: GO_TSIZE(GOM_AllSet,100,GOT_PercDfBodyW) */ #define GOCT_SizeTextRight (TAG_OUTLINE_TYPEDSIZE+33) /* TYPEDSIZE * Set the width of the right text area. * * Default: GO_TSIZE(GOM_AllSet,100,GOT_PercDfTextR) */ #define GOCT_SizeSpaceRight (TAG_OUTLINE_TYPEDSIZE+34) /* TYPEDSIZE * Set the amount of space to put between this box and box to the right. * * Default: GO_TSIZE(GOM_AllSet,100,GOT_PercDfSpaceR) */ #define GOCT_SizeSpaceAbove (TAG_OUTLINE_TYPEDSIZE+35) /* TYPEDSIZE * Set the amount of space to put between this line and the line above it. * * Default: GO_TSIZE(GOM_AllSet,100,GOT_PercDfSpaceA) */ #define GOCT_SizeTextAbove (TAG_OUTLINE_TYPEDSIZE+36) /* TYPEDSIZE * Set the height of the top text area. * * Default: GO_TSIZE(GOM_AllSet,100,GOT_PercDfTextA) */ #define GOCT_SizeBodyHeight (TAG_OUTLINE_TYPEDSIZE+37) /* TYPEDSIZE * Set the line's body height * * Default: GO_TSIZE(GOM_AllSet,100,GOT_PercDfBodyH) */ #define GOCT_SizeTextBelow (TAG_OUTLINE_TYPEDSIZE+38) /* TYPEDSIZE * Set the height of the bottom text area. * * Default: GO_TSIZE(GOM_AllSet,100,GOT_PercDfTextB) */ #define GOCT_SizeSpaceBelow (TAG_OUTLINE_TYPEDSIZE+39) /* TYPEDSIZE * Set the amount of space to put between this line and the line below it. * * Default: GO_TSIZE(GOM_AllSet,100,GOT_PercDfSpaceB) */ #define GOCT_SizeUser1 (TAG_OUTLINE_TYPEDSIZE+40) #define GOCT_SizeUser2 (TAG_OUTLINE_TYPEDSIZE+41) /* TYPEDSIZE * Set user size variables for later use. * * These variables are completely unused by the library, except that * the User1 padding is scaled by the amount of total padding width the * box is scaled, and User2 is similarily scaled by the box's padding * height. * * Default: GO_TSIZE(GOM_AllSet,0,GOT_Pixels) */ // TAG NUMBERS 42 TO 79 RESERVED HERE #define GOCT_SetBoxLeft (TAG_OUTLINE_TYPEDSIZE+80) #define GOCT_SetBoxTop (TAG_OUTLINE_TYPEDSIZE+81) #define GOCT_SetBoxWidth (TAG_OUTLINE_TYPEDSIZE+82) #define GOCT_SetBoxHeight (TAG_OUTLINE_TYPEDSIZE+83) #define GOCT_SetBodyLeft (TAG_OUTLINE_TYPEDSIZE+84) #define GOCT_SetBodyTop (TAG_OUTLINE_TYPEDSIZE+85) #define GOCT_SetSpaceLeft (TAG_OUTLINE_TYPEDSIZE+86) #define GOCT_SetTextLeft (TAG_OUTLINE_TYPEDSIZE+87) #define GOCT_SetBodyWidth (TAG_OUTLINE_TYPEDSIZE+88) #define GOCT_SetTextRight (TAG_OUTLINE_TYPEDSIZE+89) #define GOCT_SetSpaceRight (TAG_OUTLINE_TYPEDSIZE+90) #define GOCT_SetSpaceAbove (TAG_OUTLINE_TYPEDSIZE+91) #define GOCT_SetTextAbove (TAG_OUTLINE_TYPEDSIZE+92) #define GOCT_SetBodyHeight (TAG_OUTLINE_TYPEDSIZE+93) #define GOCT_SetTextBelow (TAG_OUTLINE_TYPEDSIZE+94) #define GOCT_SetSpaceBelow (TAG_OUTLINE_TYPEDSIZE+95) /* TYPEDSIZE * Directly set box's final dimensions. * * These are used to directly set a box's dimensions as shown in * its BoxAttr structure. They are parsed after the gadgets have * been fully layed out, for every command which has a BoxAttr. * * Note that there is some redundancy in the dimension information * between the total box size, the body position and the individual * size components. You may enter "-1" into any of the dimensions * that you do not care about; they will then be computed from the * other dimension information or default to 0. * * Default: Boxes and Groups start with everything filled in * correctly from the layout; Images start with everything * set to -1. */ // These are mostly position-independant command tags [at least in the sense // that their position relative to the typed size tags doesn't matter. :)] // However, all of these tags can be included multiple times and some pairs // may been to be grouped together, as described for those specific tags. #define TAG_OUTLINE_MULTITAG (TAG_OUTLINE_CMDBASE+0x200) #define GOCT_AddTagLink (TAG_OUTLINE_MULTITAG+0) /* TAGLINK * Add a link from this cmd's secondary tag list to another cmd's object. * * For every one of these tags in the cmd's tag list, space is reserved * in the secondary tag list for a single tag. At the time that the * objects are being created, these links are filled in with the * address of the object that the link points to. If any of the links * point to a object that hasn't been created yet, the creation of * the current object is delayed. If it is imposible to resolve * all of the links (ie, two object pointing to each other), then * neither of the objects will be created. * * Multiple instances of this tag may occur. * * Default: No links. */ #define GOCT_LinkFromTag (TAG_OUTLINE_MULTITAG+1) /* Tag * Specify the secondary tag that will point to a object in the outline. */ #define GOCT_LinkToStdID (TAG_OUTLINE_MULTITAG+2) /* ULONG * Specify the standard CmdID the previously specified tag will point to. * * This pair of tags operates identically to the GOCT_AddTagLink tag, * except it allows the full tag value to be specified. * * This pair of tags is used to create a link between objects. * They must come in the exact order: * ..., GOCT_LinkFromTag, TagItem, GOCT_LinkToStdID, StdID, ... * * Multiple instances of this tag pair may occur. * * Default: No links. */ #define GOCT_CopyFromTSize (TAG_OUTLINE_MULTITAG+3) /* TYPEDSIZE * Specify a TypedSize value to copy from... */ #define GOCT_CopyTSizeToTag (TAG_OUTLINE_MULTITAG+4) /* TAG * Specify the Tag the previously specified value will be copied to. * * Multiple instances of this tag pair may occur. These are used * to put a value into a tag in the secondary list before any * processing is done on the command to compute its dimensions. * These tags are processed immediately before sending the * CHM_GETMINDIMENS message to the command's hook. * * These must come in the exact order: * ..., GOCT_CopyFromTSize, TypedSize, GOCT_CopyTSizeToTag, Tag, ... * * Default: Nothing copied. */ #define GOCT_CopyUser1ToTag (TAG_OUTLINE_MULTITAG+5) #define GOCT_CopyUser2ToTag (TAG_OUTLINE_MULTITAG+6) /* Tag * Copy the current value in the User1 variable to the given * tag in the secondary tag list. * * Multiple instances of these tags may occur. They are always * processed after all of the variable-spacing typed size tags * have been processed. [Ie, when the final positions of the * objects are finally being computed.] The value copied is the * sum of the std, pad and var components of the user variable. * * Default: Nothing copied. */ // TAG NUMBERS 7 TO 29 RESERVED HERE #define GOCT_CopyScreen (TAG_OUTLINE_MULTITAG+30) #define GOCT_CopyWindow (TAG_OUTLINE_MULTITAG+31) #define GOCT_CopyDrawInfo (TAG_OUTLINE_MULTITAG+32) #define GOCT_CopyDrawPens (TAG_OUTLINE_MULTITAG+33) #define GOCT_CopyVisualInfo (TAG_OUTLINE_MULTITAG+34) #define GOCT_CopyTextAttr (TAG_OUTLINE_MULTITAG+35) #define GOCT_CopyTextFont (TAG_OUTLINE_MULTITAG+36) /* Tag * Copy global GadOutline information into a tag. * * Multiple instances of these tags may occur. These are processed * before the gadgets are first created on a window. They are * used to supply extra information to BOOPSI gadgets about the * screen and window they will be rendering into. * * Default: Nothing copied. */ // The rest of the tags can only occur once; if any occur both in the // GO_COMMANDTAGS() global list and in the command's actual list, the // command's list takes precedence. // These are the standard command tags. #define TAG_OUTLINE_COMMAND (TAG_OUTLINE_CMDBASE+0x800) #define GOCT_SetUserHook (TAG_OUTLINE_COMMAND+0) /* struct Hook * * Set the user hook function for this command. * If NULL, only use system function. * * Default: NULL */ #define GOCT_SetUserHookData (TAG_OUTLINE_COMMAND+1) /* ULONG * Set initial value for ci_UserHookData. * * Default: NULL */ #define HOTKEY_NOTRANS (1<<31) // Don't translate given character into // upper- and lower-case versions. #define HOTKEY_UPONLY (1<<30) // Assign only the upper-case version of // this character to the command. #define HOTKEY_LOWONLY (1<<29) // Assign only the lower-case version of // this character to the command. #define HOTKEY_NONE (HOTKEY_UPONLY | HOTKEY_LOWONLY) // Don't assign any hotkey. #define HOTKEY_CHARACTER (0xFF) // Mask for the actual character. #define GOCT_SetHotKey (TAG_OUTLINE_COMMAND+2) /* ULONG * Define a hotkey for this command. * * Accepts an ASCII code which is to be assigned as this command's * hotkey. Whenever this key is pressed [and, if only RAWKEY * events are being reported, when it is released], a CHM_HOTKEY * event will be sent to the command. An ASCII value of 0 is * interpreted as 'let the command assign a hotkey for me.' * The standard GadTools hook supports this by looking for the * underlined character in a label and using that as the key. * * Default: No hot key. */ #define GOCT_SetHotKeyCmd (TAG_OUTLINE_COMMAND+3) /* CMDID * Define actual command which recieves hotkeys for this command. * * This tag provides a way for you to 'redirect' hotkeys. It is * primarily intended for you to use a GadTools gadget to render * the text describing another gadget - the text gadget is created * with an underline for the appropriate hotkey. This gadget * then has the tag GOCT_SetHotKey, 0 so that the hotkey is * automatically assigned, and GOCT_SetHotKeyCmd with the CmdID * of the actually command which is to recieve these hotkey events. * * Note that only one level of this indirection is supported. * * Default: ID of this command */ // These are command tags for boxes and groups. (GOK_Box, GOK_Group) #define TAG_OUTLINE_BOX (TAG_OUTLINE_CMDBASE+0x900) #define GOCT_BoxPosInfo (TAG_OUTLINE_BOX+0) /* struct BoxPosInfo * * Supplies the address to a valid 'BoxPosInfo' structure, which * will be filled in with the current size of this box during * a Resize. If the address is ~0, the library will allocate * this structure. * * Default: 0 */ #define GOCT_IgnoreMinDimens (TAG_OUTLINE_BOX+1) /* BOOL * If TRUE, ignore this command's dimensions when computing the * minimum dimensions needed for the layout. * * Default: FALSE */ #define GOCT_IgnoreFinDimens (TAG_OUTLINE_BOX+2) /* BOOL * If TRUE, ignore this command's dimensions when computing the * final dimensions/spacing of the layout. * * Default: FALSE */ #define GOCT_IgnoreCreation (TAG_OUTLINE_BOX+3) /* BOOL * If TRUE, do not actually create the object. * * Default: FALSE */ // These are for groups only. #define TAG_OUTLINE_GROUP (TAG_OUTLINE_CMDBASE+0xA00) #define GOCT_FrameGroup (TAG_OUTLINE_GROUP+130) /* BOOL * If TRUE, any minimum dimensions in this group's outside space area * (ie, SpaceAbove, SpaceBelow, SpaceLeft and SpaceRight), is reserved * only for the group, and any boxes or groups within it are positioned * inside of this area. By default this space is zero, so you will have * to use the GOCT_SizeSpaceLeft, etc. tags to make this space show up. * * Default: TRUE */ #define GOCT_AutoDistExtra (TAG_OUTLINE_GROUP+131) /* BOOL * If TRUE, the extra space created by the difference between the box's * dimensions and its parent group's minimum dimensions are distributed * in the box to make it match the group. * * Default: FALSE */ #define GOCT_FitToGroup (TAG_OUTLINE_GROUP+132) /* BOOL * If TRUE, this box's minimum dimensions are stretched to match * its parent group's minimum dimensions. * * Default: FALSE */ #define GOCT_EvenDistGroup (TAG_OUTLINE_GROUP+133) /* BOOL * If TRUE, the boxes within the group will be forced to all have * the same size across the group's weight dimension. [Ie, the * vertical component within a vertical group.] * In other words, all the boxes within a vertical group will * be given the same height, constrained by the largest box. * * Default: FALSE */ /** ** ---------------------------------------------------------- ** GadOutline drawing definitions. ** ---------------------------------------------------------- **/ /** ** This is the type used by most of the drawing commands that take ** coordinates as arguments. It contains at most a pen to draw in ** plus two coordinate pairs and a mode which controls how the ** coordinates are interpreted, although how much of this is actually ** used is command-specific. **/ typedef unsigned long DRAWPNT; #define PNTY2_STARTBIT (0) #define PNTY2_NUMBITS (6) #define PNTX2_STARTBIT (6) #define PNTX2_NUMBITS (6) #define PNTY1_STARTBIT (12) #define PNTY1_NUMBITS (6) #define PNTX1_STARTBIT (18) #define PNTX1_NUMBITS (6) #define PNTPEN_STARTBIT (24) #define PNTPEN_NUMBITS (4) #define PNTMODE_STARTBIT (28) #define PNTMODE_NUMBITS (4) // Bit allocation: // // 3 2 2 2 1 1 0 0 0 // 1 8 4 0 6 2 8 4 0 // MMMM PPPP xxxx xxyy yyyy XXXX XXYY YYYY // // M = Mode bits // P = Pen bits // x = x1 coord bits // y = y1 coord bits // X = x2 coord bits // Y = y2 coord bits #define GETPNTY2(drawpnt) ((UBYTE)( ( ((DRAWPNT)(drawpnt)) >> PNTY2_STARTBIT ) \ & ((1<<PNTY2_NUMBITS)-1) )) #define GETPNTX2(drawpnt) ((UBYTE)( ( ((DRAWPNT)(drawpnt)) >> PNTX2_STARTBIT ) \ & ((1<<PNTX2_NUMBITS)-1) )) #define GETPNTY1(drawpnt) ((UBYTE)( ( ((DRAWPNT)(drawpnt)) >> PNTY1_STARTBIT ) \ & ((1<<PNTY1_NUMBITS)-1) )) #define GETPNTX1(drawpnt) ((UBYTE)( ( ((DRAWPNT)(drawpnt)) >> PNTX1_STARTBIT ) \ & ((1<<PNTX1_NUMBITS)-1) )) #define GETPNTPEN(drawpnt) ((UBYTE)( ( ((DRAWPNT)(drawpnt)) >> PNTPEN_STARTBIT ) \ & ((1<<PNTPEN_NUMBITS)-1) )) #define GETPNTMODE(drawpnt) ((UBYTE)( ( ((DRAWPNT)(drawpnt)) >> PNTMODE_STARTBIT ) \ & ((1<<PNTMODE_NUMBITS)-1) )) #define GO_DRAWPNT(mode,pen,x1,y1,x2,y2) \ ((DRAWPNT)( (((ULONG)(mode)&((1<<PNTMODE_NUMBITS)-1))<<PNTMODE_STARTBIT) \ | (((ULONG)(pen)&((1<<PNTPEN_NUMBITS)-1))<<PNTPEN_STARTBIT) \ | (((UWORD)(x1)&((1<<PNTX1_NUMBITS)-1))<<PNTX1_STARTBIT) \ | (((UWORD)(y1)&((1<<PNTY1_NUMBITS)-1))<<PNTY1_STARTBIT) \ | (((UWORD)(x2)&((1<<PNTX2_NUMBITS)-1))<<PNTX2_STARTBIT) \ | (((UWORD)(y2)&((1<<PNTY2_NUMBITS)-1))<<PNTY2_STARTBIT) \ )) #define SCALE_MODE (0x0) #define PIXEL_MODE (0x1) #define GO_SCLPNT(pen,x1,y1,x2,y2) \ GO_DRAWPNT(SCALE_MODE,pen,x1,y1,x2,y2) #define PX1(x) (((UWORD)x)&((1<<(PNTX1_NUMBITS-1))-1)) #define PX2(x) ( (((UWORD)x)&((1<<(PNTX1_NUMBITS-1))-1)) | (1<<(PNTX1_NUMBITS-1)) ) #define PY1(y) (((UWORD)y)&((1<<(PNTY1_NUMBITS-1))-1)) #define PY2(y) ( (((UWORD)y)&((1<<(PNTY1_NUMBITS-1))-1)) | (1<<(PNTY1_NUMBITS-1)) ) #define GO_PIXPNT(pen,x1,y1,x2,y2) \ GO_DRAWPNT(PIXEL_MODE,pen,x1,y1,x2,y2) #define TAG_OUTLINE_DRAWBASE (TAG_USER+0xA000) // Commands to control drawing pens. #define TAG_OUTLINE_PENBASE (TAG_OUTLINE_DRAWBASE+1) #define GODT_SetPen0 TAG_OUTLINE_PENBASE+0 #define GODT_SetPen1 TAG_OUTLINE_PENBASE+1 #define GODT_SetPen2 TAG_OUTLINE_PENBASE+2 #define GODT_SetPen3 TAG_OUTLINE_PENBASE+3 #define GODT_SetPen4 TAG_OUTLINE_PENBASE+4 #define GODT_SetPen5 TAG_OUTLINE_PENBASE+5 #define GODT_SetPen6 TAG_OUTLINE_PENBASE+6 #define GODT_SetPen7 TAG_OUTLINE_PENBASE+7 #define GODT_SetPen8 TAG_OUTLINE_PENBASE+8 #define GODT_SetPen9 TAG_OUTLINE_PENBASE+9 #define GODT_SetPen10 TAG_OUTLINE_PENBASE+10 #define GODT_SetPen11 TAG_OUTLINE_PENBASE+11 #define GODT_SetPen12 TAG_OUTLINE_PENBASE+12 #define GODT_SetPen13 TAG_OUTLINE_PENBASE+13 #define GODT_SetPen14 TAG_OUTLINE_PENBASE+14 #define GODT_SetPen15 TAG_OUTLINE_PENBASE+15 // Synonyms #define GODT_SetDetailPen TAG_OUTLINE_PENBASE+DETAILPEN #define GODT_SetBlockPen TAG_OUTLINE_PENBASE+BLOCKPEN #define GODT_SetTextPen TAG_OUTLINE_PENBASE+TEXTPEN #define GODT_SetShinePen TAG_OUTLINE_PENBASE+SHINEPEN #define GODT_SetShadowPen TAG_OUTLINE_PENBASE+SHADOWPEN #define GODT_SetFillPen TAG_OUTLINE_PENBASE+FILLPEN #define GODT_SetFillTextPen TAG_OUTLINE_PENBASE+FILLTEXTPEN #define GODT_SetBackgroundPen TAG_OUTLINE_PENBASE+BACKGROUNDPEN #define GODT_SetHighlightTextPen TAG_OUTLINE_PENBASE+HIGHLIGHTTEXTPEN #define GODT_SetDrI9Pen TAG_OUTLINE_PENBASE+9 #define GODT_SetDrI10Pen TAG_OUTLINE_PENBASE+10 #define GODT_SetDrI11Pen TAG_OUTLINE_PENBASE+11 #define GODT_SetDrI12Pen TAG_OUTLINE_PENBASE+12 #define GODT_SetDrI13Pen TAG_OUTLINE_PENBASE+13 #define GODT_SetDrI14Pen TAG_OUTLINE_PENBASE+14 #define GODT_SetDrI15Pen TAG_OUTLINE_PENBASE+15 /* ULONG * Set the color of a standard system pen. * * These pens correspond to the screen's DrawInfo pens, and are * initialized to the values there before starting the draw. * Pen0 and Pen1 are special in that they coorespond to the RastPort's * A and B pens, in that they are the pens used by drawing commands that * don't take an explicit pen specification. */ // TAG NUMBERS 16 TO 29 RESERVED HERE #define GODT_SetDrawInfo (TAG_OUTLINE_PENBASE+30) /* struct DrawInfo * * Supply a custom DrawInfo. * * Extracts information from the given DrawInfo to be used in * the drawing. Currently all this does is extract the dri_Pens, * although more could be done in the future. * * A NULL will reset from the GadOutline's go_DrI. * * Default: Use go_DrI */ #define GODT_SetDrawPens (TAG_OUTLINE_PENBASE+31) /* UWORD * * Set pens from the given pen array. * * Takes a ~0 terminated pen array and sets the drawing's pens * based on it. If the array ends before all of the pens have * been set, the remaining pens will be unchanged. * * Default: Use go_DrI->dri_DrawPens */ // TAG NUMBERS 32 TO 34 RESERVED HERE #define GODT_SetCompPenMap (TAG_OUTLINE_PENBASE+35) /* UWORD * * Set compliment pen mapping from the given array. * * Takes a ~0 terminated array and sets the drawing's compliment * pen map based on it. If the array ends before all of the pens * have been set, the remaining pens will be unchanged. * * Default Compliment map: * DETAILPEN --> BLOCKPEN * BLOCKPEN --> DETAILPEN * TEXTPEN --> BACKGROUNDPEN * SHINEPEN --> SHADOWPEN * SHADOWPEN --> SHINEPEN * FILLPEN --> FILLTEXTPEN * FILLTEXTPEN --> FILLPEN * BACKGROUNDPEN --> TEXTPEN * HIGHLIGHTTEXTPEN --> BACKGROUNDPEN */ #define GODT_SetUserPenMap (TAG_OUTLINE_PENBASE+36) /* UWORD * * Set user pen mapping from the given array. * * Takes a ~0 terminated array and sets the drawing's user * pen map based on it. If the array ends before all of the pens * have been set, the remaining pens will be unchanged. * * Default user map: * DETAILPEN --> DETAILPEN * BLOCKPEN --> BLOCKPEN * TEXTPEN --> TEXTPEN * SHINEPEN --> SHINEPEN * SHADOWPEN --> SHADOWPEN * FILLPEN --> FILLPEN * FILLTEXTPEN --> FILLTEXTPEN * BACKGROUNDPEN --> BACKGROUNDPEN * HIGHLIGHTTEXTPEN --> HIGHLIGHTTEXTPEN */ #define GODT_SetHighPenMap (TAG_OUTLINE_PENBASE+37) /* UWORD * * Set highlight pen mapping from the given array. * * Takes a ~0 terminated array and sets the drawing's highlight * pen map based on it. If the array ends before all of the pens * have been set, the remaining pens will be unchanged. * * Default Highlight map: * DETAILPEN --> BLOCKPEN * BLOCKPEN --> DETAILPEN * TEXTPEN --> FILLTEXTPEN * SHINEPEN --> SHADOWPEN * SHADOWPEN --> SHINEPEN * FILLPEN --> BACKGROUNDPEN * FILLTEXTPEN --> TEXTPEN * BACKGROUNDPEN --> FILLPEN * HIGHLIGHTTEXTPEN --> FILLTEXTPEN */ #define GODT_SetInactPenMap (TAG_OUTLINE_PENBASE+38) /* UWORD * * Set inactive pen mapping from the given array. * * Takes a ~0 terminated array and sets the drawing's inactive * pen map based on it. If the array ends before all of the pens * have been set, the remaining pens will be unchanged. * * Default Inactive map: * DETAILPEN --> DETAILPEN * BLOCKPEN --> BLOCKPEN * TEXTPEN --> TEXTPEN * SHINEPEN --> BACKGROUNDPEN * SHADOWPEN --> SHADOWPEN * FILLPEN --> BACKGROUNDPEN * FILLTEXTPEN --> TEXTPEN * BACKGROUNDPEN --> BACKGROUNDPEN * HIGHLIGHTTEXTPEN --> TEXTPEN */ // TAG NUMBERS 39 TO 42 RESERVED HERE #define GO_MAPPEN(from,to) ( ((from)<<16) | ((to)&0xFFFF) ) #define GODT_MapCompPen (TAG_OUTLINE_PENBASE+43) #define GODT_MapUserPen (TAG_OUTLINE_PENBASE+44) #define GODT_MapHighPen (TAG_OUTLINE_PENBASE+45) #define GODT_MapInactPen (TAG_OUTLINE_PENBASE+46) /* ULONG * Set a single pen map entry. * * Sets the single pen map entry in the upper 16 bits to the * pen in the lower 16. * Ex: * ..., GODT_MapUserPen, GO_MAPPEN(DETAILPEN,FILLPEN), ... * Would cause the DETAILPEN to be mapped to the FILLPEN when * the user map is turned on. */ // TAG NUMBERS 45 TO 49 RESERVED HERE // Standard flag control #define FLGSET(flg) ( ((ULONG)(flg))<<16 ) // Flag control bit #define FLGON(flg) ( FLGSET(flg) | (flg) ) // Set the given flag #define FLGOFF(flg) ( FLGSET(flg) | 0 ) // Clear the given flag #define FLGTOG(flg) ( (flg) ) // Toggle the given flag #define FLGALL(msk) ( 0xFFFF0000 | (msk) ) // Directly set all flags #define GODT_SetRastMode (TAG_OUTLINE_PENBASE+50) /* UBYTE * Set the rastport drawing mode for all operations. * * Can be combinations of JAM1, JAM2, COMPLEMENT, INVERSVID * as per SetDrMd(). Use FLGON(x) to set each flag and * FLGOFF(X) to clear them. You can directly set every flag * using the macro SETALL(x), with x being the desired flag * states. * * Default: JAM1 */ #define DRWMD_INACTIVE (0x8000) // Swap pens to create inactive state. #define DRWMD_HIGHLIGHT (0x4000) // Swap pens to create highlight effect. #define DRWMD_USERMAP (0x2000) // Do user mapping of pens. #define DRWMD_COMPLIMENT (0x1000) // Swap pens to get compliment. #define GODT_SetDrawMode (TAG_OUTLINE_PENBASE+51) /* UBYTE * Set the GadOutline drawing mode for all operations. * * Can be combinations of: * DRWMD_INACTIVE, DRWMD_HIGHLIGHT, DRWMD_USER, DRWMD_COMPLIMENT * * GOSD_BoopsiIm and GOSD_BoopsiGad drawing objects will automatically * set the DRWMD_INACTIVE and DRWMD_HIGHLIGHT flags based on the draw * state requested by Intuition. The pens are mapped in order from * DRWMD_INACTIVE to DRWMD_COMPLEMENT; so, if every map is turned on, * the pen used will be: dripen[inact[high[user[comp[reqpen]]]]]. * * Use FLGON(x) to set each flag and FLGOFF(X) to clear them. You can * directly set every flag using the macro SETALL(x), with x being the * desired flag states. * * Default: 0 */ #define GODT_ChooseBPen (TAG_OUTLINE_PENBASE+52) /* UWORD * Choose standard pen to be used as 'B Pen' in drawing operations * which refer to this pen. * * Default: BACKGROUNDPEN (7) */ #define GODT_SetStdDrawPat (TAG_OUTLINE_PENBASE+53) /* ULONG * Set the line drawing pattern for all operations. * * Accepts an integer which is a standard line pattern. * Currently only understand 0, which resets the pattern * to 0xFFFF, but in the future other defaults may be defined * for real patterns along with pens, draw modes, etc for them. * * Default: 0 */ #define GODT_SetCustDrawPat (TAG_OUTLINE_PENBASE+54) /* UWORD * Set the line drawing pattern for all operations. * * Accepts a 16-bit value which is the new pattern to use. * * Default: 0xFFFF */ #define FLPAT_CLEAR (0) // No pattern. #define FLPAT_HASH2 (1) // 2 x 2 hash pattern. #define FLPAT_DISABLED (2) // 4 x 2 standard intuition disabled pattern. #define GODT_SetStdFillPat (TAG_OUTLINE_PENBASE+55) /* ULONG * Set the area filling pattern for all operations. * * Accepts an integer which is a standard fill pattern. * Currently only understands the three fill patterns * defined above. * * Default: 0 */ #define GODT_SetCustFillPat2 (TAG_OUTLINE_PENBASE+56) /* ULONG * Set the area filling pattern for all operations. * * Accepts a 32-bit value which is the two lines of a new * 16 x 2 fill pattern to use. The upper 16 bits are the * first line and the lower 16 are the second. * * Default: 0xFFFFFFFF */ #define GODT_SetCustFillPat4A (TAG_OUTLINE_PENBASE+57) #define GODT_SetCustFillPat4B (TAG_OUTLINE_PENBASE+58) /* ULONG * Set the area filling pattern for all operations. * * Accepts a 32-bit value which is one-half of the 4 lines of * a new 16 x 4 fill pattern to use. A assigns the upper two * lines, and B assigns the lower two. The tags MUST be used * as a pair; never make assumptions about what an unspecified * piece will default to. */ // TAG NUMBERS 59 TO 69 RESERVED HERE #define GO_BOXBOUNDS(x1,y1,x2,y2) \ ( ((x1&0xF)<<12) | ((y1&0xF)<<8) | ((x2&0xF)<<4) | ((y2&0xF)<<0) ) #define GO_FRMBOUNDS(x1,y1,x2,y2,x3,y3,x4,y4) \ ( (GO_BOXBOUNDS(x3,y3,x4,y4)<<16) | GO_BOXBOUNDS(x1,y1,x2,y2) ) #define GODT_ResetBounds (TAG_OUTLINE_PENBASE+70) /* ULONG [See GO_BOXBOUNDS and GO_FRMBOUNDS macros.] * Set current drawing boundaries to box dimensions. * * The ULONG is divided into 8 4 bit values; the lower * 16 bits specify the corners of a standard boundary box * and the upper 16 bits, if not zero, create a frame box. * Valid x and y values are from 1 to 5, corresponding * to the left/above space, left/above text, width/height, * right/below text and right/below space. * * If the upper 16 bits are zero, The boundaries are reset * back to a box based on this environment's BoxAttr. * If the upper 16 bits are non-zero, a frame is created; * the top/left parts of the frame are specified from the * lower 16 bits and the bottom/right is from the upper 16. * NO BOUNDARY CHECKING IS DONE ON THESE VALUES! * * Ex: GO_BOXBOUNDS(3,3,3,3) - set to body area * GO_BOXBOUNDS(1,1,5,5) - set to box area * GO_FRMBOUNDS(1,1,1,1, 5,5,5,5) - set to space area frame. * * Note that frame boundary types are only partially supported. In * particular, when drawing text using frame boundaries, if the * cursor is positioned in the right/bottom part of the frame, it * will be reset back to (0,0) before drawing the text and the text * width/height will only be constrained by the top/left part of the * frame. */ #define GODT_SetLeftBound (TAG_OUTLINE_PENBASE+71) #define GODT_SetTopBound (TAG_OUTLINE_PENBASE+72) #define GODT_SetRightBound (TAG_OUTLINE_PENBASE+73) #define GODT_SetBottomBound (TAG_OUTLINE_PENBASE+74) #define GODT_SetWidthBound (TAG_OUTLINE_PENBASE+75) #define GODT_SetHeightBound (TAG_OUTLINE_PENBASE+76) /* TYPEDSIZE * Set the specified boundary to an exact amount. * * The boundary is moved by the number of pixels that the * typed size evaluates to. Note that it is entirely * possible for this to move the boundary outside of the * current BoxAttr. Use the typed size mode GOM_Add to * move the box boundary relative to its current postion. * * GODT_SetLeftBound and GODT_SetTopBound will always leave * intact the previous Width/Height or Right/Bottom bound that * was set. For example, if you set the right bound and then * the left, the width will change to keep the same right bound. * However, if you instead set the width and then the left edge, * the right bound will change to keep the same width. * * If the current boundary is a frame, it will be turned * into a standard box by this command. */ // TAG NUMBERS 77 TO 79 RESERVED HERE #define GODT_SetCursorX (TAG_OUTLINE_PENBASE+80) #define GODT_SetCursorY (TAG_OUTLINE_PENBASE+81) /* TYPEDSIZE * Set the cursor position to an exact amount. * * The cursor is moved by the number of pixels that the * typed size evaluates to. Its position will be limited * to the current boundary limits. */ // TAG NUMBERS 82 TO 89 RESERVED HERE #define TXTMD_LEFT (0x0000) // Justify left. #define TXTMD_RIGHT (0x0001) // Justify right. #define TXTMD_CENTER (0x0002) // Center text. #define TXTMD_X (0x0003) #define SETMD_X(mode) ( FLGSET(TXTMD_X) | (mode) ) #define TXTMD_ENDRIGHT (0x0000) // Finish with cursor at rightmost point #define TXTMD_ENDLEFT (0x0004) // Finish with cursor at leftmost point #define TXTMD_ENDCENTER (0x0008) // Finish with cursor at center point #define TXTMD_END (0x000C) #define SETMD_END(mode) ( FLGSET(TXTMD_END) | (mode) ) #define TXTMD_RELCENTER (0x0000) // Y coordinate is center of text #define TXTMD_RELTOP (0x0010) // Y coordinate is top of text #define TXTMD_RELBOTTOM (0x0020) // Y coordinate is bottom of text #define TXTMD_RELBASE (0x0030) // Y coordinate is baseline of text #define TXTMD_Y (0x00F0) #define SETMD_Y(mode) ( FLGSET(TXTMD_Y) | (mode) ) #define TXTMD_CHOPLEFT (0x0100) // Chop text on left rather than right #define TXTMD_REVCOLOR (0x0200) // Reverse text A and B colors #define GODT_SetTextMode (TAG_OUTLINE_PENBASE+90) /* UWORD * Set the positioning mode for drawing text. * * Can be combinations of: * One of TXTMD_LEFT, TXTMD_RIGHT, TXTMD_CENTER; * One of TXTMD_ENDLEFT, TXTMD_ENDRIGHT, TXTMD_ENDCENTER; * One of TXTMD_RELTOP, TXTMD_RELBOTTOM, TXTMD_RELCENTER, TXTMD_RELBASE; * Plus TXTMD_CHOPLEFT and TXTMD_REVCOLOR. * * Use FLGON(x) to set each flag and FLGOFF(X) to clear them. You can * directly set every flag using the macro SETALL(x), with x being the * desired flag states. * * Default: 0 */ #define GODT_ChooseTextAPen (TAG_OUTLINE_PENBASE+91) /* UWORD * Choose standard pen to be used as 'A Pen' in text drawing operations. * * Default: TEXTPEN (2) */ #define GODT_ChooseTextBPen (TAG_OUTLINE_PENBASE+92) /* UWORD * Choose standard pen to be used as 'B Pen' in text drawing operations. * * Default: BACKGROUNDPEN (7) */ // Low-level drawing commands #define TAG_OUTLINE_LOWDRAWCMD (TAG_OUTLINE_DRAWBASE+0x100) #define GODT_SetOrigin (TAG_OUTLINE_LOWDRAWCMD+1) /* DRAWPNT * Sets the origins for later use by PIXEL_MODE draw points. * * Resets the pixel-mode's origin1 and origin2 to * (x1,y1) and (x2,y2), respectively. [This is the only * command that modifies the pixel-mode origin.] * * pen is ignored - always set to zero. */ #define GODT_WritePixel (TAG_OUTLINE_LOWDRAWCMD+2) /* DRAWPNT * Write a pixel at the location (x1,y1) in the given color. * x2 and y2 are ignored - always set to zero. */ #define GODT_WritePixel2 (TAG_OUTLINE_LOWDRAWCMD+3) /* DRAWPNT * Write a pixel at the location (x1,y1) and another pixel at * location (x2,y2), both in the given color. */ #define GODT_MoveTo (TAG_OUTLINE_LOWDRAWCMD+4) /* DRAWPNT * Move cursor to location (x1,y1). * * x2, y2 and pen are ignored - always set to zero. */ #define GODT_DrawTo (TAG_OUTLINE_LOWDRAWCMD+5) /* DRAWPNT * Draw a line from current cursor location to location (x1,y1) * in current pen. Leaves cursor at location(x1,y1). * x2 and y2 are ignored - always set to zero. */ #define GODT_DrawTo2 (TAG_OUTLINE_LOWDRAWCMD+6) /* DRAWPNT * Draw a line from current cursor location to location (x1,y1) * and then another from there to (x2,y2), all in current pen. * Leaves cursor at location (x2,y2). */ #define GODT_DrawLine (TAG_OUTLINE_LOWDRAWCMD+7) /* DRAWPNT * Draw a line from location (x1,y1) to location (x2,y2) * in the current pen. */ #define GODT_DrawRect (TAG_OUTLINE_LOWDRAWCMD+8) /* DRAWPNT * Draw an unfilled rectangle with top-left corner at * location (x1,y1) and bottom-right corner at (x2,y2), * in given pen. */ #define GODT_DrawEllipse (TAG_OUTLINE_LOWDRAWCMD+9) /* DRAWPNT * Draw an unfilled ellipse with top-left corner at * location (x1,y1) and bottom-right corner at (x2,y2), * in given pen. */ // TAG NUMBERS 10 TO 29 RESERVED HERE #define GODT_FillRect (TAG_OUTLINE_LOWDRAWCMD+30) /* DRAWPNT * Draw a filled rectangle with top-left corner at * location (x1,y1) and bottom-right corner at (x2,y2), * in given pen. */ #define GODT_EraseRect (TAG_OUTLINE_LOWDRAWCMD+31) /* DRAWPNT * Clear a rectangle with top-left corner at * location (x1,y1) and bottom-right corner at (x2,y2). * pen is ignored - always set to zero. * You will commonly start your drawing with a: * GODT_ClearRect, GO_DRAWPNT(0,0,0,127,127), ... */ #define GODT_FillEllipse (TAG_OUTLINE_LOWDRAWCMD+32) /* DRAWPNT * Draw a filled ellipse with top-left corner at * location (x1,y1) and bottom-right corner at (x2,y2), * in given pen. */ #define GODT_AreaStart (TAG_OUTLINE_LOWDRAWCMD+33) /* DRAWPNT * Move to location (x1,y1) to start defining an area. * x2 and y2 and pen are ignored - always set to zero. */ #define GODT_AreaMoveTo (TAG_OUTLINE_LOWDRAWCMD+34) /* DRAWPNT * Move the current area position to location (x1,y1) of * an area definition that was started with above command. * x2 and y2 and pen are ignored - always set to zero. */ #define GODT_AreaDrawTo (TAG_OUTLINE_LOWDRAWCMD+35) /* DRAWPNT * Add a line from current area position to location (x1,y1) * into an area definition that was started with above command. * x2 and y2 and pen are ignored - always set to zero. */ #define GODT_AreaDrawTo2 (TAG_OUTLINE_LOWDRAWCMD+36) /* DRAWPNT * Add a line from current area position to location (x1,y1) * and then from there to (x2,y2) into an area definition that * was started with GODT_AreaStart command. * pen is ignored - always set to zero. */ #define GODT_AreaFill (TAG_OUTLINE_LOWDRAWCMD+37) /* DRAWPNT * Fill in area defined by previous tags with color pen. * x1, y1 and x2, y2 are ignored - always set to zero. */ // TAG NUMBERS 38 TO 49 RESERVED HERE #define GODT_DrawStdFrame (TAG_OUTLINE_LOWDRAWCMD+50) /* DRAWPNT * Draw a standard 2.0-style 3D frame with corners at * (x1,y1) and (x2,y2). The top-left side is drawn * in the given pen color, and the bottom-right in its * compliment. So a pen of SHINEPEN will produce a * raised frame and SHADOWPEN a recessed one. */ #define GODT_DrawStrFrame (TAG_OUTLINE_LOWDRAWCMD+51) /* DRAWPNT * Draw a standard 2.0-style 3D string frame. */ // TAG NUMBERS 52 TO 59 RESERVED HERE #define GODT_AdjustBounds (TAG_OUTLINE_LOWDRAWCMD+60) /* DRAWPNT * Adjust the current drawing boundaries. * * The new boundary's top-left corner is at (x1,y1) * and bottom-right at (x2,y2) relative to the * CURRENT boundaries. (You can only shrink the * boundaries using this command.) * * If the current boundary is a frame, it will be turned * into a standard box by this command. */ // Text drawing commands #define TAG_OUTLINE_TEXTDRAWCMD (TAG_OUTLINE_DRAWBASE+0x200) #define GODT_DrawText (TAG_OUTLINE_TEXTDRAWCMD+1) /* UBYTE * * Draw the given text onto the screen, centering and clipping * as needed to make it fit within the box's boundaries. * Uses current GODT_SetDrawMode, GODT_ChooseTextAPen and * GODT_ChooseTextBPen settings. */ #define GODT_DrawOldText (TAG_OUTLINE_TEXTDRAWCMD+2) /* UBYTE * * Same as GODT_DrawText, except pens A and B are the DetailPen * and its compliment, respectively. */ #define GODT_DrawStdText (TAG_OUTLINE_TEXTDRAWCMD+3) /* UBYTE * * Same as GODT_DrawText, except pens A and B are the TextPen * and its compliment, respectively. */ #define GODT_DrawHighText (TAG_OUTLINE_TEXTDRAWCMD+4) /* UBYTE * * Same as GODT_DrawText, except pens A and B are the * and its compliment, respectively. */ #define GODT_DrawFillText (TAG_OUTLINE_TEXTDRAWCMD+5) /* UBYTE * * Same as GODT_DrawText, except pens A and B are the FillTextPen * and its compliment, respectively. */ #define GODT_DrawTextTag (TAG_OUTLINE_TEXTDRAWCMD+6) #define GODT_DrawOldTextTag (TAG_OUTLINE_TEXTDRAWCMD+7) #define GODT_DrawStdTextTag (TAG_OUTLINE_TEXTDRAWCMD+8) #define GODT_DrawHighTextTag (TAG_OUTLINE_TEXTDRAWCMD+9) #define GODT_DrawFillTextTag (TAG_OUTLINE_TEXTDRAWCMD+10) /* Tag * Same as previous tags, except the data is a tag to look for * within the command list which contains a text pointer. Ex: * ..., GOCT_BorderText, "Hi!", GODT_DrawTextTag, GOCT_BorderText, ... * Would print "Hi!" at the current cursor position. */ // TAG NUMBERS 11 TO 29 RESERVED HERE #define GODT_NewLine (TAG_OUTLINE_TEXTDRAWCMD+30) /* ULONG * Perform a carriage return / new line operation on the cursor. * * The x position is reset to zero [left side of bounding box] * and the y position is incremented by the font height times * the given tag's data field. */ // TAG NUMBERS 31 TO 89 RESERVED HERE #define GODT_LeftTextPtr (TAG_OUTLINE_TEXTDRAWCMD+90) #define GODT_AboveTextPtr (TAG_OUTLINE_TEXTDRAWCMD+91) #define GODT_BodyTextPtr (TAG_OUTLINE_TEXTDRAWCMD+92) #define GODT_RightTextPtr (TAG_OUTLINE_TEXTDRAWCMD+93) #define GODT_BelowTextPtr (TAG_OUTLINE_TEXTDRAWCMD+94) /* UBYTE * * * These are "fake" tags which can be used with the * GODT_DrawText*Tag tags above; they are otherwise ignored. */ // Drawing environment commands #define TAG_OUTLINE_DRAWENVCMD (TAG_OUTLINE_DRAWBASE+0x300) #define GODT_ExecDrawing (TAG_OUTLINE_DRAWENVCMD+1) /* struct TagItem * * Execute the drawing commands pointed to. * * This tag causes the drawing tags to which it points to be * executed exactly as if they are in this list. Any changes * they make to the current environment will not be restored * when they are finished. * * Note that the commands which take identifiers for tags which * occur in the list [ie GODT_DrawTextTag] still search the * _original_ command tag list and not the child list. */ #define GODT_SpawnDrawing (TAG_OUTLINE_DRAWENVCMD+2) /* struct TagItem * * Execute the drawing in its own environment. * * This tag is identical to GODT_ExecuteDrawing except * that it creates a new environment before executing the * given tag list and restores the old environment after * it has finished. This means that any changes [ie, pen * colors, bounds, etc], made by the commands will not * effect the caller's environment. */ /*** *** These are the global GadOutline tags which are passed to the *** functions AllocGadOutline(), DimenGadOutline(), RebuidldGadOutline(), *** ResizeGadOutline(), DestroyGadOutline(), HookGadOutline(), *** UnhookGadOutline(), DrawGadOutline(). ***/ #define TAG_OUTLINE (TAG_USER+0x8000) #define GOA_BaseName (TAG_OUTLINE+1) /* UBYTE * * Set program BaseName associated with this GadOutline. * * Default: NULL (no base name) */ #define GOA_ErrorCode (TAG_OUTLINE+2) /* GOERR * * Give a memory location to store GadOutline error codes in. * * Default: NULL (no errors stored) */ #define GOA_ErrorText (TAG_OUTLINE+3) /* UBYTE ** * Give a memory location to store GadOutline error text in. * * Default: NULL (no errors stored) */ #define GOA_SetUserData (TAG_OUTLINE+4) /* void * * Set the GadOutline's UserData variable. * * Default: NULL */ #define GOA_SetUserHandler (TAG_OUTLINE+5) /* void * * Set the GadOutline's UserHandler variable. * * This is intended to be used as a vector to the user's code which * handles IDCMP messages from this window. However, the library * currently does nothing with it and you are free to use this variable * in whatever way you want. * * Default: NULL */ #define GOA_SetTransHook (TAG_OUTLINE+6) /* struct Hook * * Set the GadOutline's user Translation hook. * * Default: NULL (no user translation) */ #define GOA_SetTransHookData (TAG_OUTLINE+7) /* void * * Set the GadOutline's TransHookData variable. * * Default: NULL */ // TAG NUMBERS 8 TO 99 RESERVED HERE #define GOA_DisplayID (TAG_OUTLINE+100) /* ULONG * Specify a standard graphics.library display ID. */ #define GOA_Overscan (TAG_OUTLINE+101) /* ULONG * Specify a standard screen overscan mode. * * If no screen or window set for outline, these tags are used to find * some basic values for doing a layout. This is most often used to find * a font that the outline will fit in a screen before opening the screen. * * These tags will automatically set the minimum layout dimensions * to zero and the maximum dimensions to the size of the display mode. * * GOA_DisplayID default: 0 (generic lores) * GOA_Overscan default: OSCAN_TEXT */ #define GOA_ScreenAddr (TAG_OUTLINE+102) /* struct Screen * * Specify the screen to put the outline on. */ #define GOA_ScreenName (TAG_OUTLINE+103) /* UBYTE * * Specify the name of a public screen to put the outline on. * * If no window is supplied, these tags are used to specify the screen * that the outline will be on. If the outline is already on a window * or another screen, that window and/or screen is closed before going * onto this screen. If the screen name is NULL or the named screen * can not be opened and GOA_ScreenFallBack is TRUE, the default screen * will be used. When opening on a screen, the screen is automatically * locked and will remain locked until the outline is removed from the * screen. * * Note that only one of these tags should be specified. * These tags will automatically set the minimum layout dimensions * to zero and the maximum dimensions to the size of the screen. * * GOA_ScreenAddr default: NULL (none) * GOA_ScreenName default: NULL (default pub screen) */ #define GOA_WindowAddr (TAG_OUTLINE+104) /* Struct Window * * Specify the window to put the outline on. * * This tag gives the actual window on which to create the layout * and allows the library to create all of its object and link them * to the window. While the window is linked to the outline, it is * essentially owned by the library -- all IDCMP messages and * refreshing must go through the library routines, and the library * owns the window's UserData variable. * * This tag will automatically set the minimum layout dimensions * AND the maximum dimensions to the size of the window. * * Default: NULL (none) */ #define GOA_MaxWidth (TAG_OUTLINE+105) #define GOA_MaxHeight (TAG_OUTLINE+106) /* ULONG * Specify maximum size that the gadoutline layout can be. */ #define GOA_MinWidth (TAG_OUTLINE+107) #define GOA_MinHeight (TAG_OUTLINE+108) /* ULONG * Specify minimum size that the gadoutline layout can be. * * These are used to override the default max/min layout dimensions * set up by the library. They must be included at every call to * Remake/Resize/Hook/Unhook/etc or else they will revert to the * default dimensions as described above. * * Default: from window/screen/displayid as above. */ #define GOA_TextAttr (TAG_OUTLINE+109) /* struct TextAttr * * Specify the prefered font to use for the layout * * This tag specifies a complete font description to attempt to * do the layout in, overriding the default use of the Window or * Screen's font. If the layout will not fit within its maximum * dimensions using this font, the library will override it. * * Default: from window or screen or just boring 'ol Topaz 8. */ #define GOA_FontName (TAG_OUTLINE+110) /* UBYTE * * Specify the prefered font name, with or without .font suffix. */ #define GOA_FontSize (TAG_OUTLINE+111) /* UWORD * Specify the prefered font size. */ #define GOA_FontStyle (TAG_OUTLINE+112) /* UBYTE * Specify the prefered font style. * * These tags can be used instead of GOA_FontAttr, or used to modify * the values supplied within the GOA_FontAttr. * * Default: what GOA_FontAttr specified (or didn't, as the case may be. :) */ #define GOA_ErrorReportLevel (TAG_OUTLINE+113) /* UWORD * Specify which errors will be reported by displaying a requester. * * This tag specifies which GOTYPE_ error codes will cause GOA_SetError * to fall through to GOA_ShowError. It is formatted as a bit mask, * one bit for each possible error type, with the least significant * bit being GOTYPE_NONE. * * Default: (1L<<GOTYPE_FINE) | (1L<<GOTYPE_NOTE) | (1L<<GOTYPE_WARN) * | (1L<<GOTYPE_ALERT) | (1L<<GOTYPE_ALERT2) | (1L<<GOTYPE_ALERT3) * | (1L<<GOTYPE_FAIL) | (1L<<GOTYPE_FAIL2) | (1L<<GOTYPE_FAIL3) * * A good value to use for debugging is: * * (1L<<GOTYPE_FINE) | (1L<<GOTYPE_FINE2) * | (1L<<GOTYPE_NOTE) | (1L<<GOTYPE_NOTE2) * | (1L<<GOTYPE_WARN) | (1L<<GOTYPE_WARN2) * | (1L<<GOTYPE_ALERT) | (1L<<GOTYPE_ALERT2) | (1L<<GOTYPE_ALERT3) * | (1L<<GOTYPE_FAIL) | (1L<<GOTYPE_FAIL2) | (1L<<GOTYPE_FAIL3) */ #define GOA_ErrorFailLevel (TAG_OUTLINE+114) /* UWORD * Specify which unreported errors will become failures. * * This tag specifies which GOTYPE_ error codes, which have been set to * be unreported by the previous tag, will result in a failure being * reported. It is formatted identically to the previous tag. * * Note that this allows you to turn error types that would normally * always be a failure or a continuation into something they are not, * which is obviously not a good thing to do. :) * * Default: (1L<<GOTYPE_ALERT) | (1L<<GOTYPE_ALERT2) | (1L<<GOTYPE_ALERT3) * | (1L<<GOTYPE_FAIL) | (1L<<GOTYPE_FAIL2) | (1L<<GOTYPE_FAIL3) */ #define GOA_UserIDCMP (TAG_OUTLINE+115) /* struct MsgPort * * Specify custom message port for window's IDCMP. * * This allows you to supply a custom IDCMP port for windows opened * using GOA_OpenWindow(). This port will be automatically attached * and removed from the window by the library. A value of ~0 will * cause the library to allocate the message port itself and manage * it internally. * * Default: let window make its own. */ #define GOA_OutlineSize (TAG_OUTLINE+116) /* ULONG * Supply bounds checking for parsing the outline array. * * This is the number of BYTES your full outline is. If the library * goes over this number of bytes while parsing it, a fatal error * will occur telling you so. * * Default: if you messed it up, too bad. */ #define GOA_FontMinSize (TAG_OUTLINE+117) /* UWORD * Set the minimum point size we will scale font back to. * * Default: 8 points */ #define GOA_AllocMenus (TAG_OUTLINE+118) /* struct NewMenu * * Supplies a GadTools NewMenu array to be automatically allocated * and layed-out/attached to a window opened with GOA_OpenWindow(). * * Default: No menus. */ #define GOA_GToolsMenus (TAG_OUTLINE+119) /* struct Menu * * Supplies a menu strip that was allocated by GadTools, to be automatically * layed-out and attached to a window opened with GOA_OpenWindow(). * * Default: No menus. */ #define GOA_StandardMenus (TAG_OUTLINE+120) /* struct Menu * * Supplies a menu strip that will be attached to a window opened * with GOA_OpenWindow(). No layout or anything else of the menus * is performed before it is attached. * * Default: No menus. */ // TAG NUMBERS 121 TO 199 RESERVED HERE // Flags #define GOA_FontSystemOnly (TAG_OUTLINE+200) /* BOOL * Only allow the library to fall back to the default system fonts. * * If TRUE, the library will not attempt to reduce the point size * of the font requested by the caller in order to make it fit * within the current constraints, and will instead immediately * start trying the system fonts. The system font order is: * window -> screen -> gfxdefault -> topaz8 * * Default: FALSE */ #define GOA_FontROMFont (TAG_OUTLINE+201) /* BOOL * Set the ROMFONT flag in the TextAttr used to open fonts */ #define GOA_FontDiskFont (TAG_OUTLINE+202) /* BOOL * Set the DISKFONT flag in the TextAttr used to open fonts */ #define GOA_FontDesigned (TAG_OUTLINE+203) /* BOOL * Set the DESIGNED flag in the TextAttr used to open fonts * * These flags are used set information in the TextAttr before * calling the system to open the font. Their interpretation * depends on the OS, except setting GOA_FontDiskFont to TRUE * will cause the library to try to open diskfont.library and use * OpenDiskFont() instead of OpenFont(). * * GOA_FontROMFont Default: FALSE * GOA_FontDiskFont Default: TRUE * GOA_FontDesigned Default: TRUE */ #define GOA_ScreenFallBack (TAG_OUTLINE+204) /* BOOL * Try to open default screen if unable to open a named screen. * * If TRUE, the library will attempt to open the default public screen * if it was unable to open the screen name supplied with GOA_ScreenName. * * Default: TRUE */ #define GOA_AutoSizeVerify (TAG_OUTLINE+205) /* BOOL * Specify whether to respond to IDCMP_SIZEVERIFY events. * * If TRUE, the library will automatically unhook the gadgets from * the window before allowing it to be resized. This keeps the window * frame from getting trashed by the old gadgets during a resize and * usually means you won't need to refresh the frame. However, with * complex layouts there may be a noticable delay between the user * pressing the resize gadget and being allowed to move the window. * * Default: TRUE */ #define GOA_AutoNewSize (TAG_OUTLINE+206) /* BOOL * Specify whether to respond to IDCMP_NEWSIZE events. * * If TRUE, the library will automatically call ResizeGadOutline() * whenever the window size changes. * * Default: TRUE */ #define GOA_AddOutlineIDCMP (TAG_OUTLINE+207) /* BOOL * Automatically add IDCMP events needed by library. * * If TRUE, the window will be set to report all IDCMP events needed * by the library. This includes IDCMP_NEWSIZE, IDCMP_SIZEVERIFY and * IDCMP_RAWKEY, depending on whether the library has been told to * respond to these. * * Default: TRUE */ #define GOA_AddObjectIDCMP (TAG_OUTLINE+208) /* BOOL * Automatically add IDCMP events needed by objects. * * If TRUE, the window will be set to report all IDCMP events needed * by any objects in the layout. The exact events which will be * set depends on the objects. * * Default: TRUE */ #define GOA_DoHookCallback (TAG_OUTLINE+209) /* BOOL * Send objects HOOK/UNHOOK messages. * * If TRUE, the library will send a CHM_HOOKOBJ when the objects are * being hooked to the window and CHM_UNHOOKOBJ when they are being * removed from the window. Normally, these operations simply involve * removing all of the gadget lists from the window, and so this flag * is set to FALSE. If your user hook needs to do something special, * set this to TRUE. Please _never_ set this to false, so that the * library can change the default condition of this to TRUE at a later * time. * * Default: FALSE */ #define GOA_RedrawWinFrame (TAG_OUTLINE+210) /* BOOL * Redraw window frame after a window resize. * * If TRUE, the library will automatically refresh the window's frame * after it has been resized. Normally the library looks for * IDCMP_SIZEVERIFY events and removes the gadgets during a resize * so this does not usually need to happen. * * Default: FALSE */ #define GOA_SetWindowFont (TAG_OUTLINE+211) /* BOOL * Set the window's RastPort font to the outline's final font. * * If TRUE, the library will automatically set the window's RastPort * to the font that it uses for the layout (ie, go_TextFont). This * means that you should not change the window font yourself, or if you * do change it you must change it back before calling any gadoutline * library functions. * * Default: TRUE */ #define GOA_ClearFullWin (TAG_OUTLINE+212) /* BOOL * Clear entire window when remaking objects. * * If TRUE, the library will erase the entire window after destroying * all objects and getting ready to remake them. * If FALSE, only the area covered by the layout will be cleared. * * You will usually need to set this flag if you are drawing in the * space area around the root group. Otherwise, the library leaves * this space alone to allow you to reserve it for yourself. * * Default: FALSE */ #define GOA_SaveWinDimens (TAG_OUTLINE+213) /* BOOL * Remember the window dimensions on open/close. * * If TRUE, GOA_CloseWindow() will save the window's dimensions before * closing and a subsequent call to GOA_OpenWindow() will try to match * those dimensions as closely as possible. * * Default: TRUE */ #define GOA_WindowRelative (TAG_OUTLINE+214) /* BOOL * Window position is a relative value. * * If TRUE, any value supplied in WA_LeftEdge and WA_TopEdge is * relative to either the screen's title bar or, if the screen is * bigger than the display, the left and top positions of the display * on the screen. [Ie, so that the window appears on the visible * portion of the screen.] In addition, the window's size will be * reduced, if possible, to make sure it fits within the display * area and WA_InnerWidth and WA_InnerHeight will be relative to the * current layout's minimum dimensions. * * Default: TRUE */ #define GOA_WindowResize (TAG_OUTLINE+215) /* BOOL * Scale window size if layout doesn't fit on it. * NOT IMPLEMENTED. * * If TRUE, the library will attempt to enlarge the window if * its prefered layout dimensions will fit on a bigger window. * The window will not be resized if the layout won't fit within * the largest window on its screen. [In other words, the window * size will only change when this will guarantee that the layout * will fit on it.] * * Default: TRUE */ #define GOA_AutoHotKeys (TAG_OUTLINE+216) /* BOOL * Automatically process object hot keys. * * Default: TRUE */ /** ** Error code definitions **/ typedef unsigned long GOERR; #define ERRCODE_STARTBIT (0) // ID describing the error. #define ERRCODE_NUMBITS (16) #define ERRTYPE_STARTBIT (24) // Severity of error. #define ERRTYPE_NUMBITS (4) // Bit allocation: // // 3 2 2 2 1 1 0 0 0 // 1 8 4 0 6 2 8 4 0 // xxxx TTTT xxxx xxxx CCCC CCCC CCCC CCCC // // T = Error type // C = Error code // x = reserved. always set to 0. #define GETERRCODE(goerr) ((ULONG)( ( ((GOERR)(goerr)) >> ERRCODE_STARTBIT ) \ & ((1<<ERRCODE_NUMBITS)-1) )) #define GETERRTYPE(goerr) ((ULONG)( ( ((GOERR)(goerr)) >> ERRTYPE_STARTBIT ) \ & ((1<<ERRTYPE_NUMBITS)-1) )) #define GO_MAKEERR(type,code) \ ((GOERR)( (((ULONG)(type)&((1<<ERRTYPE_NUMBITS)-1))<<ERRTYPE_STARTBIT) \ | (((ULONG)(code)&((1<<ERRCODE_NUMBITS)-1))<<ERRCODE_STARTBIT) \ )) #define GOCODE_NONE 0 // No problem. Only use with GOTYPE_NONE. // ErrObj = none. #define GOCODE_GENERAL 1 // General-purpose error code. // ErrObj = none. #define GOCODE_MEMORY 2 // Not enough memory. // ErrObj = (ULONG) - Memory size requested. #define GOCODE_OPENLIB 3 // Unable to open a library. // ErrObj = (UBYTE *) - explantion text. #define GOCODE_OPENFONT 4 // Unable to open a font. // ErrObj - (struct TextAttr *) - font we tried. #define GOCODE_INTERR 5 // Internal error occured. // ErrObj - ULONG, use ~em and ~el to get file/line. #define GOCODE_BADARGS 6 // Function called with bad arguments, but not fatal. // ErrObj - ULONG, use ~em and ~el to get file/line. #define GOCODE_OUTBOUNDS 7 // Outline parse went out of GOA_OutlineSize bounds. // ErrObj - ULONG, size error was found at. #define GOCODE_MALFORMED 8 // Error parsing outline structure. // ErrObj = (struct CmdInfo *) - CmdInfo of error. #define GOCODE_NOBOXGROUP 9 // Box created outside of a group. // ErrObj = (struct CmdInfo *) - CmdInfo of error. #define GOCODE_UNKNOWNCMD 10 // Encountered an illegal command. // ErrObj = (struct CmdInfo *) - CmdInfo of error. #define GOCODE_BADENDGRP 11 // Endgroup command found outside of any groups. // ErrObj = (struct CmdInfo *) - CmdInfo of error. #define GOCODE_NOGROUPS 12 // There are no groups or boxes in the outline. // ErrObj = (struct CmdInfo *) - base CmdInfo. #define GOCODE_EXTRAROOTGRP 13 // Can only have one root group. // ErrObj = (struct CmdInfo *) - base CmdInfo. #define GOCODE_BADGROUP 14 // Found a bad command within a group list. // ErrObj = (struct CmdInfo *) - CmdInfo of error. #define GOCODE_BADHKCMD 15 // Hook doesn't understand this type of CmdInfo. // ErrObj = (struct CmdInfo *) - offending CmdInfo. #define GOCODE_CREATEOBJ 16 // Object creation error. // ErrObj = (struct CmdInfo *) - object's CmdInfo. #define GOCODE_BADCMDID 17 // Supplied CmdID out of bounds. // ErrObj = (CMDID) - the bad number. #define GOCODE_DUPSTDID 18 // Multiple commands have the same StdID number. // ErrObj = (CMDID) - the bad number. #define GOCODE_NOCMDID 19 // No command associated with the given CmdID. // ErrObj = (CMDID) - the bad number. #define GOCODE_DUPHOTKEY 20 // Multiple commands have the same hotkey. // ErrObj = (UBYTE) - the hot key. #define GOCODE_BADTYPEDSIZE 21 // Found an invalid TypedSize. // ErrObj = (TYPEDSIZE) - the bad number. #define GOCODE_OPENPUBSCRN 22 // Unable to open a named public screen. // ErrObj = (UBYTE *) - name of pub screen. #define GOCODE_DEFPUBSCRN 23 // Couldn't find the default public screen. // ErrObj = none. #define GOCODE_VISUALINFO 24 // Unable to allocate screen's VisualInfo. // ErrObj = (struct Screen *) - the screen we tried. #define GOCODE_DRAWINFO 25 // Unable to find screen's DrawInfo. // ErrObj = (struct Screen *) - the screen we tried. #define GOCODE_NOFITWINDOW 26 // Unable to fit layout with current font/screen. // ErrObj = none. #define GOCODE_GTCONTEXT 27 // Unable to create GadTools context. // ErrObj = none. #define GOCODE_OPENWIN 28 // Unable to open a window. // ErrObj = (struct TagItem *) - window's tags. #define GOCODE_NUM 29 // Total number of error codes // C = Continue, R = Retry, A = Abort #define GOTYPE_NONE 0 // ONLY use with GOCODE_NONE. #define GOTYPE_FINE 1 // Requester with: C #define GOTYPE_FINE2 2 // Requester with: C #define GOTYPE_FINE3 3 // Requester with: C #define GOTYPE_NOTE 4 // Requester with: C/A #define GOTYPE_NOTE2 5 // Requester with: C/A #define GOTYPE_NOTE3 6 // Requester with: C/A #define GOTYPE_WARN 7 // Requester with: C/R/A #define GOTYPE_WARN2 8 // Requester with: C/R/A #define GOTYPE_WARN3 9 // Requester with: C/R/A #define GOTYPE_ALERT 10 // Requester with: R/A #define GOTYPE_ALERT2 11 // Requester with: R/A #define GOTYPE_ALERT3 12 // Requester with: R/A #define GOTYPE_FAIL 13 // Requester with: A #define GOTYPE_FAIL2 14 // Requester with: A #define GOTYPE_FAIL3 15 // Requester with: A #define GOTYPE_NUM 16 // Possible return values for the error requester #define GOREQ_CONT 0 #define GOREQ_RETRY 1 #define GOREQ_FAIL 2 #endif