home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 199.lha / GimmeLib / scrollbar.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-12-28  |  4.8 KB  |  177 lines
  1. /*
  2.  *  FILE: scrollbar.c
  3.  *  Support routines for making scroll-bar and -button gadgets.
  4.  *
  5.  *  Public Domain, but keep my name in it as the original author.
  6.  *  31-Aug-88    Jan Sven Trabandt   first release version
  7.  *  30-Sep-88    Jan Sven Trabandt   keep up with changes to gadget.c
  8.  */
  9.  
  10.  
  11. #define I_AM_SCROLLBAR
  12. #include "gimmelib/gimmefuncs.h"
  13. #include "gimmelib/scrollbar.h"
  14. #include "gimmelib/macros.h"
  15.  
  16.  
  17. struct Gadget *gimmeOneScroll( window, id, dirflags, myflags )
  18.     struct Window   *window;
  19.     USHORT        id;
  20.     ULONG        dirflags, myflags;
  21. {
  22.     register struct Gadget  *gp;
  23.     void    *gadgmh = NULL;
  24.     USHORT  *data;
  25.     USHORT  *imagedata;
  26.  
  27.     GUESS
  28.     QUIF( !id );
  29.     gp = chainAllocMem( &gadgmh, (ULONG)sizeof(struct Gadget),
  30.                 MEMF_CLEAR | MEMF_PUBLIC );
  31.     QUIF( !gp );
  32.     gp->GadgetType = BOOLGADGET;
  33.     gp->GadgetRender = (APTR) gimmeImage( &gadgmh, GOS_BITDEPTH,
  34.                         GOS_BITWIDTH, GOS_BITHEIGHT );
  35.     QUIF( !gp->GadgetRender );
  36.  
  37.     if( dirflags & FREEVERT ) {
  38.         gp->LeftEdge = -(GOS_BITWIDTH -1);
  39.         gp->Width = GOS_BITWIDTH;
  40.         gp->Height = GOS_BITHEIGHT;
  41.         if( myflags & GOS_TOP ) {
  42.         if( window ) {
  43.             gp->TopEdge = window->BorderTop - 1;
  44.         } else {
  45.             gp->TopEdge = GIM_DFLT_TBHEIGHT;
  46.         }
  47.         gp->Flags = GADGIMAGE | GADGHCOMP | GRELRIGHT;
  48.         imagedata = gimDataOneScrollUp;
  49.         } else {
  50.         gp->TopEdge = -GIM_SZHEIGHT - (GOS_BITHEIGHT -1);
  51.         gp->Flags = GADGIMAGE | GADGHCOMP | GRELRIGHT | GRELBOTTOM;
  52.         imagedata = gimDataOneScrollDown;
  53.         }
  54.         gp->Activation = RELVERIFY | RIGHTBORDER;
  55.     } else {        /* otherwise we have FREEHORIZ */
  56.         gp->TopEdge = -(GOS_BITHEIGHT -1);
  57.         gp->Width = GOS_BITWIDTH;
  58.         gp->Height = GOS_BITHEIGHT;
  59.         if( myflags & GOS_LEFT ) {
  60.         gp->LeftEdge = 0;
  61.         gp->Flags = GADGIMAGE | GADGHCOMP | GRELBOTTOM;
  62.         imagedata = gimDataOneScrollLeft;
  63.         } else {
  64.         gp->LeftEdge = -GIM_SZWIDTH - (GOS_BITWIDTH - 1);
  65.         gp->Flags = GADGIMAGE | GADGHCOMP | GRELBOTTOM | GRELRIGHT;
  66.         imagedata = gimDataOneScrollRight;
  67.         }
  68.         gp->Activation = RELVERIFY | BOTTOMBORDER;
  69.     }
  70.     copyDataImage( imagedata, (struct Image *) gp->GadgetRender );
  71.     if( window ) {
  72.         if( window->Flags & GIMMEZEROZERO ) {
  73.         gp->GadgetType |= GZZGADGET;
  74.         }
  75.     }
  76.     gp->GadgetID = id;
  77.     gp->UserData = gadgmh;
  78.     return( gp );
  79.     ENDGUESS
  80.     if( gadgmh ) {
  81.     chainFreeMem( gadgmh );
  82.     return( NULL );
  83.     }
  84. } /* gimmeOneScroll */
  85.  
  86.  
  87. struct Gadget *gimmeScrollBar( window, id, propflags, myflags )
  88.     struct Window   *window;
  89.     USHORT        id;
  90.     ULONG        propflags, myflags;
  91. {
  92.     register struct Gadget  *gp;
  93.     SHORT   ones_size = 0;
  94.     SHORT   left, top, width, height;
  95.     ULONG   gadgflags, activation;
  96.     void    *gadgmh = NULL;
  97.  
  98.     GUESS
  99.     QUIF( !id );
  100.     if( propflags & FREEVERT ) {
  101.         propflags &= ~FREEHORIZ;
  102.         if( myflags & GSB_ONE_SCROLL ) {
  103.         ones_size = GOS_BITHEIGHT;
  104.         }
  105.         left = - (GOS_BITWIDTH -1);
  106.         top  = ones_size;
  107.         if( !(myflags & GSB_NO_TITLEBAR) ) {
  108.         if( window ) {
  109.             top += window->BorderTop - 1;
  110.         } else {
  111.             top += GIM_DFLT_TBHEIGHT;
  112.         }
  113.         }
  114.         width  = GOS_BITWIDTH;
  115.         height = -top - ones_size - GIM_SZHEIGHT;
  116.         gadgflags  = GADGHCOMP | GADGIMAGE | GRELRIGHT | GRELHEIGHT;
  117.         activation = RELVERIFY | RIGHTBORDER;
  118.     } else {        /* otherwise we have FREEHORIZ */
  119.         propflags &= ~FREEVERT;
  120.         if( myflags & GSB_ONE_SCROLL ) {
  121.         ones_size = GOS_BITWIDTH;
  122.         }
  123.         left = ones_size;
  124.         top  = - (GOS_BITHEIGHT -1);
  125.         width  = -GIM_SZWIDTH - (ones_size<<1);
  126.         height = GOS_BITHEIGHT;
  127.         gadgflags  = GADGHCOMP | GADGIMAGE | GRELBOTTOM | GRELWIDTH;
  128.         activation = RELVERIFY | BOTTOMBORDER;
  129.     }
  130.     gp = gimmePropGadget( window, id, left, top, width, height, NULL,
  131.                 NULL, activation, propflags );
  132.     QUIF( !gp );
  133.     gp->Flags = gadgflags;
  134.     if( window ) {
  135.         ((struct PropInfo *)gp->SpecialInfo)->VertBody =
  136.                 0x0FFFFL * window->Height / window->MaxHeight;
  137.         ((struct PropInfo *)gp->SpecialInfo)->HorizBody =
  138.                 0x0FFFFL * window->Width / window->MaxWidth;
  139.     }
  140.     linkChainMem( &gp->UserData, gadgmh );
  141.     return( gp );
  142.     ENDGUESS
  143.     if( gadgmh ) {
  144.     chainFreeMem( gadgmh );
  145.     return( NULL );
  146.     }
  147. } /* gimmeScrollBar */
  148.  
  149.  
  150. struct Gadget *gimmeFullScrollBar( window, id, propflags, myflags, id1, id2 )
  151.     struct Window   *window;
  152.     USHORT        id;
  153.     ULONG        propflags, myflags;
  154.     USHORT        id1, id2;
  155. {
  156.     register struct Gadget  *gp;
  157.  
  158.     GUESS
  159.     QUIF( !id );
  160.     gp = gimmeScrollBar( window, id, propflags, myflags | GSB_ONE_SCROLL );
  161.     QUIF( !gp );
  162.     /* top or left one-scroll */
  163.     gp->NextGadget = gimmeOneScroll( window, id1, propflags,
  164.                         GOS_TOP | GOS_LEFT );
  165.     QUIF( !gp->NextGadget );
  166.     /* bottom or right one-scroll */
  167.     gp->NextGadget->NextGadget = gimmeOneScroll( window, id2, propflags,
  168.                         GOS_BOT | GOS_RIGHT );
  169.     QUIF( !gp->NextGadget->NextGadget );
  170.     return( gp );
  171.     ENDGUESS
  172.     if( gp ) {
  173.     getRidOfGadgets( gp );
  174.     }
  175.     return( NULL );
  176. } /* gimmeFullScrollBar */
  177.