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