home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1994 November / macformat-018.iso / Utility Spectacular / Developer / macgambit-20-compiler-src-p1 / Runtime (.c & .h) / os_mac_eStyle.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-07-26  |  21.7 KB  |  772 lines  |  [TEXT/KAHL]
  1. /* os_mac_eStyle.c
  2.  * 2Jun92  e
  3.  */
  4.  
  5. #include <Dialogs.h>
  6. #include <Controls.h>
  7. #include <QuickDraw.h>
  8. #include <Windows.h>
  9. #include <ToolUtils.h>
  10. #include <OSUtils.h>
  11. #include <Menus.h>
  12. #include <Fonts.h>
  13. #include <resources.h>
  14.  
  15. #include "os_mac.h"
  16.  
  17. /* extensions to an editor for text files by e
  18.    questions/comments via Internet <e@Flavors.COM>
  19. */
  20. /* Copyright © e 1992. All rights reserved.
  21.     Developed using THINK C 5.0.1 for use with Gambit Scheme.
  22.     This code may be freely distributed as long as this notice remains.
  23. */
  24.  
  25. /* to do:
  26. 06Jun92  e
  27. consider checkbox to modify OK to:
  28. - Set Style for All Windows
  29. consider showing text in style
  30. - (let ((the 3) (quick 5) (brown 7)) (fox jumps over the lazy dog))
  31. - ((lambda (the quick brown) (fox jumps over (the lazy) dog)) 3 5 7)
  32. consider a way to save Window's style in the file
  33. consider a way to save Creation style (preferences)
  34. add a Use Outline Fonts checkbox
  35. */
  36.  
  37. #define MAXFONTSIZE 1023
  38.  
  39. /* resources */
  40.  
  41. #define esdID        357
  42.  
  43. /* dialog items */
  44.  
  45. #define esdOK         1
  46. #define esdCancel     2
  47. #define esdTabsEt     3
  48. #define esdTabsSt     4
  49. #define esdFont1St     5
  50. #define esdFont1Pu     6
  51. #define esdSize1St     7
  52. #define esdSize1Et     8
  53. #define esdBold1Cb     9
  54. #define esdItal1Cb    10
  55. #define esdCond1Cb    11
  56. #define esdUndr1Cb    12
  57. #define esdInvr1Cb    13
  58. #define esdExpd1Cb    14
  59. #define esdFont2St    15
  60. #define esdFont2Pu    16
  61. #define esdSize2St    17
  62. #define esdSize2Et    18
  63. #define esdBold2Cb    19
  64. #define esdItal2Cb    20
  65. #define esdCond2Cb    21
  66. #define esdUndr2Cb    22
  67. #define esdInvr2Cb    23
  68. #define esdExpd2Cb    24
  69. #define esdPS1St    25
  70. #define esdPS2St    26
  71. #define esdSize1Pu    27
  72. #define esdSize2Pu    28
  73. #define esdOutline1    29
  74. #define esdOutline2    30
  75. #define esdOKring    31
  76. #define esdThisBt    32
  77. #define esdPrefBt    33
  78. #define esdDfltBt    34
  79. #define esdGetSt    35
  80. #define esdOutline3    36
  81. #define esdApplSt    37
  82. #define esdThisCb    38
  83. #define esdPrefCb    39
  84. #define esdWrapEt    40
  85. #define esdAutoInd    42
  86.  
  87. /* the pop-up font item */
  88.  
  89. /* See: Apple Macintosh Developer Technical Support
  90.         Pop-up Menu Example Application
  91.         PopMenus.p
  92. */
  93.  
  94. static TextStyle tsNewPri, tsNewAlt;
  95. static short tabsNew;
  96. static short wrapNew;
  97. static short autoIndNew;
  98.  
  99. #define popMenuID1 128
  100. static MenuHandle popMenu1;
  101. static Rect  popUpBox1;        /* boundsrect of font popUp1 */
  102. static Rect  promptBox1;    /* boundsrect of its title */
  103. static short fontChoice1;    /* its last chosen item */
  104.  
  105. #define popMenuID2 129
  106. static MenuHandle popMenu2;
  107. static Rect  popUpBox2;        /* boundsrect of font popUp2 */
  108. static Rect  promptBox2;    /* boundsrect of its title */
  109. static short fontChoice2;    /* its last chosen item */
  110.  
  111. #define popMenuID3 130
  112. static MenuHandle popMenu3;
  113. static Rect  popUpBox3;        /* boundsrect of font popUp2 */
  114. static short sizeChoice3;    /* its last chosen item */
  115.  
  116. #define popMenuID4 131
  117. static MenuHandle popMenu4;
  118. static Rect  popUpBox4;        /* boundsrect of font popUp2 */
  119. static short sizeChoice4;    /* its last chosen item */
  120.  
  121. /* some user item action procs -- used in update events mostly */
  122.  
  123. #define leftSlop 15
  124. #define rightSlop 17
  125. #define botSlop 5
  126.  
  127. static void drawPopArrow( Rect r )
  128. { 
  129.   FrameRect( &r );
  130.   MoveTo( r.right, r.top+2 );
  131.   LineTo( r.right, r.bottom );
  132.   LineTo( r.left+2, r.bottom );
  133.   MoveTo( r.right-17, r.top+6 );
  134.   Line( 11, 0 );
  135.   Move( -10, 1 );
  136.   Line( 9, 0 );
  137.   Move( -8, 1);
  138.   Line( 7, 0 );
  139.   Move( -6, 1);
  140.   Line( 5, 0 );
  141.   Move( -4, 1 );
  142.   Line( 3, 0 );
  143.   Move( -2, 1 );
  144.   Line( 1, 0 );
  145. }
  146.  
  147. static pascal void DrawPopUpSz( DialogPtr dwind, short dinum )
  148. { short itemtype;
  149.   Handle itemhandle;
  150.   Rect r;
  151.   GetDItem( dwind, dinum, &itemtype, &itemhandle, &r );
  152.   InsetRect( &r, -1, -1 );
  153.   drawPopArrow( r );
  154. }
  155.  
  156. static void DrawPopUpX( MenuHandle popMenu, Rect* popUpBox, short lastChoice )
  157. { Rect r;
  158.   Str255 curFont;
  159.   short newWid, newLen, wid;
  160.  
  161.   GetItem( popMenu, lastChoice, curFont ); /* get currently-selected item */
  162.   r = *popUpBox;
  163.   EraseRect( &r );
  164.   InsetRect( &r, -1, -1 );
  165.   /* Make sure the title fits. Truncate it and add an ellipses (“…”) otherwise */
  166.   wid = (r.right - r.left) - (leftSlop + rightSlop);
  167.   newWid = StringWidth( curFont );
  168.   if( newWid > wid )
  169.   { newLen = curFont[0]; /* current length in characters */
  170.     wid = wid - CharWidth('…');
  171.     do
  172.     { newWid = newWid - CharWidth( curFont[newLen--] );
  173.     } while( ( newWid > wid ) && ( newLen > 0 ) );
  174.     curFont[++newLen] = '…';
  175.     curFont[0] = newLen;
  176.   }
  177.   drawPopArrow( r );
  178.   MoveTo( r.left+leftSlop, r.bottom-botSlop);
  179.   DrawString( curFont );
  180. }
  181.  
  182. static pascal void DrawPopUp1( DialogPtr theDialog, short theItem )
  183. { DrawPopUpX( popMenu1, &popUpBox1, fontChoice1 );
  184. }
  185.  
  186. static pascal void DrawPopUp2( DialogPtr theDialog, short theItem )
  187. { DrawPopUpX( popMenu2, &popUpBox2, fontChoice2 );
  188. }
  189.  
  190. /* BorderDefault draws a heavy border around the default ( OK ) button */
  191. static pascal void BorderDefault( WindowPtr dwind, short dinum )
  192. { short itemtype;
  193.   Handle itemhandle;
  194.   Rect borderRect;
  195.   GetDItem( dwind, esdOK, &itemtype, &itemhandle, &borderRect );
  196.   InsetRect( &borderRect, -4, -4 );
  197.   PenSize( 3, 3 );
  198.   FrameRoundRect( &borderRect, 16, 16 );
  199.   PenSize( 1, 1 );
  200. }
  201.  
  202. /* Outliner draws a light border around the the user item */
  203. static pascal void Outliner( WindowPtr dwind, short dinum )
  204. { short itemtype;
  205.   Handle itemhandle;
  206.   Rect borderRect;
  207.   GetDItem( dwind, dinum, &itemtype, &itemhandle, &borderRect );
  208.   /* InsetRect( &borderRect, -4, -4 ); */
  209.   PenSize( 1, 1 );
  210.   FrameRoundRect( &borderRect, 16, 16 );
  211. }
  212.  
  213. /* util fcns. */
  214.  
  215. /* cursor to IBeam if it's over an active edit line, arrow if it's not */
  216. void IBeamIt( WindowPtr dwind )
  217. { Point mouseAt;
  218.   short itemtype;
  219.   Handle itemhandle;
  220.   Rect borderRect;
  221.   short itemNum;
  222.   /* first get the current edit line out of the dialog record */
  223.   itemNum = ((DialogPeek )dwind)->editField + 1; /* always stored 1 less */
  224.   GetDItem( dwind, itemNum, &itemtype, &itemhandle, &borderRect );
  225.   GetMouse( &mouseAt );
  226.   if( PtInRect( mouseAt, &borderRect ) )
  227.     SetCursor(&ibeam_cursor);
  228.   else
  229.     SetCursor(&arrow);
  230. }
  231.  
  232. static void pseudoClick( DialogPtr dbox, short item )
  233. { short itemtype;
  234.   Rect itemrect;
  235.   Handle hC;
  236.   long tilticks;
  237.   GetDItem( dbox, item, &itemtype, &hC, &itemrect );
  238.   HiliteControl( (ControlHandle)hC, inButton );
  239.   Delay( 8, &tilticks );
  240.   HiliteControl( (ControlHandle)hC, false );
  241. }
  242.  
  243. static short apndMenu( MenuHandle hM, Str255 title, short itemno, Boolean check, Boolean realfont )
  244. {
  245.   AppendMenu( hM, title );
  246.   if( realfont ) SetItemStyle( hM, itemno, outline );
  247.   if( check )
  248.   { SetItemMark( hM, itemno, checkMark );
  249.     return itemno;
  250.   }
  251.   return 0;
  252. }
  253.  
  254. static MenuHandle sizeMenu( short id, short *ckitem, short fNum, short curSize )
  255. { MenuHandle hM;
  256.   Str255 oddSize;
  257.   short match = 0;
  258.   hM = NewMenu( id, "" );
  259.   match |= apndMenu( hM,  "\p9", 1, (curSize ==  9), RealFont( fNum,  9 ) );
  260.   match |= apndMenu( hM, "\p10", 2, (curSize == 10), RealFont( fNum, 10 ) );
  261.   match |= apndMenu( hM, "\p12", 3, (curSize == 12), RealFont( fNum, 12 ) );
  262.   match |= apndMenu( hM, "\p14", 4, (curSize == 14), RealFont( fNum, 14 ) );
  263.   match |= apndMenu( hM, "\p18", 5, (curSize == 18), RealFont( fNum, 18 ) );
  264.   match |= apndMenu( hM, "\p24", 6, (curSize == 24), RealFont( fNum, 24 ) );
  265.   if( match == 0 )
  266.   { NumToString( (long )curSize, oddSize );
  267.     InsMenuItem( hM, oddSize, 0 );
  268.     InsMenuItem( hM, "\p(-", 1 );
  269.     SetItemMark( hM, 1, checkMark );
  270.     if( RealFont( fNum, curSize ) ) SetItemStyle( hM, 1, outline );
  271.     *ckitem = 1;
  272.   }
  273.   else *ckitem = match;
  274.   return( hM );
  275. }
  276.  
  277. static short doPop( DialogPtr esd, MenuHandle popMenu, Rect popUpBox, short id, short oldChoice )
  278. { long chosen;
  279.   Point popLoc;
  280.   short newChoice;
  281.   InsertMenu( popMenu, -1 );
  282.   popLoc = topLeft(popUpBox);
  283.   LocalToGlobal( &popLoc );
  284.   CalcMenuSize( popMenu ); /* Work around Menu Mgr bug */
  285.   chosen = PopUpMenuSelect( popMenu, popLoc.v, popLoc.h, oldChoice );
  286.   DeleteMenu( id );
  287.   if( chosen != 0 )
  288.   { newChoice = LoWord(chosen);
  289.     if( newChoice != oldChoice )
  290.     { SetItemMark( popMenu, oldChoice, ' ' );
  291.       SetItemMark( popMenu, newChoice, checkMark );
  292.       EraseRect( &popUpBox );
  293.       return( newChoice );
  294.     }
  295.   }
  296.   return 0;
  297. }
  298.  
  299. /* filter proc */
  300.  
  301. #define kReturnKey 0x0D
  302. #define kEnterKey 0x03
  303. #define kEscKey 0x1B
  304. #define kTabKey 9
  305. enum  {
  306.     kBackSpace = 8,
  307.     kLeftArrow = 0x1C, kRightArrow, kUpArrow, kDownArrow,
  308.     kDeleteKey = 0x7F
  309. };
  310.  
  311. /* size menu selection => edit text box */
  312. static void doSize1( DialogPtr esd )
  313. { Rect tempRect;
  314.   short tempItem;
  315.   Handle tempHandle;
  316.   long tmp;
  317.   Str255 tStr;
  318.   GetDItem( esd, esdSize1Et, &tempItem, &tempHandle, &tempRect );
  319.   GetItem( popMenu3, sizeChoice3, tStr );
  320.   SetIText( tempHandle, tStr );
  321.   SelIText( esd, esdSize1Et, 0, 32767 );
  322.   StringToNum( tStr, &tmp);
  323.   tsNewPri.tsSize = tmp;
  324. }
  325.  
  326. /* size menu selection => edit text box */
  327. static void doSize2( DialogPtr esd )
  328. { Rect tempRect;
  329.   short tempItem;
  330.   Handle tempHandle;
  331.   long tmp;
  332.   Str255 tStr;
  333.   GetDItem( esd, esdSize2Et, &tempItem, &tempHandle, &tempRect );
  334.   GetItem( popMenu4, sizeChoice4, tStr );
  335.   SetIText( tempHandle, tStr );
  336.   SelIText( esd, esdSize2Et, 0, 32767 );
  337.   StringToNum( tStr, &tmp);
  338.   tsNewAlt.tsSize = tmp;
  339. }
  340.  
  341. /* font menu selection triggers update of size menu */
  342. static void doFont1( void )
  343. { Str255 tStr;
  344.   GetItem( popMenu1, fontChoice1, tStr );
  345.   GetFNum( tStr, &tsNewPri.tsFont );
  346.   if( popMenu3 ) DisposHandle( popMenu3 );
  347.   popMenu3 = sizeMenu( popMenuID3, &sizeChoice3, tsNewPri.tsFont, tsNewPri.tsSize );
  348. }
  349.  
  350. /* font menu selection triggers update of size menu */
  351. static void doFont2( void )
  352. { Str255 tStr;
  353.   GetItem( popMenu2, fontChoice2, tStr );
  354.   GetFNum( tStr, &tsNewAlt.tsFont );
  355.   if( popMenu4 ) DisposHandle( popMenu4 );
  356.   popMenu4 = sizeMenu( popMenuID4, &sizeChoice4, tsNewAlt.tsFont, tsNewAlt.tsSize );
  357. }
  358.  
  359. /* this function always returns a value between 1 and MAXFONTSIZE inclusive */
  360. /* an out of range number returns 8;
  361.    this is so font sizes and tab stops are reasonable */
  362. static long etToNum( DialogPtr dbox, short item )
  363. { short tempItem;
  364.   Rect tempRect;
  365.   Handle tempHandle;
  366.   long tmp;
  367.   Str255 tStr;
  368.   GetDItem( dbox, item, &tempItem, &tempHandle, &tempRect );
  369.   GetIText( tempHandle, tStr );
  370.   StringToNum( tStr, &tmp);
  371.   if( tmp > MAXFONTSIZE || tmp < 1 ) tmp = 8;
  372.   return tmp;
  373. }
  374.  
  375. /* update size menu if size edit text box changed */
  376. static void preSize1( DialogPtr esd )
  377. { long tmp;
  378.   tmp = etToNum( esd, esdSize1Et );
  379.   if( tsNewPri.tsSize != tmp )
  380.   { tsNewPri.tsSize = tmp;
  381.     if( popMenu3 ) DisposHandle( popMenu3 );
  382.     popMenu3 = sizeMenu( popMenuID3, &sizeChoice3, tsNewPri.tsFont, tsNewPri.tsSize );
  383.   }
  384. }
  385.  
  386. /* update size menu if size edit text box changed */
  387. static void preSize2( DialogPtr esd )
  388. { long tmp;
  389.   tmp = etToNum( esd, esdSize2Et );
  390.   if( tsNewAlt.tsSize != tmp )
  391.   { tsNewAlt.tsSize = tmp;
  392.     if( popMenu4 ) DisposHandle( popMenu4 );
  393.     popMenu4 = sizeMenu( popMenuID4, &sizeChoice4, tsNewAlt.tsFont, tsNewAlt.tsSize );
  394.   }
  395. }
  396.  
  397. pascal Boolean filterIt( DialogPtr esd, EventRecord *myDialogEvent, short *theDialogItem)
  398. { WindowPtr temp;
  399.   char theKey;
  400.   Rect tempRect;
  401.   short tempItem;
  402.   Handle tempHandle;
  403.   Boolean result = false;
  404.  
  405.   GetPort( &temp );
  406.   SetPort( esd );
  407.     
  408.   IBeamIt( esd ); /* make IBeam cursor when over the active edit line */
  409.     
  410.   /* do standard filtering for escape and return as OK and Cancel aliases */
  411.   /* invert the button in the dialog, so the user get's visual feedback */
  412.  
  413.   if ((myDialogEvent->what == keyDown) || (myDialogEvent->what == autoKey))
  414.   { theKey = myDialogEvent->message & charCodeMask;
  415.     if( (myDialogEvent->modifiers & (cmdKey|controlKey|optionKey)) == 0 )
  416.     { switch( theKey )
  417.       { case kReturnKey:
  418.         case kEnterKey:
  419.             *theDialogItem = esdOK;
  420.             pseudoClick( esd, esdOK );
  421.           SetPort(temp);
  422.           result = true;
  423.           break;
  424.         case kEscKey:
  425.           *theDialogItem = esdCancel;
  426.           pseudoClick( esd, esdCancel );
  427.           SetPort(temp);
  428.           result = true;
  429.           break;
  430.         case kTabKey:
  431.         case kBackSpace:
  432.         case kLeftArrow:
  433.         case kRightArrow:
  434.         case kUpArrow:
  435.         case kDownArrow:
  436.         case kDeleteKey:
  437.             break;
  438.         default:
  439.           /* filter out non-numeric keys */
  440.           if( theKey < 0x30 || theKey > 0x39 )
  441.           { SysBeep( 1 );
  442.             SetPort( temp );
  443.             result = true;
  444.           }
  445.           break;
  446.       }
  447.     }
  448.   }
  449.   else if( myDialogEvent->what == mouseDown )
  450.   { Point mouseLoc;
  451.     short newChoice;
  452.     mouseLoc = ( myDialogEvent->where );
  453.     GlobalToLocal( &mouseLoc );
  454.     switch( newChoice = FindDItem( esd, mouseLoc ) + 1 )
  455.     { case esdFont1St:
  456.       case esdFont1Pu:
  457.         InvertRect( &promptBox1 );
  458.         newChoice = doPop( esd, popMenu1, popUpBox1, popMenuID1, fontChoice1 );
  459.         InvertRect( &promptBox1 );
  460.         if( newChoice != 0 )
  461.         { fontChoice1 = newChoice;
  462.           DrawPopUp1( esd, esdFont1Pu );
  463.           *theDialogItem = esdFont1Pu;
  464.           SetPort( temp );
  465.           result = true;
  466.         }
  467.         break;
  468.       case esdFont2St:
  469.       case esdFont2Pu:
  470.         InvertRect( &promptBox2 );
  471.         newChoice = doPop( esd, popMenu2, popUpBox2, popMenuID2, fontChoice2 );
  472.         InvertRect( &promptBox2 );
  473.         if( newChoice != 0 )
  474.         { fontChoice2 = newChoice;
  475.           DrawPopUp2( esd, esdFont2Pu );
  476.           *theDialogItem = esdFont2Pu;
  477.           SetPort( temp );
  478.           result = true;
  479.         }
  480.         break;
  481.       /* case esdSize2St:  not for size menu!? */
  482.       case esdSize1Pu:
  483.           SelIText( esd, esdSize1Et, 0, 32767 );
  484.           preSize1( esd );
  485.         newChoice = doPop( esd, popMenu3, popUpBox3, popMenuID3, sizeChoice3 );
  486.         if( newChoice != 0 )
  487.         { sizeChoice3 = newChoice;
  488.           DrawPopUpSz( esd, esdSize1Pu );
  489.           *theDialogItem = esdSize1Pu;
  490.           SetPort( temp );
  491.           result = true;
  492.         }
  493.         break;
  494.       /* case esdSize2St:  not for size menu!? */
  495.       case esdSize2Pu:
  496.           SelIText( esd, esdSize2Et, 0, 32767 );
  497.           preSize2( esd );
  498.         newChoice = doPop( esd, popMenu4, popUpBox4, popMenuID4, sizeChoice4 );
  499.         if( newChoice != 0 )
  500.         { sizeChoice4 = newChoice;
  501.           DrawPopUpSz( esd, esdSize2Pu );
  502.           *theDialogItem = esdSize2Pu;
  503.           SetPort( temp );
  504.           result = true;
  505.         }
  506.         break;
  507.     }
  508.   }
  509.   return( result );
  510. }
  511.  
  512. static void check( DialogPtr dbox, short item, Boolean mark )
  513. { ControlHandle hC;
  514.   short itemtype;
  515.   Rect itemrect;    
  516.   GetDItem( dbox, item, &itemtype, (Handle)&hC, &itemrect);
  517.   SetCtlValue( hC, mark );
  518. }
  519.  
  520. static void checks( DialogPtr dbox, short style, short offs )
  521. {
  522.   check( dbox, esdBold1Cb + offs, ( style & bold ) ? 1 : 0 );
  523.   check( dbox, esdItal1Cb + offs, ( style & italic ) ? 1 : 0 );
  524.   check( dbox, esdUndr1Cb + offs, ( style & underline ) ? 1 : 0 );
  525.   check( dbox, esdCond1Cb + offs, ( style & condense ) ? 1 : 0 );
  526.   check( dbox, esdExpd1Cb + offs, ( style & extend ) ? 1 : 0 );
  527.   /*
  528.   check( dbox, esdInvr1Cb + offs, ( style & bold ) ? 1 : 0 );
  529.   */
  530. }
  531.  
  532. short checklist[] = { bold, italic, condense, underline, 0x80, extend };
  533.  
  534. static short findFontItem( MenuHandle hM, short fontNum )
  535. { short result = 1;
  536.   short i, fn;
  537.   Str255 tStr;
  538.   for( i = CountMItems( hM ); i > 0; i-- )
  539.   { GetItem( hM, i, tStr );
  540.     GetFNum( tStr, &fn );
  541.     if( fn == fontNum ) return i;
  542.     if( fn == 0 ) result = i;
  543.   }
  544.   return result;
  545. }
  546.  
  547. /* get the item's rect & set the procPtr */
  548. static void initUserItem( DialogPtr esd, short item, Rect *pRect, ProcPtr pProc )
  549. { short tempItem;
  550.   Handle tempHandle;
  551.   GetDItem( esd, item, &tempItem, &tempHandle, pRect );
  552.   SetDItem( esd, item, tempItem, (Handle)pProc, pRect );
  553. }
  554.  
  555. static void hosePops( void )
  556. {
  557.   if( popMenu1 ) DisposHandle( popMenu1 );
  558.   popMenu1 = 0;
  559.   if( popMenu2 ) DisposHandle( popMenu2 );
  560.   popMenu2 = 0;
  561.   if( popMenu3 ) DisposHandle( popMenu3 );
  562.   popMenu3 = 0;
  563.   if( popMenu4 ) DisposHandle( popMenu4 );
  564.   popMenu4 = 0;
  565. }
  566.  
  567. static void initPops( DialogPtr esd )
  568. { Str255 tStr;
  569.   short tempItem;
  570.   Rect tempRect;
  571.   Handle tempHandle;
  572.  
  573.   hosePops();
  574.   
  575.   SetPort( esd );
  576.   
  577.   popMenu1 = NewMenu( popMenuID1, "" );
  578.   AddResMenu( popMenu1, 'FONT' );
  579.   fontChoice1 = findFontItem( popMenu1, tsNewPri.tsFont );
  580.   SetItemMark( popMenu1, fontChoice1, checkMark );
  581.   InvalRect( &popUpBox1 );
  582.     
  583.   popMenu2 = NewMenu( popMenuID2, "" );
  584.   AddResMenu( popMenu2, 'FONT' );
  585.   fontChoice2 = findFontItem( popMenu2, tsNewAlt.tsFont );
  586.   SetItemMark( popMenu2, fontChoice2, checkMark );
  587.   InvalRect( &popUpBox2 );
  588.   
  589.   popMenu3 = sizeMenu( popMenuID3, &sizeChoice3, tsNewPri.tsFont, tsNewPri.tsSize );
  590.   doSize1( esd );
  591.  
  592.   popMenu4 = sizeMenu( popMenuID4, &sizeChoice4, tsNewAlt.tsFont, tsNewAlt.tsSize );
  593.   doSize2( esd );
  594.   
  595.   checks( esd, tsNewPri.tsFace,  0 );
  596.   checks( esd, tsNewAlt.tsFace, 10 );
  597.   
  598.   NumToString( (long )tabsNew, tStr );
  599.   GetDItem( esd, esdTabsEt, &tempItem, &tempHandle, &tempRect );
  600.   SetIText( tempHandle, tStr );
  601.   SelIText( esd, esdTabsEt, 0, 32767 );
  602.   
  603.   NumToString( (long )wrapNew, tStr );
  604.   GetDItem( esd, esdWrapEt, &tempItem, &tempHandle, &tempRect );
  605.   SetIText( tempHandle, tStr );
  606.   SelIText( esd, esdWrapEt, 0, 32767 );
  607.  
  608.   check( esd, esdAutoInd, autoIndNew );
  609. }  
  610.  
  611. void eStyleDlg( eRec **hE /* , TextStyle *pri, TextStyle *alt */ )
  612. { DialogPtr esd = NULL;
  613.   short hitItem = 0;
  614.   short tempItem;
  615.   Rect tempRect;
  616.   Handle tempHandle;
  617.   Boolean tBool;
  618.   long tmp1, tmp2, tmp3;
  619.   
  620.   tsNewPri = (**hE).style[0];
  621.   tsNewAlt = (**hE).style[1];
  622.   tabsNew = (**hE).tabStops;
  623.   wrapNew = (**hE).wrap;
  624.   autoIndNew = (**hE).autoInd;
  625.  
  626.   /* Get a dialog box, and set up our useritems */
  627.   esd = GetNewDialog( esdID, NULL, (WindowPtr)(-1) );
  628.         
  629.   /* Find out where our useritems are, and set their item handles to be
  630.      a pointer to our popup-drawing or other special procedure */
  631.   GetDItem( esd, esdFont1St, &tempItem, &tempHandle, &promptBox1 ); /* get the title rect */
  632.   initUserItem( esd, esdFont1Pu, &popUpBox1, DrawPopUp1 );
  633.   GetDItem( esd, esdFont2St, &tempItem, &tempHandle, &promptBox2 ); /* get the title rect */
  634.   initUserItem( esd, esdFont2Pu, &popUpBox2, DrawPopUp2 );
  635.   initUserItem( esd, esdSize1Pu, &popUpBox3, DrawPopUpSz );
  636.   initUserItem( esd, esdSize2Pu, &popUpBox4, DrawPopUpSz );
  637.   initUserItem( esd, esdOutline1, &tempRect, Outliner );
  638.   initUserItem( esd, esdOutline2, &tempRect, Outliner );
  639.   initUserItem( esd, esdOutline3, &tempRect, Outliner );
  640.  
  641.   GetDItem( esd, esdOK,&tempItem, &tempHandle, &tempRect ); /* get the OK button's rect */
  642.   InsetRect( &tempRect, -4, -4);
  643.   SetDItem( esd, esdOKring, userItem+itemDisable, (Handle)BorderDefault, &tempRect);
  644.  
  645.   /* Get two menus containing the current set of fonts */
  646.   /* and two menus containing their corresponding sizes */
  647.   initPops( esd );
  648.   
  649.   check( esd, esdThisCb, 1 );
  650.   check( esd, esdPrefCb, 0 );    /* defaulted to off  --  16Jul92  e  */
  651.     
  652.   ShowWindow( (WindowPtr)esd );
  653.   DrawDialog( esd );
  654.   do
  655.   { ModalDialog( (ModalFilterProcPtr)filterIt, &hitItem );
  656.     switch ( hitItem )
  657.     { case esdFont1Pu:
  658.         doFont1( );
  659.         break;
  660.       case esdFont2Pu:
  661.         doFont2( );
  662.         break;
  663.       case esdSize1Pu:
  664.           doSize1( esd );
  665.         break;
  666.       case esdSize2Pu:
  667.           doSize2( esd );
  668.         break;
  669.       case esdBold1Cb:
  670.       case esdItal1Cb:
  671.       case esdCond1Cb:
  672.       case esdUndr1Cb:
  673.       case esdInvr1Cb:
  674.       case esdExpd1Cb:
  675.         GetDItem( esd, hitItem, &tempItem, &tempHandle, &tempRect);
  676.         tempItem = GetCtlValue( (ControlHandle )tempHandle ) ^ 1;
  677.         if( tempItem == 0 )
  678.           tsNewPri.tsFace &= ~checklist[hitItem-esdBold1Cb];
  679.         else
  680.           tsNewPri.tsFace |=  checklist[hitItem-esdBold1Cb];
  681.         SetCtlValue( (ControlHandle )tempHandle, tempItem);
  682.         break;
  683.       case esdBold2Cb:
  684.       case esdItal2Cb:
  685.       case esdCond2Cb:
  686.       case esdUndr2Cb:
  687.       case esdInvr2Cb:
  688.       case esdExpd2Cb:
  689.         GetDItem( esd, hitItem, &tempItem, &tempHandle, &tempRect);
  690.         tempItem = GetCtlValue( (ControlHandle )tempHandle ) ^ 1;
  691.         if( tempItem == 0 )
  692.           tsNewAlt.tsFace &= ~checklist[hitItem-esdBold2Cb];
  693.         else
  694.           tsNewAlt.tsFace |=  checklist[hitItem-esdBold2Cb];
  695.         SetCtlValue( (ControlHandle )tempHandle, tempItem);
  696.         break;
  697.       case esdThisCb:
  698.       case esdPrefCb:
  699.       case esdAutoInd:
  700.         GetDItem( esd, hitItem, &tempItem, &tempHandle, &tempRect);
  701.         tempItem = GetCtlValue( (ControlHandle )tempHandle ) ^ 1;
  702.         SetCtlValue( (ControlHandle )tempHandle, tempItem);
  703.         break;
  704.       case esdThisBt:
  705.         tsNewPri   = (**hE).style[0];
  706.         tsNewAlt   = (**hE).style[1];
  707.         tabsNew    = (**hE).tabStops;
  708.         wrapNew    = (**hE).wrap;
  709.         autoIndNew = (**hE).autoInd;
  710.         initPops( esd );
  711.         break;
  712.       case esdPrefBt:
  713.         tsNewPri   = prefStylNormal;
  714.         tsNewAlt   = prefStylHilite;
  715.         tabsNew    = prefTabs;
  716.         wrapNew    = prefWrap;
  717.         autoIndNew = prefAutoInd;
  718.         initPops( esd );
  719.         break;
  720.       case esdDfltBt:
  721.         tsNewPri   = dfltStylNormal;
  722.         tsNewAlt   = dfltStylHilite;
  723.         tabsNew    = dfltTabs;
  724.         wrapNew    = dfltWrap;
  725.         autoIndNew = dfltAutoInd;
  726.         initPops( esd );
  727.         break;
  728.     }
  729.   } while ( hitItem != esdOK && hitItem != esdCancel );
  730.   
  731.   if( hitItem == esdOK )
  732.   { tsNewPri.tsSize = etToNum( esd, esdSize1Et );
  733.     tsNewAlt.tsSize = etToNum( esd, esdSize2Et );
  734.     tmp1 = etToNum( esd, esdTabsEt );
  735.     tmp2 = etToNum( esd, esdWrapEt );
  736.     GetDItem( esd, esdAutoInd, &tempItem, &tempHandle, &tempRect);
  737.     tmp3 = GetCtlValue( (ControlHandle )tempHandle );
  738.     GetDItem( esd, esdThisCb, &tempItem, &tempHandle, &tempRect);
  739.     if( GetCtlValue( (ControlHandle )tempHandle ) )
  740.     { if( (**hE).tabStops != tmp1 )
  741.       { eTeSetTabStop( hE, (short )tmp1 );
  742.       }
  743.       if( (**hE).wrap != tmp2 )
  744.       { eTeSetWrap( hE, (short )tmp2 );
  745.       }
  746.       (**hE).autoInd = tmp3;
  747.       if(    tsNewPri.tsFont != (**hE).style[0].tsFont
  748.           || tsNewPri.tsSize != (**hE).style[0].tsSize
  749.           || tsNewPri.tsFace != (**hE).style[0].tsFace
  750.           || tsNewAlt.tsFont != (**hE).style[1].tsFont
  751.           || tsNewAlt.tsSize != (**hE).style[1].tsSize
  752.           || tsNewAlt.tsFace != (**hE).style[1].tsFace
  753.         )
  754.       { eTeSetStyles( hE, &tsNewPri, &tsNewAlt );
  755.       }
  756.     }
  757.     GetDItem( esd, esdPrefCb, &tempItem, &tempHandle, &tempRect);
  758.     if( GetCtlValue( (ControlHandle )tempHandle ) )
  759.     { prefStylNormal = tsNewPri;
  760.       prefStylHilite = tsNewAlt;
  761.       prefTabs    = (short )tmp1;
  762.       prefWrap    = (short )tmp2;
  763.       prefAutoInd = (short )tmp3;
  764.       savePrefs( PREFS_FILENAME );  /*  16Jul92  e  */
  765.     }
  766.   }
  767.   hosePops();
  768.   if( esd ) DisposDialog( esd );
  769. }
  770.  
  771. /* end of os_mac_eStyle.c */
  772.