home *** CD-ROM | disk | FTP | other *** search
/ Encyclopedia of Graphics File Formats Companion / GFF_CD.ISO / software / unix / saoimage / sao1_07.tar / btnlib / attach.c next >
C/C++ Source or Header  |  1990-04-20  |  5KB  |  128 lines
  1. #ifndef lint
  2. static char SccsId[] = "%W%  %G%";
  3. #endif
  4.  
  5. /*
  6.  * Module:    attach.c (Attach Box)
  7.  * Project:    PROS -- ROSAT RSDC
  8.  * Purpose:    Attach boxes to buttons as submenus and boxes to boxes comenus
  9.  * Subroutines:    AttachSubmenu()            returns: void
  10.  * Subroutines:    JoinMenu()            returns: void
  11.  * Xlib calls:    none
  12.  * Copyright:    1989 Smithsonian Astrophysical Observatory
  13.  *        You may do anything you like with this file except remove
  14.  *        this copyright.  The Smithsonian Astrophysical Observatory
  15.  *        makes no representations about the suitability of this
  16.  *        software for any purpose.  It is provided "as is" without
  17.  *        express or implied warranty.
  18.  * Modified:    {0} Michael VanHilst    initial version        31 March 1989
  19.  *        {n} <who> -- <does what> -- <when>
  20.  */
  21.  
  22. #include <stdio.h>    /* define stderr */
  23. #include <X11/Xlib.h>    /* define Xlib types and calls (needed by Buttons.h) */
  24. #include "buttons.h"
  25.  
  26. /*
  27.  * Subroutine:    AttachSubmenu
  28.  * Purpose:    Attach a buttonbox as a submenu to a button
  29.  * Returns:    void
  30.  * Called by:    Application program
  31.  * Xlib calls:    none
  32.  * Method:    Identify btn's function which matches mask and reference, and
  33.  *        set pointer in that functions submenu array.
  34.  * Note:    Subbuttonbox(es) are drawn and activated when the button is
  35.  *        selected and dumped when the button is unselected
  36.  * Note:    Bitmask codes indicate which button option is intended
  37.  */
  38. void AttachSubmenu ( subbox, masterbox, btn, mask, reference )
  39.      ButtonBox subbox;        /* i: box being attached */
  40.      ButtonBox masterbox;    /* i: box with button recieving submenu */
  41.      int btn;            /* i: index of button to which to attach */
  42.      int mask;            /* i: mask of button's submenu function */
  43.      int reference;        /* i: reference of button's submenu function */
  44. {
  45.   ButtonRecord *button;        /* l: pointer to record of object button */
  46.   ButtonFeel *feel;        /* l: pointer to button's feel parameters */
  47.   int fnum;            /* l: index of response function */
  48.   int i;            /* l: loop counter */
  49.  
  50.   /* is the button index in error? */
  51.   if( (btn < 0) || (btn >= masterbox->btn_cnt) ) {
  52.     (void)fprintf(stderr, "WARNING: attaching to invalid-button: %d\n", btn);
  53.     return;
  54.   }
  55.   /* isolate the object button's ButtonRecord and ButtonFeel */
  56.   button = &masterbox->buttons[btn];
  57.   feel = button->feel;
  58.   /* get the correct detail option index */
  59.   for( fnum = 0; fnum < feel->nfunctions; fnum++ )
  60.     if( (feel->mask[fnum] == mask) && (feel->reference[fnum] == reference) )
  61.       break;
  62.   if( fnum >= feel->nfunctions ) {
  63.     (void)fprintf
  64.       (stderr, "WARNING: attaching submenu to non-existent option: %d %d\n",
  65.        mask, reference);
  66.     return;
  67.   }
  68.   /* can we accomodate any more submenus? */
  69.   if( button->submenu_count[fnum] >= SUBMENU_LIMIT ) {
  70.     (void)fprintf
  71.       (stderr, "WARNING: attempt to attach too many submenus. %d\n", btn);
  72.     return;
  73.   }
  74.   /* is it the kind of button that takes submenus? */
  75.   if( (feel->function[fnum] != BTNMode) &&
  76.       (feel->function[fnum] != BTNToggle) &&
  77.       (feel->function[fnum] != BTNCoMode) ) {
  78.     (void)fprintf(stderr, "WARNING: attaching to non-mode button: %d\n", btn);
  79.   }
  80.   /* is it already attached? */
  81.   for( i=0; i < button->submenu_count[fnum]; i++ ) {
  82.     if( (ButtonBox)button->submenu[fnum][i] == subbox ) {
  83.       (void)fprintf(stderr,
  84.             "NOTE: submenu already attached to button: %d\n", btn);
  85.       return;
  86.     }
  87.   }
  88.   /* set pointer to buttonbox (which was declared as int *) */
  89.   button->submenu[fnum][button->submenu_count[fnum]] = (int *)subbox;
  90.   ++button->submenu_count[fnum];
  91. }
  92.  
  93. /*
  94.  * Subroutine:    JoinMenu
  95.  * Purpose:    Attach buttonboxes as co_menus to act as one buttonbox in the
  96.  *        cases of co_mode and while button actions.
  97.  * Returns:    void
  98.  * Called by:    Application program
  99.  * Xlib calls:    none
  100.  * Method:    Place box pointers in each other's co_menu lists.
  101.  * Notea:    Order of A and B is not important.
  102.  */
  103. void JoinMenus ( box_A, box_B )
  104.      ButtonBox    box_A;        /* i: first of pair being joined */
  105.      ButtonBox    box_B;        /* i: second of pair being joined */
  106. {
  107.   int i;             /* l: loop counter */
  108.  
  109.   /* can either box accomodate any more co_menus? */
  110.   if( (box_A->co_menu_count >= SUBMENU_LIMIT) ||
  111.       (box_B->co_menu_count >= SUBMENU_LIMIT) ) {
  112.     (void)fprintf(stderr, "WARNING: attempt to join too many buttonboxes\n");
  113.     return;
  114.   }
  115.   /* are they already joined */
  116.   for( i=0; i < box_A->co_menu_count; i++ ) {
  117.     if( box_A->co_menu[i] == box_B ) {
  118.       (void)fprintf(stderr, "NOTE: submenus already joined\n");
  119.       return;
  120.     }
  121.   }
  122.   /* set pointer to buttonbox (which was declared as int *) */
  123.   box_A->co_menu[box_A->co_menu_count] = box_B;
  124.   box_B->co_menu[box_B->co_menu_count] = box_A;
  125.   ++box_A->co_menu_count;
  126.   ++box_B->co_menu_count;
  127. }
  128.