home *** CD-ROM | disk | FTP | other *** search
/ MacTech 1 to 12 / MacTech-vol-1-12.toast / Source / MacTech® Magazine / Volume 06 - 1990 / 06.01 Jan 90 / MacTutor Help Source / Code Resource Version / Source Code / help.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-09-22  |  45.9 KB  |  1,293 lines  |  [TEXT/KAHL]
  1. /***********************************************************************\
  2. | Purpose :: This is the CODE RESOURCE version of the MacTutor Help        |
  3. |             facility.  It is language independent, and can be used in    |
  4. |             any development system which gives proper access to the    |
  5. |             Macintosh toolbox.                                            |
  6. |-----------------------------------------------------------------------|
  7. |        Copyright © Joe Pillera, 1990.  All Rights Reserved.            |
  8. |    Copyright © MacTutor Magazine, 1990.  All Rights Reserved.            |
  9. \***********************************************************************/
  10.  
  11. #include "help.h"
  12. #include <SetUpA4.h>
  13.  
  14. /* Global variables */
  15. static  ListHandle  My_List_Handle;       /* Handle for a list in the dialog         */
  16. static  Rect           List_Rect;             /* Rectangle (user-item) of topic list     */
  17. static    Rect        Display_Rect;        /* Rectangle (user-item) of the display */
  18. static    Rect        Scroller_Rect;        /* Rectangle (computed) of scroll bar    */
  19. static     Rect        Dest_Rect;            /* Destination of TE rectangle            */
  20. static    Rect        View_Rect;            /* Actual viewing region of text        */
  21. static    Rect        Frame_Rect;            /* The rectangle to frame for text        */
  22. static  int            Help_Topic;            /* What topic does user want info on?    */
  23. static  int            Current_Pict;        /* Latest picture ID being displayed    */
  24. static  DialogPtr    helpPtr;            /* Pointer to the help dialog box        */
  25. static  TEHandle    myTEHandle;            /* The TE Manager data structure        */
  26. static  Handle        myTEXTHandle;        /* My handle to the TEXT resource        */
  27. static  ViewMode    Last_Type;            /* Was last one a pict or text?            */ 
  28. static    ControlHandle myControl;        /* Handle to the text scroller            */
  29. static     GrafPtr        savePort;            /* Save a pointer to the old grafport    */
  30. static    int            refnum;                /* Result of trying to open help file    */
  31.  
  32. /* Keep track of the screen types */
  33. static    ViewMode    screen_mode[ MAX_TOPICS ];
  34.  
  35. /* Number of user's help topics */
  36. static    int            Number_Of_Topics;
  37.  
  38. /* Disable his menus */
  39. static    int            First_Menu;
  40. static    int            Last_Menu;
  41.  
  42. /* Array traversal constants */
  43. static    int            START;
  44. static    int            FINIS;
  45.  
  46. /* Log positions of 'PICT' & 'TEXT' resources */
  47. static    Str255        topic_name[ MAX_TOPICS ];
  48. static    int            resource_start[ MAX_TOPICS ];
  49. static    int            resource_end[ MAX_TOPICS ];
  50.  
  51.  
  52. /***********************************************************************\
  53. |                   void  Add_List_String( theString, theList )                |
  54. |-----------------------------------------------------------------------|
  55. | Purpose :: To add a (pascal) string to a specified list.                |
  56. |-----------------------------------------------------------------------|
  57. | Arguments ::                                                            |
  58. |     theString    -> Pascal string to add.                                |
  59. |     theList        -> Pointer to the target list.                            |
  60. |-----------------------------------------------------------------------|
  61. | Returns :: void.                                                        |
  62. \***********************************************************************/
  63.  
  64. static void  Add_List_String( theString, theList )
  65. Str255   *theString;                    
  66. ListHandle   theList;                   
  67. { 
  68.     short   theRow;         /* The Row that we are adding     */
  69.     Point   cSize;          /*  Pointer to a cell in a list */
  70.  
  71.     if (theList != NIL) {
  72.         cSize.h = 0;                    
  73.         theRow = LAddRow(1, 32000, theList);
  74.         cSize.v = theRow;               
  75.         LSetCell((*theString + 1), *theString[0], cSize,theList);
  76.         LDraw(cSize, theList);          
  77.     } 
  78. }
  79.  
  80.  
  81. /***********************************************************************\
  82. |                     void  Bold_Button( dPtr, itemNum )                    |
  83. |-----------------------------------------------------------------------|
  84. | Purpose :: To draw a thick black line around any dialog box item.        |
  85. |-----------------------------------------------------------------------|
  86. | Arguments ::                                                            |
  87. |     dPtr    -> Pointer to an already opened window.                        |
  88. |     itemNum    -> Item within the dialog to highlight.                        |
  89. |-----------------------------------------------------------------------|
  90. | Returns :: void.                                                        |
  91. \***********************************************************************/
  92.  
  93. static void Bold_Button( dPtr, itemNum )
  94. DialogPtr    dPtr;
  95. int            itemNum;
  96.  {
  97.      Rect        iBox;            /* The rectangle for the button        */
  98.      int            iType;            /* Type of dialog item                */
  99.      Handle        iHandle;        /* Pointer to the item                */
  100.      PenState    oldPenState;    /* Preserve the old drawing state    */
  101.      
  102.      SystemTask();
  103.      SetPort(dPtr);
  104.      GetPenState(&oldPenState);
  105.      GetDItem(dPtr, itemNum, &iType, &iHandle, &iBox);
  106.      InsetRect(&iBox, -4, -4);
  107.      PenSize(3,3);
  108.      FrameRoundRect(&iBox, 16, 16);
  109.      SetPenState(&oldPenState);
  110.  }
  111.  
  112.  
  113. /***********************************************************************\
  114. |                 void  Center_Window( theWindow, bumpUp )                |
  115. |-----------------------------------------------------------------------|
  116. | Purpose :: To center a currently opened - but still invisible -         |
  117. |             window on the screen.  Once the window is centered, it     |
  118. |             should then be made visible for the user.                    |
  119. |-----------------------------------------------------------------------|
  120. | Arguments ::                                                            |
  121. |     theWindow    -> Pointer to an already opened window.                    |
  122. |     bumpUp        -> A percentage from center to move the window up.        |
  123. |                   Sometimes a perfectly centered window (bumpUp=0) is    |
  124. |                   annoying to a user, so I provide this facility. Note    |
  125. |                   that a negative value will push the window down.        |
  126. |    isModeless    -> If so, add an additional 20 pixels for the drag bar. |
  127. |-----------------------------------------------------------------------|
  128. | Returns :: void.                                                        |
  129. \***********************************************************************/
  130.  
  131. static void Center_Window(theWindow,bumpUp,isModeless)
  132. DialogPtr    theWindow;
  133. int            bumpUp;
  134. Boolean        isModeless;
  135.  {
  136.     Rect    tempRect;       /* Temporary rectangle                     */
  137.     int        pixels;            /* Raise from center this amount        */
  138.     int        menuBar = 20;    /* Compensate 20 pixels for menu bar    */
  139.     
  140.     /* Compute centering information */
  141.      tempRect.top = theWindow->portRect.top;
  142.     tempRect.left = theWindow->portRect.left;
  143.     tempRect.bottom = theWindow->portRect.bottom;
  144.     tempRect.right = theWindow->portRect.right;
  145.     tempRect.top = ((screenBits.bounds.bottom + menuBar + (isModeless ? 20 : 0) - 
  146.                      screenBits.bounds.top) - (tempRect.bottom - tempRect.top)) / 2;
  147.     tempRect.left = ((screenBits.bounds.right - screenBits.bounds.left) - 
  148.                     (tempRect.right - tempRect.left)) / 2;
  149.  
  150.     /* Apply any bump-up factor */
  151.     pixels = tempRect.top * (bumpUp / 100.0);
  152.     tempRect.top = tempRect.top - pixels;
  153.  
  154.     /* Now center window & make it visible */
  155.     MoveWindow(theWindow, tempRect.left, tempRect.top, TRUE);
  156.     SetPort(theWindow);              
  157.   }
  158.   
  159.  
  160. /***********************************************************************\
  161. |                           Boolean Create_Help( void )                        |
  162. |-----------------------------------------------------------------------|
  163. | Purpose :: To bring up and initialize MacTutor Help.                    |
  164. |-----------------------------------------------------------------------|
  165. | Arguments :: None.                                                    |
  166. |-----------------------------------------------------------------------|
  167. | Returns :: TRUE if all went well, FALSE otherwise.                      |
  168. \***********************************************************************/
  169.  
  170. static Boolean Create_Help()
  171. {
  172.     int            whatHit;            /* The DITL item the user selected            */
  173.     int            DType;                 /* Type of dialog item                         */
  174.     Point       cSize;              /* Pointer to a cell in a list              */
  175.     Rect        tempRect;           /* Temporary rectangle                         */
  176.     Rect        dataBounds;         /* Rect to setup the list                      */
  177.     Handle       DItem;                /* Handle to the dialog item                 */
  178.     FontInfo       ThisFontInfo;        /* Used to determine List element height      */
  179.     int            index;                /* Loop thru the topic list names            */
  180.      Rect        iBox;                /* The rectangle for the next/prev buttons    */
  181.      int            iType;                /* Type of dialog item (button)                */
  182.      Handle        iHandle;            /* Pointer to the item                        */
  183.  
  184.  
  185.     /* -- Preserve pointer to former graf port -- */
  186.     GetPort(&savePort);
  187.     
  188.     /* -- First make sure the help file is out there! -- */
  189.     refnum = OpenResFile("\pHelp Data");
  190.     if (refnum == NOT_FOUND) {
  191.       helpPtr = GetNewDialog(Help_Not_Found, NIL, FRONT);
  192.       Center_Window( helpPtr,50, FALSE );
  193.       ShowWindow(helpPtr);
  194.       Bold_Button( helpPtr, OK_Button );
  195.       SysBeep(1);
  196.       ModalDialog(NIL, &whatHit);
  197.       DisposDialog(helpPtr);
  198.       SetPort(savePort);
  199.       return(FALSE);
  200.     }
  201.     
  202.     /* Set up pointers to the introduction screen */
  203.     Help_Topic = START;
  204.     Current_Pict = resource_start[START];
  205.     Last_Type = screen_mode[START];
  206.     
  207.     /* -- Bring up the help screen -- */
  208.     helpPtr = GetNewDialog(Help_Window, NIL, FRONT);
  209.     Center_Window(helpPtr,0,TRUE);
  210.     ShowWindow(helpPtr);           
  211.     SelectWindow(helpPtr);         
  212.     SetPort(helpPtr);          
  213.     Bold_Button(helpPtr,OK_Button);
  214.     
  215.     /* Hide the next & previous buttons for the intro screen */
  216.     GetDItem(helpPtr, Next_Button, &iType, &iHandle, &iBox);
  217.     HideControl((ControlHandle)iHandle);
  218.     GetDItem(helpPtr, Prev_Button, &iType, &iHandle, &iBox);
  219.     HideControl((ControlHandle)iHandle);
  220.     
  221.     /* -- Disable the "Next" & "Previous" buttons for now -- */
  222.     Set_Button_State( Next_Button, FALSE );
  223.     Set_Button_State( Prev_Button, FALSE );
  224.  
  225.     /* -- Now build the list -- */
  226.     GetDItem(helpPtr, Topics_Area, &DType, &DItem, &tempRect);
  227.     SetRect(&List_Rect, tempRect.left, tempRect.top, tempRect.right, tempRect.bottom);
  228.     /* Start w/ full size of the dialog's user item */
  229.     tempRect = List_Rect;            
  230.     /* Make room for the scroll bar on the right */
  231.     tempRect.right = tempRect.right - 15;
  232.     /* Safety check */
  233.     if (tempRect.right <= (tempRect.left + 15)) 
  234.         tempRect.right = tempRect.left + 15;
  235.     /* Frame it */
  236.     InsetRect(&tempRect, -1, -1);       
  237.     FrameRect(&tempRect);               
  238.     InsetRect(&tempRect, 1, 1);         
  239.     SetRect(&dataBounds, 0, 0, 1, 0);
  240.     /* Width of the list */
  241.     cSize.h = tempRect.right - tempRect.left;
  242.     /* Geneva lists look more professional... */
  243.     thePort->txFont = geneva;
  244.     thePort->txSize = 10;
  245.     /* Get the current font sizes */
  246.     GetFontInfo(&ThisFontInfo);         
  247.     /* Height of a cell */
  248.     cSize.v = ThisFontInfo.ascent + ThisFontInfo.descent + ThisFontInfo.leading;
  249.     /* Make the list */
  250.     My_List_Handle =  LNew(&tempRect, &dataBounds, cSize, 0, helpPtr, TRUE, FALSE, FALSE, TRUE);
  251.     /* Set the attributes */
  252.     (*My_List_Handle)->selFlags = lOnlyOne + lNoNilHilite;
  253.     /* Draw the list */
  254.     LDoDraw(TRUE, My_List_Handle);        
  255.     cSize.v = 0;                        
  256.     LSetSelect(TRUE, cSize, My_List_Handle);
  257.     Refresh_Topics();  
  258.     
  259.     /* -- Fill in the initial list contents -- */
  260.     for ( index = START + 1; index <= FINIS; index++ ) 
  261.       Add_List_String((Str255 *)topic_name[index], My_List_Handle);
  262.     
  263.      /* -- Compute critical info once & for all -- */
  264.      GetDItem(helpPtr, Display_Area, &DType, &DItem, &tempRect);
  265.      
  266.      /* The entire display area */
  267.     SetRect(&Display_Rect,    tempRect.left,
  268.                               tempRect.top,
  269.                               tempRect.right,
  270.                               tempRect.bottom);
  271.                               
  272.      /* The scroll bar to the right of it */
  273.     SetRect(&Scroller_Rect,    Display_Rect.right - 16,
  274.                               Display_Rect.top,
  275.                               Display_Rect.right,
  276.                               Display_Rect.bottom);
  277.  
  278.     /* Create the text-edit clipping regions */
  279.     SetRect(&Frame_Rect,Display_Rect.left,
  280.                         Display_Rect.top,
  281.                         Display_Rect.right-17,
  282.                         Display_Rect.bottom);
  283.  
  284.     /* Compute the Text Edit destination rectangle */
  285.     SetRect(&Dest_Rect, Frame_Rect.left+4,
  286.                         Frame_Rect.top+4,
  287.                         Frame_Rect.right-17,
  288.                         9000);
  289.                         
  290.     /* The clipping region for the actual text */
  291.     SetRect(&View_Rect,Dest_Rect.left,
  292.                        Dest_Rect.top+2,
  293.                        Dest_Rect.right,
  294.                        Display_Rect.bottom-7);
  295.  
  296.     /*  For simplicity's sake, assume intro  */ 
  297.     /*  screen is always a picture resource. */          
  298.     Display_Pict( Initial_Picture ); 
  299.     return(TRUE);
  300. }
  301.  
  302.  
  303. /***********************************************************************\
  304. |               void  Dialog_String( theDialog, theItem, theStr)            |
  305. |-----------------------------------------------------------------------|
  306. | Purpose :: To write a string into a "static text" field of a dialog    |
  307. |             window.  Assumes the dialog box has already been opened.    |
  308. |             This routine simply hides some messy data structures        |
  309. |             involved in this very necessary operation.                    |
  310. |-----------------------------------------------------------------------|
  311. | Arguments ::                                                            |
  312. |     theDialog    -> Pointer to an already opened window.                    |
  313. |     theItem        -> Item within the dialog to set some text.                |
  314. |    theStr        -> The actual message to be posted.                        |
  315. |-----------------------------------------------------------------------|
  316. | Returns :: void.                                                        |
  317. \***********************************************************************/
  318.  
  319. static void Dialog_String( theDialog, theItem, theStr )
  320.   DialogPtr      theDialog;
  321.   int          theItem;
  322.   char            *theStr;
  323.   {
  324.       Rect        iBox;            /* The rectangle for the item    */
  325.      int            iType;            /* Type of dialog item            */
  326.      Handle        iHandle;        /* Pointer to the item            */
  327.  
  328.      GetDItem(theDialog, theItem, &iType, &iHandle, &iBox);
  329.       SetIText(iHandle, theStr);
  330.   }
  331.  
  332.  
  333. /***********************************************************************\
  334. |                       void  Display_Pict( whichOne )                        |
  335. |-----------------------------------------------------------------------|
  336. | Purpose :: Display a new picture in the picture box!                    |
  337. |-----------------------------------------------------------------------|
  338. | Arguments ::                                                            |
  339. |     whichOne    -> An offset from the resource id of the first PICT in    |
  340. |                   that category.                                        |
  341. |-----------------------------------------------------------------------|
  342. | Returns :: void.                                                        |
  343. \***********************************************************************/
  344.  
  345. static void Display_Pict( whichOne )
  346. int whichOne;
  347. {
  348.     int            nextPict;        /* Next picture to be displayed        */
  349.      Rect        iBox;            /* The rectangle of the picture        */
  350.      int            iType;            /* Type of dialog item                */
  351.      Handle        iHandle;        /* Pointer to the item                */
  352.     PicHandle    newPict;        /* Pointer to the picture area         */
  353.     int         mesg_this_one;    /* The screen we're on now            */
  354.     int            mesg_max_one;    /* Total number of screens in topic */
  355.     Str255         s1,s2,s3,s4,s5;    /* Temporary strings for message    */
  356.     
  357.     
  358.     /* Dispose of previous text record, if there was one */
  359.     if (Last_Type == text) {
  360.         DisposeControl(myControl);
  361.           TEDispose(myTEHandle); 
  362.     }
  363.  
  364.     /* Enable the next & previous buttons? */
  365.     if ( (resource_end[Help_Topic] - resource_start[Help_Topic]) >= 1 ) {
  366.         GetDItem(helpPtr, Next_Button, &iType, &iHandle, &iBox);
  367.         ShowControl((ControlHandle)iHandle);
  368.         GetDItem(helpPtr, Prev_Button, &iType, &iHandle, &iBox);
  369.         ShowControl((ControlHandle)iHandle);
  370.     }
  371.     else {
  372.         GetDItem(helpPtr, Next_Button, &iType, &iHandle, &iBox);
  373.         HideControl((ControlHandle)iHandle);
  374.         GetDItem(helpPtr, Prev_Button, &iType, &iHandle, &iBox);
  375.         HideControl((ControlHandle)iHandle);
  376.     }
  377.     
  378.     /* Compute which picture to display */
  379.     nextPict = resource_start[ Help_Topic ] + whichOne;
  380.     mesg_this_one = nextPict - resource_start[ Help_Topic ] + 1;
  381.     mesg_max_one = resource_end[ Help_Topic ] - resource_start[ Help_Topic ] + 1;
  382.  
  383.     /* Display picture */
  384.     newPict = GetPicture(nextPict);
  385.     
  386.     /* Saftey check */
  387.     if (newPict == NIL)
  388.       Error_Message( err_no_pict );
  389.  
  390.     GetDItem(helpPtr, Display_Area, &iType, &iHandle, &iBox);
  391.     EraseRect(&iBox);
  392.     DrawPicture(newPict,&iBox);
  393.     
  394.     /* Avoid an unnecessary update event */
  395.     ValidRect(&iBox);
  396.  
  397.     /* Compute new text message */
  398.     NumToString(mesg_this_one,s1);
  399.     NumToString(mesg_max_one,s2);
  400.     pStrCat( "\pStatus:  Screen ", (char *) s1, (char *) s3);
  401.     pStrCat( (char *) s3, "\p of ", (char *) s4 );
  402.     pStrCat( (char *) s4, (char *) s2, (char *) s5);
  403.     User_Message((char *)s5);
  404.     Current_Pict = nextPict;
  405.     Last_Type = pict;
  406. }
  407.  
  408.  
  409. /***********************************************************************\
  410. |                       void  Display_Text( void )                            |
  411. |-----------------------------------------------------------------------|
  412. | Purpose :: Display a text help system for the current topic.            |
  413. |-----------------------------------------------------------------------|
  414. | Arguments :: None.                                                    |
  415. |-----------------------------------------------------------------------|
  416. | Returns :: void.                                                        |
  417. \***********************************************************************/
  418.  
  419. static void Display_Text()
  420. {
  421.      int            iType;            /* Type of dialog item            */
  422.      Handle        iHandle;        /* Pointer to the item            */
  423.     Rect         tempRect;        /* For moving the scroll bar    */
  424.     
  425.     /* Dispose of previous text record, if there was one */
  426.     if (Last_Type == text) {
  427.         HUnlock(myTEXTHandle);
  428.         HUnlock(myTEHandle);
  429.         DisposeControl(myControl);
  430.           TEDispose(myTEHandle); 
  431.     }
  432.  
  433.     /* Get a handle to the TEXT resource */
  434.     myTEXTHandle = GetResource('TEXT', resource_start[ Help_Topic ]);
  435.     
  436.     /* Saftey check! */
  437.     if (myTEXTHandle == NIL)
  438.         Error_Message( err_no_text );
  439.  
  440.     HLock(myTEXTHandle);
  441.     
  442.     /* Hide the next & previous buttons */
  443.     GetDItem(helpPtr, Next_Button, &iType, &iHandle, &tempRect);
  444.     HideControl((ControlHandle)iHandle);
  445.     GetDItem(helpPtr, Prev_Button, &iType, &iHandle, &tempRect);
  446.     HideControl((ControlHandle)iHandle);
  447.  
  448.     /* Erase the display area */
  449.     EraseRect(&Display_Rect);
  450.     
  451.     /* Bring up the control */
  452.     myControl = NewControl(helpPtr,&Scroller_Rect,"",TRUE,1,1,10,16,NIL);
  453.      HiliteControl(myControl,ON);
  454.     
  455.      /* Dim the picture scrolling buttons */
  456.      Set_Button_State( Next_Button, FALSE );
  457.       Set_Button_State( Prev_Button, FALSE );
  458.      
  459.     /* Frame the text box */                 
  460.        MoveTo(Frame_Rect.right+1,Frame_Rect.top);      
  461.     LineTo(Frame_Rect.left,Frame_Rect.top);     
  462.     LineTo(Frame_Rect.left,Frame_Rect.bottom-1);        
  463.     LineTo(Frame_Rect.right+1,Frame_Rect.bottom-1);        
  464.     
  465.     /* Create a text record */
  466.     myTEHandle = TENew(&Dest_Rect,&View_Rect);
  467.     HLock(myTEHandle);
  468.     
  469.     /* Display the goods */
  470.     TESetText(*myTEXTHandle, SizeResource(myTEXTHandle), myTEHandle);
  471.     TEUpdate(&View_Rect,myTEHandle);
  472.     User_Message((char *)"\pStatus:  < Text Mode >");
  473.     
  474.     /* Do we need an active scroll bar? */
  475.     if ( ( (View_Rect.bottom - View_Rect.top) / (*myTEHandle)->lineHeight)  <
  476.          ( (*myTEHandle)->nLines ) )
  477.       HiliteControl(myControl,ON);
  478.     else
  479.       HiliteControl(myControl,OFF);
  480.     
  481.     /* Avoid an unnecessary update event */
  482.     ValidRect(&Display_Rect);
  483.     
  484.     /* Set important values and exit */
  485.     SetCtlMax(myControl,((*myTEHandle)->nLines - 
  486.                          ((View_Rect.bottom - View_Rect.top)/(*myTEHandle)->lineHeight)));
  487.     Last_Type = text;
  488. }
  489.  
  490.  
  491. /***********************************************************************\
  492. |                         void  Error_Message( theError )                    |
  493. |-----------------------------------------------------------------------|
  494. | Purpose :: To warn the user about bad information discovered while    |
  495. |             reading in the HTBL resource.                                |
  496. |-----------------------------------------------------------------------|
  497. | Arguments ::    An enumerated type describing the error detected.        |
  498. |-----------------------------------------------------------------------|
  499. | Returns :: Exits to Finder.                                            |
  500. \***********************************************************************/
  501.  
  502. static void Error_Message( theError )
  503.   ErrorTypes    theError;
  504.   {
  505.      Rect        iBox;            /* The rectangle for the button            */
  506.      int            iType;            /* Type of dialog item                    */
  507.      Handle        iHandle;        /* Pointer to the item                    */
  508.     DialogPtr      theBox;          /* Pointer to this dialog                 */
  509.     GrafPtr        savePort;        /* Save the old graf port                */
  510.       short         whatHit;        /* User selected 'Ok' or 'Cancel'         */
  511.     
  512.     /* Bring up the correct alert */
  513.     theBox = GetNewDialog(Help_Error, NIL, FRONT);
  514.     
  515.     /* Position it */
  516.     Center_Window(theBox,50,FALSE);           
  517.     ShowWindow(theBox);
  518.     Bold_Button(theBox, OK_Button);
  519.       SysBeep(1);
  520.         
  521.       /* Fill in text message */
  522.       switch (theError) {
  523.           case err_no_HTBL :
  524.                Dialog_String(theBox, 3, (char *) "\pNo HTBL (Help Table) [ID=128] resource");
  525.              Dialog_String(theBox, 4, (char *) "\pwas found on your resource fork!");
  526.              Dialog_String(theBox, 5, (char *) "\pPlease create one before continuing...");
  527.               break;
  528.  
  529.           case err_min_res :
  530.                Dialog_String(theBox, 3, (char *) "\pYou should have at least an intro");
  531.              Dialog_String(theBox, 4, (char *) "\pscreen and one help screen for your");
  532.              Dialog_String(theBox, 5, (char *) "\phelp system!");
  533.               break;
  534.  
  535.           case err_intro_pict :
  536.                Dialog_String(theBox, 3, (char *) "\pThis program assumes that the");
  537.              Dialog_String(theBox, 4, (char *) "\pintroduction screen is always a");
  538.              Dialog_String(theBox, 5, (char *) "\ppicture!  Please change this screen.");
  539.               break;
  540.  
  541.           case err_bad_type :
  542.                Dialog_String(theBox, 3, (char *) "\pScreen types are either PICT or TEXT.");
  543.              Dialog_String(theBox, 4, (char *) "\pOne of your HTBL fields for screen");
  544.              Dialog_String(theBox, 5, (char *) "\ptype is incorrect...");
  545.               break;
  546.           
  547.           case err_no_pict :
  548.                Dialog_String(theBox, 3, (char *) "\pThe PICT(s) for this topic do not");
  549.              Dialog_String(theBox, 4, (char *) "\pexist!  Very uncool.  I will exit");
  550.              Dialog_String(theBox, 5, (char *) "\pto the Finder rather than crash...");
  551.               break;
  552.  
  553.           case err_no_text :
  554.                Dialog_String(theBox, 3, (char *) "\pThe TEXT for this topic does not");
  555.              Dialog_String(theBox, 4, (char *) "\pexist!  Very uncool.  I will exit");
  556.              Dialog_String(theBox, 5, (char *) "\pto the Finder rather than crash...");
  557.               break;
  558.  
  559.           default : break;
  560.       }
  561.       
  562.       /* Enter an event loop and poll the user */
  563.      ModalDialog(NIL, &whatHit); 
  564.      DisposDialog(theBox);
  565.      ExitToShell();
  566.   }
  567.  
  568.  
  569. /***********************************************************************\
  570. |                   void  Handle_List_Event( whatHit )                        |
  571. |-----------------------------------------------------------------------|
  572. | Purpose :: To process any mouse-downs in the topics list.                |
  573. |-----------------------------------------------------------------------|
  574. | Arguments ::                                                            |
  575. |     whatHit        -> Which item was selected by the user.                    |
  576. |-----------------------------------------------------------------------|
  577. | Returns :: void.                                                        |
  578. \***********************************************************************/
  579.  
  580. static void Handle_List_Event( whatHit )
  581. int            whatHit;    
  582. {
  583.       /* Get the selected topic from the user */
  584.       Help_Topic = whatHit + 1;
  585.       /* If there is >1 screens, enable the "Next" button */
  586.       if (resource_end[Help_Topic] - resource_start[Help_Topic]) {
  587.             Set_Button_State( Next_Button, TRUE );
  588.             Set_Button_State( Prev_Button, FALSE );
  589.       }
  590.       else {
  591.             Set_Button_State( Next_Button, FALSE );
  592.             Set_Button_State(Prev_Button, FALSE );
  593.       }
  594.       
  595.       /* Display first screen in topic */
  596.       if ( screen_mode[ Help_Topic ] == pict )
  597.             Display_Pict( Initial_Picture );
  598.       else if ( screen_mode[ Help_Topic ] == text )
  599.             Display_Text();
  600.       else
  601.             SysBeep(1);
  602.  }
  603.  
  604.  
  605. /***********************************************************************\
  606. |                     void  Handle_Update( void )                            |
  607. |-----------------------------------------------------------------------|
  608. | Purpose :: To handle any update to the dialog.  For example: it will    |
  609. |             refresh the screen when another dialog has been placed        |
  610. |             over it, etc.                                                |
  611. |-----------------------------------------------------------------------|
  612. | Arguments ::    None.                                                    |
  613. |-----------------------------------------------------------------------|
  614. | Returns :: void.                                                        |
  615. \***********************************************************************/
  616.  
  617. static void Handle_Update()
  618. {
  619.      Rect        iBox;            /* The rectangle of the picture        */
  620.      int            iType;            /* Type of dialog item                */
  621.      Handle        iHandle;        /* Pointer to the item                */
  622.     PicHandle    thePict;        /* Pointer to the picture area         */
  623.     GrafPtr        oldPort;        /* Restore old graf port when done    */
  624.  
  625.  
  626.     GetPort(&oldPort);
  627.     SetPort(helpPtr);            
  628.     BeginUpdate(helpPtr);
  629.     Refresh_Topics();
  630.     Bold_Button(helpPtr,OK_Button);
  631.  
  632.     /* Specific code for text or pictures... */
  633.     if ( screen_mode[ Help_Topic ] == text ) {
  634.            MoveTo(Frame_Rect.right+1,Frame_Rect.top);      
  635.         LineTo(Frame_Rect.left,Frame_Rect.top);     
  636.         LineTo(Frame_Rect.left,Frame_Rect.bottom-1);        
  637.         LineTo(Frame_Rect.right+1,Frame_Rect.bottom-1);        
  638.         TEUpdate(&View_Rect,myTEHandle);
  639.     }
  640.     else if ( screen_mode[ Help_Topic ] == pict ) {
  641.         thePict = GetPicture(Current_Pict);
  642.         /* Saftey check */
  643.         if (thePict == NIL) {
  644.               SysBeep(1);
  645.               return;
  646.         }
  647.         GetDItem(helpPtr, Display_Area, &iType, &iHandle, &iBox);
  648.         EraseRect(&iBox);
  649.         DrawPicture(thePict,&iBox);
  650.     }
  651.     DrawDialog(helpPtr);
  652.     EndUpdate(helpPtr);
  653.     SetPort(oldPort);
  654. }
  655.  
  656.  
  657. /***********************************************************************\
  658. |                     void  Help_Event_Loop( void )                        |
  659. |-----------------------------------------------------------------------|
  660. | Purpose :: To handle any events inside my window.  Once an event         |
  661. |             takes place outside this window's domain, I return            |
  662. |             immediately, and let the main event loop handle it.        |
  663. |-----------------------------------------------------------------------|
  664. | Arguments ::    None.                                                    |
  665. |-----------------------------------------------------------------------|
  666. | Returns :: void.                                                        |
  667. \***********************************************************************/
  668.  
  669. static void Help_Event_Loop()
  670. {
  671.     EventRecord         theEvent;        /* Most current real-time user event        */
  672.     Point                 where;            /* Where (mouse location) the event occured */
  673.     Rect                tempRect;        /* Rectangle of the about... window            */
  674.     Point               myPt;            /* Current list selection point             */
  675.     WindowPtr             wPtr;            /* The pointer to the current window        */
  676.     int                 thePart;        /* The type of mouse-down that occured        */
  677.     int                 key;            /* Did the user hit the <return> key?        */
  678.     int                    whatHit;        /* Integer id of the dialog item user hit    */
  679.     Rect                   DRect;            /* Rectangle used for finding hit point     */
  680.     short                DType;             /* Type of dialog item (for OK button)        */
  681.     int                    itemHit;           /* Get selection from the user                */
  682.     Handle               DItem;            /* Handle to the dialog item                 */
  683.     long                ticks;            /* Highlight ok button when <return> hit    */
  684.     Boolean               DoubleClick;      /* Flag to see if double click on a list     */
  685.     int                    oldValue;        /* Former value of scroll bar before event  */
  686.     int                 rc;                /* Return code from TrackControl() - ignore    */
  687.     long                 cellHit;        /* Find out where user single-clicked         */
  688.     ControlHandle          aControl;        /* Event took place in my scroller            */
  689.     static  int         lastHit = -1;    /* Nicety: prevent redundant processing     */
  690.  
  691.     /* -- Enter the event loop -- */
  692.     InitCursor();
  693.     HiliteMenu(0);
  694.     for (;;) {
  695.         SetPort(helpPtr);
  696.         SelectWindow(helpPtr);
  697.         InitCursor();
  698.  
  699.         if (GetNextEvent(everyEvent, &theEvent)) {
  700.             switch (theEvent.what)
  701.             {
  702.               case updateEvt:
  703.                   if ((WindowPtr)theEvent.message == helpPtr) 
  704.                     Handle_Update();
  705.                    break;
  706.               
  707.               case keyDown:
  708.                 /* If it's a <return> key I want it  */
  709.                 key = ( (unsigned char) theEvent.message & charCodeMask );
  710.                 if ( (key == '\r') ) {
  711.                     /* Treat this like a mouse-down in the OK button */
  712.                     SetPort(helpPtr);
  713.                     GetDItem(helpPtr, OK_Button, &DType, &DItem, &DRect);
  714.                     HiliteControl((ControlHandle)DItem,1);
  715.                     Delay(8,&ticks);
  716.                     Kill_Window();
  717.                     return;
  718.                 }
  719.                   break;
  720.  
  721.               case mouseDown:
  722.                   thePart = FindWindow(theEvent.where, &wPtr);
  723.                   /* The following is very tricky code: it allows you */
  724.                   /* to switch tasks under Multifinder, but will not  */
  725.                   /* let you pull down any of the disabled menus.     */
  726.                  if ((DialogPtr)wPtr != helpPtr) {
  727.                       if (thePart != inMenuBar)
  728.                         SysBeep(1);
  729.                       continue;
  730.                   } 
  731.                   switch (thePart)
  732.                 {
  733.                   case inMenuBar:
  734.                       rc = MenuSelect(theEvent.where);
  735.                       break;
  736.                       
  737.                     case inDrag:
  738.                     tempRect = screenBits.bounds;
  739.                     SetRect(&tempRect, tempRect.left + 10, tempRect.top + 25, 
  740.                                        tempRect.right - 10,tempRect.bottom - 10);
  741.                         DragWindow(helpPtr, theEvent.where, &tempRect);
  742.                         break;
  743.  
  744.                     case inContent:
  745.                         if (DialogSelect(&theEvent, &helpPtr, &whatHit)) {
  746.                         myPt = theEvent.where;         
  747.                         GlobalToLocal(&myPt);           
  748.                             
  749.                               /* Is the user all done? */
  750.                               if (whatHit == OK_Button) {
  751.                                 Kill_Window();
  752.                                 return;
  753.                             }
  754.         
  755.                             else if ((whatHit == Next_Button) || (whatHit == Prev_Button))
  756.                               Scroll_Picture( whatHit );
  757.  
  758.                         /* Was it an event in the topics list? */
  759.                         else if (PtInRect(myPt,&List_Rect) == TRUE)  {
  760.                             DoubleClick = LClick(myPt, theEvent.modifiers, My_List_Handle);
  761.                             cellHit = LLastClick(My_List_Handle);    
  762.                             itemHit = HiWord( cellHit );    
  763.                             if ((itemHit >= 0) && (itemHit != lastHit)) {
  764.                                   lastHit = itemHit;
  765.                                   Handle_List_Event(itemHit);
  766.                             }
  767.                          } 
  768.          
  769.                         /* Was it a text scroller event? */
  770.                         else if ( (PtInRect(myPt, &Scroller_Rect))  && 
  771.                                     (screen_mode[ Help_Topic ] == text) ) {
  772.                               thePart = FindControl(myPt, wPtr, &aControl);
  773.                               oldValue = GetCtlValue(aControl);
  774.                               if ( thePart == inThumb ) {
  775.                                  rc = TrackControl(aControl, myPt, (ProcPtr)0);
  776.                                  Scroll_Text( oldValue, GetCtlValue(aControl) );
  777.                               }
  778.                               else if ( (thePart == inUpButton) || (thePart == inDownButton) ||
  779.                                       (thePart == inPageUp)   || (thePart == inPageDown) ) 
  780.                                  rc = TrackControl(aControl, myPt, &My_Scroll_Filter);
  781.                                 }                       
  782.                     }
  783.                     break;
  784.                 }
  785.             }
  786.         }
  787.     }
  788. }
  789.  
  790.  
  791. /***********************************************************************\
  792. |                               void Init_Help( void )                        |
  793. |-----------------------------------------------------------------------|
  794. | Purpose :: This code is called every time the Help system is invoked,    |
  795. |             because this is the code resource version.  The HTBL is    |
  796. |             scanned, and its values are stored in global data structs.    |
  797. |             NOTE!  This routine assumes HTBL has ID=128.                |
  798. |-----------------------------------------------------------------------|
  799. | Arguments ::    None.                                                    |
  800. |-----------------------------------------------------------------------|
  801. | Returns :: void.                                                        |
  802. \***********************************************************************/
  803.  
  804. void Init_Help()
  805. {    
  806.     int                    index;        /* Loop thru user's information     */
  807.     char                *HTBL_ptr;    /* Establish the basline pointer    */
  808.     Help_Info_Handle    h;            /* Cast HTBL to this data structure    */
  809.     long                mode;        /* Longint version of PICT or TEXT    */
  810.     char                ch;            /* First letter of PICT or TEXT     */
  811.     
  812.     /* Get handle to the HTBL resource */
  813.     h = (Help_Info_Handle) GetResource('HTBL',128);
  814.     
  815.     /* No HTBL=128 resource? */
  816.     if ((h == NIL) || (ResErr != noErr))
  817.         Error_Message( err_no_HTBL );
  818.     
  819.     /* Lock it */
  820.     HLock(h);
  821.     
  822.     /* Establish pointer to start of HTBL resource */
  823.      HTBL_ptr = (char *) *h;
  824.     First_Menu = ParseInt( (char **) &HTBL_ptr );
  825.     Last_Menu = ParseInt( (char **) &HTBL_ptr );
  826.     START = 0;
  827.     FINIS = ParseInt( (char **) &HTBL_ptr );
  828.     
  829.     /* Enough help screens to proceed? */
  830.     if (FINIS < 1) 
  831.         Error_Message( err_min_res );
  832.     
  833.     /* Now loop thru all screens & get the information */
  834.       for (index = 0; index <= FINIS; index++) {
  835.           /* Is this a 'PICT' or 'TEXT' screen? */
  836.         mode = ParseOSType( (char **) &HTBL_ptr );
  837.         ch = (char)(mode >> 24);
  838.         if ( (ch == 'P') || (ch == 'p') ) 
  839.             screen_mode[index]      = pict;
  840.         else if ( (ch == 'T') || (ch == 't') )
  841.             screen_mode[index]      = text;
  842.         else 
  843.             /* Bad screen type! */
  844.             Error_Message( err_bad_type );
  845.         
  846.         /* Is intro screen a PICT? */
  847.         if ((index == 0) && (screen_mode[index] != pict)) 
  848.             Error_Message( err_intro_pict );
  849.         
  850.         /* Get resource bounds */
  851.         resource_start[index] = ParseInt( (char **) &HTBL_ptr );
  852.         resource_end[index]   = ParseInt( (char **) &HTBL_ptr );
  853.         
  854.         /* Retrieve title of this topic */
  855.         ParseString( (char *)topic_name[index], (char **) &HTBL_ptr );
  856.     }
  857.     HUnlock(h);
  858. }
  859.  
  860.  
  861. /***********************************************************************\
  862. |                          void Kill_Window( void )                        |
  863. |-----------------------------------------------------------------------|
  864. | Purpose: When we get here, the user has clicked on the "done" button.    |
  865. |           Dispose of all dynamic (heap) data structures and restore    | 
  866. |           the original grafport.                                        |
  867. |-----------------------------------------------------------------------|
  868. | Arguments ::    None.                                                    |
  869. |-----------------------------------------------------------------------|
  870. | Returns :: Void.                                                        |
  871. \***********************************************************************/
  872.  
  873. static void Kill_Window()
  874. {
  875.  
  876.     if (Last_Type == text) {
  877.           TEDispose(myTEHandle); 
  878.     }
  879.     LDispose(My_List_Handle);
  880.     DisposDialog(helpPtr);         
  881.     CloseResFile(refnum);
  882.     SetPort(savePort);
  883. }
  884.  
  885.  
  886. /***********************************************************************\
  887. |                           void  main( void )                                |
  888. |-----------------------------------------------------------------------|
  889. | Purpose :: To present an extensive help system to the user.  This        |
  890. |             routine handles scrolling lists and dynamic pictures.        |
  891. |-----------------------------------------------------------------------|
  892. | Arguments ::    None.                                                    |
  893. |-----------------------------------------------------------------------|
  894. | Returns :: void.                                                        |
  895. \***********************************************************************/
  896.  
  897. pascal void main()
  898. {
  899.     MenuHandle    thisMenu;        /* Current menu bar to disable  */
  900.     int            index;            /* Loop thru menu resources        */
  901.     Handle        h;                /* Lock this resource myself    */
  902.     
  903.     /* Save the state of the registers */
  904.     RememberA0();
  905.     SetUpA4();
  906.     
  907.     /* Lock my code resource */
  908.     asm {
  909.         _RecoverHandle
  910.         move.l  a0, h
  911.     }
  912.     HLock(h);
  913.     
  914.     /* Re-initialize QuickDraw! */
  915.     InitGraf(&thePort);
  916.     
  917.     /* Initialize the help system */
  918.     Init_Help();
  919.     
  920.     /* Bring up the help box */
  921.     if ( Create_Help() ) {
  922.         /* Disable The Menus */
  923.         for (index = First_Menu; index <= Last_Menu; index++) {
  924.             thisMenu = GetMHandle(index);
  925.             DisableItem(thisMenu,0);
  926.         }
  927.         DrawMenuBar();
  928.         
  929.         /* Trap help window events */
  930.         Help_Event_Loop();
  931.     
  932.         /* Re-enable the menu bar and exit */
  933.         for (index = First_Menu; index <= Last_Menu; index++) {
  934.             thisMenu = GetMHandle(index);
  935.             EnableItem(thisMenu,0);
  936.         }
  937.         DrawMenuBar();
  938.     }
  939.     /* Restore the registers & exit */
  940.     HUnlock(h);
  941.     RestoreA4();
  942. }
  943.  
  944.  
  945. /***********************************************************************\
  946. |                  void My_Scroll_Filter( theControl, thePart )            |
  947. |-----------------------------------------------------------------------|
  948. | Purpose: TrackControl() will call this routine for all events except    |
  949. |           dragging the thumb wheel by the user.  All "up & down"         | 
  950. |           events by the user are then translated into the correct        |
  951. |           TextEdit Manager calls to correctly position the text.        |
  952. |-----------------------------------------------------------------------|
  953. | Arguments ::                                                            |
  954. |     theControl    -> Handle the the scroller control.                        |
  955. |     thePart        -> That part of the scroller the user interacted with.    |
  956. |-----------------------------------------------------------------------|
  957. | Returns :: Void.                                                        |
  958. \***********************************************************************/
  959.  
  960. static pascal void My_Scroll_Filter( theControl, thePart )
  961. ControlHandle     theControl;
  962. int                thePart;
  963. {
  964.     int        start, stop;    /* The outer boundry values of the scroller */
  965.     int        page;            /* The computed amount to correctly page    */
  966.     int        newValue;        /* The new value to scroll up or down        */
  967.     int        oldValue;        /* The previous value of the control        */
  968.     long    finalTicks;        /* Slow down the action to appear natural    */
  969.     
  970.     /* Get the upper & lower limits to perform saftey checks */
  971.     start = (*theControl)->contrlMin;    
  972.     stop  = (*theControl)->contrlMax;
  973.     oldValue = GetCtlValue(theControl);
  974.     
  975.     /* Compute the amount of scrolling for page ups & downs */
  976.     page = (Display_Rect.bottom - Display_Rect.top) / (*myTEHandle)->lineHeight;
  977.     
  978.     /* Get the current value of the control */
  979.     newValue = GetCtlValue(theControl);
  980.  
  981.     /* Process the event accordingly */
  982.     switch ( thePart ) {
  983.     
  984.         case inUpButton    :     /* Scroll up one line */
  985.                                 newValue -= 1;
  986.                                 /* Saftey check! */
  987.                                 if (newValue < start)
  988.                               newValue = start;
  989.                               break;
  990.                   
  991.         case inDownButton:     /* Scroll down one line */
  992.                               newValue += 1;
  993.                               /* Saftey check! */
  994.                               if (newValue > stop)
  995.                               newValue = stop;
  996.                               break;
  997.  
  998.         case inPageUp    :     /* Perform a page up */
  999.                               newValue -= page;
  1000.                               /* Saftey check! */
  1001.                               if (newValue < start)
  1002.                               newValue = start;
  1003.                               break;
  1004.  
  1005.         case inPageDown    :     /* Perform a page down */
  1006.                               newValue += page;
  1007.                               /* Saftey check! */
  1008.                               if (newValue > stop)
  1009.                               newValue = stop;
  1010.                               break;
  1011.  
  1012.         default            :     break;
  1013.     }
  1014.     
  1015.     /* Now set the control to the proper amount */
  1016.     SetCtlValue( theControl, newValue );
  1017.     Delay(2,&finalTicks); 
  1018.     Scroll_Text( oldValue, newValue );
  1019. }
  1020.   
  1021.  
  1022. /***********************************************************************\
  1023. |                          int ParseInt( pPointer )                        |
  1024. |-----------------------------------------------------------------------|
  1025. | Purpose: Get the next integer from the HTBL resource.                    |
  1026. |-----------------------------------------------------------------------|
  1027. | Arguments ::    Handle into the resource.                                |
  1028. |-----------------------------------------------------------------------|
  1029. | Returns :: Next integer in the HTBL resource.                            |
  1030. \***********************************************************************/
  1031.  
  1032. static int ParseInt( pPointer )
  1033. char    **pPointer;
  1034. {
  1035.     int                result=0;            /* Final integer result         */
  1036.     unsigned char    hiWord, lowWord;    /* Store 2 halves of the int */
  1037.     
  1038.     /* Get the raw data */
  1039.     hiWord = (unsigned char) *((*pPointer)++);
  1040.     lowWord = (unsigned char) *((*pPointer)++);
  1041.     
  1042.     /* Now pack these into the integer! */
  1043.     result = result | hiWord;
  1044.     result = (result << 8) | lowWord;
  1045.     
  1046.      return(result);
  1047. }
  1048.     
  1049.     
  1050. /***********************************************************************\
  1051. |                          int ParseOSType( pPointer )                        |
  1052. |-----------------------------------------------------------------------|
  1053. | Purpose: Get the next screen type ('PICT' or 'TEXT') from the HTBL     |
  1054. |           resource.                                                    |
  1055. |-----------------------------------------------------------------------|
  1056. | Arguments ::    Handle into the resource.                                |
  1057. |-----------------------------------------------------------------------|
  1058. | Returns :: Next longint in the HTBL resource.                            |
  1059. \***********************************************************************/
  1060.  
  1061. static long ParseOSType( pPointer )
  1062. char    **pPointer;
  1063. {
  1064.      long    result=0;        /* Final longint to return        */
  1065.     char    nextByte;        /* 1/4 of the longint             */
  1066.     int        index;            /* Loop thru bytes in a long    */
  1067.     
  1068.     /* Get the first of four bytes */
  1069.     nextByte = (char) *((*pPointer)++);
  1070.     result = result | (long) nextByte;
  1071.     
  1072.     /* Now loop thru the rest! */
  1073.     for (index = 1; index < sizeof(long); index++) {
  1074.         nextByte = (char) *((*pPointer)++);
  1075.         result = (result << 8) | (long) nextByte;
  1076.     }
  1077.      return(result);
  1078. }
  1079.  
  1080.  
  1081. /***********************************************************************\
  1082. |                      int ParseString( pDest, pSource )                    |
  1083. |-----------------------------------------------------------------------|
  1084. | Purpose: Get the next string from the HTBL resource.                    |
  1085. |-----------------------------------------------------------------------|
  1086. | Arguments ::    pDest ->   Returned string.                                |
  1087. |                pSource -> Handle to the HTBL resource.                    |
  1088. |-----------------------------------------------------------------------|
  1089. | Returns :: Final result.                                                |
  1090. \***********************************************************************/
  1091.  
  1092. static void ParseString( pDest, pSource )
  1093. char    *pDest, **pSource;
  1094. {
  1095.     int iLen = *pDest++ = *((*pSource)++);
  1096.     
  1097.     while (--iLen >= 0) 
  1098.         *pDest++ = *((*pSource)++);
  1099. }
  1100.  
  1101.  
  1102. /***********************************************************************\
  1103. |                         void  pStrCat( p1, p2, p3 )                        |
  1104. |-----------------------------------------------------------------------|
  1105. | Purpose :: Concatenate two pascal strings "p1" and "p2" together,     |
  1106. |             giving    result "p3".                                        |
  1107. |-----------------------------------------------------------------------|
  1108. | Arguments ::                                                            |
  1109. |     p1    -> Source string one.                                            |
  1110. |     p2    -> Source string two.                                            |
  1111. |     p3    -> Destination string.                                            |
  1112. |-----------------------------------------------------------------------|
  1113. | Returns :: void.                                                        |
  1114. \***********************************************************************/
  1115.  
  1116. static void pStrCat( p1, p2, p3 )
  1117. char *p1, *p2, *p3; 
  1118. {
  1119.     int len1, len2;
  1120.     
  1121.     len1 = *p1++;
  1122.     len2 = *p2++;
  1123.     
  1124.     *p3++ = len1 + len2;
  1125.     while (--len1 >= 0) *p3++=*p1++;
  1126.     while (--len2 >= 0) *p3++=*p2++;
  1127. }
  1128.  
  1129.  
  1130. /***********************************************************************\
  1131. |                         void  pStrCopy( p1, p2 )                        |
  1132. |-----------------------------------------------------------------------|
  1133. | Purpose :: To copy one pascal string into another.  Direction of         |
  1134. |             copy:  p1 --> p2.                                            |
  1135. |-----------------------------------------------------------------------|
  1136. | Arguments ::                                                            |
  1137. |     p1    -> Source string.                                                |
  1138. |     p2    -> Destination string.                                            |
  1139. |-----------------------------------------------------------------------|
  1140. | Returns :: void.                                                        |
  1141. \***********************************************************************/
  1142.  
  1143. static void pStrCopy( p1, p2 )
  1144. char *p1, *p2; 
  1145. {
  1146.     int len;
  1147.     
  1148.     len = *p2++ = *p1++;
  1149.     while (--len>=0) *p2++=*p1++;
  1150. }
  1151.  
  1152.  
  1153. /***********************************************************************\
  1154. |                       void  Refresh_Topics( void )                        |
  1155. |-----------------------------------------------------------------------|
  1156. | Purpose :: To draw (or redraw) the contents of the topics list.        |
  1157. |-----------------------------------------------------------------------|
  1158. | Arguments ::    None.                                                    |
  1159. |-----------------------------------------------------------------------|
  1160. | Returns :: void.                                                        |
  1161. \***********************************************************************/
  1162.  
  1163. static void  Refresh_Topics() 
  1164. { 
  1165.     Rect     tempRect;       /* Temporary rectangle         */
  1166.     short    DType;         /* Type of dialog item         */
  1167.     Handle   DItem;            /* Handle to dialog item     */
  1168.  
  1169.     LUpdate(helpPtr->visRgn,My_List_Handle);
  1170.     tempRect = List_Rect;            
  1171.     InsetRect(&tempRect, -1, -1);       
  1172.     FrameRect(&tempRect);               
  1173. } 
  1174.  
  1175.  
  1176. /***********************************************************************\
  1177. |                   void  Scroll_Picture( whatHit )                            |
  1178. |-----------------------------------------------------------------------|
  1179. | Purpose :: To display the next (or previous) picture in a help topic.    |
  1180. |-----------------------------------------------------------------------|
  1181. | Arguments ::                                                            |
  1182. |     whatHit    -> Equal to Next_Button or Prev_Button in the dialog box.    |
  1183. |-----------------------------------------------------------------------|
  1184. | Returns :: void.                                                        |
  1185. \***********************************************************************/
  1186.  
  1187. static void Scroll_Picture( whatHit )
  1188. int              whatHit;
  1189. {
  1190.     int        theMax;            /* High bounds of help topic     */
  1191.     int        theMin;            /* Low bounds of that topic         */
  1192.     
  1193.     /* Find out which pictures are relivant */
  1194.     theMin = resource_start[ Help_Topic ];
  1195.     theMax = resource_end[ Help_Topic ];
  1196.      
  1197.      /* Compute the new picture to display! */
  1198.      if ( (whatHit == Next_Button) && (Current_Pict < theMax) ) {
  1199.         Current_Pict++;
  1200.          Set_Button_State( Prev_Button, TRUE );
  1201.          if (Current_Pict < theMax)
  1202.            Set_Button_State( Next_Button, TRUE );
  1203.          else
  1204.            Set_Button_State( Next_Button, FALSE );
  1205.          Display_Pict( Current_Pict - theMin );
  1206.        }
  1207.        else if ( (whatHit == Prev_Button) && (Current_Pict > theMin) ) {
  1208.         Current_Pict--;
  1209.          Set_Button_State( Next_Button, TRUE );
  1210.          if (Current_Pict > theMin)
  1211.            Set_Button_State( Prev_Button, TRUE );
  1212.          else
  1213.            Set_Button_State( Prev_Button, FALSE );
  1214.          Display_Pict( Current_Pict - theMin );
  1215.        }
  1216.        else
  1217.            SysBeep(1);
  1218. }
  1219.  
  1220.  
  1221. /***********************************************************************\
  1222. |                   void  Scroll_Text( old, new )                            |
  1223. |-----------------------------------------------------------------------|
  1224. | Purpose :: To dynamically scroll the text edit window for the user.    |
  1225. |-----------------------------------------------------------------------|
  1226. | Arguments ::                                                            |
  1227. |     old    -> The previous value of the scroll bar before the user event.    |
  1228. |     new    -> The new value to scroll the text.                            |
  1229. |-----------------------------------------------------------------------|
  1230. | Returns :: void.                                                        |
  1231. \***********************************************************************/
  1232.  
  1233. static void Scroll_Text( oldValue, newValue )
  1234. int        oldValue;
  1235. int        newValue;
  1236. {
  1237.   TEScroll(0, (oldValue - newValue) * (*myTEHandle)->lineHeight, myTEHandle);
  1238. }
  1239.  
  1240.  
  1241. /***********************************************************************\
  1242. |             void  Set_Button_State( itemNum, state )                    |
  1243. |-----------------------------------------------------------------------|
  1244. | Purpose :: To either enable or disable a button within a dialog box.    |
  1245. |-----------------------------------------------------------------------|
  1246. | Arguments ::                                                            |
  1247. |     itemNum    -> Item within the dialog to modify.                        |
  1248. |    state    -> TRUE = on, FALSE = off.                                    |
  1249. |-----------------------------------------------------------------------|
  1250. | Returns :: void.                                                        |
  1251. \***********************************************************************/
  1252.  
  1253. static void Set_Button_State(itemNum, state )
  1254. int            itemNum;
  1255. Boolean        state;
  1256.  {
  1257.      Rect        iBox;            /* The rectangle for the button        */
  1258.      int            iType;            /* Type of dialog item                */
  1259.      Handle        iHandle;        /* Pointer to the item                */
  1260.      
  1261.      GetDItem(helpPtr, itemNum, &iType, &iHandle, &iBox);
  1262.      if ( state )
  1263.        HiliteControl( (ControlHandle) iHandle, 0 );
  1264.      else
  1265.        HiliteControl( (ControlHandle) iHandle, 255);
  1266.  }
  1267.  
  1268.  
  1269.  
  1270. /***********************************************************************\
  1271. |                         void  User_Message( theStr )                    |
  1272. |-----------------------------------------------------------------------|
  1273. | Purpose :: To display a status message in the "Picture Scrolling"        |
  1274. |             window.                                                    |
  1275. |-----------------------------------------------------------------------|
  1276. | Arguments ::                                                            |
  1277. |     theStr    -> The pascal string to display.                            |
  1278. |-----------------------------------------------------------------------|
  1279. | Returns :: void.                                                        |
  1280. \***********************************************************************/
  1281.  
  1282. static void User_Message( theStr )
  1283. char  *theStr;
  1284. {
  1285.      Rect        iBox;            /* The rectangle of the picture        */
  1286.      int            iType;            /* Type of dialog item                */
  1287.      Handle        iHandle;        /* Pointer to the item                */
  1288.  
  1289.     GetDItem(helpPtr, Message_Area, &iType, &iHandle, &iBox);
  1290.     SetIText(iHandle, theStr);
  1291.     DrawDialog(helpPtr); 
  1292. }
  1293.