Link the AnimOb into the list pointed to by AnimKey.
Calls AddBob with all components of a Bob and initializes
all the timers of the components of this AnimOb.
You have to provide a valid GelsInfo structure that is linked
to the RastPort (InitGels())

anOb = pointer to AnimOb structure to be added to list of
AnimObs
anKey = address of a pointer to the first AnimOb in the list
(when first calling this function the content of
this address has to be NULL!)
rp = pointer to a valid RastPort with initialized GelsInfo
structure

gfxhidd - A pointer to an OOP class of the display driver
attrs - Additional attributes to supply to the driver class during
object creation
tags - An optional TagList describing how graphics.library should
handle the driver. Valid tags are:
DDRV_BootMode - A boolean value telling that a boot mode
driver is being added. Boot mode drivers
will automatically shut down on next
AddDisplayDriverA() call, unless
DDRV_KeepBootMode = TRUE is specified.
Defaults to FALSE.
DDRV_MonitorID - Starting monitor ID to assign to the driver.
Use it with care. An attempt to add already
existing ID will fail with a DD_ID_EXISTS
code. By default the next available ID will
be picked up automatically.
DDRV_ReserveIDs - The number of subsequent monitor IDs to
reserve. Reserved IDs can be reused only
with DDRV_MonitorID tag. This tag is
provided as an aid to support possible
removable display devices. Defaults to 1.
DDRV_KeepBootMode - Do not shut down boot mode drivers. Use this
tag if you are 100% sure that your driver
won't conflict with boot mode driver (like
VGA or VESA) and won't attempt to take over
its hardware. Defaults to FALSE.
DDRV_ResultID - A pointer to a ULONG location where the ID
assigned to your driver will be placed.
Useful if you reserve some ID for future use.
Note that the returned ID will be the one
just assigned to your driver instance.
Increment it yourself in order to obtain
other reserved IDs.
DDRV_IDMask - A mask for separating the monitor ID from the
HIDD-specific part. This mask specifies what
mode ID bits are the monitor ID and what bits
actually specify the mode. The default value
is 0xFFFF0000.
Using the mask you can split your monitor ID
into 'sub-Ids'. Example:
Supplied tags: DDRV_IDMask, 0xFFFFFF00,
DDRV_ResultID, &myid
After a successful call, myid will contain the
base ID assigned by graphics.library to your
driver, let's say 0x00140000. However, since
you specified a longer mask, you leave only
one byte for mode designation, and reserve
the whole range of IDs from 0x001400xx to
0x0014FFxx for different instances of your
driver. They can now be used by specifying
DDRV_MonitorID with corresponding value.
Note that for this feature to work correctly,
you also need to override ID processing in
your driver class. Default methods provided
by the hidd.graphics.graphics base class
suppose that the whole lower word of the mode
ID specifies the display mode.
It is generally not allowed to specify
shorter masks than 0xFFFF0000. The only
driver which can do this is the Amiga(TM)
chipset driver, which needs to occupy the
reserved range of IDs from 0x0000xxxx to
0x000Axxxx. In any other case, supplying a
short mask will cause undefined behavior.
Since DDRV_ReserveIDs provides a simpler way
to reserve IDs for your driver (without the
need to override mode ID processing), this
option can be considered experimental and
even private. In fact the primary reason for
it to exist is to provide support for
Amiga(tm) chipset driver.

error - One of following codes:
DD_OK - Operation completed OK.
DD_NO_MEM - There is not enough memory to set up internal
data.
DD_ID_EXISTS - Attempt to assign monitor IDs that are already
used.
DD_IN_USE - One of boot-mode drivers is in use and cannot
be shut down.
DD_DRIVER_ERROR - Failure to create driver object.

sizex, sizey - The width and height in pixels
depth - The depth of the bitmap. A depth of 1 will allocate a
bitmap for two colors, a depth of 24 will allocate a bitmap for
16 million colors. Pixels with AT LEAST this many bits will be
allocated.
flags - One of these flags:
BMF_CLEAR: Fill the bitmap with color 0.
BMF_DISPLAYABLE: to specify that this bitmap data should
be allocated in such a manner that it can be displayed.
Displayable data has more severe alignment restrictions
than non-displayable data in some systems.
Note that it may be not enough to specify only this flag
to make the bitmap really displayable. See "INTERNALS"
section below.
BMF_INTERLEAVED: tells graphics that you would like your
bitmap to be allocated with one large chunk of display
memory for all bitplanes. This minimizes color flashing on
deep displays. If there is not enough contiguous RAM for an
interleaved bitmap, graphics.library will fall back to a
non-interleaved one.
BMF_MINPLANES: causes graphics to only allocate enough
space in the bitmap structure for "depth" plane pointers.
This is for system use and should not be used by
applications use as it is inefficient, and may waste
memory.
BMF_SPECIALFMT: causes graphics to allocate a bitmap
of a standard CyberGraphX format. The format
(PIXFMT_????) must be stored in the 8 most significant bits.
BMF_RTGTAGS,
BMF_RTGCHECK,
BMF_FRIENDSTAG: Setting these flags to 1's while BMF_SPECIALFMT
and BMF_INVALID are set to 0 means that friend_bitmap
points to a taglist instead of BitMap structure.
friend_bitmap - pointer to another bitmap, or NULL. If this pointer
is passed, then the bitmap data will be allocated in
the most efficient form for blitting to friend_bitmap.
This pointer can also point to a TagList, if specified by flags.
In this case it may contain the following tags:
- BMATags_Friend (struct BitMap *)
An actual pointer to friend bitmap. Defaults to NULL.
- BMATags_Depth (ULONG)
Depth of the bitmap to create. Defaults to depth argument
of AllocBitMap().
- BMATags_Clear (BOOL)
Tells if the newly created bitmap should be explicitly
cleared. Defaults to the value of BMF_CLEAR flag in
AllocBitMap() arguments.
- BMATags_Displayable (BOOL)
Tells if the bitmap should be displayable by the hardware.
Defaults to the value of BMF_DISPLAYABLE flag in AllocBitMap()
arguments.
- BMATags_NoMemory (BOOL)
Tells AllocBitMap() not to allocate actual bitmap storage. Only
header is allocated and set up. Default value is FALSE.
- BMATags_DisplayID (ULONG)
Allocate a displayable bitmap for specified display mode.

When allocating using a friend_bitmap bitmap, it is not safe to assume
anything about the structure of the bitmap data if that friend_bitmap
BitMap might not be a standard Amiga bitmap (for instance, if the
workbench is running on a non-Amiga display device, its
Screen->RastPort->BitMap won't be in standard Amiga format. The
only safe operations to perform on a non-standard BitMap are:
blitting it to another bitmap, which must be either a
standard Amiga bitmap, or a friend_bitmap of this bitmap.
blitting from this bitmap to a friend_bitmap bitmap or to a
standard Amiga bitmap.
attaching it to a rastport and making rendering calls.
Good arguments to pass for the friend_bitmap are your window's
RPort->BitMap, and your screen's RastPort->BitMap. Do NOT pass
&(screenptr->BitMap)!
BitMaps not allocated with BMF_DISPLAYABLE may not be used as
Intuition Custom BitMaps or as RasInfo->BitMaps. They may be
blitted to a BMF_DISPLAYABLE BitMap, using one of the BltBitMap()
family of functions.
When allocating a displayable bitmap, make sure that its size is
within limits allowed by the display driver. Use GetDisplayInfoData()
with DTAG_DIMS in order to obtain the needed information.

SPRITEA_Width (ULONG) - Width of the sprite. If bitmap is smaller it will
be filled on the right side with transparent
pixels. Defaults to 16.
SPRITEA_XReplication (LONG) - 0 - perform a 1 to 1 conversion
1 - each pixel from the source is replicated twice
2 - each pixel is replicated 4 times.
-1 - skip every 2nc pixel in the source bitmap
-2 - only include every fourth pixel from the source.
SPRITEA_YReplication (LONG) - like SPRITEA_YReplication, but for vertical direction.
SPRITEA_OutputHeight (ULONG) - Output height of the sprite. Must be at least as high
as the bitmap. Defaults to bitmap height.
SPRITEA_Attach - (Not implemented)

Animate every AnimOb in the list. In particular do the following:
- update location and velocities
- call AnimOb's special routine if supplied
- for every component of the Anim ob do:
- switch to new sequence if current sequence times out
- call the special routine of the component if supplied
- set the the coordinates of the VSprite of this
sequence to whatever these routines cause
INPUT
anKey = address of a pointer to the first AnimOb in the list
(same address that was passed to AddAnimOb!)
rp = pointer to a valid RastPort structure

rp - pointer to a valid RastPort structure with a pointer to
the previously initialized AreaInfo structure.
cx - x coordinate of the center point relative to rastport
cy - y coordinate of the center point relative to rastport
a - horizontal radius of the ellipse (> 0)
b - vertical radius of the ellipse (> 0)

Process the filled vector buffer.
After the operation the buffer is reinitialized for
processing of further Area functions.
Makes use of the raster given by the TmpRas structure that
is linked to the rastport.

There is still a problem when some polygons are filled that
pixels are missing. This could be due to the way lines are
drawn. All lines should be drawn from lower
y coordinates to higher y coordinates since this is the
way the algorithm calculates lines here. For example, it
might make a difference whether a line is drawn from lower
to higher y coordinates. Examples for two same lines with
different layout:
**** *****
***** ****

Define a new starting point in the vector list for the following
polygon defined by calls to AreaDraw(). The last polygon is closed
if it wasn't closed by the user and the new starting points are
added to the vector collection matrix.

rp - pointer to a valid RastPort structure with a pointer to
the previously initialized AreaInfo structure.
x - x-coordinate of the starting-point in the raster
y - y-coordinate of the starting-point in the raster

Try to lock the current layer. If it is already locked this
function will return FALSE, TRUE otherwise.
If the layer could be locked successfully nesting will take place
which means that for every successful locking of a layer
UnlockLayerRom() has to be called for that layer to let other
tasks access that layer.

Pass a BitScaleArgs structure filled with the following arguments
to this function:
bsa_SrcX, bsa_SrcY - upper left coordinate in source bitmap
bsa_SrcWidth, bsa_SrcHeight - Width and Height of source bitmap
bsa_DestX, bsa_DestY - upper left coordinate in destination
bitmap
bsa_DestWidth, bsa_DestHeight - this function will set these
values. Use the bsa_???Factor for scaling
bsa_XSrcFactor:bsa_XDestFactor - Set these to get approximately
the same ratio as bsa_SrcWidth:bsa_DestWidth, but
usually not exactly the same number.
bsa_YSrcFactor:bsa_YDestFactor - Set these to get approximately
the same ratio as bsa_SrcHeight:DestHeight, but
usually not exactly the same number.
bsa_SrcBitMap - pointer to source bitmap to be scaled
bsa_DestBitMap - pointer to destination bitmap which will
hold the scaled bitmap. Make sure it's
big enough!
bsa_Flags - reserved for future use. Set it to zero!
bsa_XDDA, bsa_YDDA - for future use.
bsa_Reserved1, bsa_Reserved2 - for future use.

- Overlapping source and destination bitmaps are not supported
- Make sure that you provide enough memory for the destination
bitmap to hold the result
- In the destination bitmap only the area where the scaled
source bitmap is put into is changed. A frame of the old
bitmap is left.

srcBitMap - Copy from this bitmap.
xSrc, ySrc - This is the upper left corner of the area to copy.
destBitMap - Copy to this bitmap. May be the same as srcBitMap.
xDest, yDest - Upper left corner where to place the copy
xSize, ySize - The size of the area to copy
minterm - How to copy. Most useful values are 0x00C0 for a vanilla
copy, 0x0030 to invert the source and then copy or 0x0050
to ignore the source and just invert the destination. If
you want to calculate other values, then you must know that
channel A is set, if you are inside the rectangle, channel
B is the source and channel C is the destination of the
rectangle.
Bit ABC
0 000
1 001
2 010
3 011
4 100
5 101
6 110
7 111
So 0x00C0 means: D is set if one is inside the rectangle
(A is set) and B (the source) is set and cleared otherwise.
To fill the rectangle, you would want to set D when A is
set, so the value is 0x00F0.
mask - Which planes should be copied. Typically, you should set
this to ~0L.
tempA - If the copy overlaps exactly to the left or right (i.e. the
scan line addresses overlap), and tempA is non-zero, it
points to enough chip accessible memory to hold a line of a
source for the blit (i.e. CHIP RAM). BltBitMap will allocate
(and free) the needed TempA if none is provided and one is
needed. Blit overlap is determined from the relation of
the first non-masked planes in the source and destination
bit maps.

If a special hardware is available, this function will use it.
As a special case, plane pointers of destBitMap can contain NULL
or -1, which will act as if the plane was filled with 0's or 1's,
respectively.

memBlock - pointer to beginning of memory to be cleared
flags - set bit 0 to force function to wait until
the blitter - if used - is done
set bit 1 for row/bytesperrow - mode
bytecount - if bit 1 is set to 1: bytecount contains an even number
of bytes to clear
if bit 1 is set to 0: low 16 bits are taken as number of
bytes per row and upper 16 bits
are taken as number of rows.

source - pointer to the aligned UWORD in which the top-lefthand corner
of the template is located.
xSrc - bit offset of top-lefthand corner of template from start of
UWORD pointed to by 'source' input (0 to 15).
srcMod - number of bytes per row in template's bitplane.
destRP - destination RastPort.
xDest,yDest - upper left corner of destination.
xSize,ySize - size of destination.

vp - pointer to ViewPort structure that this sprite is
relative to, or NULL if relative only top of View
oldsprite - pointer to the old ExtSprite structure
newsprite - pointer to the new ExtSprite structure
tags - pointer to taglist

vp - pointer to a viewport
bm - pointer to a BitMap structure. This BitMap structure must be of
the same layout as the one attached to the viewport
(same depth, alignment and BytesPerRow)
db - pointer to a DBufInfo

Copies the contents of one rastport to another rastport.
Takes care of layered and non-layered source and destination
rastports.
If you have a window you should always use this function instead
of BltBitMap().

srcRP - Copy from this RastPort.
xSrc, ySrc - This is the upper left corner of the area to copy.
destRP - Copy to this RastPort.
xDest, yDest - Upper left corner where to place the copy
xSize, ySize - The size of the area to copy
minterm - How to copy. Most useful values are 0x00C0 for a vanilla
copy, 0x0030 to invert the source and then copy or 0x0050
to ignore the source and just invert the destination. If
you want to calculate other values, then you must know that
channel A is set, if you are inside the rectangle, channel
B is the source and channel C is the destination of the
rectangle.
Bit ABC
0 000
1 001
2 010
3 011
4 100
5 101
6 110
7 111
So 0x00C0 means: D is set if one is inside the rectangle
(A is set) and B (the source) is set and cleared otherwise.
To fill the rectangle, you would want to set D when A is
set, so the value is 0x00F0.

RealViewPort - ViewPort to coerce
MonitorID - Monitor number to coerce to
(i.e. a mode masked with MONITOR_ID_MASK)
Flags - PRESERVE_COLORS - keep the number of bitplanes
in the ViewPort
AVOID_FLICKER - do not coerce to an interlace mode

If the layer has a superbitmap all the parts that are visible will
be refreshed with what is in the superbitmap. This function should
be called after the SuperBitMap of the layer was synchronized with
SyncSBitMap() and manipulated.

Add a copper wait instruction to the given user copper list.
The copper is told to wait for a vertical beam position v and
a horizontal beam position h.
If you are using CWAIT() a call to CWait() and CBump() will
be made.

Neither effects of algorithmic additions nor rp_TxSpacing is included
when the bounding box and font size are calculated. Note that te_Width
only will be negative when FPF_REVPATH is specified for the font; left
moving characters are ignored considering the font width (right moving
character when FPF_REVPATH is set), but affects the bounding box size.

Deallocate all buffers for a whole AnimOb. In particular this
means getting buffers for
- BorderLine
- SaveBuffer
- CollMask
- ImageShadow (points to the same memory as CollMask does)
- if db is set to TRUE the user wants double-buffering, so we need
- DBufPacket
- BufBuffer

Allocates and initializes a ColorMap structure and passes back the
pointer. This enables you to do calls to SetRGB4() and LoadRGB4()
to load colors for a view port.
The ColorTable pointer in the ColorMap structure points to a hardware
specific colormap data structure which you should not interpret.

Allocate all buffers for a whole AnimOb. In particular this
means getting buffers for
- BorderLine
- SaveBuffer
- CollMask
- ImageShadow (points to the same memory as CollMask does)
- if db is set to TRUE the user wants double-buffering, so we need
- DBufPacket
- BufBuffer

cm - ColorMap structure obtained via GetColorMap()
firstcolor - the index of first color register to get (starting with 0)
ncolors - the number of color registers to examine and write
into the table
table - a pointer to an array of 32 bit RGB triplets

Read the current settings of a RastPort into variables.
The ti_Tag field specifies the attribute to read and the
ti_Data field points to an address where to store the result.
All results are stored as IPTRs!

Try to get a hardware sprite for the simple sprite manager.
There are eight sprites available in the system and by calling
this function you can allocate one for yourself. You have to
call this function before talking to other sprite routines.
If you want a 15 color sprite, you must allocate both sprites
(see the manual!) and set the SPRITE_ATTACHED bit in the
odd sprite's posctldata array.

-1 - if the selected sprite is not available (pick was 0-7) or
no further sprites are available (pick was -1). -1 will
also be found in the SimpleSprite structure.
0-7: The sprite number of your allocated sprite. The number will
also be found in the SimpleSprite structure.

Associate a special graphics extended data structure with another
structure via the other structure's pointer. Later, when you call
GfxLookUp() with the other structure's pointer you may receive
the pointer to this special graphics extended data structure, if it
is available

Makes the two VSprites head and tail of the gel list that is connected
to the GelsInfo structure. The two VSprites are linked together and
their x and y coordinates are initialized such that the serve as the
keystones of the list.

head - pointer to the VSprite structure to be used as head of the gel list
tail - pointer to the VSprite structure to be used as tail of the gel list
GInfo - pointer to the GelsInfo structure to be initialized

vp - ViewPort
table - pointer to table of records
1 Word with the number of colors to load
1 Word with the first color to be loaded.
3 Longwords representing a left justified 32 bit RGB triplet.
The list is terminated by a count value of 0.

Locks the layer. Returns when the layer is locked for
exclusive use.
This call behaves like when a semaphore is locked. The
same task may lock the same layer several times without
locking itself out. For every call to this function a
call to UnlockLayerRom() has to be made as the calls nest.
This function will also prevent intuition from locking the
layer so the layer should not be blocked too long.
This function does exactly the same as layers/LockLayer()

error - Result of the operation:
MVP_OK - Everything is OK, ViewPort is ready
MVP_NO_MEM - There was not enough memory for internal data
MVP_NO_VPE - There was no ViewPortExtra for this ViewPort and no memory to
allocate a temporary one.
MVP_NO_DSPINS - There was not enough memory for Amiga(tm) copperlist.
MVP_NO_DISPLAY - The BitMap can't be displayed using specified mode (for example,
misaligned or wrong depth).

Move sprite to a new position on the screen. Coordinates
are specified relatively to given ViewPort, or relatively
to the entire View (physical display) if the ViewPort is NULL.
This function works also with extended sprites, since
struct SimpleSprite is a part of struct ExtSprite.

AROS currently supports only one sprite #0 for mouse pointer.
Other sprite numbers are ignored by this function.
ViewPort is also used in order to specify the physical display.
If it's not specified, Amiga(tm) chipset display is assumed.
This is available only on Amiga(tm) architecture.

Prepare the view for being displayed. Calculate necessary internal data.
For Amiga(tm) chipset this function also merges together the display, color, sprite and user
coprocessor instructions into a single coprocessor instruction stream.

Shared palette entries should not be changed (via SetRGB??())
since other applications might use the same color.
A PaletteExtra structure must have been attached to the
ColorMap prior to calling this function (AttachPalExtra()).

The blitter is allocated for exclusive use by the calling task.
This function returns immediately if no other task is using
the blitter right now or if no blits are in the queues (QBlit(),
QBSBlit()). Otherwise the function will block until the blitter
can be accessed.
It is good practice to start the blitter immediately after calling
this function and then call DisownBlitter() so other tasks can
use the blitter.

The routine that function in the bltnode is pointing to is
called when the blitter is ready for work. No other task will
be able to access the blitter while you're doing the blit.
Queued blits have precedence over a task that tries to own the
blitter via OwnBlitter(). So all queued blitter requests will
be done first until the task that attempts a OwnBlitter can
actually access the blitter.

Not all hardware has a blitter. On hardware where there is no
blitter, a blitter is simulated. Therefore all code that will
be executed in the function that is called must not contain
code that is hacking the blitter's register but should contain
calls to graphics functions instead.

The routine that function in the bltnode is pointing to is
called when the blitter is ready for work. No other task will
be able to access the blitter while you're doing the blit.
Queued blits have precedence over a task that tries to own the
blitter via OwnBlitter(). So all queued blitter requests will
be done first until the task that attempts a OwnBlitter can
actually access the blitter.

Not all hardware has a blitter. On hardware where there is no
blitter, a blitter is simulated. Therefore all code that will
be executed in the function that is called must not contain
code that is hacking the blitter's register but should contain
calls to graphics functions instead.

Use this to precalculate the width/height of the destination
bitmap. As factor give the width/height of the original bitmap
that is to be scaled via ScaleBitMap(), as numerator give
the value you will write into bsa_XSrcFactor/bsa_YSrcFactor
and as denominator the value of bsa_XDestFactor/bsa_YDestFactor.

Scroll the contents of a rastport (dx,dy) towards (0,0).
The empty spaces is filled by a call to RectFill().
Only the pixel in the rectangle (xMin,yMin)-(xMax,yMax)
will be affected. The lower right corner (xMax, yMax) is
automatically adjusted to the lower right corner in case
it would be outside.
After this operation the Flags bit of the layer associated
with this rastport, if there is any layer, should be tested
for simple layers in case there has any damage been created.

Scroll the contents of a rastport (dx,dy) towards (0,0).
The empty spaces is filled by a call to EraseRect().
Only the pixel in the rectangle (xMin,yMin)-(xMax,yMax)
will be affected. The lower right corner (xMax, yMax) is
automatically adjusted to the lower right corner in case
it would be outside.
After this operation the Flags bit of the layer associated
with this rastport, if there is any layer, should be tested
for simple layers in case there has any damage been created.

region - pointer to a region structure
rect - pointer to the rectangle within which the scrolling has to happen.
If NULL, the region's bounds are used instead.
dx, dy - the amount of pixels by which to scroll the region. Negative values mean
respectively left and up, positive values mean right and down.

AROS video drivers can perform a validation of offsets, and may refuse
to scroll the screen too far (if they somehow can't provide the requested
offset). In this case offset values in the ViewPort will be updated in
order to reflect the real result of the operation.

Specify a display driver notification callback.
The callback function is called using "C" calling convention and its
declaration should have a form:
APTR DriverNotify(APTR object, BOOL add, APTR userdata);
The function will be called upon display driver insertion and removal.
Upon insertion the parameters will be the following:
object - A pointer to a struct MonitorHandle for the new driver
add - TRUE, indicates driver insertion
userdata - User data originally passed to SetDisplayDriverCallback()
The function should return a pointer to opaque data object which will
be stored in the display driver handle structure.
Upon driver removal the parameters mean:
object - A pointer to opaque object returned by the callback when
the driver was added.
add - FALSE, indicates driver removal.
userdata - User data originally passed to SetDisplayDriverCallback()
Callback return value is ignored in removal mode.

Set the maximum pen value for a rastport. This will instruct the
graphics.library that the owner of the rastport will not be rendering
in any colors whose index is >maxpen. Therefore speed optimizations
on certain operations are possible and will be done.
Basically this call sets the rastport mask, if this would improve speed.
On devices where masking would slow things down (chunky pixels), it will
be a no-op.

Sets the destination region to the source region.
Allocates necessary RegionRectangles if necessary
and deallocates any excessive RegionRectangles in
the destination Region. The source Region remains
untouched.
If the system runs out of memory during allocation
of RegionRectangles the destination Region will
.

vp - Modify this viewport
n - Change this color. If the color is outside the range of
valid colors, it will be ignored.
r, g, b - The new values for the red, green and blue. The
valid range is from 0x000000 (no intensity) to
0xFFFFFFFF (full intensity).

If there is a ColorMap for this viewport, then the value will
be stored in the ColorMap.
The selected color register is changed to match your specs.
If the color value is unused then nothing will happen.

Lower order bits of the palette specification will be discarded,
depending on the color palette resolution of the target graphics
device. Use 0xffffffff for the full value, 0x7fffffff for 50%,
etc. You can find out the palette range for your screen by
querying the graphics data base.

Store the (r,g,b) triplet at index n in the ColorMap structure.
The changes will not be immediately displayed. Use this function
before linking the ColorMap to a ViewPort. Do not access the entries
in the ColorTable yourself, as the ColorTable format is subject to
change.

vp - Modify this viewport
n - Change this color. If the color is outside the range of
valid colors, it will be ignored.
r, g, b - The new values for the red, green and blue. The
valid range is from 0x0 (no intensity) to
0xF (full intensity).

If there is a ColorMap for this viewport, then the value will
be stored in the ColorMap.
The selected color register is changed to match your specs.
If the color value is unused then nothing will happen.

Lower order bits of the palette specification will be discarded,
depending on the color palette resolution of the target graphics
device. Use 0xf for the full value, 0x7 for 50%,
etc. You can find out the palette range for your screen by
querying the graphics data base.

Setting one of RPTAG_ClipRectangle or RPTAG_ClipRectangleFlags
allocates internal extra data for the RastPort. After finishing using
this RastPort, you need to manually deallocate the extra data using
FreeVec(rp->RP_Extra).

The style bits used hereinafter (the font may not support all the styles
you wish to set). Note that this is possibly more style bits than you
affected by calling SetSoftStyle() as a font may have intrinsic style
bits set.

If the layer has a superbitmap all the parts that are visible will
be copied into the superbitmap. This is usually not done except when
parts of a superbitmapped layer become hidden the visible parts are
stored into the superbitmap.

rp - RastPort
string - address of string
count - number of characters
textExtent - storing place for the result
te_Width - same as TextLength() result: the rp_cp_x
advance that rendering this text would cause.
te_Height - same as tf_YSize. The height of the
font.
te_Extent.MinX - the offset to the left side of the
rectangle this would render into.
Often zero.
te_Extent.MinY - same as -tf_Baseline. The offset
from the baseline to the top of the
rectangle this would render into.
te_Extent.MaxX - the offset of the left side of the
rectangle this would render into.
Often the same as te_Width-1.
te_Extent.MaxY - same as tf_YSize-tf_Baseline-1.
The offset from the baseline to the
bottom of the rectangle this would
render into.

rp - Use the settings in this RastPort (e.g. Font)
string - Use this string
strLen - The length of the string
textExtent - The size actually occupied will be returned here
constrainingExtent - If non-NULL, the routine will use the
dimensions of the box described here
strDirection - In which is the next character. Must be either 1
or -1. If it is -1, then string must point to the end (the
first character to check) of the text to fit (this is for
checking text which runs from right to left).
constrainingBitWidth - If constrainingExtent is NULL, then this
is the width of the bounding box.
constrainingBitHeight - If constrainingExtent is NULL, then this
is the height of the bounding box.

Unlocks a previously locked layer for access by other applications
or intuition itself.
If a task has locked a layer multiple times it must unlock it
as many times as well as locks nest.
This functions does the same as layers/UnlockLayerRom()

rp - destination RastPort
xstart,ystart - starting point
xstop,ystop - stopping point
array - array with pen values
bytesperrow - The number of bytes per row in the source array.
This should be at least as large as the number of pixels
being written per line.

rp - destination RastPort
xstart,ystart - starting point
xstop,ystop - stopping point
array - array of pen values. Size must be at least
(((width+15)>>4)<<4)*(ystop-ystart+1) bytes.
temprp - temporary rastport
(copy of rp with Layer set to NULL,
temporary memory allocated for
temprp->BitMap with Rows set to 1,
temprp->BitMap with BytesPerRow set to ((width+15)>>4)<<1,
and temporary memory allocated for
temprp->BitMap->Planes[])