home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / games / volume16 / nethack31 / patch1j / patches01s next >
Text File  |  1993-03-05  |  54KB  |  1,983 lines
  1. *** /tmp/da09374    Thu Feb 25 10:29:06 1993
  2. --- sys/mac/maccurs.c    Sun Feb 21 16:06:06 1993
  3. ***************
  4. *** 91,96 ****
  5. --- 91,99 ----
  6.   }
  7.   
  8.   
  9. + #if 0
  10. + /* Now we use click_to_cmd() instead. */
  11. + 
  12.   int
  13.   clickSector ( int x , int y , int toX , int toY )
  14.   {
  15. ***************
  16. *** 155,161 ****
  17.       }
  18.   }
  19.   
  20. ! 
  21.   
  22.   
  23.   Boolean
  24. --- 158,164 ----
  25.       }
  26.   }
  27.   
  28. ! #endif
  29.   
  30.   
  31.   Boolean
  32. *** /tmp/da09398    Thu Feb 25 10:29:12 1993
  33. --- sys/mac/macmain.c    Thu Feb 11 12:12:23 1993
  34. ***************
  35. *** 114,120 ****
  36.           boolean remember_wiz_mode = wizard;
  37.   #endif
  38.   #ifdef NEWS
  39. !         if(flags.news) display_file(NEWS, FALSE);
  40.   #endif
  41.           pline("Restoring save file...");
  42.           mark_synch();    /* flush output */
  43. --- 114,123 ----
  44.           boolean remember_wiz_mode = wizard;
  45.   #endif
  46.   #ifdef NEWS
  47. !         if(flags.news) {
  48. !             display_file(NEWS, FALSE);
  49. !             flags.news = FALSE;    /* in case dorecover() fails */
  50. !         }
  51.   #endif
  52.           pline("Restoring save file...");
  53.           mark_synch();    /* flush output */
  54. ***************
  55. *** 174,185 ****
  56.       attemptingto("proceed");
  57.   #if defined(MAC_MPW32) && !defined(MODEL_FAR)
  58.       UnloadAllSegments();                        /* Do this before naming residents */
  59. !     IsResident( (Ptr) display_nhwindow );        /* Sample resident segments */
  60.       IsResident( (Ptr) rhack );
  61.       IsResident( (Ptr) engr_at );
  62.       IsResident( (Ptr) movemon );
  63.       IsResident( (Ptr) attacktype ) ;
  64.       IsResident( (Ptr) mac_get_nh_event ) ;
  65.   #endif
  66.       moveloop();
  67.       /*NOTREACHED*/
  68. --- 177,197 ----
  69.       attemptingto("proceed");
  70.   #if defined(MAC_MPW32) && !defined(MODEL_FAR)
  71.       UnloadAllSegments();                        /* Do this before naming residents */
  72. !     IsResident( (Ptr) um_dist );                /* Sample resident segments */
  73. !     IsResident( (Ptr) flush_screen );
  74.       IsResident( (Ptr) rhack );
  75. +     IsResident( (Ptr) remove_cadavers );
  76. +     IsResident( (Ptr) dog_move );
  77. +     IsResident( (Ptr) gethungry );
  78.       IsResident( (Ptr) engr_at );
  79. +     IsResident( (Ptr) domove );
  80. +     IsResident( (Ptr) carried );
  81.       IsResident( (Ptr) movemon );
  82.       IsResident( (Ptr) attacktype ) ;
  83.       IsResident( (Ptr) mac_get_nh_event ) ;
  84. +     IsResident( (Ptr) dosounds ) ;
  85. +     IsResident( (Ptr) t_at ) ;
  86. +     IsResident( (Ptr) nh_timeout ) ;
  87.   #endif
  88.       moveloop();
  89.       /*NOTREACHED*/
  90. ***************
  91. *** 434,441 ****
  92.   #define    kUnLoaded 0x3F3C                /* if unloaded then a LoadSeg trap */
  93.                                           /* Note: probably incorrect for -model far! */
  94.   
  95. ! /* #define TRACKSEGS /* Utility to print a trace of segment load frequencies. Add
  96. !    a call to ListGUnloads into terminate() in end.c to use it */
  97.   
  98.   #ifdef TRACKSEGS
  99.   
  100. --- 446,452 ----
  101.   #define    kUnLoaded 0x3F3C                /* if unloaded then a LoadSeg trap */
  102.                                           /* Note: probably incorrect for -model far! */
  103.   
  104. ! /* #define TRACKSEGS /* Utility to print a trace of segment load frequencies. */
  105.   
  106.   #ifdef TRACKSEGS
  107.   
  108. ***************
  109. *** 447,453 ****
  110.     int i;
  111.     FILE *f;
  112.     
  113. !   f = fopen("unloads","r+");
  114.     fprintf(f,"%d calls to UnloadAllSegments\n\n",gUnloads[0]);
  115.     for (i=1; i<=pMaxSegNum; i++) {
  116.        fprintf(f,"Unloaded %10s, segment %2d, %6d times\n",gSegNames[i],i,gUnloads[i]);
  117. --- 458,464 ----
  118.     int i;
  119.     FILE *f;
  120.     
  121. !   f = fopen("unloads","w");
  122.     fprintf(f,"%d calls to UnloadAllSegments\n\n",gUnloads[0]);
  123.     for (i=1; i<=pMaxSegNum; i++) {
  124.        fprintf(f,"Unloaded %10s, segment %2d, %6d times\n",gSegNames[i],i,gUnloads[i]);
  125. ***************
  126. *** 504,509 ****
  127. --- 515,521 ----
  128.       SetResLoad(false);    
  129.   
  130.       #ifdef TRACKSEGS
  131. +     atexit(&ListGUnloads);
  132.       gUnloads[0]=0;
  133.       #endif
  134.       for (i=1; i<=pMaxSegNum; i++) {
  135. *** /tmp/da09414    Thu Feb 25 10:29:17 1993
  136. --- sys/mac/mactopl.c    Thu Feb 18 17:37:56 1993
  137. ***************
  138. *** 7,13 ****
  139.   #include <OSUtils.h>
  140.   #include <Packages.h>
  141.   
  142. - // int NDECL(mac_doprev_message);
  143.   // char FDECL(yn_function,(const char *, const char *, CHAR_P));
  144.   
  145.   int FDECL ( try_key_queue , ( char * ) ) ;
  146. --- 7,12 ----
  147. ***************
  148. *** 25,59 ****
  149.   extern winid inSelect ;
  150.   extern short frame_corner ;
  151.   
  152. - int
  153. - mac_doprev_message(void)
  154. - {
  155. -     NhWindow * aWin = & theWindows [ WIN_MESSAGE ] ;
  156. -     char * start , * stop ;
  157.   
  158. -     if ( ! WIN_MESSAGE )
  159. -         return 0 ;
  160. - 
  161. -     stop = * aWin -> windowText ;
  162. -     start = * aWin -> windowText + aWin -> textBase - 2 ;
  163. - 
  164. -     while ( start > stop && * start != 10 && * start != 13 )
  165. -         start -- ;
  166. - 
  167. -     if ( start <= stop )
  168. -         aWin -> textBase = 0L ;
  169. -     else
  170. -         aWin -> textBase = start - stop + 1 ;
  171. -     if ( aWin -> textBase > aWin -> windowTextLen )
  172. -         aWin -> textBase = aWin -> windowTextLen ;
  173. - 
  174. -     display_nhwindow ( WIN_MESSAGE , FALSE ) ;
  175. -     InvalRect ( & ( aWin -> theWindow -> portRect ) ) ;
  176. - 
  177. -     return 0 ;
  178. - }
  179. - 
  180. - 
  181.   char
  182.   queued_resp(char *resp)
  183.   {
  184. --- 24,30 ----
  185. ***************
  186. *** 414,420 ****
  187.           topl_set_resp(resp, def);
  188.   
  189.           do {
  190. !             c = nhgetch();
  191.               if (c && resp && !strchr(resp, c)) {
  192.                   nhbell();
  193.                   c = '\0';
  194. --- 385,391 ----
  195.           topl_set_resp(resp, def);
  196.   
  197.           do {
  198. !             c = readchar();
  199.               if (c && resp && !strchr(resp, c)) {
  200.                   nhbell();
  201.                   c = '\0';
  202. *** /tmp/da09430    Thu Feb 25 18:16:50 1993
  203. --- sys/mac/macwin.c    Thu Feb 25 18:07:54 1993
  204. ***************
  205. *** 79,85 ****
  206. --- 79,100 ----
  207.   
  208.   Boolean gClickedToMove = 0 ; /* For ObscureCursor */
  209.   
  210. + static unsigned long gNextClickRepeat = 0xffffffff ;
  211.   
  212. + static Point clicked_pos ;    /* For nh_poskey */
  213. + static int clicked_mod ;
  214. + 
  215. + static Boolean cursor_locked = false ;
  216. + 
  217. + void
  218. + lock_mouse_cursor(Boolean new_cursor_locked)
  219. + {
  220. +     cursor_locked = new_cursor_locked;
  221. +     if (new_cursor_locked)
  222. +         PostEvent(osEvt, mouseMovedMessage<<24);
  223. + }
  224. + 
  225. + 
  226.   /*
  227.    * Add key to input queue, force means replace last if full
  228.    */
  229. ***************
  230. *** 115,120 ****
  231. --- 130,140 ----
  232.   MacFlags macFlags ;
  233.   
  234.   /*
  235. +  * The screen layouts on the small 512x342 screen need special cares.
  236. +  */
  237. + Boolean small_screen;
  238. + 
  239. + /*
  240.    * Async flag for keeping track of scrollbars...
  241.    * Used by InvalScrollBar ( )
  242.    */
  243. ***************
  244. *** 121,129 ****
  245.   static NhWindow * asyDSC = (NhWindow *) NULL ;
  246.   
  247.   /*
  248. !  * The font to be used in the text window
  249.    */
  250. ! short text_wind_font = geneva;
  251.   
  252.   /*
  253.    * Whether to adjust the height of a text window according to its contents
  254. --- 141,150 ----
  255.   static NhWindow * asyDSC = (NhWindow *) NULL ;
  256.   
  257.   /*
  258. !  * The font to be used in the text window, will be set to geneva after
  259. !  * we create the base window
  260.    */
  261. ! short text_wind_font = monaco;
  262.   
  263.   /*
  264.    * Whether to adjust the height of a text window according to its contents
  265. ***************
  266. *** 136,146 ****
  267.   MenuHandle appleMenu ;
  268.   MenuHandle fileMenu ;
  269.   MenuHandle editMenu ;
  270. ! MenuHandle extendMenu ;
  271. ! MenuHandle miscMenu ;
  272. ! MenuHandle helpMenu ;
  273. ! MenuHandle commandsMenu ;
  274.   MenuHandle thingsMenu ;
  275.   
  276.   #define NHW_BASE 0
  277.   winid BASE_WINDOW ; // Was: , WIN_MAP , WIN_MESSAGE , WIN_INVEN , WIN_STATUS ;
  278. --- 157,168 ----
  279.   MenuHandle appleMenu ;
  280.   MenuHandle fileMenu ;
  281.   MenuHandle editMenu ;
  282. ! MenuHandle actionMenu ;
  283. ! MenuHandle inventoryMenu ;
  284.   MenuHandle thingsMenu ;
  285. + MenuHandle extendedMenu ;
  286. + MenuHandle infoMenu ;
  287. + MenuHandle helpMenu ;
  288.   
  289.   #define NHW_BASE 0
  290.   winid BASE_WINDOW ; // Was: , WIN_MAP , WIN_MESSAGE , WIN_INVEN , WIN_STATUS ;
  291. ***************
  292. *** 271,277 ****
  293.       InitSegMgmt( itworked );    /* itworked is always in the main segment */
  294.       
  295.       attemptingto("start up");
  296. !     
  297.       if ( Gestalt ( gestaltOSAttr , & l ) ) {
  298.           macFlags . processes = 0 ;
  299.           macFlags . tempMem = 0 ;
  300. --- 293,299 ----
  301.       InitSegMgmt( itworked );    /* itworked is always in the main segment */
  302.       
  303.       attemptingto("start up");
  304. ! 
  305.       if ( Gestalt ( gestaltOSAttr , & l ) ) {
  306.           macFlags . processes = 0 ;
  307.           macFlags . tempMem = 0 ;
  308. ***************
  309. *** 324,330 ****
  310.   }
  311.   
  312.   
  313. ! #define MAX_HEIGHT 200
  314.   #define MIN_HEIGHT 50
  315.   #define MIN_WIDTH 300
  316.   
  317. --- 346,352 ----
  318.   }
  319.   
  320.   
  321. ! #define MAX_HEIGHT 100
  322.   #define MIN_HEIGHT 50
  323.   #define MIN_WIDTH 300
  324.   
  325. ***************
  326. *** 355,361 ****
  327.       width = nhWin -> charWidth * NUM_COLS ;
  328.   
  329.       if ( ! RetrievePosition ( kMapWindow , & top , & left ) ) {
  330. !         top = GetMBarHeight ( ) * 2 ;
  331.           left = ( screenArea . right - width ) / 2 ;
  332.       }
  333.   
  334. --- 377,383 ----
  335.       width = nhWin -> charWidth * NUM_COLS ;
  336.   
  337.       if ( ! RetrievePosition ( kMapWindow , & top , & left ) ) {
  338. !         top = GetMBarHeight ( ) + ( small_screen ? 2 : 20 ) ;
  339.           left = ( screenArea . right - width ) / 2 ;
  340.       }
  341.   
  342. ***************
  343. *** 389,400 ****
  344.       theWindow = nhWin -> theWindow ;
  345.   
  346.       if ( ! RetrievePosition ( kMessageWindow , & top , & left ) ) {
  347. !         top = statTop + statHeight + 20 ;
  348.           left = statLeft ;
  349.       }
  350.   
  351.       if ( ! RetrieveSize ( kMessageWindow , top , left , & height , & width ) ) {
  352. !         height = screenArea . bottom - top - 2 ;
  353.           if ( height > MAX_HEIGHT ) {
  354.               height = MAX_HEIGHT ;
  355.           } else if ( height < MIN_HEIGHT ) {
  356. --- 411,424 ----
  357.       theWindow = nhWin -> theWindow ;
  358.   
  359.       if ( ! RetrievePosition ( kMessageWindow , & top , & left ) ) {
  360. !         top = statTop + statHeight ;
  361. !         if ( ! small_screen )
  362. !             top += 20 ;
  363.           left = statLeft ;
  364.       }
  365.   
  366.       if ( ! RetrieveSize ( kMessageWindow , top , left , & height , & width ) ) {
  367. !         height = screenArea . bottom - top - ( small_screen ? 2-SBARHEIGHT : 2 ) ;
  368.           if ( height > MAX_HEIGHT ) {
  369.               height = MAX_HEIGHT ;
  370.           } else if ( height < MIN_HEIGHT ) {
  371. ***************
  372. *** 410,419 ****
  373.       mesgWidth = width ;
  374.   
  375.   /* Move these windows */
  376. -     MoveWindow ( theWindows [ WIN_STATUS ] . theWindow , statLeft , statTop , 1 ) ;
  377. -     SizeWindow ( theWindows [ WIN_STATUS ] . theWindow , statWidth , statHeight , 1 ) ;
  378.       MoveWindow ( theWindows [ WIN_MESSAGE ] . theWindow , mesgLeft , mesgTop , 1 ) ;
  379.       SizeWindow ( theWindows [ WIN_MESSAGE ] . theWindow , mesgWidth , mesgHeight , 1 ) ;
  380.       MoveWindow ( theWindows [ WIN_MAP ] . theWindow , mainLeft , mainTop , 1 ) ;
  381.       SizeWindow ( theWindows [ WIN_MAP ] . theWindow , mainWidth , mainHeight , 1 ) ;
  382.   
  383. --- 434,443 ----
  384.       mesgWidth = width ;
  385.   
  386.   /* Move these windows */
  387.       MoveWindow ( theWindows [ WIN_MESSAGE ] . theWindow , mesgLeft , mesgTop , 1 ) ;
  388.       SizeWindow ( theWindows [ WIN_MESSAGE ] . theWindow , mesgWidth , mesgHeight , 1 ) ;
  389. +     MoveWindow ( theWindows [ WIN_STATUS ] . theWindow , statLeft , statTop , 1 ) ;
  390. +     SizeWindow ( theWindows [ WIN_STATUS ] . theWindow , statWidth , statHeight , 1 ) ;
  391.       MoveWindow ( theWindows [ WIN_MAP ] . theWindow , mainLeft , mainTop , 1 ) ;
  392.       SizeWindow ( theWindows [ WIN_MAP ] . theWindow , mainWidth , mainHeight , 1 ) ;
  393.   
  394. ***************
  395. *** 437,443 ****
  396.                       } else {
  397.                           if ( ! RetrievePosition ( kTextWindow , & top , & left ) ) {
  398.                               top = GetMBarHeight ( ) * 2 ;
  399. !                             left = screenArea . right - 3 ;
  400.                           }
  401.                           top += ( numText * GetMBarHeight ( ) ) ;
  402.                           while ( top > screenArea . bottom - MIN_HEIGHT ) {
  403. --- 461,468 ----
  404.                       } else {
  405.                           if ( ! RetrievePosition ( kTextWindow , & top , & left ) ) {
  406.                               top = GetMBarHeight ( ) * 2 ;
  407. !                             left = screenArea . right - 3 - ( theWindow -> portRect . right -
  408. !                                                               theWindow -> portRect . left ) ;
  409.                           }
  410.                           top += ( numText * GetMBarHeight ( ) ) ;
  411.                           while ( top > screenArea . bottom - MIN_HEIGHT ) {
  412. ***************
  413. *** 445,452 ****
  414.                               left -= 20 ;
  415.                           }
  416.                           numText ++ ;
  417. !                         MoveWindow ( theWindow , left - ( theWindow -> portRect . right -
  418. !                             theWindow -> portRect . left ) , top , 1 ) ;
  419.                       }
  420.                   }
  421.               }
  422. --- 470,476 ----
  423.                               left -= 20 ;
  424.                           }
  425.                           numText ++ ;
  426. !                         MoveWindow ( theWindow , left , top , 1 ) ;
  427.                       }
  428.                   }
  429.               }
  430. ***************
  431. *** 498,504 ****
  432.       ( ( WindowPeek ) aWin -> theWindow ) -> windowKind = WIN_BASE_KIND
  433.           + type ;
  434.       aWin -> windowTextLen = 0L ;
  435. -     aWin -> textBase = 0L ;
  436.       aWin -> clear = 0 ; /* Yes, we need to inval the area on a clear */
  437.       aWin -> scrollBar = (ControlHandle) NULL ;
  438.       switch ( type ) {
  439. --- 522,527 ----
  440. ***************
  441. *** 530,535 ****
  442. --- 553,560 ----
  443.               aWin -> theWindow = (WindowPtr) NULL ;
  444.               return WIN_ERR ;
  445.           }
  446. +         aWin -> windowTextLen = 0L ;
  447. +         aWin -> lin = 0 ;
  448.           break ;
  449.       }
  450.   
  451. ***************
  452. *** 600,606 ****
  453.           siz . bottom - siz . top , FALSE ) ;
  454.       MoveWindow ( aWin -> theWindow , siz . left , siz . top , FALSE ) ;
  455.   
  456. !     if ( type == NHW_MENU || type == NHW_TEXT ) {
  457.           Rect r = siz ;
  458.           Boolean bool ;
  459.           OffsetRect ( & r , - r . left , - r . top ) ;
  460. --- 625,631 ----
  461.           siz . bottom - siz . top , FALSE ) ;
  462.       MoveWindow ( aWin -> theWindow , siz . left , siz . top , FALSE ) ;
  463.   
  464. !     if ( type == NHW_MENU || type == NHW_TEXT || type == NHW_MESSAGE ) {
  465.           Rect r = siz ;
  466.           Boolean bool ;
  467.           OffsetRect ( & r , - r . left , - r . top ) ;
  468. ***************
  469. *** 619,624 ****
  470. --- 644,660 ----
  471.   }
  472.   
  473.   
  474. + static MenuHandle
  475. + mustGetMHandle(int menu_id)
  476. + {
  477. +     MenuHandle menu = GetMHandle(menu_id);
  478. +     if (menu == nil) {
  479. +         comment("Cannot find the menu.", menu_id);
  480. +         ExitToShell();
  481. +     }
  482. +     return menu;
  483. + }
  484. + 
  485.   void
  486.   InitRes ( void )
  487.   {
  488. ***************
  489. *** 628,650 ****
  490.       mustwork(ResError());
  491.       SetMenuBar ( mBar ) ;
  492.       
  493. !     appleMenu = GetMHandle ( 128 ) ;
  494. !     mustwork(ResError());
  495.       AppendMenu ( appleMenu , ( ConstStr255Param ) "\002(-" ) ;
  496.       AddResMenu ( appleMenu , 'DRVR' ) ;
  497.   
  498. !     fileMenu = GetMHandle ( 129 ) ;
  499. !     mustwork(ResError());
  500. !     editMenu = GetMHandle ( 130 ) ;
  501. !     mustwork(ResError());
  502. !     extendMenu = GetMHandle ( 131 ) ;
  503. !     mustwork(ResError());
  504. !     miscMenu = GetMHandle ( 132 ) ;
  505. !     mustwork(ResError());
  506. !     commandsMenu = GetMHandle ( 133 ) ;
  507. !     mustwork ( ResError ( ) ) ;
  508. !     thingsMenu = GetMHandle ( 134 ) ;
  509. !     mustwork ( ResError ( ) ) ;
  510.   
  511.       if ( macFlags . help ) {
  512.           if ( HMGetHelpMenuHandle ( & helpMenu ) ) {
  513. --- 664,680 ----
  514.       mustwork(ResError());
  515.       SetMenuBar ( mBar ) ;
  516.       
  517. !     appleMenu = mustGetMHandle ( 128 ) ;
  518.       AppendMenu ( appleMenu , ( ConstStr255Param ) "\002(-" ) ;
  519.       AddResMenu ( appleMenu , 'DRVR' ) ;
  520.   
  521. !     fileMenu = mustGetMHandle ( 129 ) ;
  522. !     editMenu = mustGetMHandle ( 130 ) ;
  523. !     actionMenu = mustGetMHandle ( 131 ) ;
  524. !     inventoryMenu = mustGetMHandle ( 132 ) ;
  525. !     thingsMenu = mustGetMHandle ( 133 ) ;
  526. !     extendedMenu = mustGetMHandle ( 134 ) ;
  527. !     infoMenu = mustGetMHandle ( 135 ) ;
  528.   
  529.       if ( macFlags . help ) {
  530.           if ( HMGetHelpMenuHandle ( & helpMenu ) ) {
  531. ***************
  532. *** 667,672 ****
  533. --- 697,706 ----
  534.   {
  535.       int i ;
  536.   
  537. +     Rect scr = (*GetGrayRgn())->rgnBBox;
  538. +     small_screen = scr.bottom - scr.top <=    9*40 ||
  539. +                    scr.bottom - scr.top <= 12*40 && flags.large_font;
  540. + 
  541.       InitRes ( ) ;
  542.   
  543.       theWindows = ( NhWindow * ) NewPtr ( NUM_MACWINDOWS *
  544. ***************
  545. *** 688,698 ****
  546.       putstr(BASE_WINDOW, 0,
  547.         "         By Stichting Mathematisch Centrum and M. Stephenson.");
  548.       putstr(BASE_WINDOW, 0, "         See license for details.");
  549. !     putstr(BASE_WINDOW, 0, "  ");
  550.       display_nhwindow(BASE_WINDOW, FALSE);
  551.   
  552.       flags . window_inited = 1 ;
  553.       DimMenuBar ( ) ;
  554.   }
  555.   
  556.   
  557. --- 722,733 ----
  558.       putstr(BASE_WINDOW, 0,
  559.         "         By Stichting Mathematisch Centrum and M. Stephenson.");
  560.       putstr(BASE_WINDOW, 0, "         See license for details.");
  561. !     putstr(BASE_WINDOW, 0, "");
  562.       display_nhwindow(BASE_WINDOW, FALSE);
  563.   
  564.       flags . window_inited = 1 ;
  565.       DimMenuBar ( ) ;
  566. +     normal_font ( ) ;
  567.   }
  568.   
  569.   
  570. ***************
  571. *** 720,726 ****
  572.       Rect r2 = theWindow -> portRect ;
  573.       Rect r = r2 ;
  574.       Boolean vis ;
  575. !     short val ;
  576.   
  577.       if ( ! aWin -> scrollBar ) {
  578.           return ;
  579. --- 755,761 ----
  580.       Rect r2 = theWindow -> portRect ;
  581.       Rect r = r2 ;
  582.       Boolean vis ;
  583. !     short val , lin ;
  584.   
  585.       if ( ! aWin -> scrollBar ) {
  586.           return ;
  587. ***************
  588. *** 730,738 ****
  589.       r2 . bottom -= SBARHEIGHT ;
  590.       r2 . right += 1 ;
  591.       r2 . top -= 1 ;
  592. !     MoveControl ( aWin -> scrollBar , r2 . left , r2 . top ) ;
  593. !     SizeControl ( aWin -> scrollBar , r2 . right - r2 . left ,
  594. !         r2 . bottom - r2 . top ) ;
  595.       vis = ( r2 . bottom > r2 . top + 50 ) ;
  596.       if ( vis && ! ( * aWin -> scrollBar ) -> contrlVis ) {
  597.           ShowControl ( aWin -> scrollBar ) ;
  598. --- 765,777 ----
  599.       r2 . bottom -= SBARHEIGHT ;
  600.       r2 . right += 1 ;
  601.       r2 . top -= 1 ;
  602. !     if ( ( * aWin -> scrollBar ) -> contrlRect . top  != r2 . top ||
  603. !          ( * aWin -> scrollBar ) -> contrlRect . left != r2 . left )
  604. !         MoveControl ( aWin -> scrollBar , r2 . left , r2 . top ) ;
  605. !     if ( ( * aWin -> scrollBar ) -> contrlRect . bottom != r2 . bottom ||
  606. !          ( * aWin -> scrollBar ) -> contrlRect . right  != r2 . right )
  607. !         SizeControl ( aWin -> scrollBar , r2 . right  - r2 . left ,
  608. !                                           r2 . bottom - r2 . top ) ;
  609.       vis = ( r2 . bottom > r2 . top + 50 ) ;
  610.       if ( vis && ! ( * aWin -> scrollBar ) -> contrlVis ) {
  611.           ShowControl ( aWin -> scrollBar ) ;
  612. ***************
  613. *** 739,747 ****
  614.       } else if ( ! vis && ( * aWin -> scrollBar ) -> contrlVis ) {
  615.           HideControl ( aWin -> scrollBar ) ;
  616.       }
  617. !     if ( aWin -> lin ) {
  618. !         short max = aWin -> lin - ( r . bottom - r . top ) / aWin ->
  619.               charHeight ;
  620.           if ( max < 0 ) max = 0 ;
  621.           SetCtlMax ( aWin -> scrollBar , max ) ;
  622.           if ( max ) HiliteControl ( aWin -> scrollBar , 0 ) ;
  623. --- 778,794 ----
  624.       } else if ( ! vis && ( * aWin -> scrollBar ) -> contrlVis ) {
  625.           HideControl ( aWin -> scrollBar ) ;
  626.       }
  627. !     lin = aWin -> lin;
  628. !     if ( aWin == theWindows + WIN_MESSAGE ) {
  629. !         short min ;
  630. !         r . bottom -= SBARHEIGHT + 1 ;
  631. !         min = aWin -> save_lin + ( r . bottom - r . top ) / aWin ->
  632.               charHeight ;
  633. +         if ( lin < min )
  634. +             lin = min ;
  635. +     }
  636. +     if ( lin ) {
  637. +         short max = lin - ( r . bottom - r . top ) / aWin -> charHeight ;
  638.           if ( max < 0 ) max = 0 ;
  639.           SetCtlMax ( aWin -> scrollBar , max ) ;
  640.           if ( max ) HiliteControl ( aWin -> scrollBar , 0 ) ;
  641. ***************
  642. *** 775,780 ****
  643. --- 822,828 ----
  644.   mac_clear_nhwindow ( winid win )
  645.   {
  646.       long l ;
  647. +     Rect r ;
  648.       register char * start , * stop ;
  649.       WindowPtr theWindow ;
  650.       NhWindow * aWin = & theWindows [ win ] ;
  651. ***************
  652. *** 791,797 ****
  653.           return ;
  654.       }
  655.       SetPort ( theWindow ) ;
  656. !     InvalRect ( & ( theWindow -> portRect ) ) ;
  657.       switch ( ( ( WindowPeek ) theWindow ) -> windowKind - WIN_BASE_KIND ) {
  658.       case NHW_MAP :
  659.           stop = ( char * ) ( ( MapData * ) ( * aWin -> windowText ) )
  660. --- 839,850 ----
  661.           return ;
  662.       }
  663.       SetPort ( theWindow ) ;
  664. !     r = theWindow -> portRect ;
  665. !     if ( aWin -> scrollBar )
  666. !         r . right -= SBARWIDTH + 1 ;
  667. !     if ( aWin == theWindows + WIN_MESSAGE )
  668. !         r . bottom -= SBARHEIGHT + 1 ;
  669. !     InvalRect ( & r ) ;
  670.       switch ( ( ( WindowPeek ) theWindow ) -> windowKind - WIN_BASE_KIND ) {
  671.       case NHW_MAP :
  672.           stop = ( char * ) ( ( MapData * ) ( * aWin -> windowText ) )
  673. ***************
  674. *** 806,836 ****
  675.           while ( start > stop ) * -- start = CHAR_BLANK ;
  676.           break ;
  677.       case NHW_MESSAGE :
  678. !         l = GetHandleSize ( aWin -> windowText ) ;
  679. !         if ( l > TEXT_BLOCK * 2 ) {
  680. !             BlockMove ( * aWin -> windowText + TEXT_BLOCK ,
  681. !                 * aWin -> windowText , l - TEXT_BLOCK ) ;
  682. !             SetHandleSize ( aWin -> windowText , l - TEXT_BLOCK ) ;
  683. !             aWin -> windowTextLen -= TEXT_BLOCK ;
  684. !             if ( aWin -> windowTextLen < 0 ) {
  685. !                 aWin -> windowTextLen = 0 ;
  686. !             }
  687.           }
  688. ! #if 1
  689. !         aWin->textBase = aWin->windowTextLen;
  690. ! #else
  691. !         stop = * aWin -> windowText ;
  692. !         start = stop + aWin -> windowTextLen - 1 ;
  693. !         while ( -- start > stop ) {
  694. !             if ( * start == CHAR_CR || * start == CHAR_LF )
  695. !                 break ;
  696.           }
  697. !         if ( start > stop ) {
  698. !             aWin -> textBase = start - stop + 1 ;
  699. !         } else {
  700. !             aWin -> textBase = 0L ;
  701.           }
  702. - #endif
  703.           break ;
  704.       default :
  705.           SetHandleSize ( aWin -> windowText , TEXT_BLOCK ) ;
  706. --- 859,882 ----
  707.           while ( start > stop ) * -- start = CHAR_BLANK ;
  708.           break ;
  709.       case NHW_MESSAGE :
  710. !         l = 0;
  711. !         while (aWin->lin > flags.msg_history) {
  712. !             const char cr = CHAR_CR;
  713. !             l = Munger(aWin->windowText, l, &cr, 1, nil, 0) + 1;
  714. !             --aWin->lin;
  715.           }
  716. !         if (l) {
  717. !             aWin->windowTextLen -= l;
  718. !             BlockMove(*aWin->windowText + l, *aWin->windowText, aWin->windowTextLen);
  719.           }
  720. !         aWin->last_more_lin = aWin->lin;
  721. !         aWin->save_lin        = aWin->lin;
  722. !         aWin->scrollPos = aWin->lin ? aWin->lin - 1 : 0;
  723. !         if (aWin->scrollBar) {
  724. !             SetCtlMax  (aWin->scrollBar, aWin->lin);
  725. !             SetCtlValue(aWin->scrollBar, aWin->scrollPos);
  726. !             InvalScrollBar(aWin);
  727.           }
  728.           break ;
  729.       default :
  730.           SetHandleSize ( aWin -> windowText , TEXT_BLOCK ) ;
  731. ***************
  732. *** 838,844 ****
  733.           aWin -> lin = 0 ;
  734.           aWin -> wid = 0 ;
  735.           aWin -> scrollPos = 0 ;
  736. -         aWin -> textBase = 0L ;
  737.           if ( aWin -> scrollBar ) {
  738.               SetCtlMax ( aWin -> scrollBar , 0 ) ;
  739.               InvalScrollBar ( aWin ) ;
  740. --- 884,889 ----
  741. ***************
  742. *** 853,859 ****
  743.   
  744.   Boolean
  745.   ClosingWindowChar(const int c) {
  746. !     return  c == CHAR_ESC || c == CHAR_BLANK || c == CHAR_LF || c == CHAR_CR ;
  747.   }
  748.   
  749.   
  750. --- 898,905 ----
  751.   
  752.   Boolean
  753.   ClosingWindowChar(const int c) {
  754. !     return  c == CHAR_ESC || c == CHAR_BLANK || c == CHAR_LF || c == CHAR_CR ||
  755. !             c == 'q' ;
  756.   }
  757.   
  758.   
  759. ***************
  760. *** 884,889 ****
  761. --- 930,938 ----
  762.   {
  763.       if (!top_line || in_topl_mode())
  764.           Debugger();
  765. + 
  766. +     putstr(WIN_MESSAGE, ATR_BOLD, query);
  767. + 
  768.       (*top_line)->viewRect.left = 0;
  769.   
  770.       topl_query_len = strlen(query);
  771. ***************
  772. *** 893,899 ****
  773.       TECalText(top_line);
  774.   
  775.       display_nhwindow(WIN_MESSAGE, FALSE);
  776. -     putstr(WIN_MESSAGE, ATR_BOLD, query);
  777.   }
  778.   
  779.   
  780. --- 942,947 ----
  781. ***************
  782. *** 902,912 ****
  783.   {
  784.       int ans_len = (*top_line)->teLength - topl_query_len;
  785.       NhWindow *aWin = theWindows + WIN_MESSAGE;
  786. -     char tmp[3] = "  ";
  787.   
  788.       if (!in_topl_mode())
  789.           Debugger();
  790. -     (*top_line)->viewRect.left += 10000;
  791.   
  792.       BlockMove(*(*top_line)->hText + topl_query_len, answer, ans_len);
  793.       answer[ans_len] = '\0';
  794. --- 950,958 ----
  795. ***************
  796. *** 916,926 ****
  797.           -- aWin -> windowTextLen ;
  798.           -- aWin -> lin ;
  799.       }
  800. !     if (strlen(answer) <= 1) {
  801. !         if (answer[0]) tmp[0] = answer[0];
  802. !         putstr(WIN_MESSAGE, ATR_BOLD, tmp);
  803. !     } else
  804. !         putstr(WIN_MESSAGE, ATR_BOLD, answer);
  805.   }
  806.   
  807.   /*
  808. --- 962,970 ----
  809.           -- aWin -> windowTextLen ;
  810.           -- aWin -> lin ;
  811.       }
  812. !     putstr(WIN_MESSAGE, ATR_BOLD, answer);
  813. ! 
  814. !     (*top_line)->viewRect.left += 10000;
  815.   }
  816.   
  817.   /*
  818. ***************
  819. *** 1044,1054 ****
  820.       int r_len, r_len1;
  821.   
  822.       if (!resp) {
  823. !         static char any_str[2] = { CHAR_ANY, '\0' };
  824.           resp = any_str;
  825.           def = CHAR_ANY;
  826.       }
  827.   
  828.       r_len1 = strlen(resp);
  829.       r_len  = strlen(topl_resp);
  830.       if (r_len < r_len1)
  831. --- 1088,1099 ----
  832.       int r_len, r_len1;
  833.   
  834.       if (!resp) {
  835. !         const char any_str[2] = { CHAR_ANY, '\0' };
  836.           resp = any_str;
  837.           def = CHAR_ANY;
  838.       }
  839.   
  840. +     SetPort(theWindows[WIN_MESSAGE].theWindow);
  841.       r_len1 = strlen(resp);
  842.       r_len  = strlen(topl_resp);
  843.       if (r_len < r_len1)
  844. ***************
  845. *** 1123,1128 ****
  846. --- 1168,1206 ----
  847.   }
  848.   
  849.   
  850. + void
  851. + adjust_window_pos(NhWindow *aWin, WindowPtr theWindow, short w)
  852. + {
  853. +     const Rect scr_r   = (*GetGrayRgn())->rgnBBox,
  854. +                win_ind = { 20, 2, 3, 3 };
  855. +     const short    min_w = theWindow->portRect.right - theWindow->portRect.left,
  856. +                 max_w = scr_r.right - scr_r.left - win_ind.left - win_ind.right;
  857. +     Point pos;
  858. +     short h = aWin->lin * aWin->charHeight, max_h;
  859. + 
  860. +     SetPort(theWindow);
  861. +     if (!RetrieveWinPos(theWindow, &pos.v, &pos.h)) {
  862. +         pos.v = theWindow->portRect.top;
  863. +         pos.h = theWindow->portRect.left;
  864. +         LocalToGlobal(&pos);
  865. +     }
  866. + 
  867. +     max_h = full_screen ? scr_r.bottom - win_ind.bottom - scr_r.top - win_ind.top
  868. +                         : scr_r.bottom - win_ind.bottom - pos.v;
  869. +     if (h > max_h      ) h = max_h;
  870. +     if (h < MIN_HEIGHT) h = MIN_HEIGHT;
  871. +     if (w < min_w      ) w = min_w;
  872. +     if (w > max_w      ) w = max_w;
  873. +     SizeWindow(theWindow, w, h, true);
  874. + 
  875. +     if (pos.v + h + win_ind.bottom > scr_r.bottom)
  876. +         pos.v = scr_r.bottom - h - win_ind.bottom;
  877. +     if (pos.h + w + win_ind.right  > scr_r.right)
  878. +         pos.h = scr_r.right     - w - win_ind.right;
  879. +     MoveWindow(theWindow, pos.h, pos.v, false);
  880. + }
  881. + 
  882. + 
  883.   /*
  884.    * display/select/update the window.
  885.    * If f is true, this window should be "modal" - don't return
  886. ***************
  887. *** 1145,1213 ****
  888.       }
  889.   
  890.       if ( f && inSelect == WIN_ERR && ( win == BASE_WINDOW || win == WIN_MESSAGE ) ) {
  891. !         if ( win == WIN_MESSAGE )
  892.               topl_set_resp ( NULL , 0 ) ;
  893. !         /* The following piece of code prevents the "-- More --" prompt to be on a new
  894. !            line by itself.  I comment it out because the result looks ugly to me. */
  895. ! #ifdef 0
  896. !         if ( aWin -> windowTextLen > 0 &&
  897. !              ( * aWin -> windowText ) [ aWin -> windowTextLen - 1 ] == CHAR_CR ) {
  898. !             -- aWin -> windowTextLen ;
  899. !             -- aWin -> lin ;
  900.           }
  901. ! #endif
  902. !         putstr ( win , ATR_INVERSE , "-- More --" ) ;
  903.       }
  904.   
  905. !     if ( ! ( ( WindowPeek ) theWindow ) -> visible ) {
  906. !         const Rect scr_r   = (*GetGrayRgn())->rgnBBox,
  907. !                    win_ind = { 20, 2, 3, 3 };
  908. !         const Point scr_sz = { scr_r.bottom - scr_r.top, scr_r.right - scr_r.left },
  909. !                     wp_sz  = { theWindow->portRect.bottom - theWindow->portRect.top,
  910. !                                theWindow->portRect.right  - theWindow->portRect.left };
  911. !         const short max_h = scr_sz.v - win_ind.top    - win_ind.bottom,
  912. !                     max_w = scr_sz.h - win_ind.left - win_ind.right;
  913. !         const char cr = CHAR_CR;
  914.   
  915. !         long line_start = 0, line_end;
  916. !         short w = wp_sz.h,
  917. !               h = full_screen ? aWin->lin * aWin->charHeight : wp_sz.v;
  918. !         Point pos = { theWindow->portRect.top, theWindow->portRect.left };
  919. !         SetPort(theWindow);
  920. !         LocalToGlobal(&pos);
  921.   
  922. !         HLock(aWin->windowText);
  923. !         while (line_start < aWin->windowTextLen) {
  924. !             short line_w;
  925. !             line_end = Munger(aWin->windowText, line_start, &cr, 1, nil, 0);
  926. !             if (line_end < 0)
  927. !                 line_end = aWin->windowTextLen;
  928. !             line_w = TextWidth(*aWin->windowText, line_start, line_end - line_start) +
  929. !                      (SBARWIDTH + 2);
  930. !             if (w < line_w)
  931. !                 w = line_w;
  932. !             line_start = line_end + 1;
  933. !         }
  934. !         HUnlock(aWin->windowText);
  935. ! 
  936. !         if (h > max_h) h = max_h;
  937. !         if (w > max_w) w = max_w;
  938. !         SizeWindow(theWindow, w, h, FALSE);
  939. ! 
  940. !         if ( ! ( ( WindowPeek ) theWindow ) -> visible ) {
  941. !             short top , left ;
  942. !             if ( ! RetrieveWinPos ( theWindow , & top , & left ) ) {
  943. !                 if (pos.v + h + win_ind.bottom > scr_r.bottom)
  944. !                     pos.v = scr_r.bottom - h - win_ind.bottom;
  945. !                 if (pos.h + w + win_ind.right  > scr_r.right)
  946. !                     pos.h = scr_r.right     - w - win_ind.right;
  947. !                 top = pos . v ;
  948. !                 left = pos . h ;
  949.               }
  950. !             MoveWindow(theWindow, left, top, FALSE);
  951.           }
  952.   
  953. !         SelectWindow ( theWindow ) ;
  954.           ShowWindow ( theWindow ) ;
  955.       }
  956.   
  957. --- 1223,1266 ----
  958.       }
  959.   
  960.       if ( f && inSelect == WIN_ERR && ( win == BASE_WINDOW || win == WIN_MESSAGE ) ) {
  961. !         if ( win == WIN_MESSAGE ) {
  962.               topl_set_resp ( NULL , 0 ) ;
  963. !             if ( aWin -> windowTextLen > 0 &&
  964. !                  ( * aWin -> windowText ) [ aWin -> windowTextLen - 1 ] == CHAR_CR ) {
  965. !                 -- aWin -> windowTextLen ;
  966. !                 -- aWin -> lin ;
  967. !             }
  968.           }
  969. !         putstr ( win , flags . standout ? ATR_INVERSE : ATR_NONE , " --More--" ) ;
  970.       }
  971.   
  972. !     if ( ! ( ( WindowPeek ) theWindow ) -> visible || full_screen ) {
  973.   
  974. !         int kind = ((WindowPeek)theWindow)->windowKind - WIN_BASE_KIND;
  975. !         if (kind == NHW_TEXT || kind == NHW_MENU) {
  976. !             const char cr = CHAR_CR;
  977. !             short w = 0;
  978. !             long line_start = 0;
  979. !             HLock(aWin->windowText);
  980.   
  981. !             while (line_start < aWin->windowTextLen) {
  982. !                 long line_end;
  983. !                 short line_w;
  984. !                 line_end = Munger(aWin->windowText, line_start, &cr, 1, nil, 0);
  985. !                 if (line_end < 0)
  986. !                     line_end = aWin->windowTextLen;
  987. !                 line_w = TextWidth(*aWin->windowText, line_start, line_end - line_start);
  988. !                 if (w < line_w)
  989. !                     w = line_w;
  990. !                 line_start = line_end + 1;
  991.               }
  992. !             HUnlock(aWin->windowText);
  993. ! 
  994. !             adjust_window_pos(aWin, theWindow, w + (SBARWIDTH+2));
  995.           }
  996.   
  997. !         if ( ! small_screen || win != WIN_MESSAGE || f )
  998. !             SelectWindow ( theWindow ) ;
  999.           ShowWindow ( theWindow ) ;
  1000.       }
  1001.   
  1002. ***************
  1003. *** 1227,1233 ****
  1004.   
  1005.           if ( win == WIN_MESSAGE )
  1006.               topl_set_resp ( "" , '\0' ) ;
  1007. !         else
  1008.               HideWindow ( theWindow ) ;
  1009.   
  1010.       } else {
  1011. --- 1280,1286 ----
  1012.   
  1013.           if ( win == WIN_MESSAGE )
  1014.               topl_set_resp ( "" , '\0' ) ;
  1015. !         else if ( win != WIN_MAP && win != WIN_STATUS )
  1016.               HideWindow ( theWindow ) ;
  1017.   
  1018.       } else {
  1019. ***************
  1020. *** 1325,1334 ****
  1021.   void
  1022.   GeneralKey ( EventRecord * theEvent , WindowPtr theWindow )
  1023.   {
  1024. -     int i ;
  1025. - 
  1026.       trans_num_keys ( theEvent ) ;
  1027. - 
  1028.       addToKeyQueue ( topl_resp_key ( theEvent -> message & 0xff ) , 1 ) ;
  1029.   }
  1030.   
  1031. --- 1378,1384 ----
  1032. ***************
  1033. *** 1426,1431 ****
  1034. --- 1476,1483 ----
  1035.           }
  1036.           ++r_idx;
  1037.       }
  1038. + 
  1039. +     macClickText(theEvent, theWindow);
  1040.   }
  1041.   
  1042.   
  1043. ***************
  1044. *** 1441,1472 ****
  1045.   static void
  1046.   macClickMap ( EventRecord * theEvent , WindowPtr theWindow )
  1047.   {
  1048. !     if ( ! theEvent || ! theWindow ) {
  1049. !         Debugger ( ) ;
  1050. !     }
  1051. !     {
  1052. !         NhWindow * nhw = ( NhWindow * ) GetWRefCon ( theWindow ) ;
  1053. !         Point where ;
  1054. !         short posX , posY ;
  1055. !         short sector ;
  1056. !         char theDirectionChar [ 18 ] = {
  1057. !             ' ' , 'k' , 'u' , 'l' , 'n' , 'j' , 'b' , 'h' , 'y' ,
  1058. !             'o' , 'K' , 'U' , 'L' , 'N' , 'J' , 'B' , 'H' , 'Y' ,
  1059. !         } ;
  1060.   
  1061. !         where = theEvent -> where ;
  1062. !         GlobalToLocal ( & where ) ;
  1063. !         posX = where . h / nhw -> charWidth ;
  1064. !         posY = where . v / nhw -> charHeight ;
  1065. ! 
  1066. !     /* 0 is ON, 1 is top, then clockwise */
  1067. !         sector = clickSector ( u . ux , u . uy , posX , posY ) ;
  1068. !         if ( theEvent -> modifiers & shiftKey ) {
  1069. !             sector += 9 ;
  1070. !         }
  1071. !         addToKeyQueue ( theDirectionChar [ sector ] , 0 ) ;
  1072. ! 
  1073. !         gClickedToMove = 1 ;
  1074.       }
  1075.   }
  1076.   
  1077. --- 1493,1516 ----
  1078.   static void
  1079.   macClickMap ( EventRecord * theEvent , WindowPtr theWindow )
  1080.   {
  1081. !     int shift_down = theEvent->modifiers & shiftKey;
  1082. !     NhWindow *nhw = (NhWindow *)GetWRefCon(theWindow);
  1083. !     Point where = theEvent->where;
  1084. !         GlobalToLocal(&where);
  1085. !         where.h /= nhw->charWidth;
  1086. !         where.v /= nhw->charHeight;
  1087. !     clicked_mod = shift_down ? CLICK_2 : CLICK_1;
  1088.   
  1089. !     if (strchr(topl_resp, click_to_cmd(where.h, where.v, clicked_mod)))
  1090. !         nhbell();
  1091. !     else {
  1092. !         if (cursor_locked)
  1093. !             while (WaitMouseUp())
  1094. !                 SystemTask();
  1095. !         else if (!shift_down)
  1096. !             gNextClickRepeat = TickCount() + *(short *)KeyThresh;
  1097. !         gClickedToMove = TRUE;
  1098. !         clicked_pos = where;
  1099.       }
  1100.   }
  1101.   
  1102. ***************
  1103. *** 1495,1508 ****
  1104.       SetCtlValue ( theBar , now - amtToScroll ) ;
  1105.       winToScroll -> scrollPos = now - amtToScroll ;
  1106.       r = winToScroll -> theWindow -> portRect ;
  1107. !     r . right -= 15 ;
  1108.       ScrollRect ( & r , 0 , amtToScroll * winToScroll -> charHeight , rgn ) ;
  1109.       if ( rgn ) {
  1110.           InvalRgn ( rgn ) ;
  1111. -         r . top = r . bottom - 16 ;
  1112. -         r . left = r . right ;
  1113. -         r . right += 15 ;
  1114. -         InvalRect ( & r ) ;
  1115.           BeginUpdate ( winToScroll -> theWindow ) ;
  1116.       }
  1117.       winToScroll -> updateFunc  ( & fake , winToScroll -> theWindow ) ;
  1118. --- 1539,1550 ----
  1119.       SetCtlValue ( theBar , now - amtToScroll ) ;
  1120.       winToScroll -> scrollPos = now - amtToScroll ;
  1121.       r = winToScroll -> theWindow -> portRect ;
  1122. !     r . right -= SBARWIDTH ;
  1123. !     if ( winToScroll == theWindows + WIN_MESSAGE )
  1124. !         r . bottom -= SBARHEIGHT + 1 ;
  1125.       ScrollRect ( & r , 0 , amtToScroll * winToScroll -> charHeight , rgn ) ;
  1126.       if ( rgn ) {
  1127.           InvalRgn ( rgn ) ;
  1128.           BeginUpdate ( winToScroll -> theWindow ) ;
  1129.       }
  1130.       winToScroll -> updateFunc  ( & fake , winToScroll -> theWindow ) ;
  1131. ***************
  1132. *** 1535,1548 ****
  1133.       SetCtlValue ( theBar , now + amtToScroll ) ;
  1134.       winToScroll -> scrollPos = now + amtToScroll ;
  1135.       r = winToScroll -> theWindow -> portRect ;
  1136. !     r . right -= 15 ;
  1137.       ScrollRect ( & r , 0 , - amtToScroll * winToScroll -> charHeight , rgn ) ; 
  1138.       if ( rgn ) {
  1139.           InvalRgn ( rgn ) ;
  1140. -         r . top = r . bottom - 16 ;
  1141. -         r . left = r . right ;
  1142. -         r . right += 15 ;
  1143. -         InvalRect ( & r ) ;
  1144.           BeginUpdate ( winToScroll -> theWindow ) ;
  1145.       }
  1146.       winToScroll -> updateFunc  ( & fake , winToScroll -> theWindow ) ;
  1147. --- 1577,1588 ----
  1148.       SetCtlValue ( theBar , now + amtToScroll ) ;
  1149.       winToScroll -> scrollPos = now + amtToScroll ;
  1150.       r = winToScroll -> theWindow -> portRect ;
  1151. !     r . right -= SBARWIDTH ;
  1152. !     if ( winToScroll == theWindows + WIN_MESSAGE )
  1153. !         r . bottom -= SBARHEIGHT + 1 ;
  1154.       ScrollRect ( & r , 0 , - amtToScroll * winToScroll -> charHeight , rgn ) ; 
  1155.       if ( rgn ) {
  1156.           InvalRgn ( rgn ) ;
  1157.           BeginUpdate ( winToScroll -> theWindow ) ;
  1158.       }
  1159.       winToScroll -> updateFunc  ( & fake , winToScroll -> theWindow ) ;
  1160. ***************
  1161. *** 1615,1620 ****
  1162. --- 1655,1674 ----
  1163.   }
  1164.   
  1165.   
  1166. + int
  1167. + mac_doprev_message(void)
  1168. + {
  1169. +     if (WIN_MESSAGE) {
  1170. +         display_nhwindow(WIN_MESSAGE, FALSE);
  1171. +         amtToScroll = 1;
  1172. +         winToScroll = &theWindows[WIN_MESSAGE];
  1173. +         SetPort(winToScroll->theWindow);
  1174. +         Up(winToScroll->scrollBar, inUpButton);
  1175. +     }    
  1176. +     return 0 ;
  1177. + }
  1178. + 
  1179. + 
  1180.   static void
  1181.   macClickMenu ( EventRecord * theEvent , WindowPtr theWindow )
  1182.   {
  1183. ***************
  1184. *** 1742,1747 ****
  1185. --- 1796,1802 ----
  1186.   
  1187.       GetClip(org_clip);
  1188.   
  1189. +     DrawControls(theWindow);
  1190.       DrawGrowIcon(theWindow);
  1191.   
  1192.       l = 0;
  1193. ***************
  1194. *** 1794,1808 ****
  1195.       /* Clip to the portrect - scrollbar/growicon *before* adjusting the rect
  1196.           to be larger than the size of the window (!) */
  1197.       RectRgn(clip, &r);
  1198.       if ( r . right < MIN_RIGHT )
  1199.           r . right = MIN_RIGHT ;
  1200.   
  1201.       if (in_topl_mode()) {
  1202.           RgnHandle topl_rgn = NewRgn();
  1203.           Rect topl_r = r;
  1204. !         for (l = aWin->windowTextLen - 1; --l >= aWin->textBase; )
  1205. !             if ((*aWin->windowText)[l] == CHAR_CR)
  1206. !                 topl_r.top += aWin->charHeight;
  1207.           l = (*top_line)->destRect.right - (*top_line)->destRect.left;
  1208.           (*top_line)->viewRect = topl_r;
  1209.           (*top_line)->destRect = topl_r;
  1210. --- 1849,1880 ----
  1211.       /* Clip to the portrect - scrollbar/growicon *before* adjusting the rect
  1212.           to be larger than the size of the window (!) */
  1213.       RectRgn(clip, &r);
  1214. +     SectRgn(clip, org_clip, clip);
  1215.       if ( r . right < MIN_RIGHT )
  1216.           r . right = MIN_RIGHT ;
  1217. +     r . top -= aWin -> scrollPos * aWin -> charHeight ;
  1218.   
  1219. + #if 0
  1220. +     /* If you enable this band of code (and disable the next band), you will get
  1221. +        fewer flickers but a slower performance while drawing the dot line. */
  1222. +     {    RgnHandle dotl_rgn = NewRgn();
  1223. +         Rect dotl;
  1224. +         dotl.left    = r.left;
  1225. +         dotl.right    = r.right;
  1226. +         dotl.bottom = r.top + aWin->save_lin * aWin->charHeight;
  1227. +         dotl.top    = dotl.bottom - 1;
  1228. +         FillRect(&dotl, &qd.gray);
  1229. +         RectRgn(dotl_rgn, &dotl);
  1230. +         DiffRgn(clip, dotl_rgn, clip);
  1231. +         DisposeRgn(dotl_rgn);
  1232. +         SetClip(clip);
  1233. +     }
  1234. + #endif
  1235. + 
  1236.       if (in_topl_mode()) {
  1237.           RgnHandle topl_rgn = NewRgn();
  1238.           Rect topl_r = r;
  1239. !         topl_r.top += (aWin->lin - 1) * aWin->charHeight;
  1240.           l = (*top_line)->destRect.right - (*top_line)->destRect.left;
  1241.           (*top_line)->viewRect = topl_r;
  1242.           (*top_line)->destRect = topl_r;
  1243. ***************
  1244. *** 1812,1830 ****
  1245.           RectRgn(topl_rgn, &topl_r);
  1246.           DiffRgn(clip, topl_rgn, clip);
  1247.           DisposeRgn(topl_rgn);
  1248.       }
  1249.   
  1250. -     SectRgn(clip, org_clip, clip);
  1251. -     SetClip(clip);
  1252.       DisposeRgn(clip);
  1253.   
  1254.       TextFont ( aWin -> fontNum ) ;
  1255.       TextSize ( aWin -> fontSize ) ;
  1256.       HLock ( aWin -> windowText ) ;
  1257. !     TextBox ( * ( aWin -> windowText ) + aWin -> textBase , aWin ->
  1258. !         windowTextLen - aWin -> textBase , & r , teJustLeft ) ;
  1259.       HUnlock ( aWin -> windowText ) ;
  1260.   
  1261.       SetClip(org_clip);
  1262.       DisposeRgn(org_clip);
  1263.   }
  1264. --- 1884,1906 ----
  1265.           RectRgn(topl_rgn, &topl_r);
  1266.           DiffRgn(clip, topl_rgn, clip);
  1267.           DisposeRgn(topl_rgn);
  1268. +         SetClip(clip);
  1269.       }
  1270.   
  1271.       DisposeRgn(clip);
  1272.   
  1273.       TextFont ( aWin -> fontNum ) ;
  1274.       TextSize ( aWin -> fontSize ) ;
  1275.       HLock ( aWin -> windowText ) ;
  1276. !     TextBox ( * aWin -> windowText , aWin -> windowTextLen , & r , teJustLeft ) ;
  1277.       HUnlock ( aWin -> windowText ) ;
  1278.   
  1279. + #if 1
  1280. +     r.bottom = r.top + aWin->save_lin * aWin->charHeight;
  1281. +     r.top     = r.bottom - 1;
  1282. +     FillRect(&r, &qd.gray);
  1283. + #endif
  1284. + 
  1285.       SetClip(org_clip);
  1286.       DisposeRgn(org_clip);
  1287.   }
  1288. ***************
  1289. *** 1941,1948 ****
  1290.           r . right = MIN_RIGHT ;
  1291.       r . top -= aWin -> scrollPos * aWin -> charHeight ;
  1292.       HLock ( aWin -> windowText ) ;
  1293. !     TextBox ( * ( aWin -> windowText ) + aWin -> textBase , aWin ->
  1294. !         windowTextLen - aWin -> textBase , & r , teJustLeft ) ;
  1295.       HUnlock ( aWin -> windowText ) ;
  1296.       if ( h ) {
  1297.           SetClip ( h ) ;
  1298. --- 2017,2023 ----
  1299.           r . right = MIN_RIGHT ;
  1300.       r . top -= aWin -> scrollPos * aWin -> charHeight ;
  1301.       HLock ( aWin -> windowText ) ;
  1302. !     TextBox ( * aWin -> windowText , aWin -> windowTextLen , & r , teJustLeft ) ;
  1303.       HUnlock ( aWin -> windowText ) ;
  1304.       if ( h ) {
  1305.           SetClip ( h ) ;
  1306. ***************
  1307. *** 1989,1996 ****
  1308.       r . top -= aWin -> scrollPos * aWin -> charHeight ;
  1309.       r . right -= SBARWIDTH;
  1310.       HLock ( aWin -> windowText ) ;
  1311. !     TextBox ( * ( aWin -> windowText ) + aWin -> textBase , aWin ->
  1312. !         windowTextLen - aWin -> textBase , & r , teJustLeft ) ;
  1313.       HUnlock ( aWin -> windowText ) ;
  1314.       draw_growicon_vert_only(theWindow);
  1315.       if ( h ) {
  1316. --- 2064,2070 ----
  1317.       r . top -= aWin -> scrollPos * aWin -> charHeight ;
  1318.       r . right -= SBARWIDTH;
  1319.       HLock ( aWin -> windowText ) ;
  1320. !     TextBox ( * aWin -> windowText , aWin -> windowTextLen , & r , teJustLeft ) ;
  1321.       HUnlock ( aWin -> windowText ) ;
  1322.       draw_growicon_vert_only(theWindow);
  1323.       if ( h ) {
  1324. ***************
  1325. *** 2037,2042 ****
  1326. --- 2111,2117 ----
  1327.   macCursorMap ( EventRecord * theEvent , WindowPtr theWindow , RgnHandle mouseRgn )
  1328.   {
  1329.       Point where ;
  1330. +     char * dir_bas , * dir ;
  1331.       CursHandle ch ;
  1332.       GrafPtr gp ;
  1333.       NhWindow * nhw = ( NhWindow * ) GetWRefCon ( theWindow ) ;
  1334. ***************
  1335. *** 2047,2059 ****
  1336.   
  1337.       where = theEvent -> where ;
  1338.       GlobalToLocal ( & where ) ;
  1339. !     ch = GetCursor ( 512 + clickSector ( u . ux , u . uy , where . h / nhw -> charWidth ,
  1340. !         where . v / nhw -> charHeight ) ) ;
  1341.       if ( ch ) {
  1342.   
  1343.           HLock ( ( Handle ) ch ) ;
  1344.           SetCursor ( * ch ) ;
  1345. !         ReleaseResource ( ( Handle ) ch ) ;
  1346.   
  1347.       } else {
  1348.   
  1349. --- 2122,2142 ----
  1350.   
  1351.       where = theEvent -> where ;
  1352.       GlobalToLocal ( & where ) ;
  1353. ! 
  1354. !     if ( cursor_locked )
  1355. !         dir = NULL ;
  1356. !     else {
  1357. !         dir_bas = flags . num_pad ? ndir : sdir ;
  1358. !         dir = strchr ( dir_bas , click_to_cmd ( where . h / nhw -> charWidth ,
  1359. !                                                 where . v / nhw -> charHeight ,
  1360. !                                                 CLICK_1 ) ) ;
  1361. !     }
  1362. !     ch = GetCursor ( dir ? dir - dir_bas + 513 : 512 ) ;
  1363.       if ( ch ) {
  1364.   
  1365.           HLock ( ( Handle ) ch ) ;
  1366.           SetCursor ( * ch ) ;
  1367. !         HUnlock ( ( Handle ) ch ) ;
  1368.   
  1369.       } else {
  1370.   
  1371. ***************
  1372. *** 2226,2231 ****
  1373. --- 2309,2316 ----
  1374.               InitCursor ( ) ;
  1375.               SetRect ( & r , 80 , 2 * aWin -> charHeight + 1 , r . right ,
  1376.                   r . bottom ) ;
  1377. +             if ( aWin == theWindows + WIN_MESSAGE )
  1378. +                 r . top += SBARHEIGHT + 1 ;
  1379.               l = GrowWindow ( theWindow , theEvent -> where , & r ) ;
  1380.               SizeWindow ( theWindow , l & 0xffff , l >> 16 , FALSE ) ;
  1381.               SaveWindowSize ( theWindow ) ;
  1382. ***************
  1383. *** 2347,2372 ****
  1384.               }
  1385.               FlushEvents ( keyDownMask , 0 ) ;
  1386.           }
  1387. -         /*
  1388. -          * This somewhat elaborate hack is needed to make the menu
  1389. -          * commands work right. They're also needed for fast typists.
  1390. -          */
  1391. -         if ( keyQueue [ 0 ] && in_topl_mode() ) {
  1392. -             int i ;
  1393. - 
  1394. -             theEvent -> what = keyDown ;
  1395. -             theEvent -> modifiers = 0 ;
  1396. -             theEvent -> message = keyQueue [ 0 ] ;
  1397. - 
  1398. - /* extract from key queue */
  1399. -             for ( i = 0 ; i < QUEUE_LEN - 1 ; i ++ ) {
  1400. -                 keyQueue [ i ] = keyQueue [ i + 1 ] ;
  1401. -             }
  1402. -             keyQueue [ i ] = 0 ;
  1403. -             SetPort ( theWindows [ WIN_MESSAGE ] . theWindow ) ;
  1404. -             theWindows [ WIN_MESSAGE ] . keyFunc ( theEvent ,
  1405. -                 theWindows [ WIN_MESSAGE ] . theWindow ) ;
  1406. -         }
  1407.           break ;
  1408.       }
  1409.   }
  1410. --- 2432,2437 ----
  1411. ***************
  1412. *** 2380,2389 ****
  1413.       DisableItem ( appleMenu , 0 ) ;
  1414.       DisableItem ( fileMenu , 0 ) ;
  1415.       DisableItem ( editMenu , 0 ) ;
  1416. !     DisableItem ( extendMenu , 0 ) ;
  1417. !     DisableItem ( miscMenu , 0 ) ;
  1418. !     DisableItem ( commandsMenu , 0 ) ;
  1419.       DisableItem ( thingsMenu , 0 ) ;
  1420.       DrawMenuBar ( ) ;
  1421.   }
  1422.   
  1423. --- 2445,2455 ----
  1424.       DisableItem ( appleMenu , 0 ) ;
  1425.       DisableItem ( fileMenu , 0 ) ;
  1426.       DisableItem ( editMenu , 0 ) ;
  1427. !     DisableItem ( actionMenu , 0 ) ;
  1428. !     DisableItem ( inventoryMenu , 0 ) ;
  1429.       DisableItem ( thingsMenu , 0 ) ;
  1430. +     DisableItem ( extendedMenu , 0 ) ;
  1431. +     DisableItem ( infoMenu , 0 ) ;
  1432.       DrawMenuBar ( ) ;
  1433.   }
  1434.   
  1435. ***************
  1436. *** 2394,2403 ****
  1437.       EnableItem ( appleMenu , 0 ) ;
  1438.       EnableItem ( fileMenu , 0 ) ;
  1439.       EnableItem ( editMenu , 0 ) ;
  1440. !     EnableItem ( extendMenu , 0 ) ;
  1441. !     EnableItem ( miscMenu , 0 ) ;
  1442. !     EnableItem ( commandsMenu , 0 ) ;
  1443.       EnableItem ( thingsMenu , 0 ) ;
  1444.       DrawMenuBar ( ) ;
  1445.   }
  1446.   
  1447. --- 2460,2470 ----
  1448.       EnableItem ( appleMenu , 0 ) ;
  1449.       EnableItem ( fileMenu , 0 ) ;
  1450.       EnableItem ( editMenu , 0 ) ;
  1451. !     EnableItem ( actionMenu , 0 ) ;
  1452. !     EnableItem ( inventoryMenu , 0 ) ;
  1453.       EnableItem ( thingsMenu , 0 ) ;
  1454. +     EnableItem ( extendedMenu , 0 ) ;
  1455. +     EnableItem ( infoMenu , 0 ) ;
  1456.       DrawMenuBar ( ) ;
  1457.   }
  1458.   
  1459. ***************
  1460. *** 2408,2422 ****
  1461.   {
  1462.       EventRecord anEvent ;
  1463.   
  1464. !     if ( ( inSelect != WIN_ERR || ! flags . window_inited || in_topl_mode() ) &&
  1465. !         ! mBarDimmed ) {
  1466. !         DimMenuBar ( ) ;
  1467. !         mBarDimmed = 1 ;
  1468. !     } else if ( inSelect == WIN_ERR && flags . window_inited && mBarDimmed &&
  1469. !                 ! in_topl_mode() ) {
  1470. !         UndimMenuBar ( ) ;
  1471. !         mBarDimmed = 0 ;
  1472. !     }
  1473.       /*
  1474.        * We want to take care of keys in the buffer as fast as
  1475.        * possible
  1476. --- 2475,2489 ----
  1477.   {
  1478.       EventRecord anEvent ;
  1479.   
  1480. !     if ( ( inSelect == WIN_ERR && flags . window_inited && ! in_topl_mode ( ) )
  1481. !          == mBarDimmed )
  1482. !         if ( mBarDimmed ) {
  1483. !             UndimMenuBar ( ) ;
  1484. !             mBarDimmed = 0 ;
  1485. !         } else {
  1486. !             DimMenuBar ( ) ;
  1487. !             mBarDimmed = 1 ;
  1488. !         }
  1489.       /*
  1490.        * We want to take care of keys in the buffer as fast as
  1491.        * possible
  1492. ***************
  1493. *** 2447,2459 ****
  1494.   {
  1495.       int ch ;
  1496.       register int i ;
  1497.   
  1498.       wait_synch ( ) ;
  1499.   
  1500. !     if ( flags . window_inited && ! theWindows [ WIN_MAP ] . cursorDrawn &&
  1501. !         theWindows [ WIN_MAP ] . theWindow ) {
  1502. !         SetPort ( theWindows [ WIN_MAP ] . theWindow ) ;
  1503. !         DrawMapCursor ( & theWindows [ WIN_MAP ] ) ;
  1504.       }
  1505.   
  1506.       if ( ! keyQueue [ 0 ] ) {
  1507. --- 2514,2532 ----
  1508.   {
  1509.       int ch ;
  1510.       register int i ;
  1511. +     NhWindow * nhw = flags . window_inited ? theWindows + WIN_MAP : nil ;
  1512.   
  1513. +     if ( theWindows ) {
  1514. +         NhWindow * aWin = theWindows + WIN_MESSAGE ;
  1515. +         if ( aWin )
  1516. +             aWin -> last_more_lin = aWin -> lin ;
  1517. +     }
  1518. + 
  1519.       wait_synch ( ) ;
  1520.   
  1521. !     if ( nhw && ! nhw -> cursorDrawn && nhw -> theWindow ) {
  1522. !         SetPort ( nhw -> theWindow ) ;
  1523. !         DrawMapCursor ( nhw ) ;
  1524.       }
  1525.   
  1526.       if ( ! keyQueue [ 0 ] ) {
  1527. ***************
  1528. *** 2461,2469 ****
  1529.           static char warn = 0 ;
  1530.   
  1531.           PurgeSpace ( & total , & contig ) ;
  1532. !         if ( contig < 64000L || total < 256000L ) {
  1533.               if ( ! warn ) {
  1534. !                 DebugStr ( ( ConstStr255Param ) "\014Low Memory !" ) ;
  1535.                   warn = 1 ;
  1536.               }
  1537.           } else {
  1538. --- 2534,2542 ----
  1539.           static char warn = 0 ;
  1540.   
  1541.           PurgeSpace ( & total , & contig ) ;
  1542. !         if ( contig < 25000L || total < 50000L ) {
  1543.               if ( ! warn ) {
  1544. !                 pline ( "Low Memory!" ) ;
  1545.                   warn = 1 ;
  1546.               }
  1547.           } else {
  1548. ***************
  1549. *** 2473,2481 ****
  1550.   
  1551.       do {
  1552.           doDawdle = ( in_topl_mode() ? GetCaretTime ( ) : 120L ) ;
  1553.           get_nh_event ( ) ;
  1554.           ch = keyQueue [ 0 ] ;
  1555. !     } while ( ! ch ) ;
  1556.   
  1557.       if ( ! gClickedToMove ) {
  1558.           ObscureCursor ( ) ;
  1559. --- 2546,2573 ----
  1560.   
  1561.       do {
  1562.           doDawdle = ( in_topl_mode() ? GetCaretTime ( ) : 120L ) ;
  1563. + 
  1564. +         if ( nhw ) {
  1565. +             SetPort ( nhw -> theWindow ) ;
  1566. +             if ( WaitMouseUp ( ) ) {
  1567. +                 unsigned long tick = TickCount ( ) ;
  1568. +                 if ( tick >= gNextClickRepeat ) {
  1569. +                     Point where ;
  1570. +                     GetMouse ( & where ) ;
  1571. +                     SetPt ( & clicked_pos , where . h / nhw -> charWidth ,
  1572. +                                             where . v / nhw -> charHeight ) ;
  1573. +                     gClickedToMove = TRUE ;
  1574. +                     gNextClickRepeat = tick + * ( short * ) KeyRepThresh ;
  1575. +                 }
  1576. +                 if ( doDawdle > * ( short * ) KeyRepThresh )
  1577. +                     doDawdle = * ( short * ) KeyRepThresh ;
  1578. +             } else
  1579. +                 gNextClickRepeat = 0xffffffff ;
  1580. +         }
  1581. + 
  1582.           get_nh_event ( ) ;
  1583.           ch = keyQueue [ 0 ] ;
  1584. !     } while ( ! ch && ! gClickedToMove ) ;
  1585.   
  1586.       if ( ! gClickedToMove ) {
  1587.           ObscureCursor ( ) ;
  1588. ***************
  1589. *** 2536,2548 ****
  1590.       /* Here and in mac_raw_print_bold I assume that once theWindows got
  1591.          allocated by mac_init_nhwindows we can safely do putstr on BASE_WINDOW,
  1592.          even after mac_exit_nhwindows is called or flags.window_inited is reset
  1593. !        to zero.  Is this assumption correct? */
  1594.       if ( theWindows ) {
  1595.   
  1596.           ShowWindow ( theWindows [ BASE_WINDOW ] . theWindow ) ;
  1597.           SelectWindow ( theWindows [ BASE_WINDOW ] . theWindow ) ;
  1598.   
  1599. !         putstr ( BASE_WINDOW , 0 , str ) ;
  1600.   
  1601.       } else
  1602.           showerror ( str , NULL ) ;
  1603. --- 2628,2644 ----
  1604.       /* Here and in mac_raw_print_bold I assume that once theWindows got
  1605.          allocated by mac_init_nhwindows we can safely do putstr on BASE_WINDOW,
  1606.          even after mac_exit_nhwindows is called or flags.window_inited is reset
  1607. !        to zero.  Is this assumption correct?
  1608. !        Also add a space or a bullet before each line to indicate the bold face
  1609. !        before we really implement the text attributes */
  1610.       if ( theWindows ) {
  1611. +         char lstr [ 200 ] = " " ;
  1612. +         strcat ( lstr , str ) ;
  1613.   
  1614.           ShowWindow ( theWindows [ BASE_WINDOW ] . theWindow ) ;
  1615.           SelectWindow ( theWindows [ BASE_WINDOW ] . theWindow ) ;
  1616.   
  1617. !         putstr ( BASE_WINDOW , 0 , lstr ) ;
  1618.   
  1619.       } else
  1620.           showerror ( str , NULL ) ;
  1621. ***************
  1622. *** 2553,2563 ****
  1623.   mac_raw_print_bold ( const char * str )
  1624.   {
  1625.       if ( theWindows ) {
  1626.   
  1627.           ShowWindow ( theWindows [ BASE_WINDOW ] . theWindow ) ;
  1628.           SelectWindow ( theWindows [ BASE_WINDOW ] . theWindow ) ;
  1629.   
  1630. !         putstr ( BASE_WINDOW , ATR_BOLD , str ) ;
  1631.   
  1632.       } else {
  1633.           nhbell ( ) ;
  1634. --- 2649,2661 ----
  1635.   mac_raw_print_bold ( const char * str )
  1636.   {
  1637.       if ( theWindows ) {
  1638. +         char lstr [ 200 ] = "\xA5"/*bullet*/ ;
  1639. +         strcat ( lstr , str ) ;
  1640.   
  1641.           ShowWindow ( theWindows [ BASE_WINDOW ] . theWindow ) ;
  1642.           SelectWindow ( theWindows [ BASE_WINDOW ] . theWindow ) ;
  1643.   
  1644. !         putstr ( BASE_WINDOW , ATR_BOLD , lstr ) ;
  1645.   
  1646.       } else {
  1647.           nhbell ( ) ;
  1648. ***************
  1649. *** 2596,2602 ****
  1650.       Rect r ;
  1651.   
  1652.       if ( in_putstr > 3 ) {
  1653. !         DebugStr ( ( ConstStr255Param ) "\012Recursion!" ) ;
  1654.           return ;
  1655.       }
  1656.       if ( win < 0 || win >= NUM_MACWINDOWS ) {
  1657. --- 2694,2700 ----
  1658.       Rect r ;
  1659.   
  1660.       if ( in_putstr > 3 ) {
  1661. !         DebugStr ( ( ConstStr255Param ) "\pRecursion!" ) ;
  1662.           return ;
  1663.       }
  1664.       if ( win < 0 || win >= NUM_MACWINDOWS ) {
  1665. ***************
  1666. *** 2612,2642 ****
  1667.       in_putstr ++ ;
  1668.       kind = ( ( WindowPeek ) ( aWin -> theWindow ) ) -> windowKind -
  1669.           WIN_BASE_KIND ;
  1670.   
  1671.       if ( kind == NHW_MAP || kind == NHW_STATUS ) {
  1672. !         short    h = ( NUM_COLS - aWin->cursor.h - strlen(str) );
  1673. !         /*
  1674. !          * The "dungeon" window
  1675. !          * putsym will call curs, so no updates necessary.
  1676. !          */
  1677. !         while ( * str ) {
  1678. !             putsym ( win , aWin -> cursor . h , aWin -> cursor . v , * str ) ;
  1679. !             curs ( win , aWin -> cursor . h + 1 , aWin -> cursor . v ) ;
  1680. !             str ++ ;
  1681. !         }
  1682. !         h = (h < 0) ? 0 : h;
  1683. !         while( h-- ) {
  1684. !             putsym ( win , aWin -> cursor . h , aWin -> cursor . v , CHAR_BLANK ) ;
  1685. !             curs ( win , aWin -> cursor . h + 1 , aWin -> cursor . v ) ;
  1686. !         }
  1687.       } else {
  1688.           char * sr , * ds ;
  1689.           /*
  1690.            * A "default" text window - uses TextBox
  1691.            * We just add the text, without attributes for now
  1692.            */
  1693.           len = GetHandleSize ( aWin -> windowText ) ;
  1694. -         slen = strlen ( str ) ;
  1695.           while ( aWin -> windowTextLen + slen + 1 > len ) {
  1696.               len = ( len > 2048 ) ? ( len + 2048 ) : ( len * 2 ) ;
  1697.               SetHandleSize ( aWin -> windowText , len ) ;
  1698. --- 2710,2753 ----
  1699.       in_putstr ++ ;
  1700.       kind = ( ( WindowPeek ) ( aWin -> theWindow ) ) -> windowKind -
  1701.           WIN_BASE_KIND ;
  1702. +     slen = strlen ( str ) ;
  1703.   
  1704.       if ( kind == NHW_MAP || kind == NHW_STATUS ) {
  1705. !         char *row;
  1706. !         r.right     = aWin->theWindow->portRect.right;
  1707. !         r.left     = aWin->charWidth    * aWin->cursor.h;
  1708. !         r.bottom = aWin->charHeight *(aWin->cursor.v + 1);
  1709. !         r.top     = r.bottom - aWin->charHeight;
  1710. !         EraseRect(&r);
  1711. !         MoveTo(r.left, r.bottom - aWin->leading);
  1712. !         DrawText(str, 0, slen);
  1713. ! 
  1714. !         if (slen > NUM_COLS - aWin->cursor.h)
  1715. !             slen = NUM_COLS - aWin->cursor.h;
  1716. !         row = &((MapData *)*aWin->windowText)->map[aWin->cursor.v][aWin->cursor.h];
  1717. !         strncpy(row, str, slen);
  1718. !         memset(row + slen, CHAR_BLANK, NUM_COLS - slen - aWin->cursor.h);
  1719. !         curs(win, NUM_COLS, aWin->cursor.v);
  1720. ! 
  1721.       } else {
  1722.           char * sr , * ds ;
  1723. + 
  1724. +         r = aWin->theWindow->portRect;
  1725. +         if (win && win == WIN_MESSAGE) {
  1726. +             r.right  -= SBARWIDTH  + 1;
  1727. +             r.bottom -= SBARHEIGHT + 1;
  1728. +             if ( aWin->last_more_lin < aWin->scrollPos )
  1729. +                 aWin->last_more_lin = aWin->scrollPos;
  1730. +             if ( flags.page_wait && aWin->last_more_lin <=
  1731. +                  aWin->lin - (r.bottom - r.top) / aWin->charHeight )
  1732. +                 display_nhwindow(win, TRUE);
  1733. +         }
  1734. + 
  1735.           /*
  1736.            * A "default" text window - uses TextBox
  1737.            * We just add the text, without attributes for now
  1738.            */
  1739.           len = GetHandleSize ( aWin -> windowText ) ;
  1740.           while ( aWin -> windowTextLen + slen + 1 > len ) {
  1741.               len = ( len > 2048 ) ? ( len + 2048 ) : ( len * 2 ) ;
  1742.               SetHandleSize ( aWin -> windowText , len ) ;
  1743. ***************
  1744. *** 2643,2649 ****
  1745.               if ( MemError ( ) ) {
  1746.                   error ( "SetHandleSize (putstr)" ) ;
  1747.                   aWin -> windowTextLen = 0L ;
  1748. !                 aWin -> textBase = 0 ;
  1749.                   aWin -> lin = 0 ;
  1750.               }
  1751.           }
  1752. --- 2754,2760 ----
  1753.               if ( MemError ( ) ) {
  1754.                   error ( "SetHandleSize (putstr)" ) ;
  1755.                   aWin -> windowTextLen = 0L ;
  1756. !                 aWin -> save_lin = 0 ;
  1757.                   aWin -> lin = 0 ;
  1758.               }
  1759.           }
  1760. ***************
  1761. *** 2662,2701 ****
  1762.               sr ++ ;
  1763.               ds ++ ;
  1764.           }
  1765. !         if ( slen > 1 ) {
  1766. !             ( * ( aWin -> windowText ) ) [ len + slen ] = CHAR_CR ;
  1767. !             aWin -> windowTextLen += slen + 1 ;
  1768. !             aWin -> lin ++ ;
  1769. !         } else {
  1770. !             aWin -> windowTextLen += slen ;
  1771. !         }
  1772.       
  1773.           SetPort ( aWin -> theWindow ) ;
  1774. -         r = aWin -> theWindow -> portRect ;
  1775. -         if ( win && win == WIN_MESSAGE ) {
  1776. -             r . bottom -= SBARHEIGHT + 1 ;
  1777. -         }
  1778.           InvalRect ( & r ) ;
  1779.           aWin -> clear = 0 ;
  1780.           if ( kind == NHW_MESSAGE ) {
  1781. !             char * ptr , * stop ;
  1782. !             long oldBase = aWin -> textBase ;
  1783. !             short lines = ( r . bottom - r . top ) / aWin -> charHeight - 1 ;
  1784. ! 
  1785. !             stop = * aWin -> windowText ;
  1786. !             ptr = stop + aWin -> windowTextLen - 1 ;
  1787. !             while ( lines >= 0 && -- ptr > stop ) {
  1788. !                 if ( * ptr == CHAR_CR || * ptr == CHAR_LF )
  1789. !                     lines -- ;
  1790.               }
  1791. -             if ( ptr <= stop ) {
  1792. -                 aWin -> textBase = 0L ;
  1793. -             } else {
  1794. -                 aWin -> textBase = ptr - stop + 1 ;
  1795. -             }
  1796. -             if ( oldBase > aWin -> textBase ) {
  1797. -                 aWin -> textBase = oldBase ;
  1798. -             }
  1799.           }
  1800.           if ( aWin -> scrollBar ) {
  1801.               InvalScrollBar ( aWin ) ;
  1802. --- 2773,2793 ----
  1803.               sr ++ ;
  1804.               ds ++ ;
  1805.           }
  1806. ! 
  1807. !         ( * ( aWin -> windowText ) ) [ len + slen ] = CHAR_CR ;
  1808. !         aWin -> windowTextLen += slen + 1 ;
  1809. !         aWin -> lin ++ ;
  1810.       
  1811.           SetPort ( aWin -> theWindow ) ;
  1812.           InvalRect ( & r ) ;
  1813.           aWin -> clear = 0 ;
  1814.           if ( kind == NHW_MESSAGE ) {
  1815. !             short min = aWin->lin - (r.bottom - r.top) / aWin->charHeight;
  1816. !             if (aWin->scrollPos < min) {
  1817. !                 aWin->scrollPos = min;
  1818. !                 SetCtlMax  (aWin->scrollBar, aWin->lin);
  1819. !                 SetCtlValue(aWin->scrollBar, min);
  1820.               }
  1821.           }
  1822.           if ( aWin -> scrollBar ) {
  1823.               InvalScrollBar ( aWin ) ;
  1824. ***************
  1825. *** 2751,2760 ****
  1826. --- 2843,2856 ----
  1827.               break ;
  1828.           }
  1829.       } else {
  1830. + #if 1
  1831. +         Debugger ( ) ;
  1832. + #else
  1833.           char ss [ 2 ] ;
  1834.           ss [ 0 ] = sym ;
  1835.           ss [ 1 ] = 0 ;
  1836.           putstr ( win , 0 , ss ) ;
  1837. + #endif
  1838.       }
  1839.   }
  1840.   
  1841. ***************
  1842. *** 2881,2890 ****
  1843.   int
  1844.   mac_nh_poskey ( int * a , int * b , int * c )
  1845.   {
  1846. !     if ( ! a || ! b || ! c ) {
  1847. !         Debugger ( ) ;
  1848. !     }
  1849. !     return nhgetch ( ) ;
  1850.   }
  1851.   
  1852.   
  1853. --- 2977,2987 ----
  1854.   int
  1855.   mac_nh_poskey ( int * a , int * b , int * c )
  1856.   {
  1857. !     int ch = nhgetch();
  1858. !     *a = clicked_pos.h;
  1859. !     *b = clicked_pos.v;
  1860. !     *c = clicked_mod;
  1861. !     return ch;
  1862.   }
  1863.   
  1864.   
  1865. ***************
  1866. *** 2891,2902 ****
  1867.   void
  1868.   mac_start_menu ( winid win )
  1869.   {
  1870. !     NhWindow * aWin = & theWindows [ win ] ;
  1871. ! 
  1872. !     HideWindow ( aWin -> theWindow ) ;
  1873. !     SetHandleSize ( aWin -> windowText , TEXT_BLOCK ) ;
  1874. !     aWin -> wid = 0 ;
  1875. !     aWin -> lin = 0 ;
  1876.       clear_nhwindow ( win ) ;
  1877.   }
  1878.   
  1879. --- 2988,2994 ----
  1880.   void
  1881.   mac_start_menu ( winid win )
  1882.   {
  1883. !     HideWindow ( theWindows [ win ] . theWindow ) ;
  1884.       clear_nhwindow ( win ) ;
  1885.   }
  1886.   
  1887. ***************
  1888. *** 2956,2982 ****
  1889.   char
  1890.   mac_select_menu ( winid win )
  1891.   {
  1892. -     short w , h ;
  1893.       int c , l ;
  1894. -     WindowPtr theWin = theWindows [ win ] . theWindow ;
  1895.       NhWindow * aWin = & theWindows [ win ] ;
  1896.   
  1897.       inSelect = win ;
  1898.   
  1899.       SetPort ( theWin ) ;
  1900. !     if ( aWin -> wid && aWin -> lin ) {
  1901. !         w = aWin -> wid + 16 ;
  1902. !         h = aWin -> lin * aWin -> charHeight ;
  1903. !         if ( w > 450 ) {
  1904. !             w = 450 ;
  1905. !         }
  1906. !         if ( h > 300 ) {
  1907. !             h = 300 ;
  1908. !         }
  1909. !         SizeWindow ( theWin , w , h , TRUE ) ;
  1910. !         if ( aWin -> scrollBar ) {
  1911. !             InvalScrollBar ( aWin ) ;
  1912. !         }
  1913.       }
  1914.       SelectWindow ( theWin ) ;
  1915.       ShowWindow ( theWin ) ;
  1916. --- 3048,3063 ----
  1917.   char
  1918.   mac_select_menu ( winid win )
  1919.   {
  1920.       int c , l ;
  1921.       NhWindow * aWin = & theWindows [ win ] ;
  1922. +     WindowPtr theWin = aWin -> theWindow ;
  1923.   
  1924.       inSelect = win ;
  1925.   
  1926. +     adjust_window_pos ( aWin , theWin , aWin -> wid + ( SBARWIDTH + 2 ) ) ;
  1927.       SetPort ( theWin ) ;
  1928. !     if ( aWin -> scrollBar ) {
  1929. !         InvalScrollBar ( aWin ) ;
  1930.       }
  1931.       SelectWindow ( theWin ) ;
  1932.       ShowWindow ( theWin ) ;
  1933. ***************
  1934. *** 2983,2989 ****
  1935.       InvalRect ( & ( theWin -> portRect ) ) ;
  1936.   
  1937.       do {
  1938. !         while ( ! ( c =  nhgetch ( ) ) ) ;
  1939.           for ( l = 0 ; l < aWin -> lin ; l ++ ) {
  1940.               if ( aWin -> itemChars [ l ] == c )
  1941.                   goto done ;
  1942. --- 3064,3070 ----
  1943.       InvalRect ( & ( theWin -> portRect ) ) ;
  1944.   
  1945.       do {
  1946. !         c = nhgetch ( ) ;
  1947.           for ( l = 0 ; l < aWin -> lin ; l ++ ) {
  1948.               if ( aWin -> itemChars [ l ] == c )
  1949.                   goto done ;
  1950. ***************
  1951. *** 3185,3191 ****
  1952.       DialogPtr        characterDialog;
  1953.       short            itemHit, lastItemSelected, type;
  1954.       Rect            box;
  1955. !     
  1956.       characterDialog = GetNewDialog(132, (Ptr) NULL, (WindowPtr) -1);
  1957.       
  1958.       /*
  1959. --- 3266,3287 ----
  1960.       DialogPtr        characterDialog;
  1961.       short            itemHit, lastItemSelected, type;
  1962.       Rect            box;
  1963. ! 
  1964. !     char pc;
  1965. !     if ((pc = highc(pl_character[0])) != 0) {
  1966. !         char pbuf[QBUFSZ];
  1967. !         EventRecord update_evt;
  1968. !         if(index(pl_classes, pc) != (char*) 0) {
  1969. !             pl_character[0] = pc;
  1970. !             return;
  1971. !         }
  1972. !         putstr(WIN_MESSAGE, 0, "");
  1973. !         Sprintf(pbuf, "Unknown role: %c", pc);
  1974. !         putstr(WIN_MESSAGE, 0, pbuf);
  1975. !         while (CheckUpdate(&update_evt))
  1976. !             HandleUpdate(&update_evt);
  1977. !     }
  1978. ! 
  1979.       characterDialog = GetNewDialog(132, (Ptr) NULL, (WindowPtr) -1);
  1980.       
  1981.       /*
  1982.  
  1983.