If the user has an autopointer tool (sunmouse), the call will
succeed, but the tool will deactivate the window right after
this function has activated it. It is not a good idea to try to
prevent this by waiting for IDCMP_INACTIVEWINDOW and activating
the window again since that will produce an annoying flicker and
it will slow down the computer a lot.

window - Add gadget to this window
gadget - Add this gadget
position - The position to add the gadget in the list of
gadgets already in the window. Use 0 to insert the
gadget before all others or ~0 to append it to the
list.

window - Add gadgets to this window
gadget - This is the list of gadgets to add
position - Where to insert the gadgets in the list of gadgets
already in the window. Use 0 to insert the gadgets
before all others in the window or ~0 to append them.
numGad - How many gadgets of the list should be added.
Use -1 to add all gadgets in the list.
requester - Pointer to the requester structure if the window is
a requester.

Allocate a ScreenBuffer (and BitMap) for double or multiple
buffering in Intuition screens. Use this function to obtain a
ScreenBuffer for the screen's initial BitMap and for all other
BitMaps you want to swap in.
This function also allocates a DBufInfo from graphics.library
The returned ScreenBuffer contains a pointer to that DBufInfo.
See graphics.library/AllocDBufInfo() for more information on
how to use this struct to obtain info when it is safe to render
into an old buffer and when to switch.

screen - Screen to double-buffer
bitmap - You may pre-allocate a BitMap for CUSTOMBITMAP screens,
and pass the pointer to get a ScreenBuffer referring to it.
If you specify NULL, intuition will allocate the BitMap for
you. For non-CUSTOMBITMAP screens this parameter must be NULL.
flags - A combination of these flags:
SB_SCREEN_BITMAP for non-CUSTOMBITMAP screens to get a
ScreenBuffer referring to the screen's actual BitMap
(For CUSTOMBITMAP screens just pass the BitMap you used for
OpenScreen() as the bitmap parameter)
SB_COPY_BITMAP to copy the screen's BitMap intto the
ScreenBuffer's BitMap. Use this to get intuition rendered
stuff into your bitmap (such as menu-bars or gadgets).
May be omitted if the screen has no intuition rendered stuff,
as well as for allocating a ScreenBuffer for the screen's
initial BitMap.

You may render into the resulting BitMap.
Use the sb_DBufInfo field to access graphics.library's ViewPort
buffering features to e.g check if it is safe to reuse the previous
BitMap. Otherwise you risk to write into the on-screen BitMap and
damage menu or gadget rendering.

The WorkBench program wants to call this function to signal
Intuition that it is active or shutting down.
Intuition then uses the MsgPort to tell the WorkBench to open or
close its windows if the user called OpenWorkbench() or
CloseWorkbench().
When the MsgPort is non-NULL Intuition will send IntuiMessages to
it with the Class field set to WBENCHMESSAGE and Code field set to
either WBENCHOPEN or WBENCHCLOSE. Intuition assumes that when the
WorkBench task replies this messages, it already has opened/closed
its windows.

Opens a requester, which provides one or more choices. The control is
returned to the application after the requester was opened. It is
handled by subsequent calls to SysReqHandler() and closed by calling
FreeSysRequest().

RefWindow - A reference window. If NULL, the requester opens on
the default public screen.
easyStruct - The EasyStruct structure (<intuition/intuition.h>),
which describes the requester.
IDCMP - IDCMP flags, which should satisfy the requester, too. This is
useful for requesters, which want to listen to disk changes,
etc. Note that this is not a pointer to the flags as in
EasyRequestArgs().
Args - The arguments for easyStruct->es_TextFormat.

window - The window in which the requester will appear
bodytext - The Text to be shown in the body of the requester
postext - The Text to be shown in the positive choice gadget
negtext - The Text to be shown in the negative choice gadget
IDCMPFlags - The IDCMP Flags for this requester
width, height - The dimensions of the requester

Do double or multiple buffering on an intuition screen in an
intuition-cooperative way. The ScreenBuffer's BitMap will be
installed on the specified screen, if possible. After a signal from
graphics.library, the previously installed BitMap will be available
for re-use. Consult graphics.library/AllocDBufInfo() and
graphics.library/ChangeVPBitMap() for further information.

alertnumber - Value determining type of alert. For historical reasons,
this is the same value as passed to Alert(). However,
this functions takes into account only AT_DeadEnd bit.
string - A pointer to text data. Text data have the following layout:
each string is preceded by 3 bytes. The first two of them are
the X coordinates of the string in the alert display. This is
given as a big-endian value. The third byte is the Y
coordinate of the text's baseline. Then a NUL-terminated
string follows by itself. After the NUL terminator there's
one more byte. If it's not zero, another string starts from
the next byte. Zero marks the end of the sequence. The text
is always rendered using the topaz/8 font.
height - The height of alert display in pixels.

Always FALSE if AT_DeadEnd bit is set in alertnumber. Otherwise the
function returns TRUE or FALSE depending on what user chooses. In
AROS, alerts are presented in a requester with two gadgets: Ok and
Cancel. Ok returns TRUE; Cancel returns FALSE.
If the alert could not be posted for whatever reason, FALSE is
returned.

This function is obsolete and exists only for backwards compatibility
with AmigaOS(tm). On various modern systems this function has
different effects. On classic Amiga(tm) this function may not work
with RTG displays, so it is generally deprecated. Please don't use it
in new software! Use legitimate intuition requesters if you want to
present some message to the user.

Deletes a BOOPSI object. All memory associated with the object
is freed. The object must have been created with NewObject().
Some object contain other object which might be freed as well
when this function is used on the "parent" while others might
also contain children but won't free them. Read the documentation
of the class carefully to find out how it behaves.

gad - The gadget to work on
win - The window which contains the gadget or the requester with
the gadgets.
req - If the gadget is in a requester, you must specify that one,
too.
message - Send this message to the gadget.

Draws one or more borders in the specified RastPort. Rendering
will start at the position which you get when you add the offsets
leftOffset and topOffset to the LeftEdge and TopEdge specified
in the Border structure. All coordinates are relative to that point.

rp - Render in this RastPort
image - Render this image
leftOffset, topOffset - Add this offset to the position stored in the
image.
state - Which state (see intuition/imageclass.h for possible
values).
drawInfo - The DrawInfo from the screen.

Window - A reference window. If NULL, the requester opens on
the default public screen.
easyStruct - The EasyStruct structure (<intuition/intuition.h>)
describing the requester.
IDCMP_Ptr - Pointer to IDCMP flags. The requester will be closed early
if any of the specified message types is received. This is useful
for requesters that want to listen to disk changes etc. The
contents of this pointer is set to the IDCMP flag that caused the
requester to close. This pointer may be NULL.
ArgList - The arguments for easyStruct->es_TextFormat.

Only for class implementatores.
Tries to free a class which has been created with MakeClass() in the
first place. This will not succeed in all cases: Classes which
still have living objects or which are still being used by subclasses
can't simply be freed. In this case this call will fail.
Public classes will always be removed with RemoveClass() no matter
if FreeClass() would succeed or not. This gurantees that after the
call to FreeClass() no new objects can be created.
If you have a pointer to allocated memory in cl_UserData, you must
make a copy of that pointer, call FreeClass() and if the call
succeeded, you may free the memory. If you don't follow these rules,
you might end up with a class which is partially freed.

FALSE if the class couldn't be freed at this time. This can happen
either if there are still objects from this class or if the class
is used a SuperClass of at least another class.
TRUE if the class could be freed. You must not use iclass after
that.

When used SB_SCREEN_BITMAP on allocating the ScreenBuffer
(ie. the ScreenBuffer only refers to the screen's BitMap) you must
FreeScreenBuffer() the ScreenBuffer before closing the screen.
Intuition will recognize when FreeScreenBuffer() is called for the
currently installed ScreenBuffer that it must not free the BitMap.
This is left to the CloseScreen() function.

attrID - ID of the attribute you want
object - Ask the attribute from this object
storagePtr - This is a pointer to memory which is large enough
to hold a copy of the attribute. Most classes will simply
put a copy of the value stored in the object here but this
behaviour is class specific. Therefore read the instructions
in the class description carefully.

drawInfo - an object pointer to query. It is possible to set this
argument to NULL when querying GDIA_Color or GDIA_Pen
attributes. In this case values will be retrieved from
system preferences.
attrID - ID of the attribute you want. The following IDs are
currently defined:
GDIA_Color - 0RGB value of the color corresponding to a given pen.
It is possible to retrieve these values only from
DrawInfos belonging to direct-color screens. Pen ID
should be ORed with attribute ID.
GDIA_Pen - LUT color number corresponding to a given pen.
GDIA_Version - Version number of the DrawInfo object.
GDIA_DirectColor - TRUE if the DrawInfo belongs to direct-color screen. Note
that in case of failure it also sets success indicator to
FALSE.
GDIA_NumPens - Number of pens or colors defined in this DrawInfo object.
GDIA_Font - Font specified in this DrawInfo.
GDIA_Depth - Depth of this DrawInfo. Note that this attribute will
return real depth of DrawInfo's screen, however dri_Depth
member will contain 8 for AmigaOS(tm) compatibility.
GDIA_ResolutionX - X resolution in ticks
GDIA_ResolutionY - Y resolution in ticks
GDIA_CheckMark - A pointer to CheckMark image object for the menu.
GDIA_MenuKey - A pointer to Menu (Amiga) key image object for the menu.
resultPtr - an optional storage area for success indicator. You
can set this parameter to NULL.

Copy part or all infos about a screen into a private buffer.
To copy the Workbench, one would call
GetScreenData (buffer, sizeof(struct Screen), WBENCHSCREEN, NULL)
If the screen is not open, this call will open it. You can use
this function for these purposes:
1) Get information about the workbench in order to open a window
on it (eg. size).
2) Clone a screen.

Returns the address of the menuitem 'menunumber' of 'menustrip'.
The number is the one you get from intuition after the user has
selected a menu.
The menunumber must be well-defined.
Valid numbers are MENUNULL, which makes the routine return NULL,
or valid item number of your menustrip, which contains
- a valid menu number
- a valid item number
- if the menu-item has a sub-item, a valid sub-item number
Menu number and item number must be specified. Sub-item, if
available, is optional, therefore this function returns either
the item or sub-item.

This function "lends" the menus of one window to another. This makes
the menu events (e.g. menu button presses) take place in another
window's menu (i.e. the other window's strip and screen).
This function is used to unify two windows on different attached
screens. (E.g. a painting program with an attached palette screen
can open the menu on the main screen if the menu button is
pressed on the palette screen.)

Locks a public screen, thus preventing it from closing. This is
useful if you want to put up a visitor window on a public screen
and need to check some of the public screen's fields first -- not
locking the screen may lead to the public screen not existing when
your visitor window is ready.
If you try to lock the Workbench screen or the default public screen
and there isn't any, the Workbench screen will be automatically opened
and locked.

Only for class implementators.
This function creates a new public BOOPSI class. The SuperClass
should be another BOOPSI class; all BOOPSI classes are subclasses
of the ROOTCLASS.
SuperClasses can by private or public. You can specify a name/ID
for the class if you want it to become a public class. For public
classes, you must call AddClass() afterwards to make it public
accessible.
The return value contains a pointer to the IClass structure of your
class. You must specify your dispatcher in cl_Dispatcher. You can
also store shared data in cl_UserData.
To get rid of the class, you must call FreeClass().

classID - NULL for private classes otherwise the name/ID of the
public class.
superClassID - Name/ID of a public SuperClass. NULL is you don't
want to use a public SuperClass or if you have the pointer
your SuperClass.
superClassPtr - Pointer to the SuperClass. If this is non-NULL,
then superClassID is ignored.
instanceSize - The amount of memory which your objects need (in
addition to the memory which is needed by the SuperClass(es))
flags - For future extensions. To maintain comaptibility, use 0
for now.

This routine modifies the state of your window's IDCMP (Intuition
Direct Communication Message Port).
Depending on the current state in the IDCMPFlags of the window and
the specified flags these actions are possible:
IDCMP flags Action
0 0 Nothing happens.
0 !=0 The flags are copied in the IDCMPFlags of the window
and a MessagePort is created and stored in the
UserPort of the window.
!=0 0 The IDCMPFlags are cleared and the MessagePort in the
UserPort is deleted.
!=0 !=0 The flags are copied to the IDCMPFlags of the
window.

You can set up the Window->UserPort to any port of your own
before you call ModifyIDCMP(). If IDCMPFlags is non-null but
your UserPort is already initialized, Intuition will assume that
it's a valid port with task and signal data preset and Intuition
won't disturb your set-up at all, Intuition will just allocate
the Intuition message port half of it. The converse is true
as well: if UserPort is NULL when you call here with
IDCMPFlags == NULL, Intuition will deallocate only the Intuition
side of the port.
This allows you to use a port that you already have allocated:
- OpenWindow() with IDCMPFlags equal to NULL (open no ports)
- set the UserPort variable of your window to any valid port of your
own choosing
- call ModifyIDCMP with IDCMPFlags set to what you want
- then, to clean up later, set UserPort equal to NULL before calling
CloseWindow() (leave IDCMPFlags alone) BUT FIRST: you must make
sure that no messages sent your window are queued at the port,
since they will be returned to the memory free pool.
For an example of how to close a window with a shared IDCMP,
see the description for CloseWindow().
Intuition v50 features a WA_UserPort tag, which allows to set
the UserPort at OpenWindow stage. Please note that using this tag
changes the behaviour of ModifyIDCMP() slightly. Creating/disposing
message ports is now up to the app. ModifyIDCMP(win,0) still clears
win->UserPort pointer, but the message port is NOT disposed - you
need to store it and dispose yourself! Also calling
ModifyIDCMP(win,someidcmp) on a window with NULL win->UserPort will
NOT create a new port!

gadget - Must be a PROPGADGET
window - The window which contains the gadget
requester - If the gadget has GTYP_REQGADGET set, this must be
non-NULL.
flags - New flags
horizPot - New value for the HorizPot field of the PropInfo
vertPot - New value for the VertPot field of the PropInfo
horizBody - New value for the HorizBody field of the PropInfo
vertBody - New value for the VertBody field of the PropInfo

Changes the values in the PropInfo-structure of a proportional
gadget and refreshes the specified number of gadgets beginning
at the proportional gadget. If numGad is 0 (zero), then no
refreshing is done.

gadget - Must be a PROPGADGET.
window - The window which contains the gadget
requester - If the gadget has GTYP_REQGADGET set, this must be
non-NULL.
flags - New flags
horizPot - New value for the HorizPot field of the PropInfo
vertPot - New value for the VertPot field of the PropInfo
horizBody - New value for the HorizBody field of the PropInfo
vertBody - New value for the VertBody field of the PropInfo
numGad - How many gadgets to refresh. 0 means none (not even
the current gadget) and -1 means all of them.

If NewModifyProp does not work for you, check if you
really have a gadget with GTYP_PROPGADGET set. If you
create a new gadget object from PROPGCLASS, you
might very well get a GTYP_CUSTOMGADGET gadget.
As a workaround, you might have to set the
gadget type to GTYP_PROPGADGET manually during the
call to NewModifyProp. Intuition does this, too.

Use this function to create BOOPSI objects (BOOPSI stands for
"Basic Object Oriented Programming System for Intuition).
You may specify a class either by it's name (if it's a public class)
or by a pointer to its definition (if it's a private class). If
classPtr is NULL, classID is used.

classPtr - Pointer to a private class (or a public class if you
happen to have a pointer to it)
classID - Name of a public class
tagList - Initial attributes. Read the documentation of the class
carefully to find out which attributes must be specified
here and which can.

Use this function to iterate through a list of BOOPSI objects.
You may do whatever you want with the object returned, even
remove it from the list or dispose it, and then continue to
iterate through the list.

screen - Pointer to the public screen your window is open in or
NULL if you don't have a pointer to a public screen.
namebuff - Pointer to a buffer with (at least) MAXPUBSCREENNAME+1
characters to put the name of the next public screen in.

We cannot guarantee that the public screen, the name of which you got
by using this function, is available when you call for instance
LockPubScreen(). Therefore you must be prepared to handle failure of
that kind of functions.
This function may return the name of a public screen which is in
private mode.
The cycle order is undefined, so draw no conclusions based on it!

This function sets up a RastPort for exclusive use by custom
gadget hook routines. Call this function each time a hook
routine needs to render into the gadget and ReleaseGIRPort()
immediately afterwards.

SA_Left
Default: 0
SA_Top
Default: 0
SA_Width
Default depends on display clip
SA_Height
Default depends on display clip
SA_Depth
Select depth of screen. This specifies how many
colors the screen can display.
Default: 1
SA_DetailPen
Pen number for details.
Default: 0
SA_BlockPen
Pen number for block fills.
Default: 1
SA_Title (STRPTR)
Default: NULL
SA_Font (struct TextAttr *)
Default: NULL, meaning user's preferred monospace font
SA_BitMap (struct BitMap *)
Provide a custom bitmap.
SA_ShowTitle (BOOL)
Default: TRUE
SA_Behind (BOOL)
Screen will be created behind other open screens.
Default: FALSE
SA_Quiet (BOOL)
Intuition doesn't draw system gadgets and screen title.
Defaults: FALSE
SA_Type
PUBLICSCREEN or CUSTOMSCREEN.
SA_DisplayID
32-bit display mode ID, as defined in the <graphics/modeid.h>.
SA_Overscan
Set an overscan mode.
Possible values:
OSCAN_TEXT - A region which is fully visible.
Recommended for text display.
OSCAN_STANDARD - A region whose edges are "just out of view."
Recommended for games and presentations.
OSCAN_MAX - Largest region which Intuition can handle comfortably.
OSCAN_VIDEO - Largest region the graphics.library can display.
Default: OSCAN_TEXT
SA_DClip (struct Rectangle *)
Define a DisplayClip region. See QueryOverscan().
It's easier to use SA_Overscan.
SA_AutoScroll (BOOL)
Screens can be larger than the DisplayClip region. Set this tag
to TRUE if you want to enable automatic scrolling when you reach
the edge of the screen with the mouse pointer.
SA_PubName (STRPTR)
Make this screen a public screen with the given name.
Screen is opened in "private" mode.
SA_Pens (UWORD *)
Define the pen array for struct DrawInfo. This enables
the 3D look.
This array contains often just the terminator ~0.
You define a list of pens which overwrite the DrawInfo pens.
The pen arrayy must be terminated with ~0.
SA_PubTask (struct Task *)
Task to be signalled, when last visitor window of a public
screen is closed.
SA_PubSig (UBYTE)
Signal number used to notify a task when the last visitor window
of a public screen is closed.
SA_Colors (struct ColorSpec *)
Screen's initial color palette. Array must be terminated
with ColorIndex = -1.
SA_FullPalette (BOOL)
Intuition maintains a set of 32 preference colors.
Default: FALSE
SA_ErrorCode (ULONG *)
Intuition puts additional error code in this field when
opening the screen failed.
OSERR_NOMONITOR - monitor for display mode not available.
OSERR_NOCHIPS - you need newer custom chips for display mode.
OSERR_NOMEM - couldn't get normal memory
OSERR_NOCHIPMEM - couldn't get chip memory
OSERR_PUBNOTUNIQUE - public screen name already used
OSERR_UNKNOWNMODE - don't recognize display mode requested
OSERR_TOODEEP - screen too deep to be displayed on
this hardware (V39)
OSERR_ATTACHFAIL - An illegal attachment of screens was
requested (V39)
SA_SysFont
Select screen font type. This overwrites SA_Font.
Values:
0 - Fixed-width font (old-style)
1 - Font which is set by font preferences editor. Note:
windows opened on this screen will still have the rastport
initialized with the fixed-width font (sysfont 0).
Default: 0
SA_Parent (struct Screen *)
Attach the screen to the given parent screen.
SA_FrontChild (struct Screen *)
Attach given child screen to this screen. Child screen
must already be open. The child screen will go to the
front of the screen group.
SA_BackChild (struct Screen *)
Attach given child screen to this screen. Child screen
must already be open. The child screen will go behind other
child screens.
SA_BackFill (struct Hook *)
Backfill hook (see layers.library/InstallLayerInfoHook() ).
SA_Draggable (BOOL)
Make screen draggable.
Default: TRUE
SA_Exclusive (BOOL)
Set to TRUE if the screen must not share the display with
other screens. The screen will not be draggable and doesn't
appear behind other screens, but it still is depth arrangeable.
Default: FALSE
SA_SharePens (BOOL)
Per default, Intuition obtains the pens of a public screen with
PENF_EXCLUSIVE. Set this to TRUE to instruct Intuition to leave
the pens unallocated.
Default: FALSE
SA_Colors32 (ULONG *)
Data is forwarded to graphics.library/LoadRGB32().
Overwrites values which were set by SA_Colors.
SA_Interleaved (BOOL)
Request interleaved bimap. It this fails a non-interleaved
bitmap will be allocated.
Default: FALSE
SA_VideoControl (struct TagItem *)
Taglist which will be passed to VideoControl() after the
screen is open.
SA_ColorMapEntries:
Number of entries of the ColorMap.
Default: 1<<depth, but not less than 32
SA_LikeWorkbench (BOOL)
Inherit depth, colors, pen-array, screen mode, etc. from
the Workbench screen. Individual attributes can be overridden
with tags.
Default: FALSE
SA_MinimizeISG (BOOL)
Minimize the Inter-Screen-Gap. For compatibility,

If you need a pointer to the screen's bitmap use
Screen->RastPort.BitMap instead of &Screen->BitMap.
If you want DOS requester to appear on your screen you have to do:
process = FindTask(0);
process->pr_WindowPtr = (APTR) window;
The old value of pr->WindowPtr must be reset before you quit your
program.

WA_Left - Left edge of the window
WA_Top - Top edge of the window
WA_Width - Width of the window
WA_Height - Height of the window
WA_DetailPen - Pen number for window details (obsolete)
WA_BlockPen - Pen number for filled blocks (obsolete)
WA_IDCMP - Define what events should send messages to your task
WA_Flags
Initial values for various boolean window properties. Can be
overwritten by WA_... tags.
WA_Gadgets (struct Gadget *)
Pointer to a linked list of gadgets
WA_Title (STRPTR) - Window title string
WA_CustomScreen (struct Screen *)
Open window on the given screen
WA_SuperBitMap (struct BitMap *)
Create window with superbitmap refreshing
WA_MinWidth - Minimum width of the window
WA_MinHeight - Minimum height of the window
WA_MaxWidth - Maximum width of the window
WA_MaxHeight - Maximum height of the window
Use 0 to keep the current size as limit. The maximums can be
set to -1 or ~0 to limit size only to screen dimension.
WA_SizeGadget (BOOL) - Make window resizeable
WA_DragBar (BOOL) - Make window dragable
WA_DepthGadget (BOOL) - Add a depth gadget
WA_CloseGadget (BOOL) - Add a close gadget
WA_Backdrop (BOOL)
Create a window which is placed behind other windows
WA_ReportMouse (BOOL) - Store mouse position in struct Window
WA_NoCareRefresh (BOOL)
Use this if you don't want to be responsible for calling
BeginRefresh()/EndRefresh().
WA_Borderless (BOOL) - Create borderless window
WA_Activate (BOOL)
Make this window the active one, i.e. it
receives the input from mouse and keyboard.
WA_RMBTrap (BOOL)
Set to TRUE if you want to get button events
events for the right mouse button.
WA_SimpleRefresh (BOOL)
Enable simplerefresh mode. Only specify if TRUE.
WA_SmartRefresh (BOOL)
Enable smartrefresh mode. Only specify if TRUE.
WA_SizeBRight (BOOL) - Place size gadget in right window border
WA_SizeBBottom (BOOL) - Place size gadget in bottom window border
WA_GimmeZeroZero (BOOL)
Create a GimmeZeroZero window. The window borders have their own
layer, so you can't overdraw it. The coordinate 0,0 is related to
the inner area of the window. This makes handling of windows
easier, but it slows down the system.
WA_NewLookMenus (BOOL)
Use DrawInfo colors for rendering the menu bar.
WA_ScreenTitle (STRPTR)
Screen title which is shown when window is active.
WA_AutoAdjust (BOOL)
TRUE means that Intuition can move or shrink the window
to fit on the screen, within the limits given with
WA_MinWidth and WA_MinHeight. This attribute defaults
to TRUE when you call OpenWindowTags() with a NULL pointer
for NewWindow.
WA_InnerWidth
WA_InnerHeight
Dimensions of the interior region of the window.
Note that this restricts border gadgets:
- GACT_LEFTBORDER gadgets can't be GFLG_RELWIDTH if
WA_InnerWidth is used.
- GACT_RIGHTBORDER gadgets must be GFLG_RELRIGHT if
WA_InnerWidth is used.
- GACT_TOPBORDER gadgets can't be GFLG_RELHEIGHT if
WA_InnerHeight is used.
- GACT_BOTTOMBORDER gadgets must be GFLG_RELBOTTOM if
WA_InnerHeight is used.
WA_PubScreen (struct Screen *)
Open the window on the public screen with the given address.
An address of NULL means default public screen. You're
responsible that the screen stays open until OpenWindowTags()
has finished, i.e.
you're the owner of the screen,
you have already a window open on the screen
or you use LockPubScreen()
WA_PubScreenName (STRPTR)
Open the window on the public screen with the given name.
WA_PubScreenFallBack (BOOL)
TRUE means that the default public screen can be used if
the specified named public screen is not available.
WA_Zoom (WORD *)
4 WORD's define the initial Left/Top/Width/Height of the
alternative zoom position/dimension. This adds a zoom
gadget to the window. If both left and top are set to ~0
the window will only be resized.
WA_MouseQueue
Limits the number of possible mousemove messages. Can
be changed with SetMouseQueue().
WA_RptQueue
Limits the number of possible repeated IDCMP_RAWKEY,
IDCMP_VANILLAKEY and IDCMP_IDCMPUPDATE messages.
WA_BackFill (struct Hook *)
Function to be called for backfilling
WA_MenuHelp (BOOL)
Enables menuhelp. Pressing the help key during menu handling
sends IDCMP_MENUHELP messages.
WA_NotifyDepth (BOOL)
If TRUE send IDCMP_CHANGEWINDOW events when window is
depth arranged. Code field will be CWCODE_DEPTH.
WA_Checkmark (struct Image *)
Image to use as a checkmark in menus.
WA_AmigaKey (struct Image *)
Image to use as the Amiga-key symbol in menus.
WA_Pointer (APTR)
The pointer to associate with the window. Use NULL
for the Preferences default pointer. You can create
custom pointers with NewObject() on "pointerclass".
Default: NULL.
WA_BusyPointer (BOOL)
Enable the Preferences busy-pointer.
Default: FALSE.
WA_PointerDelay (BOOL)
Set this to TRUE to delay change of the pointer image.
This avoids flickering of the mouse pointer when it's
changed for short times.
WA_HelpGroup (ULONG)
Get IDCMP_GADGETHELP messages not only from the active
window, but from all its windows.
You have to get a help ID with utility.library/GetUniqueID()
and use it as data for WA_HelpGroup for all windows.
WA_HelpGroupWindow (struct Window *)
Alternative for WA_HelpGroup. Use the helpgroup of
another window.
WA_TabletMessages (BOOL)
Request extended tablet data.
Default: FALSE
WA_ToolBox (BOOL)
Make this window a toolbox window
WA_Parent (struct Window *)
Make the window a child of the given window.
WA_Visible (BOOL)
Make window visible.
Default: TRUE
WA_ShapeRegion (struct Region *)
WA_ShapeHook (struct Hook *)

Tries to (re)open WorkBench screen. If successful return value
is a pointer to the screen structure, which shouldn't be used,
because other programs may close the WorkBench and make the
pointer invalid. If this function fails the return value is NULL.

Query overscan dimensions. The resulting rectangle can be used
with SA_DisplayID.
Overscan types:
OSCAN_TEXT: completely visible. Left/Top is always 0,0.
OSCAN_STANDARD: visible bounds of monitor. Left/Top may be negative.
OSCAN_MAX: The largest displayable region.
OSCAN_VIDEO: The absolute largest region that the graphics.library
can display. This region must be used as-is.

gadgets - The first gadget to be refreshed
window - The gadget must be in this window
requester - If any gadget has GTYP_REQGADGET set, this must
point to a valid Requester. Otherwise the value is ignored.

gadgets - This is the first gadget which will be refreshed.
window - The window which contains the gadget
requester - If the gadget has GTYP_REQGADGET set, this must be
a pointer to a Requester; otherwise the value is
ignored.
numGad - How many gadgets should be refreshed. The value
may range from 0 to MAXLONG. If there are less gadgets
in the list than numGad, only the gadgets in the
list will be refreshed.

Works like a "fast" SetMenuStrip() as it doesn't check Menu or
calculate internal values before attaching the Menu to the Window.
Use this function only if the Menu has been added before by
SetMenuStrip() and you changed nothing in the struct except
CHECKED and ITEMENABLED flags.

Move the specified screen to the front or back, based on passed flag.
If the screen is in a group, the screen will change its position in
the group only. If the screen is the parent of a group, the whole
group will be moved.

screen - Move this screen.
flags - SDEPTH_TOFRONT or SDEPTH_TOBACK for bringing the screen to
front or back.
If the screen is a child of another screen you may specify
SDEPTH_INFAMILY to move the screen within the family. If
not specified the whole family will move.
reserved - For future use. MUST be NULL by now.

I am not sure, if it is enough to just send a SNOTIFY message to one
screen. I would suggest, the former FirstScreen gets a SDEPTH_TOBACK
message and the new FirstScreen gets a SDEPTH_TOFRONT message.
Currently only the screen supplied with ScreenDepth gets a message.
But those messages need to be sent in front of the actual
screen depth change because of the SNOTIFY_WAIT_REPLY-flag must be
able to block the action. But we only know after int_screendepth(),
if there was a change and which change took place.
So I leave it, as it is. This way SNOTIFY_WAIT_REPLY should work
at least. Is there something written in the AutoDocs, how this has
to be done (each screen gets a message)?
(o1i)

Move a screen to the specified position or by the specified
increment. Resolution is always the screen resolution.
If this move would be out of bounds, the move is clipped at
these boundaries. The real new position can be obtained from
LeftEdge and TopEdge of the screen's structure.

screen - Move this screen
flags - One of SPOS_RELATIVE, SPOS_ABSOLUTE or SPOS_MAKEVISIBLE
Use SPOS_FORCEDRAG to override non-movable screens ie. screens
opened with {SA_Draggable,FLASE} attribute.
SPOS_RELATIVE (or NULL) moves the screen by a delta of x1,y1.
SPOS_ABSOLUTE moves the screen to the specified position x1,y1.
SPOS_MAKEVISIBLE moves an oversized scrolling screen to make
the rectangle (x1,y1),(x2,y2) visible
x1,y1 - Absolute (SPOS_ABSOLUTE) or relative (SPOS_RELATIVE) coordinate
to move screen, or upper-left corner of rectangle
(SPOS_MAKEVISIBLE)
x2,y2 - Ignored with SPOS_ABSOLUTE and SPOS_RELATIVE.
Lower-right corner of rectangle with SPOS_MAKEVISIBLE.

Move a screen behind all other screens. If the screen is in a
group, the screen will be moved behind all other screens in the
group only. If the screen is the parent of a group, the whole
group will be moved in the back.

You will see the screen move behind all other screens. If some
screen before this screen occupies the whole display, then it
will disappear completely. If all other screens occupy only part
of the display, the screen will appear behind the screens.

Move a screen in front of all other screens. If the screen is in a
group, the screen will be moved in front of all other screens in the
group only. If the screen is the parent of a group, the whole
group will be moved in the front.

Scrolls the content of the rectangle defined by (xmin,ymin)-
(xmax,ymax) by (dx,dy) towards (0,0). This function calls
ScrollRasterBF().
The advantage of this function over calling ScrollRasterBF() is
that the window will be informed about damages. A damage happens
if in a simple window parts from concelealed areas are scrolled
to visible areas. The visible areas will be blank as simple
windows store no data for concealed areas.
The blank parts that appear due to the scroll will be filled
with EraseRect() and are not considered damaged areas.

win - pointer to window in which to scroll
dx,dy - scroll by (dx,dy) towards (0,0)
xmin,ymin - upper left corner of the rectangle that will be
affected by the scroll
xmax,ymax - lower rigfht corner of the rectangle that will be
affected by the scroll

Scrolls the content of the rectangle defined by (xmin,ymin)-
(xmax,ymax) by (dx,dy) towards (0,0). This function calls
ScrollRasterBF().
The advantage of this function over calling ScrollRasterBF() is
that the window will be informed about damages. A damage happens
if in a simple window parts from concelealed areas are scrolled
to visible areas. The visible areas will be blank as simple
windows store no data for concealed areas.
The blank parts that appear due to the scroll will be filled
with EraseRect() and are not considered damaged areas.

win - pointer to window in which to scroll
dx,dy - scroll by (dx,dy) towards (0,0)
xmin,ymin - upper left corner of the rectangle that will be
affected by the scroll
xmax,ymax - lower rigfht corner of the rectangle that will be
affected by the scroll

Specifies the default public screen for visitor windows to open up on.
The screen is used when a requested public screen is not available
and the FALLBACK option is enabled or when the visitor window asks for
the default public screen.

Try to set the DMRequest of a window. A DMRequest is a requester that
appears if the user double-clicks with the menu button.
The new DMRequest will only be set if the old DMRequest is not in use.
The official way to change the DMRequest is to call ClearDMRequest()
until it returns TRUE and then call SetDMRequest().

This function calculates internal values and is therfore the
official way to add a new MenuStrip to Window.
Always do a ClearMenuStrip() before closing the Window or adding
another MenuStrip to the Window.

window - Change it for this window
pointer - The shape of the new pointer as a bitmap with depth 2.
height - Height of the pointer
width - Width of the pointer (must be <= 16)
xOffset, yOffset - The offset of the "hot spot" relative to the
left, top edge of the bitmap.

prefbuffer - The buffer which contains your settings for the
preferences.
size - The number of bytes of the buffer you want to be copied.
inform - If TRUE, all windows with IDCMP_NEWPREFS IDCMPFlags set
get an IDCMP_NEWPREFS message.

modes - The new set of flags to consider. Currently defined flags are:
SHANGHAI: Workbench windows are opened on the default public
screen.
POPPUBSCREEN: When a visitor window opens on a public screen, the
screen is brought to front.

window - Change the title for this window or the screen which the
window contains.
windowTitle - New title for the window or ((UBYTE *)~0L) to keep the
old title or NULL for no title. If you specify a string,
this string is *NOT* copied.
screenTitle - New title for the screen of the window or ((UBYTE *)~0L)
to keep the old title or NULL for no title. If you specify
a title for the screen, this title will be shown when the
window becomes active. If you specify a string, this string
is *NOT* copied.

Modify SHOWTITLE flag of the screen and refresh the screen and
its windows.
If ShowIt is TRUE the screen's title bar will be shown in front of
WFLG_BACKDROP windows. A value of FALSE will bring the title bar
behind all windows.

SNA_PubName (STRPTR) - Name of the public screen. NULL means
you'll get notifications for all
screens.
SNA_MsgPort (struct MsgPort*) - Notifications will be sent to this
port.
SNA_SigBit (BYTE) - The signal bit to use
SNA_SigTask (struct Task*) - The task to signal
SNA_UserData (IPTR) - For your personal use. Will be copied
into snm_UserData of the messages you
receive.
SNA_Hook (struct Hook*)
SNA_Priority (Byte) - Priority in the notification queue.
SNA_Notify (ULONG) - SNOTIFY_ flags, see
intuition/intuition.h

Handles a requester, which was opened with BuildSysRequest() or
BuildEasyRequestArgs(). When this function is called all outstanding
IDCMP requests are processed. If an IDCMP request that would close
a normal EasyRequestArgs() is encountered, SysReqHandler() returns
with a return code equally to the return code EasyRequestArgs()
would have returned. You may call this function in synchronous or
asynchronous mode, by setting the WaitInput parameter.

window - The window pointer returned by either BuildSysRequest() or
BuildEasyRequestArgs().
IDCMPFlagsPtr - Pointer to a ULONG to store the IDCMP flag that was
received by the window. This will be set if you
provided additional IDCMP flags to BuildSysRequest() or
BuildEasyRequest(). You may set this to NULL. You must
initialize the pointed to ULONG every time you call
SysReqHandler().
WaitInput - Set this to TRUE, if you want this function to wait for
the next IDCMP request, if there is none at the moment
the function is called.

-2, if the requester was not satisfied. Normally you want to call
this function at least until this function returns something
different than -2.
-1, if one of the IDCMP flags of idcmpPTR was set.
0, if the rightmost button was clicked or an error occured.
n, if the n-th button from the left was clicked.

Release a lock to a screen locked by LockPubScreen().
Identify screen by the pointer returned from LockPubScreen()
and pass NULL name in normal cases.
Sometimes it might be useful to specify the name string. In
this case the screen pointer will be ignored.