home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD1.iso / FileMover / HF-OM1.DMS / in.adf / OpusSDK.lha / SDK / docs / gui.doc < prev    next >
Encoding:
Text File  |  1996-08-28  |  11.4 KB  |  371 lines
  1. dopus5.library/ActivateStrGad                   dopus5.library/ActivateStrGad
  2.  
  3.     NAME
  4.         ActivateStrGad - Activate a string gadget.
  5.  
  6.     SYNOPSIS
  7.         ActivateStrGad(gadget, window)
  8.                          A0      A1
  9.  
  10.         void ActivateStrGad(struct Gadget *, struct Window *);
  11.  
  12.     FUNCTION
  13.         This function activates a string gadget in a window. The difference
  14.         between this and the standard ActivateGadget() call is that the
  15.         cursor will be positioned at the end of the string.
  16.  
  17.     INPUTS
  18.         gadget - string gadget you wish to activate
  19.         window - window the gadget is in
  20.  
  21.     SEE ALSO
  22.         intuition.library/ActivateGadget()
  23.  
  24. dopus5.library/AddScrollBars                     dopus5.library/AddScrollBars
  25.  
  26.     NAME
  27.         AddScrollBars - Add BOOPSI scrollers to a window
  28.  
  29.     SYNOPSIS
  30.         AddScrollBars(window, list, drawinfo, flags)
  31.                         A0     A1      A2       D0
  32.  
  33.         struct Gadget *AddScrollBars(struct Window *, struct List *,
  34.                                      struct DrawInfo *, short);
  35.  
  36.     FUNCTION
  37.         This function adds BOOPSI scrollers (proportional gadget and two
  38.         arrows) to a window. It can add scrollers either horizontally,
  39.         vertically or both.
  40.  
  41.     INPUTS
  42.         window - window to add scrollers to. The window must have a border
  43.         for the side(s) you wish to add scrollers to. For example, if you
  44.         add a horizontal scroller, the window must have a bottom border
  45.         (ie the WFLG_SIZEBBOTTOM flag is set).
  46.  
  47.         list - this must point to an initialise List structure. The
  48.         gadgets created by this routine will be added to this List, which
  49.         can later be freed by BOOPSIFree().
  50.  
  51.         drawinfo - pointer to the screen's DrawInfo structure
  52.  
  53.         flags - the type of scrollers you want :
  54.  
  55.                 SCROLL_VERT     - vertical scroller
  56.                 SCROLL_HORIZ    - horizontal scroller
  57.                 SCROLL_NOIDCMP  - this flag signified that the scrollers
  58.                                   are only to return the normal
  59.                                   IDCMP_GADGETUP, IDCMP_GADGETDOWN and
  60.                                   IDCMP_MOUSEMOVE messages. If not
  61.                                   specified, the gadgets also generate
  62.                                   IDCMP_IDCMPUPDATE messages.
  63.  
  64.     RESULT
  65.         This routine returns 0 if it fails. If it succeeds, it returns a
  66.         pointer to the last gadget created. This pointer is not particularly
  67.         useful; it just signifies success. To actually add the gadgets to the
  68.         window, call AddGList() on the first gadget in the supplied List
  69.         structure, and then RefreshGList().
  70.  
  71.         The gadgets created by this function have pre-defined IDs. If you
  72.         use this routine you should make sure that your own gadgets do not
  73.         conflict with these IDs. See the "dopus/gui.h" file for the ID values.
  74.  
  75.     SEE ALSO
  76.         FindBOOPSIGadget(), BOOPSIFree(),
  77.         intuition.library/GetScreenDrawInfo(), intuition.library/AddGList(),
  78.         intuition.library/RefreshGList()
  79.  
  80. dopus5.library/BOOPSIFree                           dopus5.library/BOOPSIFree
  81.  
  82.     NAME
  83.         BOOPSIFree - free a list of BOOPSI gadgets
  84.  
  85.     SYNOPSIS
  86.         BOOPSIFree(list)
  87.                     A0
  88.  
  89.         void BOOPSIFree(struct List *);
  90.  
  91.     FUNCTION
  92.         This routine iterates through a list of BOOPSI gadgets, calling
  93.         DisposeObject on each one in turn. It then reinitialises the list.
  94.  
  95.     INPUTS
  96.         list - List of gadgets to free
  97.  
  98.     SEE ALSO
  99.         AddScrollBars(), intuition.library/DisposeObject()
  100.  
  101. dopus5.library/DisposeBitMap                     dopus5.library/DisposeBitMap
  102.  
  103.     NAME
  104.         DisposeBitMap - free a bitmap created with NewBitMap()
  105.  
  106.     SYNOPSIS
  107.         DisposeBitMap(bm)
  108.                       A0
  109.  
  110.         void DisposeBitMap(struct BitMap *);
  111.  
  112.     FUNCTION
  113.         This routine frees a bitmap and the associated bitplanes that was
  114.         allocated with the NewBitMap() function. Under OS39 it simply passes
  115.         the bitmap through to the graphics.library FreeBitMap() call. Under
  116.         OS37 it frees the bitmap and bitplanes manually.
  117.  
  118.     INPUTS
  119.         bm - BitMap to free
  120.  
  121.     RESULT
  122.         The BitMap is freed.
  123.  
  124.     SEE ALSO
  125.         NewBitMap(), graphics.library/FreeBitMap()
  126.  
  127. dopus5.library/DrawBox                                 dopus5.library/DrawBox
  128.  
  129.     NAME
  130.         DrawBox - draw a 3D box
  131.  
  132.     SYNOPSIS
  133.         DrawBox(rp, rect, info, recessed)
  134.                 A0   A1    A2      D0
  135.  
  136.         void DrawBox(struct RastPort *, struct Rectangle *,
  137.                      struct DrawInfo *, BOOL);
  138.  
  139.     FUNCTION
  140.         This routine draws a single-pixel 3D box, using the current pen
  141.         settings in the DrawInfo you supply.
  142.  
  143.     INPUTS
  144.         rp - RastPort to draw into
  145.         rect - Rectangle to draw
  146.         info - Screen's DrawInfo
  147.         recessed - set to TRUE if you want a recessed box
  148.  
  149.     SEE ALSO
  150.         intuition.library/GetScreenDrawInfo()
  151.  
  152. dopus5.library/DrawFieldBox                        dopus5.libary/DrawFieldBox
  153.  
  154.     NAME
  155.         DrawFieldBox - draw a 3D field box
  156.  
  157.     SYNOPSIS
  158.         DrawFieldBox(rp, rect, info)
  159.                      A0   A1    A2
  160.  
  161.         void DrawFieldBox(struct RastPort *, struct Rectangle *,
  162.                           struct DrawInfo *);
  163.  
  164.     FUNCTION
  165.         Draws a 3D field box (eg the path field in DOpus listers).
  166.  
  167.     INPUTS
  168.         rp - RastPort to draw into
  169.         rect - Rectangle to draw
  170.         info - Screen's DrawInfo
  171.  
  172.     SEE ALSO
  173.         intuition.library/GetScreenDrawInfo()
  174.  
  175. dopus5.library/FindBOOPSIGadget               dopus5.library/FindBOOPSIGadget
  176.  
  177.     NAME
  178.         FindBOOPSIGadget - find a gadget by ID in a BOOPSI list
  179.  
  180.     SYNOPSIS
  181.         FindBOOPSIGadget(list, id)
  182.                           A0   D0
  183.  
  184.         struct Gadget *FindBOOPSIGadget(struct List *, USHORT);
  185.  
  186.     FUNCTION
  187.         This routine iterates through the supplied list of gadgets looking
  188.         for one with the supplied ID. If found, it returns it.
  189.         This routine can be used to find a specific gadget in the List
  190.         created by AddScrollBars(). eg,
  191.  
  192.             vert_scroll=FindBOOPSIGadget(&list,GAD_VERT_SCROLLER);
  193.  
  194.     INPUTS
  195.         list - List of BOOPSI gadgets
  196.         id - ID to look for
  197.  
  198.     RESULT
  199.         If the gadget is found, it is returned, otherwise NULL.
  200.  
  201.     SEE ALSO
  202.         AddScrollBars()
  203.  
  204. dopus5.library/GetPalette32                       dopus5.library/GetPalette32
  205.  
  206.     NAME
  207.         GetPalette32 - get a 32 bit palette from a ViewPort
  208.  
  209.     SYNOPSIS
  210.         GetPalette32(vp, palette, count, first)
  211.                      A0    A1       D0     D1
  212.  
  213.         void GetPalette32(struct ViewPort *, ULONG, USHORT, short);
  214.  
  215.     FUNCTION
  216.         This routine copies the palette from the supplied ViewPort into
  217.         the supplied buffer. Under OS39 it is identical in operation to
  218.         the graphics.library GetRGB32() function. The advantage of using
  219.         this function is that it also works under OS37. Under OS37, the
  220.         4 bit colour values are extended to full 32 bit.
  221.  
  222.     INPUTS
  223.         vp - ViewPort to load colours from
  224.         palette - array of ULONGs to store palette (3 per pen)
  225.         count - number of pen values to copy
  226.         first - first pen to copy
  227.  
  228.     RESULT
  229.         The palette values are stored in the supplied array.
  230.  
  231.     SEE ALSO
  232.         LoadPalette32(), graphics.library/GetRGB32()
  233.  
  234. dopus5.library/LoadPalette32                     dopus5.library/LoadPalette32
  235.  
  236.     NAME
  237.         LoadPalette32 - load a 32 bit palette in a ViewPort
  238.  
  239.     SYNOPSIS
  240.         LoadPalette32(vp, palette)
  241.                       A0     A1
  242.  
  243.         void LoadPalette32(struct ViewPort *, ULONG *);
  244.  
  245.     FUNCTION
  246.         This routine loads a 32 bit palette into a ViewPort. It is
  247.         identical in operation to the graphics.library LoadRGB32()
  248.         function, except that it also works under OS37.
  249.  
  250.     INPUTS
  251.         vp - ViewPort to load palette
  252.         palette - Palette to load (in LoadRGB32() format)
  253.  
  254.     RESULT
  255.         The palette is loaded.
  256.  
  257.     SEE ALSO
  258.         GetPalette32, graphics.library/LoadRGB32()
  259.  
  260. dopus5.library/NewBitMap                             dopus5.library/NewBitMap
  261.  
  262.     NAME
  263.         NewBitMap - allocate a bitmap and bitplanes
  264.  
  265.     SYNOPSIS
  266.         NewBitMap(sizex, sizey, depth, flags, friend)
  267.                    D0      D1     D2     D3      A0
  268.  
  269.         struct BitMap *NewBitMap(ULONG, ULONG, ULONG, ULONG, struct BitMap *);
  270.  
  271.     FUNCTION
  272.         This routine allocates a BitMap and the bitplanes for it. It is
  273.         identical in operation to the graphics.library AllocBitMap() call,
  274.         except that it works under OS37. Under OS37 the bitmap and planes
  275.         are allocated manually, and the friend parameter is ignored.
  276.  
  277.         Under OS39, if a friend bitmap is supplied and that friend is not
  278.         a standard BitMap (ie BMF_STANDARD is not set), the new bitmap will
  279.         be allocated with the BMF_MINPLANES flag. This makes CyberGfx allocate
  280.         a fast chunky bitmap.
  281.  
  282.     INPUTS
  283.         sizex - width of bitmap
  284.         sizey - height of bitmap
  285.         depth - number of bitplanes
  286.         flags - bitmap flags
  287.         friend - friend bitmap
  288.  
  289.     RESULT
  290.         Returns the BitMap if successful, otherwise NULL.
  291.  
  292.     SEE ALSO
  293.         DisposeBitMap(), graphics.library/AllocBitMap()
  294.  
  295. dopus5.library/ScreenInfo                           dopus5.library/ScreenInfo
  296.  
  297.     NAME
  298.         ScreenInfo - return information about a screen
  299.  
  300.     SYNOPSIS
  301.         ScreenInfo(screen)
  302.                      A0
  303.  
  304.         ULONG ScreenInfo(struct Screen *);
  305.  
  306.     FUNCTION
  307.         This routine is designed to return simple information about a screen.
  308.  
  309.     INPUTS
  310.         screen - Screen to obtain information about.
  311.  
  312.     RESULT
  313.         Currently, the only flag defined for the result is SCRI_LORES, which
  314.         indicates that the screen is low resolution, or does not have a 1:1
  315.         pixel ratio.
  316.  
  317. dopus5.library/FindPubScreen                     dopus5.library/FindPubScreen
  318.  
  319.     NAME
  320.         FindPubScreen - find (and lock) a public screen
  321.  
  322.     SYNOPSIS
  323.         FindPubScreen(screen, lock)
  324.                         A0     D0
  325.  
  326.         struct PubScreenNode *FindPubScreen(struct Screen *, BOOL);
  327.  
  328.     FUNCTION
  329.         This function takes the address of a Screen, and searches for it in
  330.         the system Public Screen list. If it is found, the address of the
  331.         PubScreenNode is returned.
  332.  
  333.     INPUTS
  334.         screen - Screen to search for
  335.         lock - Set to TRUE if you want the screen to be locked on return
  336.  
  337.     RESULT
  338.         Returns the PubScreenNode of the screen if found, otherwise NULL.
  339.         If 'lock' is set to TRUE, the public screen will be locked for you
  340.         and you should call UnlockPubScreen() on it when you are finished.
  341.  
  342.     SEE ALSO
  343.         intuition.library/LockPubScreen()
  344.  
  345. dopus5.library/SetBusyPointer                   dopus5.library/SetBusyPointer
  346.  
  347.     NAME
  348.         SetBusyPointer - set busy pointer in a window
  349.  
  350.     SYNOPSIS
  351.         SetBusyPointer(window)
  352.                          A0
  353.  
  354.         void SetBusyPointer(struct Window *);
  355.  
  356.     FUNCTION
  357.         This function sets the mouse pointer in the supplied window to
  358.         the busy pointer. Under OS39 it uses the system-defined busy
  359.         pointer. Under OS37 it uses a standard watch image.
  360.  
  361.     INPUTS
  362.         window - Window to set busy pointer for
  363.  
  364.     RESULT
  365.         The busy pointer is set in the supplied window. You should call
  366.         ClearPointer() when you have finished.
  367.  
  368.     SEE ALSO
  369.         intuition.library/SetWindowPointer, intuition.library/ClearPointer
  370.  
  371.