home *** CD-ROM | disk | FTP | other *** search
/ No Fragments Archive 12: Textmags & Docs / nf_archive_12.iso / MAGS / SOURCES / ATARI_SRC.ZIP / atari source / FALCON / ACC / DRIVERS.ACC / POPMENU.C < prev    next >
Encoding:
C/C++ Source or Header  |  2001-02-10  |  68.7 KB  |  2,429 lines
  1. /* POPMENU.C
  2.  *==========================================================================
  3.  * DESCRIPTION: Generic Popup Routines ( New and Improved )
  4.  * VERSION 0.00  Started:    February 7, 1991
  5.  * VERSION 0.10            March    4, 1991
  6.  * version 1.00            April    24,1991
  7.  *                Recreated damaged files
  8.  *                Removed open workstation calls.
  9.  *                vhandle = graf_handle()
  10.  * December 4, 1992 REMOVED MAJOR AMOUNTS OF CODE.
  11.  *            This version is OLD OLD OLD compared to the
  12.  *            AES 4.0 version - Its DRASTICALLY Different.
  13.  *            For this app, only check mark, disable and submenus
  14.  *            are supported.
  15.  *
  16.  *
  17.  * INCLUDE: POPMENU.H
  18.  * Requires: POP_HEAD.H
  19.  *
  20.  */
  21.  
  22.  
  23.  
  24. /* INCLUDE FILES
  25.  *==========================================================================
  26.  */
  27. #include <sys\gemskel.h>
  28. #include <string.h >
  29. #include <tos.h>
  30. #include <stdlib.h>
  31. #include <stdio.h>
  32.  
  33. #include "pop_head.h"
  34. #include "device.h"
  35.  
  36.  
  37. /* EXTERNS
  38.  *==========================================================================
  39.  */
  40. extern int xres, yres;
  41.  
  42.  
  43. /* PROTOTYPES
  44.  *==========================================================================
  45.  */
  46. void    InitPopUpMenus( void );
  47. int    GetNewPopMenu( void );
  48. POP_PTR    GetMenuPtr( int MenuID );
  49.  
  50. BOOLEAN    InitCmdChar( POP_PTR PopPtr );
  51. void    BuildCmdChar( POP_PTR PopPtr );
  52. void    BuildKeyCodes( POP_PTR PopPtr, char *text, int num_entry );
  53. void    DeletePopUpMenu( int MenuID );
  54.  
  55. int     InsertPopUpMenu( char *text, int num_entries, int height );
  56. long    PopUpMenuSelect( int MenuID, int xpos, int ypos, int Item );
  57. BOOLEAN Pop_Blit( long *PopPtr, GRECT *xclip, int flag );
  58.  
  59.  
  60. BOOLEAN Build_Objects( POP_PTR curptr );
  61. void    SetRootNode( OBJECT *tree, int xpos, int ypos, int Width, int Num );
  62. void    SetTextNode( OBJECT *tree, int parent, POP_PTR PopPtr, int obj, int Ypos, int textnum, int Width );
  63. long    CalcTextBufferSize( POP_PTR PopPtr );
  64. void    BuildText( POP_PTR PopPtr );
  65. int    CountBlanksNeeded( char *dindex, char *dtemp, int width, int num );
  66.  
  67.  
  68. BOOLEAN    Pop_Arrow( POP_PTR PopPtr, int obj );
  69. void    UpArrowStatus( POP_PTR PopPtr );
  70. void    DownArrowStatus( POP_PTR PopPtr );
  71. void    SetArrowClickDelay( long delay );
  72.  
  73. /* KEYCODE CHECKING */
  74. long    CheckForKeyCodes( POP_PTR PopPtr, char *text, int num_entry );
  75. char    *CheckForCtrl( char *text );
  76. char    *CheckForAlt( char *text );
  77. char    *CheckForCapKey( char *text );
  78. char    *CheckForCmdKey( char *text );
  79. BOOLEAN CheckForDisable( char *text );
  80. BOOLEAN    CheckForMenuCheck( char *text );
  81. char     *CheckForSubMenu( char *text );
  82. char    *CheckForFuncKey( char *text );
  83. BOOLEAN    CheckForDuplicate( char *text );
  84.    
  85. /* APPEARANCE OF ITEMS */
  86. void    SetHeight( int MenuID, int Height );
  87. void    SetNumItems( int MenuID, int NumItems );
  88.  
  89. void    CheckItem( int MenuID, int item, BOOLEAN check );
  90. void    DisableItem( int MenuID, int item );
  91. void    EnableItem( int MenuID, int item );
  92.    
  93. void    SetItemCmd( int MenuID, int item, char cmd );
  94. char    GetItemCmd( int MenuID, int item );
  95.  
  96. void    SetSubMenuID( int MenuID, int item, int ID );
  97. int    GetSubMenuID( int MenuID, int item );
  98.  
  99. void    SetItemMark( int MenuID, int item, char key );
  100. char    GetItemMark( int MenuID, int item );
  101.  
  102. void    SetFuncMark( int MenuID, int item, int num );
  103. int     GetFuncMark( int MenuID, int item );
  104.  
  105. void    SetItem( int MenuID, int item, char *text );
  106. char    *GetItem( int MenuID, int item );
  107.  
  108. int    GetStartItem( int MenuID );
  109. void    SetStartItem( int MenuID, int item );
  110.  
  111.  
  112. /* SUBMENU HANDLING */
  113. POP_PTR    DoSubMenu( POP_PTR PopPtr, int obj );
  114. BOOLEAN    ShowSubMenu( int MenuID, int xpos, int ypos, GRECT *rect );
  115. void    HideSubMenu( POP_PTR PopPtr );
  116. long    EvntSubMenu( POP_PTR PopPtr );
  117. int    FindNum( POP_PTR PopPtr, int obj );
  118. long    MenuChoice( void );
  119.  
  120.  
  121. /* SUBMENU DELAY */
  122. long    GetTimeHz( void );
  123. void    SetSubMenuDelay( long ms );
  124. void    SetSubDragDelay( long ms );
  125.  
  126.  
  127. void    AdjustToScreen( POP_PTR PopPtr, int xpos, int ypos, GRECT *rect, BOOLEAN byte_flag, BOOLEAN Display_Flag );
  128. void    WaitForUpButton( void );
  129.  
  130.  
  131.  
  132. /* EXTERNALS
  133.  *==========================================================================
  134.  * These functions and variables are required and must be
  135.  * supplied externally.
  136.  */
  137.  
  138. int    BUT_OR( void );        /* Used to ensure left mouse button */
  139. extern  int   (*BADDR)( void );
  140. extern  int    BSTATE;
  141. extern  int    BREAL;
  142.  
  143.  
  144. /* DEFINES
  145.  *==========================================================================
  146.  */
  147. #define INIT_DISPLAY_DELAY  300L    /* Initial Submenu Display Delay   */ 
  148. #define INIT_DRAG_DELAY     3000L   /* Initial Submenu Drag Delay      */
  149. #define INIT_CLICK_DELAY    150L   /* Delay for STARTING arrow scroll */
  150.  
  151.  
  152.  
  153. #define STLOW    2
  154. #define STMED    3
  155.  
  156. #define MAX_MENUS    10       /* Maximum # of Menus allowed...*/
  157.                    /* DEFINED TO BE 10 MENUS FOR THIS APP*/
  158.  
  159.  
  160. #define UP_ARROW    0x01
  161. #define DOWN_ARROW    0x02
  162. #define RIGHT_ARROW    0x03
  163.  
  164.  
  165.  
  166. /* GLOBAL
  167.  *==========================================================================
  168.  */
  169. POP_NODE MenuList[ MAX_MENUS ];        /* Menu structure Storage */
  170. BOOLEAN  free_flag[ MAX_MENUS ];
  171. char CmdText[ 10 ];        /* Temp string storage...       */
  172. char TempString[ 255 ];
  173. int  xout[57];            /* used for vq_extnd() */
  174.  
  175.  
  176. long SUBMENU_DELAY;        /* Delay time for submenus to appear ( ms )    */
  177. long SUBDRAG_DELAY;        /* Delay time for submenus to go active( ms)   */
  178. long CLICK_DELAY;        /* Delay time for arrows to start scrolling(ms)*/
  179. long TimeInHz;            /* Current Time in 200 Hz */
  180.  
  181.                 /* Used by the MenuChoice() call         */
  182. int  CurObject;            /* Current Object clicked on. ( Global ) */
  183. int  CurMenu;            /* Current Menu clicked on. ( Global )   */
  184.  
  185.  
  186. /* FUNCTIONS
  187.  *==========================================================================
  188.  */
  189.  
  190.  
  191. /* InitPopMenus()
  192.  * ====================================================================
  193.  * Simply clears out the flags in the free_flags structure.
  194.  */
  195. void
  196. InitPopUpMenus( void )
  197. {
  198.    int i;
  199.    
  200.    for( i = 0; i < MAX_MENUS; i++ )
  201.       free_flag[ i ] = FALSE;
  202.    SetSubMenuDelay( INIT_DISPLAY_DELAY );
  203.    SetSubDragDelay( INIT_DRAG_DELAY );        
  204.    SetArrowClickDelay( INIT_CLICK_DELAY );
  205. }
  206.  
  207.  
  208.  
  209. /* InsertPopMenu()
  210.  * ====================================================================
  211.  * Returns: Pointer to the POPUP structure.
  212.  * IN:   
  213.  *       XHEIGHT ( in characters ) - actually, number of entries displayed
  214.  *     NUM_ENTRIES           - Total # of menu entries.
  215.  *     Pointer to text address...
  216.  * OUT: # >= 0    Valid Menu ID
  217.  *      # < 0     Error messages.
  218.  *                -1 = Memory Allocation Error.
  219.  *          -2 = No more Menu Slots available.
  220.  */
  221. int
  222. InsertPopUpMenu( char *text, int num_entries, int height )
  223. {
  224.     POP_PTR PopPtr;
  225.     int     MenuID;
  226.     
  227.     MenuID = GetNewPopMenu();
  228.     
  229.     /* No more menu slots available.*/
  230.     if( MenuID == -1 )
  231.        return( -2 );
  232.  
  233.     PopPtr = GetMenuPtr( MenuID );
  234.     PPREV( PopPtr )   = ( POP_PTR )NULL;
  235.        
  236.     PMENUID( PopPtr ) = MenuID;     
  237.     PXPOS( PopPtr )   = PYPOS( PopPtr ) = 0;
  238.     PNUM( PopPtr )    = num_entries;
  239.     POBJECT( PopPtr ) = ( OBJECT *)NULL;
  240.     
  241.     /* Take care of height of menu */ 
  242.     if( height > PNUM( PopPtr ) )
  243.         height = PNUM( PopPtr );
  244.     PHEIGHT( PopPtr )     = height;
  245.     PIX_HEIGHT( PopPtr )  = ( PHEIGHT( PopPtr ) * gl_hchar );
  246.     PTEXT( PopPtr )       = text;
  247.     
  248.     if( !InitCmdChar( PopPtr ))
  249.     {
  250.        /* If memory error, clear out the Menu Slot
  251.         * and return a -1.
  252.         */
  253.        free_flag[ MenuID ] = FALSE;       
  254.        MenuID = -1;
  255.     }
  256.     return( MenuID );
  257. }
  258.  
  259.  
  260.  
  261. /* GetNewPopMenu()
  262.  * ====================================================================
  263.  * Find an unused slot for a menu.
  264.  * RETURN( -1 ) if there are no more menu slots available.
  265.  */
  266. int
  267. GetNewPopMenu( void )
  268. { 
  269.     int i;
  270.     
  271.     for( i = 0; i < MAX_MENUS; i++ )
  272.     {
  273.     if( !free_flag[ i ] )
  274.     {
  275.        free_flag[i] = TRUE;
  276.        return( i );
  277.     }   
  278.     }
  279.     return( -1 );
  280. }
  281.  
  282.  
  283.  
  284.  
  285. /* GetMenuPtr()
  286.  * ====================================================================
  287.  * Returns a pointer to the Menu Structure if given a valid menuID
  288.  */
  289. POP_PTR
  290. GetMenuPtr( int MenuID )
  291. {
  292.     return( ( POP_PTR )&MenuList[ MenuID ] );
  293. }
  294.  
  295.  
  296.  
  297. /* InitCmdChar()
  298.  * ====================================================================
  299.  * Initializes the CmdChar memory for a menu structure.
  300.  * The memory is MALLOCed! So the application MUST call
  301.  * DeletePopMenu() for each menu created. OR ELSE...!
  302.  * Need to check for malloc failures.
  303.  * RETURN: FALSE = ERROR!
  304.  *       TRUE  = AOK!
  305.  * It will be up to the program to inform the user that
  306.  * no menu was created and initialized.
  307.  */
  308. BOOLEAN
  309. InitCmdChar( POP_PTR PopPtr )
  310. {
  311.     int i;
  312.     
  313.     PCmdChar( PopPtr ) = ( CmdChar *)malloc( (long)( (long)PNUM( PopPtr ) + 10L ) * (long)sizeof( CmdChar ));
  314.     /* We go up to + 2 because we have ...
  315.      * PNUM() = UP ARROW TEXT
  316.      * PNUM+1 = DOWN ARROW TEXT
  317.      * PNUM+2 = BLANK TEXT
  318.      */
  319.     if( PCmdChar( PopPtr ) )
  320.     { 
  321.       for( i = 0; i <= ( PNUM( PopPtr ) + 2 ); i++ )
  322.       {
  323.          CmdState( PopPtr->CharPtr[ i ] ) = NORMAL;
  324.          CmdSubMenu( PopPtr->CharPtr[ i ] ) = -1;
  325.          CmdFlag( PopPtr->CharPtr[i] ) = '\0';
  326.       }
  327.       
  328.       BuildCmdChar( PopPtr );
  329.       return( TRUE );
  330.     }
  331.     else
  332.       return( FALSE );
  333. }
  334.  
  335.  
  336.  
  337.  
  338. /* BuildCmdChar()
  339.  * ====================================================================
  340.  * Calculate the text buffer size that we'll have to malloc, based upon
  341.  * the largest text string and the number of entries.
  342.  */
  343. void
  344. BuildCmdChar( POP_PTR PopPtr )
  345. {
  346.    char *txtptr;
  347.    long length;
  348.    int  count;
  349.    
  350.    txtptr = PTEXT( PopPtr );
  351.    if( txtptr )
  352.    {
  353.        for( count = 0; count < PNUM( PopPtr ); count++ )
  354.        {    
  355.          length = strlen( txtptr );
  356.          BuildKeyCodes( PopPtr, txtptr, count );
  357.          txtptr += ( length + 1 );
  358.        }
  359.    }
  360. }
  361.  
  362.  
  363.  
  364.  
  365.  
  366. /* BuildKeyCodes()
  367.  * =====================================================================
  368.  * Checks the text string for various keycodes and subtracts
  369.  * an appropriate amount from the length if any are found.
  370.  * For many of these, there should only be one of them.
  371.  * We then ADD back in the amount of ACTUAL text usage this item
  372.  * would take. IE: a Function Key can be F10 so 3 characters...
  373.  * or a CmdKey can be the letters: 'DELETE' 6 characters added.
  374.  * This will also fill up the CMDCHAR structures.
  375.  */
  376. void
  377. BuildKeyCodes( POP_PTR PopPtr, char *text, int num_entry )
  378. {
  379.     char *txtptr;
  380.     
  381.     /* Check for the '@' character which will tell us to
  382.      * disable the current menu item that we are working on.
  383.      */
  384.     
  385.     if( CheckForDisable( text ) )
  386.       DisableItem( PMENUID( PopPtr ), num_entry );
  387.     else   
  388.       EnableItem( PMENUID( PopPtr ), num_entry );
  389.  
  390.     /* Check for CheckMark  ( ! ) */
  391.     CheckItem( PMENUID( PopPtr ), num_entry, CheckForMenuCheck( text ) );
  392.  
  393.     if( ( txtptr = CheckForSubMenu( text ) ) != NULL )
  394.     {
  395.     CmdFlag( PopPtr->CharPtr[ num_entry ] ) = '~';
  396.     txtptr++;
  397.     CmdSubMenu( PopPtr->CharPtr[ num_entry ] ) = atoi( txtptr );
  398.     } 
  399. }
  400.  
  401.  
  402.  
  403.  
  404. /* DeletePopUpMenu()
  405.  * ====================================================================
  406.  */
  407. void
  408. DeletePopUpMenu( int MenuID )
  409. {
  410.    POP_PTR PopPtr;
  411.    
  412.    if( free_flag[ MenuID ] )
  413.    {
  414.      free_flag[ MenuID ] = FALSE;
  415.      PopPtr = GetMenuPtr( MenuID );
  416.      
  417.      if( PCmdChar( PopPtr ) )
  418.        free( PCmdChar( PopPtr ) );
  419.        
  420.      PCmdChar( PopPtr ) = ( CmdChar *)NULL;
  421.    }  
  422. }
  423.  
  424.  
  425.  
  426.  
  427. /* PopUpMenuSelect()
  428.  * ====================================================================
  429.  * Displays the actual popup menu.
  430.  * Let's the user select an object.
  431.  * IN:   POP_PTR PopPtr;
  432.  *       int     xpos;
  433.  *       int     ypos;
  434.  *       int     Start_Obj;  Index to show selected else start with 0
  435.  *       BOOLEAN Arrow_Flag; If TRUE, display arrows if height < num_items.
  436.  *                    FALSE, don't display arrows if height < num_items.
  437.  * returns:  long where....
  438.  *        HIGH WORD    LOW WORD
  439.  *         MenuID          Item Selected.
  440.  *           -1L if NONE selected.
  441.  *         If the MenuID is valid, but the item is -1, then
  442.  *         the user clicked on a disabled menu item.
  443.  *         -2L if Memory Allocation Error
  444.  *         -3L if workstation error.
  445.  */
  446. long
  447. PopUpMenuSelect( int MenuID, int xpos, int ypos, int Item )
  448. {
  449.     
  450.     long    obj;
  451.     POP_PTR PopPtr;
  452.     GRECT   rect;
  453.     MRETS   mk;
  454.     int     max_height;
  455.         
  456.     WaitForUpButton();
  457.     wind_update( BEG_MCTRL );
  458.  
  459.     if( !open_vwork() )
  460.       return( -2L );
  461.  
  462.     vq_extnd( vhandle, 0, xout );
  463.     xres = xout[0];
  464.     yres = xout[1];    
  465.  
  466.     vex_butv( vhandle, BUT_OR, &BADDR );    
  467.     
  468.     PopPtr = GetMenuPtr( MenuID );
  469.     PopUpItem( PopPtr ) = Item;
  470.  
  471.     PXPOS( PopPtr )   = xpos;
  472.     PYPOS( PopPtr )   = ypos;
  473.     PPREV( PopPtr )   = ( POP_PTR )NULL;
  474.  
  475.     /* Take care of height of menu */ 
  476.     if( PHEIGHT( PopPtr ) > PNUM( PopPtr ) )
  477.         PHEIGHT( PopPtr ) = PNUM( PopPtr );
  478.  
  479.     /* Limit Height to Height of screen - ( 2 * gl_hchars ) */
  480.     max_height = yres - ( 2 * gl_hchar );
  481.     while( ( PHEIGHT( PopPtr ) * gl_hchar ) > max_height )
  482.        PHEIGHT( PopPtr ) -= 1;
  483.  
  484.     PIX_HEIGHT( PopPtr )  = ( PHEIGHT( PopPtr ) * gl_hchar );
  485.  
  486.        
  487.     /* Take care of the width of the menu here...*/
  488.     PTEXTBUFFSIZE( PopPtr ) = CalcTextBufferSize( PopPtr );
  489.     PIX_WIDTH( PopPtr )     = ( PWIDTH( PopPtr ) * gl_wchar );
  490.  
  491.     AdjustToScreen( PopPtr, xpos, ypos, &rect, FALSE, TRUE );
  492.     if( Pop_Blit( (long *)&PMEM( PopPtr ), &PObRect( PopPtr ), 0 ) )
  493.     {
  494.        if( Build_Objects( PopPtr ) )
  495.        {
  496.          obj = EvntSubMenu( PopPtr );
  497.          if( obj == -2L ) /* returning from a submenu - error */
  498.              obj = -1L;    /* then set it to click on nothing */
  499.          Pop_Blit( (long *)&PMEM( PopPtr ), &PObRect( PopPtr ), 1 );
  500.        }
  501.        else    /* Memory Allocation Error in Space Capsule */
  502.          obj = -2L;  
  503.  
  504.        if( POBJECT( PopPtr ) )
  505.            free( POBJECT( PopPtr ) );
  506.         
  507.        if( PTEXTBUFF( PopPtr ) )    
  508.            free( PTEXTBUFF( PopPtr ) );
  509.         
  510.     }
  511.     else    /* ERROR: Memory Allocation Error */
  512.       obj = -2L;
  513.  
  514.     POBJECT( PopPtr )   = ( OBJECT *)NULL;
  515.     PTEXTBUFF( PopPtr ) = ( char *)NULL;
  516.     
  517.     Evnt_button( 1, 1, 0, &mk );
  518.  
  519.     vex_butv( vhandle, BADDR, &BADDR );
  520.     close_vwork();
  521.     
  522.     wind_update( END_MCTRL );
  523.  
  524.     return( obj );
  525. }
  526.  
  527.  
  528.  
  529.  
  530. /* Build_Objects()
  531.  * ====================================================================
  532.  * RETURN: TRUE - AOK
  533.  *         FALSE- Memory Allocation Error
  534.  */
  535. BOOLEAN
  536. Build_Objects( POP_PTR PopPtr )
  537. {
  538.    int     num_objects;
  539.    GRECT   rect;
  540.    int     text_index;        /* Index into the text data 0 based */
  541.    int     count;
  542.    int     ypos;        /* Y position of object ( in characters*/
  543.    int     temp;
  544.           
  545.    OBJECT *tree;
  546.    int    obj;
  547.  
  548.    /* Calculate the number of objects needed...
  549.     * ROOT + # of STRINGS + ( safety buffer )
  550.     */
  551.    num_objects = 1 + PHEIGHT( PopPtr ) + 10; /* + 10 for safety buffer */
  552.  
  553.    /* get the memory for this number of objects */   
  554.    POBJECT( PopPtr ) = ( OBJECT * )malloc( (long)(sizeof( OBJECT ) * (long)num_objects )); 
  555.     
  556.    /* Malloc the text memory and then build them. */
  557.    /* Need malloc checking of course...           */
  558.    PTEXTBUFF( PopPtr) = malloc( PTEXTBUFFSIZE( PopPtr ) );
  559.    
  560.    /* Memory Allocation Error */
  561.    if( !POBJECT( PopPtr ) || !PTEXTBUFF( PopPtr ) )
  562.        return( FALSE );
  563.  
  564.    BuildText( PopPtr );
  565.  
  566.        
  567.    /* setup the root */
  568.    tree = POBJECT( PopPtr );
  569.    SetRootNode( tree, PXPOS( PopPtr ), PYPOS( PopPtr ),
  570.                 PWIDTH( PopPtr ), PHEIGHT( PopPtr ) );
  571.    
  572.    ypos = text_index = 0;
  573.    
  574.    obj = 1;            /* Start Creating from object 1 */
  575.    PFIRST( PopPtr ) = 1;    /* first G_STRING starts at 3   */
  576.  
  577.    POFFSET( PopPtr )   = ( PopUpItem( PopPtr ) + ( PNUM( PopPtr ) > PHEIGHT( PopPtr ) )) / PHEIGHT( PopPtr );
  578.  
  579.    if( POFFSET( PopPtr ) )
  580.    {
  581.        POFFSET( PopPtr ) = PopUpItem( PopPtr );
  582.        temp = PNUM( PopPtr ) - PHEIGHT( PopPtr ) + 1;
  583.  
  584.        if( POFFSET( PopPtr ) >= temp )
  585.            POFFSET( PopPtr ) = temp;
  586.    }      
  587.    text_index = POFFSET( PopPtr );
  588.    
  589.    for( count = 0; count < PHEIGHT( PopPtr ); count++ )
  590.    {
  591.       if( count == 0 )
  592.       {
  593.        if( POFFSET( PopPtr ) )
  594.              SetTextNode( tree, ROOT, PopPtr, obj++, ypos++, PNUM( PopPtr ), PWIDTH( PopPtr ) );
  595.            else  
  596.            {
  597.              if( CmdState( PopPtr->CharPtr[ text_index ] ) & CHECKED )
  598.                  CheckObj( obj );
  599.              SetTextNode( tree, ROOT, PopPtr, obj++, ypos++, text_index++, PWIDTH( PopPtr ) );
  600.            }  
  601.       }  
  602.       else
  603.       {
  604.         if( count >=  ( PHEIGHT( PopPtr ) - 1 ) )
  605.         {
  606.            if( ( POFFSET( PopPtr ) + PHEIGHT( PopPtr ) ) < PNUM( PopPtr ) )
  607.               SetTextNode( tree, ROOT, PopPtr, obj++, ypos++, PNUM( PopPtr ) + 1, PWIDTH( PopPtr ) );
  608.            else
  609.            {
  610.               if( CmdState( PopPtr->CharPtr[ text_index ] ) & CHECKED )
  611.                  CheckObj( obj );
  612.  
  613.               SetTextNode( tree, ROOT, PopPtr, obj++, ypos++, text_index++, PWIDTH( PopPtr ) );
  614.            }   
  615.         }
  616.         else      
  617.         {
  618.            if( CmdState( PopPtr->CharPtr[ text_index ] ) & CHECKED )
  619.                CheckObj( obj );
  620.  
  621.            SetTextNode( tree, ROOT, PopPtr, obj++, ypos++, text_index++, PWIDTH( PopPtr ) );
  622.         } 
  623.       }
  624.    }   
  625.    PLAST( PopPtr ) = obj - 1;
  626.    ObFlags( obj - 1 ) = LASTOB;
  627.  
  628.    rect = ObRect( ROOT );
  629.    rect.g_x -= 2;
  630.    rect.g_y -= 2;
  631.    rect.g_w += 5;
  632.    rect.g_h += 5;
  633.    rc_intersect( &desk, &rect );        /* clip to desktop */
  634.    Objc_draw( tree, ROOT, MAX_DEPTH, &rect );
  635.    return( TRUE );
  636. }
  637.  
  638.  
  639.  
  640. /* SetRootNode()
  641.  * ====================================================================
  642.  */
  643. void
  644. SetRootNode( OBJECT *tree, int xpos, int ypos, int Width, int Num )
  645. {
  646.     ObNext( ROOT )  = -1;
  647.     ObHead( ROOT )  = -1;
  648.     ObTail( ROOT )  = -1;
  649.     ObType( ROOT )  = G_BOX;
  650.     ObFlags( ROOT ) = NONE;
  651.     ObState( ROOT ) = SHADOWED;
  652.     ObIndex( ROOT ) = 0xFF1100L;
  653.  
  654.     /* fix up for screen...*/
  655.     ObX( ROOT ) = xpos;
  656.     ObY( ROOT ) = ypos;
  657.     ObW( ROOT ) = Width * gl_wchar;
  658.     ObH( ROOT ) = Num * gl_hchar;
  659. }
  660.  
  661.  
  662.  
  663. /* SetTextNode()
  664.  * ====================================================================
  665.  */
  666. void
  667. SetTextNode( OBJECT *tree, int parent, POP_PTR PopPtr, int obj, int Ypos, int textnum, int Width )
  668. {
  669.        ObNext( obj ) = -1;
  670.        ObHead( obj ) = -1;
  671.        ObTail( obj ) = -1;
  672.  
  673.        ObType( obj )   = G_STRING;
  674.        ObFlags( obj )  = NONE;
  675.        
  676.        ObString( obj ) = &PTEXTBUFF( PopPtr )[ ( PWIDTH( PopPtr ) + 1 ) * textnum ];
  677.  
  678.        ObState( obj )  = CmdState( PopPtr->CharPtr[ textnum ] );
  679.  
  680.        ObX( obj )      = 0;
  681.        ObY( obj )      = Ypos * gl_hchar;
  682.        ObW( obj )      = Width * gl_wchar;
  683.        ObH( obj )      = gl_hchar;
  684.        objc_add( tree, parent, obj );
  685. }
  686.  
  687.  
  688.  
  689.  
  690. /* CalcTextBufferSize()
  691.  * ====================================================================
  692.  * Calculate the text buffer size that we'll have to malloc, based upon
  693.  * the largest text string and the number of entries.
  694.  */
  695. long
  696. CalcTextBufferSize( POP_PTR PopPtr )
  697. {
  698.    char *xptr;
  699.    long size;
  700.    long xsize;
  701.    long actual;
  702.    int  i;
  703.    
  704.    size = 0L;
  705.    PWIDTH( PopPtr ) = 0;
  706.    xptr = ( char *)NULL;
  707.    xptr = PTEXT( PopPtr );
  708.    if( xptr )
  709.    {
  710.        for( i = 0; i < PNUM( PopPtr ); i++ )
  711.        {    
  712.          xsize = strlen( xptr );
  713.          actual = CheckForKeyCodes( PopPtr, xptr, i );
  714.          if( actual > size )
  715.             size = actual;
  716.          xptr += ( xsize + 1 );
  717.  
  718.          /* Get's us past the nulls to the head of the next string */
  719.          while( !( *xptr ) )
  720.            xptr++;         
  721.        }
  722.        /* size-> now contains the length of the longest string. */
  723.        size += 1;              /* for a blank after...*/
  724.        size += 2;           /* for 2 blanks before the string*/
  725.        /* Number of characters in our longest string...*/
  726.        PWIDTH( PopPtr ) = (int)size;
  727.  
  728.        size += 1;            /* for the null.       */
  729.        size += 10;            /* for the Control Keys or RT Arrow */
  730.        size *= PNUM( PopPtr );  /* For the number of entries. */
  731.        size += ( size / 2 );    /* Buffer area, just in case  */  
  732.    }
  733.    return( size );
  734. }
  735.  
  736.  
  737. /* BuildText()
  738.  * ====================================================================
  739.  * Takes the pointer to the menu_text given by the program and
  740.  * builds the text in the memory buffer where...
  741.  *  1) 2 spaces before each text string.
  742.  *  2) 1 space after the longest string.
  743.  *  3) pads spaces after shorter strings to match the longest string.
  744.  *  4) Null terminates each string.
  745.  *  5) *# - The char following is duplicated the width of the menu.
  746.  *        Characters following it are ignored to the end of the string.
  747.  *        example: *-    The line is filled with "---------"
  748.  *  6) @  - means to disable this menu item
  749.  *  7) /# - means that there is a keycode: ie: /T ==   [T]
  750.  *  8) ## - means that there is a function key.  #10 is F10
  751.  *  9) ^# - means that there is a ctrl key:  ^H
  752.  * 10) $# - means that there is a CmdKey: ie: $H = HELP ( 4 chars )
  753.  *     We ACKNOWLEDGE -----
  754.  *     [H] HELP    [U] Undo    [E] Escape    [I] Insert
  755.  *     [D] DEL        [C] Clr        [h] Home    [T] TAB
  756.  *     [e] ENTER    [R] RETURN
  757.  *
  758.  * 11) &# - means that there is an ALT Key:  &A - Alt A
  759.  * 12) ~# - means that there is a submenu: ~1 - attach submenu 1
  760.  * 13) !  - means that the menu item is CHECKED.
  761.  */
  762. void
  763. BuildText( POP_PTR PopPtr )
  764. {
  765.    char *sindex;        /* Pointer to source text...    */
  766.    char *stemp;            /* Pointer INTO source text     */
  767.    char *dindex;        /* Pointer to destination text  */
  768.    char *dtemp;            /* Pointer INTO destination text*/
  769.    int  num_entries;        /* Number of entries counter... */
  770.    int  num;
  771.    long length;            /* length of a string...    */
  772.    long i;            /* temp variable...        */
  773.    
  774.    if( !PTEXTBUFF( PopPtr ) )    /* if there is no destination buffer...*/
  775.        return;            /* skip doing all of this...           */
  776.           
  777.    sindex = PTEXT( PopPtr );
  778.    dindex = PTEXTBUFF( PopPtr );
  779.  
  780.    for( num_entries = 0; num_entries <= PNUM( PopPtr ); num_entries++ )
  781.    {
  782.      if( num_entries < PNUM( PopPtr ) )
  783.      {
  784.          strcpy( dindex, "  " );    /* Pad the entry with 2 blanks */
  785.          stemp = sindex;        /* Get a pointer to the source */
  786.          dtemp = dindex+2;        /* Get a pointer to the dest...*/
  787.  
  788.      /* Copy the source string to the destination buffer
  789.       * skipping the HOT chars that will allow submenus,
  790.       * disabling menus, keycodes etc.
  791.       */
  792.      while( *stemp )
  793.      {
  794.         switch( *stemp )
  795.         {
  796.            case '@': /* Disable menu item */
  797.            case '!': /* CheckMark menu item */
  798.                     stemp++;
  799.                     break;
  800.  
  801.            case '~': /* Submenu  */
  802.                     stemp += 2;
  803.                     break;
  804.  
  805.            default: *dtemp++ = *stemp++;
  806.                    break;
  807.         }
  808.      }
  809.  
  810.      /* Now add in the necessary text for the Keycodes..*/
  811.          switch( CmdFlag( PopPtr->CharPtr[ num_entries ] ) )
  812.          {
  813.           case '~': /* Submenu */
  814.             num = CountBlanksNeeded( dindex, dtemp, PWIDTH( PopPtr ), 2 );
  815.             for( i = 0; i < num; i++ )                    
  816.                 *dtemp++ = ' ';     /* add a space */
  817.                     *dtemp++ = RIGHT_ARROW;    /* Right Arrow */   
  818.                     *dtemp++ = ' ';
  819.                     break;
  820.                              
  821.              default:
  822.                        break;
  823.      }
  824.      *dtemp = '\0';         
  825.       
  826.            /* Get the length of the destination string and
  827.             * pad it with blanks to make it the width of 
  828.             * the final string wanted.
  829.             */
  830.          length = strlen( dindex );
  831.          for( i = length; i < PWIDTH( PopPtr ); i++ )
  832.             strcat( dindex, " " );
  833.  
  834.        /* Get the length of the actual string and
  835.         * advance it to the next string skipping the NULL
  836.         * and moving to the first char of the next string.
  837.         */
  838.        length = strlen( sindex );
  839.        sindex = sindex + length + 1;
  840.        
  841.        /* Advance us thru the nulls to the start of the next string*/
  842.        while( !(*sindex) )
  843.          sindex++;
  844.  
  845.        /* Advance dest to end of the new string */   
  846.        dindex = dindex + PWIDTH( PopPtr ) + 1;
  847.      }
  848.      else
  849.      {
  850.        /* The PNUM() menu item will have an UP Arrow in its text */
  851.        strcpy( dindex, " " );
  852.        for( i = 1; i < PWIDTH( PopPtr ); i++ )
  853.           strcat( dindex, " " );  
  854.        *(dindex + 2 ) = UP_ARROW;    /* UP ARROW */
  855.           
  856.        /* The PNUM() + 1 menu item will have a DOWN Arrow in its text */
  857.        dindex = dindex + PWIDTH( PopPtr ) + 1;
  858.        strcpy( dindex, " " );
  859.        for( i = 1; i < PWIDTH( PopPtr ); i++ )
  860.           strcat( dindex, " " );  
  861.        *(dindex + 2 ) = DOWN_ARROW;    /* DOWN ARROW */       
  862.        
  863.        /* The PNUM() + 2 menu item will have a blank string in its text*/
  864.        dindex = dindex + PWIDTH( PopPtr ) + 1;
  865.        strcpy( dindex, " " );
  866.        for( i = 1; i < PWIDTH( PopPtr ); i++ )
  867.           strcat( dindex, " " );  
  868.      }     
  869.    }
  870. }
  871.  
  872.  
  873.  
  874. /* CountBlanksNeeded()
  875.  * ====================================================================
  876.  * Counts the number of blanks to go between the menu item and the
  877.  * control key or whatever.
  878.  */
  879. int
  880. CountBlanksNeeded( char *dindex, char *dtemp, int width, int num )
  881. {
  882.     long length;
  883.     
  884.     *dtemp   = '\0';
  885.     length = strlen( dindex );
  886.     return( width - 1 - (int)length - num );
  887. }
  888.  
  889.  
  890.  
  891.  
  892. /* Pop_Arrow()
  893.  *==========================================================================
  894.  * Scroll the popup menu items if up or down arrow is selected.
  895.  * 
  896.  * IN: int obj:        up or down arrow is selected.
  897.  *     int *offset:    Offset into the menu items text array
  898.  *     int num_items:   Total number of menu items involved.
  899.  *     char *items[]:   Pointer to the text array
  900.  *
  901.  * OUT: TRUE - ended on a submenu
  902.  *    FALSE - ended on a normal menu item.
  903.  */
  904. BOOLEAN
  905. Pop_Arrow( POP_PTR PopPtr, int obj )
  906. {
  907.    OBJECT *tree;
  908.    int    DrawFlag;
  909.    int    i,j;
  910.    GRECT  rect;
  911.    GRECT  xrect, clip;
  912.    MRETS  mk;
  913.    int    pxy[8];
  914.    int    xclip[4];
  915.    long   location = 0L;    /* SCREEN MFDB        */
  916.    BOOLEAN DelayFlag;
  917.    BOOLEAN ReturnFlag;
  918.                  
  919.    tree = POBJECT( PopPtr );
  920.  
  921.    xrect = ObRect( obj );
  922.    objc_offset( tree, obj, &xrect.g_x, &xrect.g_y );
  923.    DelayFlag  = TRUE;
  924.    ReturnFlag = FALSE;
  925.    
  926.    do
  927.    {
  928.        BSTATE = 0;
  929.        DrawFlag = FALSE;
  930.        /* Up Arrow Selected AND not at the top */
  931.        if( ( obj == PFIRST( PopPtr ) ) && ( POFFSET( PopPtr ) > 0 ))
  932.        {
  933.          POFFSET( PopPtr ) -= 1;
  934.          DrawFlag = TRUE;
  935.          /* special handling...to make it jump to zero if
  936.           * we are displaying item 2, we can jump to zero, blit and
  937.           * redraw the top 2 items instead.
  938.           */
  939.          if( POFFSET( PopPtr ) == 1 )
  940.              POFFSET( PopPtr ) = 0;    
  941.        }
  942.  
  943.        /* DOWN Arrow and not within PHEIGHT() items from the bottom */
  944.        if( ( obj == PLAST( PopPtr ) ) && ( POFFSET( PopPtr ) <= ( PNUM( PopPtr ) - PHEIGHT( PopPtr ) ) ) )
  945.        {
  946.          POFFSET( PopPtr ) += 1;
  947.          DrawFlag = TRUE;
  948.          /* Special handling for first item only */
  949.          if( POFFSET( PopPtr ) == 1 )
  950.          {
  951.            if( ( POFFSET( PopPtr ) + PHEIGHT( PopPtr ) - 1 ) < PNUM( PopPtr ) )
  952.                  POFFSET( PopPtr ) += 1;
  953.          }
  954.        }
  955.  
  956.        j = POFFSET( PopPtr );
  957.        if( DrawFlag )
  958.        {
  959.           UpArrowStatus( PopPtr );
  960.             DownArrowStatus( PopPtr );      
  961.  
  962.           /* Get the Blit Rectangle */
  963.           clip = ObRect( PFIRST( PopPtr ));
  964.           objc_offset( tree, ROOT, &clip.g_x, &clip.g_y );
  965.           clip.g_h *= PHEIGHT( PopPtr );
  966.       
  967.           /* Calculate the height */
  968.       
  969.           if( strchr( ObString( PFIRST( PopPtr ) ), UP_ARROW ) )
  970.           {
  971.              clip.g_h -= gl_hchar;    /* Subtract 1 char height     */
  972.              clip.g_y += gl_hchar;    /* Move the Ypos down 1 level */ 
  973.           }
  974.       
  975.           if( strchr( ObString( PLAST( PopPtr )), DOWN_ARROW ) )
  976.           {
  977.             clip.g_h -= gl_hchar;    /* Subtract 1 char height      */
  978.           }
  979.       
  980.           /* Set up SOURCE rectangle */
  981.           rc_intersect( &desk, &clip );
  982.           rect = clip;
  983.           rc_2xy( &clip, ( WORD *)&pxy[0] );   
  984.  
  985.           if( obj == PFIRST( PopPtr ) )
  986.               clip.g_y += gl_hchar;
  987.       
  988.           if( obj == PLAST( PopPtr ) )
  989.               clip.g_y -= gl_hchar;
  990.           rc_intersect( &desk, &clip );
  991.           rc_2xy( &clip, ( WORD *)&pxy[4] );   
  992.  
  993.           clip = rect;
  994.           rc_2xy( &clip, ( WORD *)&xclip[0] );   
  995.           vs_clip( vhandle, 1, xclip );
  996.           graf_mouse( M_OFF, 0L );
  997.           vro_cpyfm( vhandle, 3, pxy, ( MFDB *)&location, ( MFDB *)&location );
  998.           graf_mouse( M_ON, 0L );
  999.       
  1000.             for( i = PFIRST( PopPtr ); i <= PLAST( PopPtr ); i++ )
  1001.             {
  1002.              if( ObType( i ) == G_STRING )
  1003.              {
  1004.                 if( i == PFIRST( PopPtr ) && strchr( ObString( PFIRST( PopPtr )), UP_ARROW ))
  1005.                 {
  1006.                     ObString( i ) = &PTEXTBUFF( PopPtr )[ ( PWIDTH( PopPtr ) + 1 ) * PNUM( PopPtr ) ];
  1007.                     continue;
  1008.                 }
  1009.                     
  1010.                 if( i == PLAST( PopPtr ) &&  strchr( ObString( PLAST( PopPtr )), DOWN_ARROW ))
  1011.                 {
  1012.                     ObString( i ) = &PTEXTBUFF( PopPtr )[ ( PWIDTH( PopPtr ) + 1 ) * ( PNUM( PopPtr ) + 1 ) ];
  1013.                     continue;
  1014.                 }    
  1015.                  
  1016.               SetNormal( i );
  1017.               if( CmdState( PopPtr->CharPtr[j] ) & CHECKED )
  1018.                   CheckObj( i );
  1019.                     
  1020.                 if( CmdState( PopPtr->CharPtr[j] ) & DISABLED )
  1021.                     Disable( i );
  1022.                       
  1023.                 ObString( i ) = &PTEXTBUFF( PopPtr )[ ( PWIDTH( PopPtr ) + 1 ) * j++ ];
  1024.           }   
  1025.           }
  1026.   
  1027.       
  1028.           if( obj == PFIRST( PopPtr ) )
  1029.           {
  1030.              rect = ObRect( obj );
  1031.              objc_offset( tree, obj, &rect.g_x, &rect.g_y );
  1032.              if( strchr( ObString( obj ), UP_ARROW ) )
  1033.                  rect.g_y += gl_hchar;
  1034.              else
  1035.              {
  1036.                  rect.g_h += gl_hchar;
  1037.                  ObString( obj ) = &PTEXTBUFF( PopPtr )[ 0 ];
  1038.                  if( !(CmdState( PopPtr->CharPtr[ 0 ] ) & DISABLED) )
  1039.                    Select( obj );
  1040.                    
  1041.                  if( CmdState( PopPtr->CharPtr[ 0 ] ) & CHECKED )
  1042.                    CheckObj( obj );
  1043.              }   
  1044.           }     
  1045.       
  1046.           if( obj == PLAST( PopPtr ) )    
  1047.           {
  1048.              rect = ObRect( obj );
  1049.              objc_offset( tree, obj, &rect.g_x, &rect.g_y );
  1050.              rect.g_y -= gl_hchar;
  1051.              if( !strchr( ObString( obj ), DOWN_ARROW ) )
  1052.              {
  1053.            rect.g_h += gl_hchar;         
  1054.                ObString( obj ) = &PTEXTBUFF( PopPtr )[ ( PWIDTH( PopPtr ) + 1 ) * ( PNUM( PopPtr ) - 1 )];
  1055.                if( !(CmdState( PopPtr->CharPtr[ PNUM( PopPtr ) - 1 ] ) & DISABLED) )
  1056.                    Select( obj );
  1057.                if( CmdState( PopPtr->CharPtr[ PNUM( PopPtr ) - 1 ] ) & CHECKED )
  1058.                    CheckObj( obj );
  1059.              }   
  1060.           }
  1061.           Objc_draw( tree, ROOT, MAX_DEPTH, &rect ); 
  1062.        }
  1063.        else
  1064.        {
  1065.           if( ( obj == PFIRST( PopPtr ) )   &&
  1066.            ( !strchr( ObString( obj ), UP_ARROW )) &&
  1067.               ( !( CmdState( PopPtr->CharPtr[ 0 ] ) & DISABLED )) &&
  1068.               (  CmdFlag( PopPtr->CharPtr[0] ) == '~' )
  1069.             )
  1070.             ReturnFlag = TRUE;
  1071.  
  1072.           if( ( obj == PLAST( PopPtr ) )   &&
  1073.            ( !strchr( ObString( obj ), DOWN_ARROW ) ) &&
  1074.               ( !( CmdState( PopPtr->CharPtr[ PNUM( PopPtr ) - 1 ] ) & DISABLED )) &&
  1075.               (  CmdFlag( PopPtr->CharPtr[ PNUM( PopPtr ) - 1 ] ) == '~' )
  1076.             )
  1077.             ReturnFlag = TRUE;
  1078.        }
  1079.        
  1080.        if( DelayFlag )
  1081.        {
  1082.            Evnt_timer( CLICK_DELAY );
  1083.            DelayFlag = FALSE;
  1084.        }    
  1085.  
  1086.        Graf_mkstate( &mk );  
  1087.    }while( (( BSTATE == 1 ) || ( BREAL == 1 )) && ( xy_inrect( mk.x, mk.y, &xrect )));
  1088.  
  1089.    Evnt_button( 1, 1, 0, &mk );       /* Make sure we have an up button...*/
  1090.    return( ReturnFlag );
  1091. }
  1092.  
  1093.  
  1094.  
  1095.  
  1096. /* Pop_Blit()
  1097.  * ====================================================================
  1098.  * Blit from screen to buffer or buffer to screen for Popup Box redraws.
  1099.  *
  1100.  * IN: long *PopPtr:    Pointer to memory buffer...
  1101.  *     GRECT *clip:    GRECT of clip blit area
  1102.  *     int   flag:    0 - blit from screen to buffer
  1103.  *                      1 - blit from buffer to screen
  1104.  *
  1105.  * OUT: returns TRUE if successful, FALSE if failed.
  1106.  */
  1107. BOOLEAN
  1108. Pop_Blit( long *PopPtr, GRECT *xclip, int flag )
  1109. {
  1110.    long     location = 0L;    /* SCREEN MFDB        */
  1111.    int      nplanes;        /* Number of planes    */
  1112.    unsigned long size;        /* size of malloc    */
  1113.    int      pxy[8];        /* pxy for blit        */
  1114.    GRECT    clip;
  1115.    MFDB     PopMFDB;        /* buffer MFDB        */
  1116.  
  1117.    clip      = ( GRECT )*xclip;
  1118.    clip.g_x -= 2;        /* adjust the clip area to take care of*/
  1119.    clip.g_y -= 2;        /* the edges and shadows...           */
  1120.    clip.g_w += 5;
  1121.    clip.g_h += 5;   
  1122.    rc_2xy( &clip, ( WORD *)&pxy[0] );
  1123.    vs_clip( vhandle, 1, pxy ); 
  1124.  
  1125.    vq_extnd( vhandle, 1, work_out );
  1126.    nplanes = work_out[4];
  1127.  
  1128.    if( !flag )                    /* screen to buffer blit*/
  1129.    {
  1130.      size = (unsigned long)(((long)clip.g_w + 7L )/8L) *
  1131.             (long)clip.g_h * (long)nplanes;
  1132.      size *= 2L;       
  1133.      *PopPtr = (long )malloc( (unsigned long ) size );
  1134.    }  
  1135.    
  1136.    if( !*PopPtr )
  1137.          return( FALSE );
  1138.  
  1139.    PopMFDB.fd_addr     = (long *)*PopPtr;    /* Setup the MFDB      */
  1140.    PopMFDB.fd_w        = clip.g_w;            
  1141.    PopMFDB.fd_h        = clip.g_h;
  1142.    PopMFDB.fd_wdwidth   = ( clip.g_w + 15 ) / 16;
  1143.    PopMFDB.fd_stand     = 0;
  1144.    PopMFDB.fd_nplanes   = nplanes;
  1145.    PopMFDB.fd_r1     = PopMFDB.fd_r2 = PopMFDB.fd_r3 = 0;
  1146.    
  1147.    graf_mouse( M_OFF, 0L );
  1148.    if(!flag )            
  1149.    { 
  1150.      /* Screen to buffer blit */  
  1151.      rc_intersect( &desk, &clip );        
  1152.      rc_2xy( &clip, ( WORD *)&pxy[0] );
  1153.      pxy[4] = pxy[5] = 0;           
  1154.      pxy[6] = clip.g_w - 1;
  1155.      pxy[7] = clip.g_h - 1;
  1156.      vro_cpyfm( vhandle, 3, pxy, ( MFDB *)&location, &PopMFDB );
  1157.    }
  1158.    else                
  1159.    {
  1160.      /* Buffer to screen blit */
  1161.      rc_intersect( &desk, &clip );
  1162.      pxy[0] = pxy[1] = 0;           
  1163.      pxy[2] = clip.g_w - 1; 
  1164.      pxy[3] = clip.g_h - 1;
  1165.      rc_2xy( &clip, ( WORD *)&pxy[4] );   
  1166.      vro_cpyfm( vhandle, 3, pxy, &PopMFDB, ( MFDB *)&location );
  1167.      if( *PopPtr )
  1168.          free( (long *)*PopPtr );
  1169.      *PopPtr = 0L;    
  1170.    }
  1171.    graf_mouse( M_ON, 0L );
  1172.  
  1173.    return( TRUE );
  1174. }
  1175.  
  1176.  
  1177.  
  1178.  
  1179. /* UpArrowStatus()
  1180.  * =====================================================================
  1181.  */
  1182. void
  1183. UpArrowStatus( POP_PTR PopPtr )
  1184. {
  1185.   OBJECT *tree;
  1186.   GRECT  rect;
  1187.     
  1188.   tree = POBJECT( PopPtr );
  1189.     
  1190.   /* Check if we need to activate the UP ARROW or deactivate it */
  1191.   if( POFFSET( PopPtr ) )    /* display the UP ARROW */
  1192.   {
  1193.      if( !strchr( ObString( PFIRST( PopPtr )), UP_ARROW ) )
  1194.      {
  1195.           rect = ObRect( PFIRST( PopPtr ) );
  1196.           objc_offset( tree, PFIRST( PopPtr ), &rect.g_x, &rect.g_y );
  1197.           
  1198.           SetNormal( PFIRST( PopPtr ) );
  1199.           ObString( PFIRST( PopPtr ) ) = &PTEXTBUFF( PopPtr )[ ( PWIDTH( PopPtr ) + 1 ) * PNUM( PopPtr )  ];
  1200.           Objc_draw( tree, ROOT, MAX_DEPTH, &rect );
  1201.      }
  1202.   }
  1203.   else
  1204.     ObString( PFIRST( PopPtr ) ) = &PTEXTBUFF( PopPtr )[ ( PWIDTH( PopPtr ) + 1 ) * ( PNUM( PopPtr ) + 2 ) ];
  1205. }
  1206.  
  1207.  
  1208.  
  1209. /* DownArrowStatus()
  1210.  * =====================================================================
  1211.  */
  1212. void
  1213. DownArrowStatus( POP_PTR PopPtr )
  1214. {
  1215.   OBJECT *tree;
  1216.   GRECT  rect;
  1217.     
  1218.   tree = POBJECT( PopPtr );
  1219.   
  1220.   /* Check if we need to display the DOWN ARROW */
  1221.  
  1222.   /* DISPLAY the DOWN ARROW */
  1223.   if( ( POFFSET( PopPtr ) + PHEIGHT( PopPtr )) <= PNUM( PopPtr ) )
  1224.   {
  1225.       if( !strchr( ObString( PLAST( PopPtr )), DOWN_ARROW ) )
  1226.       {
  1227.         rect = ObRect( PLAST( PopPtr ) );
  1228.         objc_offset( tree, PLAST( PopPtr ), &rect.g_x, &rect.g_y );
  1229.  
  1230.         SetNormal( PLAST( PopPtr ) );
  1231.         ObString( PLAST( PopPtr ) ) = &PTEXTBUFF( PopPtr )[ ( PWIDTH( PopPtr ) + 1 ) * ( PNUM( PopPtr ) + 1 ) ];
  1232.         Objc_draw( tree, ROOT, MAX_DEPTH, &rect );
  1233.       }
  1234.   }
  1235.   else
  1236.     ObString( PLAST( PopPtr ) ) = &PTEXTBUFF( PopPtr )[ ( PWIDTH( PopPtr ) + 1 ) * ( PNUM( PopPtr ) + 2 ) ];
  1237. }
  1238.  
  1239.  
  1240.  
  1241.  
  1242. /* SetArrowClickDelay()
  1243.  * =====================================================================
  1244.  * Set the Click Delay before the menu starts to scroll.
  1245.  */
  1246. void
  1247. SetArrowClickDelay( long delay )
  1248. {
  1249.    CLICK_DELAY = (( delay > 0L ) ? ( delay ) : ( INIT_CLICK_DELAY ));
  1250. }
  1251.  
  1252.  
  1253.  
  1254.  
  1255. /* CHECK FOR KEYCODES...
  1256.  * =====================================================================
  1257.  * Checks the string for the keystrings below so that they may be
  1258.  * subtracted from the length of the string for calculation purposes.
  1259.  */
  1260.  
  1261.  
  1262. /* CheckForDisable()
  1263.  * =====================================================================
  1264.  * Looks for a @ in the string.
  1265.  * Returns TRUE if found, FALSE if not.
  1266.  */
  1267. BOOLEAN
  1268. CheckForDisable( char *text )
  1269. {
  1270.    return( ( BOOLEAN )strchr( text, '@' ) );
  1271. }
  1272.  
  1273.  
  1274. /* CheckForMenuCheck()
  1275.  * =====================================================================
  1276.  * Looks for a ! in the string.
  1277.  * Returns TRUE if found, FALSE if not.
  1278.  */
  1279. BOOLEAN
  1280. CheckForMenuCheck( char *text )
  1281. {
  1282.   return( ( BOOLEAN )strchr( text, '!' ) );
  1283. }
  1284.  
  1285.  
  1286.  
  1287. /* CheckForSubMenu()
  1288.  * =====================================================================
  1289.  * Looks for a ~ in the string.
  1290.  * Returns the pointer to the string where it starts.
  1291.  */
  1292. char
  1293. *CheckForSubMenu( char *text )
  1294. {
  1295.    return( strchr( text, '~' ) );
  1296. }
  1297.  
  1298.  
  1299.  
  1300.  
  1301. /* CheckForKeyCodes()
  1302.  * =====================================================================
  1303.  * Checks the text string for various keycodes and subtracts
  1304.  * an appropriate amount from the length if any are found.
  1305.  * For many of these, there should only be one of them.
  1306.  * We then ADD back in the amount of ACTUAL text usage this item
  1307.  * would take. IE: a Function Key can be F10 so 3 characters...
  1308.  * or a CmdKey can be the letters: 'DEL' 3 characters added.
  1309.  * This will also fill up the CMDCHAR structures.
  1310.  */
  1311. long
  1312. CheckForKeyCodes( POP_PTR PopPtr, char *text, int num_entry )
  1313. {
  1314.     long length;
  1315.  
  1316.     length = strlen( text );
  1317.     if( strchr( text, '@' ))
  1318.        length -= 1L;
  1319.  
  1320.     if( strchr( text, '!' ))
  1321.        length -= 1L;
  1322.  
  1323.      if( CmdFlag( PopPtr->CharPtr[ num_entry ] )  == '~' )
  1324.          length += 1L;
  1325.          
  1326.     return( length );
  1327. }
  1328.  
  1329.  
  1330.  
  1331.  
  1332. /* END OF KEYCODE CHECKING
  1333.  * =====================================================================
  1334.  */
  1335.  
  1336.  
  1337. /* CONTROLLING THE APPEARANCE OF ITEMS
  1338.  * =====================================================================
  1339.  */
  1340.  
  1341. /* SetHeight()
  1342.  * =====================================================================
  1343.  * Set the height of the Menu.( in chars ).
  1344.  */
  1345. void
  1346. SetHeight( int MenuID, int Height )
  1347. {
  1348.    POP_PTR PopPtr;
  1349.    
  1350.    PopPtr = GetMenuPtr( MenuID );
  1351.    
  1352.    if( Height > 0 )
  1353.       PHEIGHT( PopPtr ) = Height;
  1354. }
  1355.  
  1356.  
  1357.  
  1358. /* SetNumItems()
  1359.  * =====================================================================
  1360.  * Set the number of items in the menu. This can be used to display
  1361.  * fewer items than the InsertMenu() call created.
  1362.  */
  1363. void
  1364. SetNumItems( int MenuID, int NumItems )
  1365. {
  1366.    POP_PTR PopPtr;
  1367.   
  1368.    PopPtr = GetMenuPtr( MenuID );
  1369.    if( NumItems > 0 )
  1370.       PNUM( PopPtr ) = NumItems;
  1371. }
  1372.  
  1373.  
  1374.  
  1375. /* CheckItem()
  1376.  * =====================================================================
  1377.  * Places or removes a check mark at the left of a menu item.
  1378.  */
  1379. void
  1380. CheckItem( int MenuID, int item, BOOLEAN check )
  1381. {
  1382.     POP_PTR PopPtr;
  1383.     
  1384.     PopPtr = GetMenuPtr( MenuID );
  1385.     if( check )
  1386.       CmdState( PopPtr->CharPtr[ item ] ) |= CHECKED;
  1387.     else
  1388.       CmdState( PopPtr->CharPtr[ item ] ) &= ~CHECKED;
  1389. }
  1390.  
  1391.  
  1392.  
  1393. /* DisableItem()
  1394.  * =====================================================================
  1395.  * Disables a menu item.
  1396.  */
  1397. void
  1398. DisableItem( int MenuID, int item )
  1399. {
  1400.    POP_PTR PopPtr;
  1401.    
  1402.    PopPtr = GetMenuPtr( MenuID );
  1403.    CmdState( PopPtr->CharPtr[ item ] ) |= DISABLED;
  1404. }
  1405.  
  1406.  
  1407.  
  1408. /* EnableItem()
  1409.  * =====================================================================
  1410.  * Enables a menu item.
  1411.  */
  1412. void
  1413. EnableItem( int MenuID, int item )
  1414. {
  1415.    POP_PTR PopPtr;
  1416.    
  1417.    PopPtr = GetMenuPtr( MenuID );
  1418.    CmdState( PopPtr->CharPtr[ item ] ) &= ~DISABLED;
  1419. }
  1420.  
  1421.  
  1422. /* SetItemCmd()
  1423.  * =====================================================================
  1424.  * This can be used to attach a submenu to a menu item.
  1425.  * You must still call 'SetSubMenuID()' tell the popups which
  1426.  * submenu to attach. Otherwise, this is a great way to change
  1427.  * the keyboard shortcuts. Use SetItemMark() to change the
  1428.  * keyboard shortcuts AFTER setting the type with the SetItemCmd().
  1429.  */
  1430. void
  1431. SetItemCmd( int MenuID, int item, char cmd ) 
  1432. {
  1433.    POP_PTR PopPtr;
  1434.    
  1435.    PopPtr = GetMenuPtr( MenuID );
  1436.    CmdFlag( PopPtr->CharPtr[ item ] ) = cmd;
  1437. }
  1438.  
  1439.  
  1440. /* GetItemCmd()
  1441.  * =====================================================================
  1442.  * This can be used to determine if a submenu is attached to 
  1443.  * this menu item. It returns the current command.
  1444.  * RETURNS: 
  1445.  *           '~' == SubMenu for example
  1446.  */
  1447. char
  1448. GetItemCmd( int MenuID, int item )
  1449. {
  1450.     POP_PTR PopPtr;
  1451.  
  1452.     PopPtr = GetMenuPtr( MenuID );
  1453.     return( CmdFlag( PopPtr->CharPtr[ item ] ) );
  1454. }
  1455.  
  1456.  
  1457.  
  1458. /* SetSubMenuID()
  1459.  * =====================================================================
  1460.  * This can be used to change the ID of the submenu associated
  1461.  * with a menu item. Nothing happens of course, if the menu_item 
  1462.  * does not have a submenu CMD.
  1463.  */
  1464. void
  1465. SetSubMenuID( int MenuID, int item, int ID )
  1466. {
  1467.    POP_PTR PopPtr;
  1468.  
  1469.    PopPtr = GetMenuPtr( MenuID );
  1470.    if( GetItemCmd( MenuID, item ) == '~' )
  1471.      CmdSubMenu( PopPtr->CharPtr[ item ] ) = ID;
  1472. }
  1473.  
  1474.  
  1475. /* GetSubMenuID()
  1476.  * =====================================================================
  1477.  * This can be used to get the ID of the submenu associated
  1478.  * with the menu item. Course, the item must HAVE a submenu in
  1479.  * the first place. Use GetItemCmd to determine if there is a
  1480.  * submenu.
  1481.  * RETURN: -1 if there is no submenu.
  1482.  */
  1483. int
  1484. GetSubMenuID( int MenuID, int item )
  1485. {
  1486.    POP_PTR PopPtr;
  1487.  
  1488.    PopPtr = GetMenuPtr( MenuID );
  1489.    if( GetItemCmd( MenuID, item ) == '~' )
  1490.      return( CmdSubMenu( PopPtr->CharPtr[ item ] ));
  1491.    else
  1492.      return( -1 );  
  1493. }
  1494.  
  1495.  
  1496.  
  1497. /* SetItem()
  1498.  * =====================================================================
  1499.  * Set the Menu item string.
  1500.  * 1) The string must not exceed the original string length.
  1501.  * 2) Meta characters will be printed as regular text.
  1502.  * 3) If the string is longer than the original, then
  1503.  *    the new string will be truncated.
  1504.  */
  1505. void
  1506. SetItem( int MenuID, int item, char *text )
  1507. {
  1508.    POP_PTR PopPtr;
  1509.    int     count;
  1510.    char    *txtptr;
  1511.    long    length;
  1512.    long    length2;
  1513.            
  1514.    PopPtr = GetMenuPtr( MenuID );
  1515.  
  1516.    txtptr = PTEXT( PopPtr );
  1517.    if( txtptr )
  1518.    {
  1519.        for( count = 0; count < item; count++ )
  1520.        {    
  1521.          length = strlen( txtptr );
  1522.          txtptr += ( length + 1 );
  1523.        }
  1524.        /* we've reached the text area that we want. */
  1525.        length = strlen( txtptr );
  1526.        strncpy( txtptr, text, length );
  1527.        length2 = strlen( txtptr );
  1528.        for( count = (int)length2; count < length; count++ )
  1529.           strcat( txtptr, " " );
  1530.    }
  1531. }
  1532.  
  1533.  
  1534.  
  1535. /* GetItem() 
  1536.  * =====================================================================
  1537.  * Returns the string associated with the menu item WITHOUT
  1538.  * the meta characters.
  1539.  */
  1540. char
  1541. *GetItem( int MenuID, int item )
  1542. {
  1543.    POP_PTR PopPtr;
  1544.    int     count;
  1545.    char    *txtptr;
  1546.    char    *sptr;
  1547.    char    *dptr;
  1548.    long    length;
  1549.             
  1550.    PopPtr = GetMenuPtr( MenuID );
  1551.  
  1552.    txtptr = PTEXT( PopPtr );
  1553.    if( txtptr )
  1554.    {
  1555.        for( count = 0; count < item; count++ )
  1556.        {    
  1557.          length = strlen( txtptr );
  1558.          txtptr += ( length + 1 );
  1559.        }
  1560.        
  1561.        /* we've reached the text area that we want. */
  1562.        length = strlen( txtptr );
  1563.        sptr = txtptr;
  1564.        dptr = &TempString[0];
  1565.        
  1566.        while( *sptr )
  1567.        {
  1568.        
  1569.           switch( *sptr )
  1570.           {
  1571.                  case '@':
  1572.               case '!': sptr++;
  1573.                     break;
  1574.  
  1575.               case '~':
  1576.             sptr += 2;
  1577.                    break;
  1578.  
  1579.                  default:  *dptr++ = *sptr++;
  1580.                            break;
  1581.            }
  1582.        }
  1583.        *dptr = '\0';
  1584.        return( ( char *)&TempString[0] );
  1585.    }
  1586.    return( (char *)NULL );
  1587. }
  1588.  
  1589.  
  1590.  
  1591. /* SetStartItem()
  1592.  * =====================================================================
  1593.  * This can be used to Set the start item on a submenu. This will
  1594.  * work of course, on the main menu too.
  1595.  */
  1596. void
  1597. SetStartItem( int MenuID, int item )
  1598. {
  1599.    POP_PTR PopPtr;
  1600.    
  1601.    PopPtr = GetMenuPtr( MenuID );
  1602.    PopUpItem( PopPtr ) = item;
  1603. }
  1604.  
  1605.  
  1606.  
  1607. /* GetStartItem()
  1608.  * =====================================================================
  1609.  * This can be used to get the start item in a submenu. Or at least
  1610.  * wot it currently thinks it is...
  1611.  */
  1612. int
  1613. GetStartItem( int MenuID )
  1614. {
  1615.    POP_PTR PopPtr;
  1616.    
  1617.    PopPtr = GetMenuPtr( MenuID );
  1618.    return( PopUpItem( PopPtr ) );
  1619. }
  1620.  
  1621.  
  1622.  
  1623. /* END OF APPEARANCE OF ITEMS
  1624.  * =====================================================================
  1625.  */
  1626.  
  1627.  
  1628. /* SUBMENU HANDLING
  1629.  * =====================================================================
  1630.  */
  1631.  
  1632.  
  1633.  
  1634. /* DoSubMenu()
  1635.  * =====================================================================
  1636.  * Display the submenu if necessary...
  1637.  *
  1638.  */
  1639. POP_PTR
  1640. DoSubMenu( POP_PTR PopPtr, int obj )
  1641. {
  1642.    int        num;
  1643.    POP_PTR SubPopPtr;
  1644.    GRECT   SubRect;   
  1645.    int     MenuID;
  1646.    OBJECT  *tree;
  1647.    int     curx;
  1648.    
  1649.  
  1650.    ActiveTree( POBJECT( PopPtr ) );
  1651.    SubPopPtr = ( POP_PTR )NULL;
  1652.    if( obj != -1 )
  1653.    {
  1654.      num = FindNum( PopPtr, obj );
  1655.      if( CmdFlag( PopPtr->CharPtr[ num ] ) == '~' )
  1656.      {
  1657.         SubRect   = ObRect( obj );
  1658.         objc_offset( tree, obj, &SubRect.g_x, &SubRect.g_y );
  1659.       
  1660.         MenuID    = CmdSubMenu( PopPtr->CharPtr[ num ] );
  1661.         SubPopPtr = GetMenuPtr( MenuID );
  1662.         /* Displays faster if drawn on a byte boundary.*/
  1663.         curx = SubRect.g_x + SubRect.g_w -1 - gl_wchar;
  1664.         curx = (( curx + 7 )/8)*8;
  1665.         if( !ShowSubMenu( MenuID, curx, SubRect.g_y, &SubRect ))
  1666.            SubPopPtr = ( POP_PTR )NULL;
  1667.      }
  1668.    }  
  1669.    return( SubPopPtr );
  1670. }
  1671.  
  1672.  
  1673.  
  1674.  
  1675. /* ShowSubMenu()
  1676.  * =====================================================================
  1677.  * Display the Initial Submenu 
  1678.  * RETURN: TRUE - AOK
  1679.  *         FALSE - Memory allocation error.
  1680.  */
  1681. BOOLEAN
  1682. ShowSubMenu( int MenuID, int xpos, int ypos, GRECT *rect )
  1683. {
  1684.     POP_PTR PopPtr;
  1685.     int     max_height;
  1686.            
  1687.     PopPtr = GetMenuPtr( MenuID );
  1688.  
  1689.     PPREV( PopPtr ) = ( POP_PTR )NULL;
  1690.         
  1691.     PXPOS( PopPtr )   = xpos;
  1692.     PYPOS( PopPtr )   = ypos;
  1693.  
  1694.     /* Take care of height of menu */ 
  1695.     if( PHEIGHT( PopPtr ) > PNUM( PopPtr ) )
  1696.         PHEIGHT( PopPtr ) = PNUM( PopPtr );
  1697.  
  1698.     /* Limit Height to Height of screen - ( 2 * gl_hchars ) */
  1699.     max_height = yres - ( 2 * gl_hchar );
  1700.     while( ( PHEIGHT( PopPtr ) * gl_hchar ) > max_height )
  1701.        PHEIGHT( PopPtr ) -= 1;
  1702.  
  1703.     PIX_HEIGHT( PopPtr )  = ( PHEIGHT( PopPtr ) * gl_hchar );
  1704.  
  1705.     /* Take care of the width of the menu here...*/
  1706.     PTEXTBUFFSIZE( PopPtr ) = CalcTextBufferSize( PopPtr );
  1707.     PIX_WIDTH( PopPtr )     = ( PWIDTH( PopPtr ) * gl_wchar );
  1708.  
  1709.     AdjustToScreen( PopPtr, xpos, ypos, rect, TRUE, FALSE );
  1710.  
  1711.     if( Pop_Blit( (long *)&PMEM( PopPtr ), &PObRect( PopPtr ), 0 ) )
  1712.     {
  1713.         if( Build_Objects( PopPtr ))
  1714.           return( TRUE );
  1715.     }    
  1716.     return( FALSE );
  1717. }
  1718.  
  1719.  
  1720.  
  1721.  
  1722. /* HideSubMenu()
  1723.  * =====================================================================
  1724.  * Hides the Submenu and free's any memory that it malloc'ed.
  1725.  */
  1726. void
  1727. HideSubMenu( POP_PTR PopPtr )
  1728. {
  1729.     Pop_Blit( (long *)&PMEM( PopPtr ), &PObRect( PopPtr ), 1 );
  1730.  
  1731.     if( POBJECT( PopPtr ) )
  1732.         free( POBJECT( PopPtr ) );
  1733.         
  1734.     if( PTEXTBUFF( PopPtr ) )    
  1735.         free( PTEXTBUFF( PopPtr ) );
  1736.         
  1737.     POBJECT( PopPtr )   = ( OBJECT *)NULL;
  1738.     PTEXTBUFF( PopPtr ) = ( char *)NULL;
  1739. }
  1740.  
  1741.  
  1742.  
  1743.  
  1744. /* EvntSubMenu()
  1745.  * ====================================================================
  1746.  * Submenu Handling...
  1747.  * IN: POP_PTR PopPtr
  1748.  * OUT: long      -1L   No Menu Items selected.
  1749.  *                -2L   We've rentered the submenu ( won't get to user )
  1750.  *                High Word         Low Word
  1751.  *                ---------        --------
  1752.  *                 Menu ID            -1      Selected Disabled Item
  1753.  *           Menu ID        Menu Item Selected Menu Item.
  1754.  */
  1755. long
  1756. EvntSubMenu( POP_PTR PopPtr )
  1757. {
  1758.    long   result;            /* Result to return with...     */
  1759.    MRETS  mk;                /* mouse structures          */
  1760.    int    oldobj;            /* old object              */
  1761.    int    done = FALSE;            /* Done flag to return..    */
  1762.    int    obj;                /* object mouse is over...      */
  1763.    int    event;            /* Mouse button event flag    */
  1764.                        /* TRUE = event occurred    */
  1765.    POP_PTR SubPopPtr;            /* Pointer to Submenu...        */
  1766.    POP_PTR TempPtr;            /* Temporary Submenu Pointer    */
  1767.    
  1768.    GRECT  SubRect;            /* ObRect of Submenu        */
  1769.    GRECT  TempRect;            /* Temp ObRect                */
  1770.    
  1771.    GRECT  wall;               /* ObRect for boundary checks   */
  1772.    GRECT  BoxRect;            /* ObRect for boundary checks   */
  1773.    GRECT  DragRect;            /* ObRect for Drag boundary     */
  1774.  
  1775.    OBJECT *tree;            /* Object tree declaration      */
  1776.    int    Action;            /* Action that is occurring     */
  1777.    int    num;                /* temp number storage        */
  1778.    int    ActiveObj;            /* Current Active Object        */
  1779.    
  1780.    long CurTimeHz;            /* Time in 200Hz...*/
  1781.    BOOLEAN MenuDelayFlag;        /* Display Submenu Delay in effect*/
  1782.    BOOLEAN MenuDragFlag;        /* Drag Submenu Delay in effect  */
  1783.    BOOLEAN DragStart;            /* Start Drag Submenu Delay...   */
  1784.    int  MenuObject;            /* Object to start the timer on*/            
  1785.    int  OldY;                /* Old Y pos for a drag */   
  1786.    int  OldX;
  1787.          
  1788.    ActiveTree( POBJECT( PopPtr ) );
  1789.    Graf_mkstate( &mk );
  1790.  
  1791.    oldobj     = -1;
  1792.    obj        = objc_find( tree, ROOT, MAX_DEPTH, mk.x, mk.y );
  1793.    SubPopPtr  = ( POP_PTR )NULL;
  1794.    BoxRect    = ObRect( ROOT );
  1795.    result     = -1L;
  1796.    OldY          = 0;
  1797.    OldX       = 0;
  1798.       
  1799.    MenuDelayFlag = FALSE;    
  1800.    MenuDragFlag  = FALSE;      
  1801.    DragStart     = FALSE;
  1802.    ActiveObj     = -1;
  1803.    BSTATE      = BREAL = 0;
  1804.  
  1805.    do
  1806.    {
  1807.        if( obj != -1 )
  1808.        {    
  1809.        if( obj != oldobj )
  1810.           {
  1811.          wall = ObRect( obj );
  1812.          objc_offset( tree, obj, &wall.g_x, &wall.g_y );
  1813.           if( SubPopPtr )
  1814.             {
  1815.             PPREV( SubPopPtr ) = ( POP_PTR )NULL;
  1816.             HideSubMenu( SubPopPtr );
  1817.             SubPopPtr = ( POP_PTR )NULL;
  1818.             MenuDragFlag  = FALSE;
  1819.             MenuDelayFlag = FALSE;
  1820.             DragStart     = FALSE;
  1821.             ActiveObj = -1;
  1822.          }
  1823.          if(( oldobj != -1 ) && ( oldobj != obj ))
  1824.               deselect( tree, oldobj );
  1825.  
  1826.          if( ( obj == PFIRST( PopPtr ) && strchr( ObString( obj ), UP_ARROW ) ) ||
  1827.              ( obj == PLAST( PopPtr ) && strchr( ObString( obj ), DOWN_ARROW ) )
  1828.            )
  1829.            deselect( tree, obj );  
  1830.          else
  1831.          {
  1832.             if( !IsDisabled( obj ) ) 
  1833.             {
  1834.                   select( tree, obj );
  1835.  
  1836.                if( ( num = FindNum( PopPtr, obj )) != -1 )
  1837.            {
  1838.               if( CmdFlag( PopPtr->CharPtr[ num ] ) == '~' )
  1839.               {
  1840.                  Supexec( GetTimeHz );
  1841.                  CurTimeHz     = TimeInHz;
  1842.                  MenuDelayFlag = TRUE;
  1843.                  MenuDragFlag  = FALSE;
  1844.                      DragStart     = FALSE;
  1845.                  MenuObject    = obj;
  1846.               }  
  1847.            }                
  1848.                }  
  1849.             }  
  1850.        }
  1851.        }
  1852.        else
  1853.        {
  1854.      if(( oldobj != -1 ) && ( oldobj != obj ) )
  1855.          {
  1856.         deselect( tree, oldobj );
  1857.          }
  1858.        }
  1859.        oldobj = obj;
  1860.        
  1861.        Graf_mkstate( &mk );
  1862.        OldY = mk.y;
  1863.        OldX = mk.x;
  1864.        do
  1865.        {
  1866.                BSTATE = 0;
  1867.             if( MenuDragFlag )
  1868.             {
  1869.                if( ( !xy_inrect( mk.x, mk.y, &wall ) || 
  1870.                    ( SubPopPtr && xy_inrect( mk.x, mk.y, &SubRect ) ))
  1871.                  )
  1872.                {
  1873.           if( DragStart )
  1874.           {
  1875.                     Supexec( GetTimeHz );
  1876.                     CurTimeHz = TimeInHz;
  1877.                     DragStart = FALSE;
  1878.                     DragRect.g_x = mk.x;
  1879.                     DragRect.g_y = SubRect.g_y;
  1880.                     DragRect.g_h = SubRect.g_h;
  1881.                     
  1882.                     OldX = mk.x;
  1883.                     OldY = mk.y;
  1884.                                 
  1885.                     if( mk.x <= SubRect.g_x )
  1886.                     {
  1887.                        DragRect.g_w = SubRect.g_w + ( SubRect.g_x - DragRect.g_x );
  1888.                     }
  1889.                     else
  1890.                     {
  1891.                DragRect.g_x = SubRect.g_x;
  1892.                        DragRect.g_w = mk.x - SubRect.g_x + 1;
  1893.                     }
  1894.                   }  
  1895.  
  1896.               if( SubPopPtr )
  1897.                   {
  1898.                        if( !DragStart )
  1899.                        {
  1900.                  Supexec( GetTimeHz );
  1901.                  if( ( TimeInHz - CurTimeHz ) >= SUBDRAG_DELAY )
  1902.                      MenuDragFlag = FALSE;
  1903.  
  1904.                  if( !xy_inrect( mk.x, mk.y, &DragRect ) ||
  1905.                      (xy_inrect( mk.x, mk.y, &DragRect ) &&
  1906.                       ( mk.x == OldX ) &&
  1907.                       ( mk.y != OldY )
  1908.                  ) 
  1909.                    )  
  1910.                    MenuDragFlag = FALSE;    
  1911.                  else
  1912.                  {
  1913.                         DragRect.g_x = mk.x;
  1914.                         if( mk.x <= SubRect.g_x )
  1915.                         {
  1916.                                   DragRect.g_w = SubRect.g_w + ( SubRect.g_x - DragRect.g_x );
  1917.                             }
  1918.                             else
  1919.                            {
  1920.                        DragRect.g_x = SubRect.g_x;
  1921.                                DragRect.g_w = mk.x - SubRect.g_x + 1;
  1922.                             }
  1923.                  }    
  1924.                }      
  1925.  
  1926.                        /* We're in the new submenu...*/
  1927.                        if( xy_inrect( mk.x, mk.y, &SubRect ) )
  1928.                        {
  1929.                          Action = 0;
  1930.                          MenuDragFlag = FALSE;
  1931.                          break;    
  1932.                        }    
  1933.                        MenuDelayFlag = FALSE;
  1934.                   }
  1935.                }
  1936.             }
  1937.             else
  1938.         {            
  1939.                 BoxRect = ObRect( ROOT );
  1940.                 if( xy_inrect( mk.x, mk.y, &BoxRect ) )
  1941.                 {
  1942.                        /* We're in our current submenu still
  1943.                      * but we might be in a new menu item.
  1944.                      */
  1945.                        Action = 1;
  1946.                        break;
  1947.                 }      
  1948.                 else           
  1949.                 {
  1950.                     /* Checking to see if we're in any of the previous menus */
  1951.                     TempPtr = PPREV( PopPtr );
  1952.                     while( TempPtr )
  1953.                     {
  1954.                        /* We're in a previous submenu or root */
  1955.                        TempRect = PObRect( TempPtr );
  1956.                        if( xy_inrect( mk.x, mk.y, &TempRect ) )
  1957.                        {
  1958.                           Action = 2;
  1959.                           goto abort;
  1960.                    }
  1961.                    TempPtr = PPREV( TempPtr );
  1962.                     }
  1963.                 }
  1964.                 
  1965.                 /* if we reach here, we're outside of all the rectangles.*/
  1966.             if( SubPopPtr )
  1967.             {
  1968.                    HideSubMenu( SubPopPtr );
  1969.                PPREV( SubPopPtr ) = ( POP_PTR )NULL;
  1970.                SubPopPtr     = ( POP_PTR )NULL;
  1971.                ActiveObj     = -1;
  1972.                MenuDragFlag  = FALSE;
  1973.                MenuDelayFlag = FALSE;
  1974.                 }
  1975.  
  1976.             if( oldobj != -1 )
  1977.             {
  1978.               deselect( tree, oldobj );
  1979.               oldobj = obj = -1;
  1980.             }  
  1981.             }
  1982.             Action = -1;
  1983.  
  1984.             OldX = mk.x;
  1985.             OldY = mk.y;
  1986.             Evnt_timer( 0L );         /* Kludge to put in a delay 
  1987.                               * so that we can get a new mouse
  1988.                               * x,y with > 1 pixel difference
  1989.                               */
  1990.             Graf_mkstate( &mk );
  1991.     }while( !BSTATE );
  1992. abort:
  1993.        /* we've exited due to a button click, OR
  1994.         * we've entered one of the rectangles.
  1995.         * Let's see wot we've got.
  1996.         * If Action == -1, then the user clicked outside of
  1997.         * ANY rectangles and we should just exit and close
  1998.         * down all of the menus.
  1999.         */
  2000.        Graf_mkstate( &mk );
  2001.        obj = objc_find( tree, ROOT, MAX_DEPTH, mk.x, mk.y );
  2002.  
  2003.        /* Fix for when the submenu is displayed and we click
  2004.         * on its title to exit.
  2005.         */
  2006.        if(  xy_inrect( mk.x, mk.y, &wall ) &&
  2007.             SubPopPtr && MenuDragFlag && ( BSTATE == 1 ) )
  2008.         Action = 1;            
  2009.           
  2010.        event = FALSE;
  2011.        switch( Action )
  2012.        {
  2013.           case 0:  /* Entered the New Submenu, if there is one */
  2014.                if( SubPopPtr )
  2015.                {
  2016.                   /* need to check wot is returned...*/
  2017.                   result = EvntSubMenu( SubPopPtr );
  2018.                   if(( result == -1L ) || ( result != -2L ) )
  2019.                   {
  2020.                      obj = -1;
  2021.                      event = TRUE;
  2022.                      goto leave;
  2023.                   }
  2024.                   TempPtr = SubPopPtr;   
  2025.                   PPREV( SubPopPtr ) = ( POP_PTR )NULL;
  2026.                   HideSubMenu( SubPopPtr );
  2027.                   SubPopPtr     = ( POP_PTR )NULL;
  2028.                   MenuDragFlag  = FALSE;
  2029.               MenuDelayFlag = FALSE;
  2030.  
  2031.               Graf_mkstate( &mk );
  2032.                       obj = objc_find( tree, ROOT, MAX_DEPTH, mk.x, mk.y );
  2033.                   num = FindNum( PopPtr, obj );
  2034.                      if( ( obj != -1 ) && ( ActiveObj == obj ) &&
  2035.                          ( CmdFlag( PopPtr->CharPtr[ num ] ) == '~' ) &&
  2036.                          ( GetMenuPtr( CmdSubMenu( PopPtr->CharPtr[ num ] )) == TempPtr )
  2037.                        )
  2038.               {
  2039.                   if( !IsSelected( obj ) )
  2040.                 select( tree, obj );
  2041.  
  2042.                   if( ( SubPopPtr = DoSubMenu( PopPtr, obj )) != ( POP_PTR )NULL )
  2043.                         {
  2044.                           ActiveObj = obj;
  2045.                       SubRect = PObRect( SubPopPtr );
  2046.               ActiveTree( POBJECT( PopPtr ) );
  2047.                       PPREV( SubPopPtr ) = PopPtr;
  2048.                           MenuDragFlag       = TRUE;
  2049.                           DragStart          = TRUE;
  2050.                    wall = ObRect( obj );
  2051.                   objc_offset( tree, obj, &wall.g_x, &wall.g_y );
  2052.                     }  
  2053.               }
  2054.               else
  2055.                 ActiveObj = -1;
  2056.                }     
  2057.                  break;
  2058.                   
  2059.           case 1:  /* we are still in the current submenu...*/
  2060.                    /* The user click on an arrow button? */
  2061.                   if( (( BSTATE == 1 ) || ( BREAL == 1 )) && (( obj == PFIRST( PopPtr)  && strchr( ObString( obj ), UP_ARROW )) ||
  2062.                        (( obj == PLAST( PopPtr ) ) && strchr( ObString( obj ), DOWN_ARROW ))
  2063.                      )) 
  2064.                    {
  2065.                     if( Pop_Arrow( PopPtr, obj ) )
  2066.                       {
  2067.                  if( ( num = FindNum( PopPtr, obj )) != -1 )
  2068.                  {
  2069.                    if( CmdFlag( PopPtr->CharPtr[ num ] ) == '~' )
  2070.                    {
  2071.                      Supexec( GetTimeHz );
  2072.                      CurTimeHz     = TimeInHz;
  2073.                      MenuDelayFlag = TRUE;
  2074.                      MenuObject    = obj;
  2075.                    }  
  2076.                  }                
  2077.                       }
  2078.                   }
  2079.                   else
  2080.                   {
  2081.                      if( !SubPopPtr && MenuDelayFlag && ( MenuObject == obj ))
  2082.                      {
  2083.                        Supexec( GetTimeHz );
  2084.                        if( ( TimeInHz - CurTimeHz ) >= SUBMENU_DELAY )
  2085.                        {
  2086.                             MenuDelayFlag = FALSE;
  2087.                  if( !IsSelected( obj ) )
  2088.                       select( tree, obj );
  2089.  
  2090.                       if( ( SubPopPtr = DoSubMenu( PopPtr, obj )) != ( POP_PTR )NULL )
  2091.                      {
  2092.                        ActiveObj = obj;
  2093.                            SubRect   = PObRect( SubPopPtr );
  2094.                    ActiveTree( POBJECT( PopPtr ) );
  2095.                            PPREV( SubPopPtr ) = PopPtr;
  2096.                            MenuDragFlag       = TRUE;
  2097.                            DragStart          = TRUE;
  2098.                        wall = ObRect( obj );
  2099.                        objc_offset( tree, obj, &wall.g_x, &wall.g_y );
  2100.                          }     
  2101.                            
  2102.                        }    
  2103.                      }
  2104.                      else
  2105.                        MenuDelayFlag = FALSE;
  2106.                            
  2107.                      /* we are just in another menu item.
  2108.                       * If a submenu was displayed, hide it.
  2109.                       */
  2110.               if( SubPopPtr && ( ActiveObj != obj ) )
  2111.               {
  2112.                     PPREV( SubPopPtr ) = ( POP_PTR )NULL;
  2113.                         HideSubMenu( SubPopPtr );
  2114.                     SubPopPtr     = ( POP_PTR )NULL;
  2115.                 MenuDragFlag  = FALSE;
  2116.                 MenuDelayFlag = FALSE;
  2117.                     ActiveObj     = -1;
  2118.                   }
  2119.                   
  2120.                   /* if the buttons are down, they clicked on something*/
  2121.                   if(( BSTATE == 1 ) || ( BREAL == 1 ))
  2122.                   {
  2123.                       event = TRUE;
  2124.                       
  2125.                           obj = objc_find( tree, ROOT, MAX_DEPTH, mk.x, mk.y );
  2126.                           
  2127.                           CurMenu   = PMENUID( PopPtr );
  2128.                           CurObject = obj;
  2129.                           result    = 0L;
  2130.                   }
  2131.                   }
  2132.                  break;
  2133.                  
  2134.           case 2:  /* we have entered a previous submenu...  */
  2135.            result = -2L;
  2136.  
  2137.           case -1: /* we have clicked outside of ANY submenus.*/
  2138.                  if( Action == -1 )
  2139.                  {
  2140.                     /* don't exit if not a left button click */
  2141.                     if( BSTATE != 1 )
  2142.                       goto leave;
  2143.                  }
  2144.                  CurMenu = CurObject = -1;
  2145.           default: event = TRUE;
  2146.            obj    = -1;
  2147.                  break;
  2148.        }
  2149.  
  2150. leave:              
  2151.        if( event )
  2152.        {
  2153.           if( SubPopPtr )
  2154.           {
  2155.              PPREV( SubPopPtr ) = ( POP_PTR )NULL;
  2156.              HideSubMenu( SubPopPtr );
  2157.                SubPopPtr = ( POP_PTR )NULL;
  2158.           }
  2159.       done = TRUE;
  2160.        }     
  2161.  
  2162.    }while( !done );
  2163.  
  2164.          
  2165.    if(( obj != -1 ) && ( result != -2L ) && ( result != -1L ) )
  2166.    {
  2167.       result = 0L;
  2168.       result = ( int )PMENUID( PopPtr );
  2169.       result = ( result << 16L );
  2170.       
  2171.       if( !IsDisabled( obj ) )
  2172.         obj = FindNum( PopPtr, obj );
  2173.       else
  2174.         obj = -1;
  2175.       result |= ( obj & 0x0000FFFF );
  2176.    }
  2177.    return( result );
  2178. }
  2179.  
  2180.  
  2181.  
  2182. /* FindNum()
  2183.  * =====================================================================
  2184.  * Given the object #, find the adjusted index of the menu item.
  2185.  */
  2186. int
  2187. FindNum( POP_PTR PopPtr, int obj )
  2188. {
  2189.     int offset;
  2190.     
  2191.     offset = POFFSET( PopPtr );
  2192.     if( offset > 0 )
  2193.         offset -= 1;
  2194.     obj -= PFIRST( PopPtr );
  2195.     obj += offset;    
  2196.     return( obj );    
  2197. }
  2198.  
  2199.  
  2200.  
  2201.  
  2202. /* MenuChoice()
  2203.  * =====================================================================
  2204.  * Returns the CURRENT values of the menu and object clicked on.
  2205.  * Call ONLY after the PopMenuSelect() call has returned.
  2206.  */
  2207. long
  2208. MenuChoice( void )
  2209. {
  2210.    long value;
  2211.    POP_PTR PopPtr;
  2212.    int obj;
  2213.    
  2214.    value = 0L;
  2215.    value = ( int )CurMenu;
  2216.    value = ( value << 16L );
  2217.    
  2218.    if( CurMenu != -1 )
  2219.    {
  2220.       PopPtr = GetMenuPtr( CurMenu );   
  2221.       obj = FindNum( PopPtr, CurObject );
  2222.    }     
  2223.    else
  2224.       obj = -1;
  2225.    value |= ( obj & 0x0000FFFF );
  2226.    return( value );
  2227. }
  2228.  
  2229.  
  2230. /* END OF SUBMENU ROUTINES
  2231.  * =====================================================================
  2232.  */
  2233.  
  2234.  
  2235.  
  2236.  
  2237.  
  2238. /* SUBMENU DELAY ROUTINES
  2239.  * =====================================================================
  2240.  */
  2241.  
  2242. /* GetTimeHz()
  2243.  * =====================================================================
  2244.  * Gets the System time in 20ms ticks.
  2245.  */
  2246. long
  2247. GetTimeHz( void )
  2248. {
  2249.    long *ptr;
  2250.    
  2251.    ptr = ( long *)0x4BA;
  2252.    TimeInHz = *ptr;
  2253.    return( TimeInHz );
  2254. }
  2255.  
  2256.  
  2257.  
  2258.  
  2259. /* SetSubMenuDelay()
  2260.  * =====================================================================
  2261.  * Sets the length of time before a submenu appears as the user drags
  2262.  * the pointer thru a menu list.
  2263.  * The Units are in # of Milliseconds. ( 1000 = 1 second ).
  2264.  */
  2265. void
  2266. SetSubMenuDelay( long ms )
  2267. {
  2268.    if( ms < 0L )
  2269.        ms = INIT_DISPLAY_DELAY;
  2270.    if( ms )    
  2271.        ms /= 20L;     
  2272.    SUBMENU_DELAY = ms;
  2273. }
  2274.  
  2275.  
  2276.  
  2277.  
  2278. /* SetSubDragDelay()
  2279.  * =====================================================================
  2280.  * Sets the length of time the user has to drag diagonally, a pointer
  2281.  * to an active submenu before the submenu closes.
  2282.  */
  2283. void
  2284. SetSubDragDelay( long ms )
  2285. {
  2286.    if( ms < 0L )
  2287.        ms = INIT_DRAG_DELAY;
  2288.    if( ms )    
  2289.        ms /= 20L;
  2290.    SUBDRAG_DELAY = ms;
  2291. }
  2292.  
  2293.  
  2294. /* END OF SUBMENU DELAY ROUTINES
  2295.  * =====================================================================
  2296.  */
  2297.  
  2298.  
  2299.  
  2300. /* AdjustToScreen()
  2301.  * =====================================================================
  2302.  * Takes the Submenu XY and adjusts it so that it fits within
  2303.  * the screen area still. If there is an optional object, we will
  2304.  * adjust around that.
  2305.  * If we DO adjust, we'll try to get it on a byte boundary.
  2306.  * BOOLEAN byte_flag - a flag to align the xpos on a byte boundary.
  2307.  *                   - TRUE - YES!
  2308.  *             - NOTE: if the menu does not want byte adjusting
  2309.  *                 BUT it is off the screen, we will adjust
  2310.  *                 it back ONTO the screen on a byte boundary.
  2311.  *                 We just won't byte_adjust it if its already
  2312.  *                 on the screen in its entirety.
  2313.  * BOOLEAN Display_Flag; - a flag for vertical alignment of submenus.
  2314.  *             - When the submenu extends BELOW the bottom
  2315.  *               of the screen, there are 2 ways to adjust
  2316.  *               the menu.
  2317.  *             1)Adjust by displaying the menu upwards vertically
  2318.  *               from the rectangle button.
  2319.  *             2)Adjust by moving the menu upwards 1 gl_hchar
  2320.  *               at a time until the menu does not extend
  2321.  *               below the screen boundary.
  2322.  *             TRUE - Use Version 1
  2323.  *             FALSE - Use Version 2
  2324.  */
  2325. void
  2326. AdjustToScreen( POP_PTR PopPtr, int xpos, int ypos, GRECT *rect, BOOLEAN byte_flag, BOOLEAN Display_Flag )
  2327. {
  2328.     int temp;
  2329.     int position;
  2330.            
  2331.     /* Handle the X Coordinate Adjustments...
  2332.      *------------------------------------------------------------------
  2333.      */
  2334.     temp = xpos + PIX_WIDTH( PopPtr );
  2335.     if( temp > ( xres - 4 ))
  2336.     {
  2337.         if( !byte_flag )
  2338.         {
  2339.           temp -= ( xres - 4 );
  2340.           temp = ( temp + gl_wchar )/gl_wchar;
  2341.           temp *= gl_wchar;
  2342.           xpos -= temp;
  2343.         }
  2344.         else
  2345.         {
  2346.           xpos = rect->g_x - PIX_WIDTH( PopPtr );
  2347.           xpos = ( xpos + gl_wchar )/gl_wchar;
  2348.           xpos *= gl_wchar;
  2349.         }        
  2350.     }
  2351.     else
  2352.     {
  2353.         if( byte_flag )
  2354.         {
  2355.           xpos = ( xpos + ( gl_wchar - 1 ) )/gl_wchar;
  2356.           xpos *= gl_wchar;
  2357.         }     
  2358.     }
  2359.     
  2360.     /* Handle X limits < 0 */
  2361.     while( xpos <= 0 )
  2362.        xpos += gl_wchar;
  2363.     PXPOS( PopPtr )   = xpos;
  2364.     
  2365.  
  2366.     /* Handle the Y Coordinate Adjustments...
  2367.      *------------------------------------------------------------------
  2368.      */
  2369.     /* Calculates the Position so that the submenu start item 
  2370.      * is adjacent to the button that activated it.
  2371.      */
  2372.     position = ( PopUpItem( PopPtr ) + ( PNUM( PopPtr ) > PHEIGHT( PopPtr ) )) / PHEIGHT( PopPtr );
  2373.     if( position )
  2374.     {
  2375.        position = PopUpItem( PopPtr );
  2376.        temp = PNUM( PopPtr ) - PHEIGHT( PopPtr ) + 1;
  2377.  
  2378.        if( position  >= temp )
  2379.            position   = temp;
  2380.        position -= 1;    
  2381.     }      
  2382.     position = PopUpItem( PopPtr ) - position;
  2383.     ypos = ypos - ( position * gl_hchar );
  2384.  
  2385.     
  2386.     /* Calculates a new position if the submenu exceeds the
  2387.      * height of the screen.
  2388.      */        
  2389.     temp = ypos + PIX_HEIGHT( PopPtr );
  2390.     if( temp > ( yres - 4 ))
  2391.     {
  2392.        if( Display_Flag )
  2393.           ypos = ypos - ( (PHEIGHT( PopPtr ) - position - 1 )* gl_hchar );        
  2394.        else
  2395.        {
  2396.           do
  2397.           {
  2398.              ypos -= gl_hchar;
  2399.              temp = ypos + PIX_HEIGHT( PopPtr );
  2400.           }while( temp > ( yres - 4 ) );
  2401.        }
  2402.     }
  2403.     
  2404.     while( ypos <= ( gl_hchar + ( gl_hchar/2 ) ))
  2405.        ypos += gl_hchar;
  2406.        
  2407.     PYPOS( PopPtr )   = ypos;
  2408. }
  2409.  
  2410.  
  2411.  
  2412.  
  2413. /* WaitForUpButton()
  2414.  * =====================================================================
  2415.  * Waits for an up button.
  2416.  */
  2417. void
  2418. WaitForUpButton( void )
  2419. {
  2420.   MRETS mk;
  2421.   
  2422.   do
  2423.   {
  2424.      Graf_mkstate( &mk );
  2425.   }while( mk.buttons );
  2426. }
  2427.  
  2428.  
  2429.