home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 April: Mac OS SDK / Dev.CD Apr 96 SDK / Dev.CD Apr 96 SDK1.toast / Development Kits (Disc 1) / AppleScript / Development Tools / Sample Code / MenuScripter / Sources / MSUtils.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-02-25  |  16.2 KB  |  609 lines  |  [TEXT/MPS ]
  1. /*
  2.     MSUtils.c
  3.     
  4.     Version 1.0d6
  5.     
  6.     Copyright © SRL Data 1992, 1993
  7.     
  8.     All rights reserved.
  9.     
  10.     Produced by : SRL Data
  11.     Originally Developed for UK.DTS
  12. */
  13.  
  14.  
  15. #include <PLStringFuncs.h>
  16. #include <Events.h>
  17. #include <Traps.h>
  18. #include <Dialogs.h>
  19. #include <Fonts.h>
  20. #include <Packages.h>
  21. #include <AppleEvents.h>
  22. #include <TextUtils.h>
  23. #include "MSUtils.h"
  24.  
  25. /**-----------------------------------------------------------------------
  26.         Name:             LesserOf
  27.         Purpose:        Returns the Lesser of two longints.
  28.     -----------------------------------------------------------------------**/
  29. #pragma segment Utils
  30.         
  31. pascal long LesserOf(long A, long B)
  32.  {
  33.    if (A<B)
  34.        return(A);
  35.      else
  36.        return(B);
  37.  }   /*LesserOf*/
  38.             
  39. /**-----------------------------------------------------------------------
  40.         Name:             GreaterOf
  41.         Purpose:        Returns the Greater of two longints.
  42.     -----------------------------------------------------------------------**/
  43.     
  44. #pragma segment Utils
  45.         
  46. pascal long GreaterOf(long A, long B)
  47.  {
  48.    if (A>B)
  49.        return(A);
  50.      else
  51.        return(B);
  52.  }  /*GreaterOf*/
  53.             
  54. /**-----------------------------------------------------------------------
  55.         Name:             ShowError
  56.         Purpose:        Reports an error to the user as both string and number.
  57.     -----------------------------------------------------------------------**/
  58. #pragma segment Utils
  59.         
  60. pascal void ShowError(Str255  theError,
  61.                                           long    theErrorCode)
  62. {
  63.    short     alertResult;
  64.    Str255    theString;
  65.      OSErr     myErr;
  66.      
  67.      myErr = AEInteractWithUser(kAEDefaultTimeout, nil,nil);
  68.      
  69.      if (myErr == noErr)
  70.        {
  71.              SetCursor(&qd.arrow);
  72.              NumToString(theErrorCode, theString);
  73.              ParamText(theError, theString, (unsigned char *)"", (unsigned char *)"");
  74.              alertResult = Alert(300, nil);
  75.          }
  76. } /* ShowError */
  77.  
  78. /**-----------------------------------------------------------------------
  79.         Name:             Ours
  80.         Purpose:        Checks the frontmost window belongs to the app.
  81.     -----------------------------------------------------------------------**/
  82. #pragma segment Utils        
  83.     
  84. pascal Boolean Ours(WindowPtr aWindow)
  85.  {
  86.         if (aWindow)
  87.             if (((WindowPeek)aWindow)->windowKind == zoomDocProc)
  88.                 return(true);
  89.         return(false);
  90. } /* Ours */
  91.  
  92. /**-----------------------------------------------------------------------
  93.         Name:             SetShortMenus
  94.         Purpose:        Cuts the menus down to a minimum - Apple File Edit.
  95.                                 Greys out the unavailable options - used when no docs open
  96.     -----------------------------------------------------------------------**/
  97. #pragma segment Utils        
  98.  
  99. pascal void SetShortMenus()
  100. { 
  101.     DeleteMenu(mfontID);
  102.     DeleteMenu(sizeID);
  103.     DeleteMenu(styleID);
  104.     DeleteMenu(mscriptID);
  105.  
  106.     DisableItem(myMenus[fileM], fmClose);
  107.     DisableItem(myMenus[fileM], fmSave);
  108.     DisableItem(myMenus[fileM], fmSaveAs);
  109.     DisableItem(myMenus[fileM], fmRevert);
  110.     DisableItem(myMenus[fileM], fmPrint);
  111.     DisableItem(myMenus[fileM], fmPageSetUp);
  112.  
  113.     /* now the unnecessary items on the edit menu */
  114.                 
  115.     DisableItem(myMenus[editM], undoCommand);
  116.     DisableItem(myMenus[editM], cutCommand);
  117.     DisableItem(myMenus[editM], copyCommand);
  118.     DisableItem(myMenus[editM], clearCommand);
  119.     DisableItem(myMenus[editM], pasteCommand);
  120.     DisableItem(myMenus[editM], selectAllCommand);
  121.  
  122.     DrawMenuBar();
  123. }  /* SetShortMenus */
  124.  
  125. /**-----------------------------------------------------------------------
  126.         Name:             SetLongMenus
  127.         Purpose:        Reinstates the full menu bar - called when first document
  128.                     opened.
  129.     -----------------------------------------------------------------------**/
  130. #pragma segment Utils        
  131.  
  132. pascal void SetLongMenus()
  133.   {
  134.         InsertMenu(myMenus[fontM], 0);
  135.         InsertMenu(myMenus[sizeM], 0);
  136.         InsertMenu(myMenus[styleM], 0);
  137.         InsertMenu(myMenus[scriptM], 0);
  138.  
  139.         EnableItem(myMenus[fileM], fmClose);
  140.         EnableItem(myMenus[fileM], fmSave);
  141.         EnableItem(myMenus[fileM], fmSaveAs);
  142.         EnableItem(myMenus[fileM], fmRevert);
  143.         EnableItem(myMenus[fileM], fmPrint);
  144.         EnableItem(myMenus[fileM], fmPageSetUp);
  145.  
  146.         /* now the necessary items on the edit menu -
  147.             many other items fixed on each pass thru the main event
  148.             loop or before the window pulled down
  149.         */
  150.         
  151.         EnableItem(myMenus[editM], selectAllCommand);
  152.  
  153.         DrawMenuBar();
  154.     }  /* SetLongMenus */
  155.  
  156. /**-----------------------------------------------------------------------
  157.         Name:             SetStyleMenu
  158.         Purpose:        Sets the style menu checking to reflect the style of the
  159.                     first character of the current selection in the given
  160.                                 document.
  161.     -----------------------------------------------------------------------**/
  162. #pragma segment Utils        
  163.         
  164. pascal void SetStyleMenu(DPtr theDoc)
  165.   {
  166.     TextStyle        theTStyle;
  167.         short       contMode;
  168.         short       i;
  169.         
  170.         contMode = doFace;
  171.         
  172.         TEContinuousStyle(&contMode,&theTStyle,theDoc->theText);
  173.         
  174.         if ((contMode & doFace) != 0)
  175.             {
  176.                 CheckItem(myMenus[styleM], cPlain,     (theTStyle.tsFace == 0));
  177.                 CheckItem(myMenus[styleM], cBold,      (bold      & theTStyle.tsFace));
  178.                 CheckItem(myMenus[styleM], cItalic,    (italic    & theTStyle.tsFace));
  179.                 CheckItem(myMenus[styleM], cUnderline, (underline & theTStyle.tsFace));
  180.                 CheckItem(myMenus[styleM], cOutline,   (outline   & theTStyle.tsFace));
  181.                 CheckItem(myMenus[styleM], cShadow,    (shadow    & theTStyle.tsFace));
  182.                 CheckItem(myMenus[styleM], cCondense,  (condense  & theTStyle.tsFace));
  183.                 CheckItem(myMenus[styleM], cExtend,    (extend    & theTStyle.tsFace));
  184.           }
  185.         else
  186.             for (i=cPlain; i<= cExtend; i++)
  187.                 CheckItem(myMenus[styleM], i,     false);
  188.   }
  189.  
  190. /**-----------------------------------------------------------------------
  191.     Name:       SetSizeMenu
  192.     Purpose:    Outline all the items if the current font is an
  193.                 outline font. Check the size of the current selection
  194.   -----------------------------------------------------------------------**/
  195. #pragma segment Utils        
  196.  
  197. pascal void SetSizeMenu(DPtr theDoc)
  198.   {
  199.       short             i;
  200.         short                aSize;
  201.         short                max;
  202.     long                 theSize;
  203.     Str255        name;
  204.     Boolean       sizeinMenu;
  205.     Boolean       oldState;
  206.     Point         numer;
  207.     TextStyle        theStyle;
  208.         TEHandle    myText;
  209.         short       contMode;
  210.       
  211.     numer.h = 1;
  212.     numer.v = 1;
  213.  
  214.     myText = theDoc->theText;
  215.         
  216.         contMode = doSize+doFont;
  217.         
  218.         TEContinuousStyle(&contMode,&theStyle,theDoc->theText);
  219.         
  220.     sizeinMenu = false;
  221.     max = CountMItems(myMenus[sizeM]);
  222.         for (i = 1; i <= max - 5; i++)
  223.       {
  224.                 GetItem(myMenus[sizeM], i, (unsigned char *)&name);
  225.                 StringToNum(name, &theSize);
  226.                 aSize = (short)theSize;
  227.  
  228.                 if (RealFont(theStyle.tsFont, aSize) && (contMode & doFont) != 0) // there is only one font and this size exists
  229.                     SetItemStyle(myMenus[sizeM], i, outline);
  230.                 else
  231.                     SetItemStyle(myMenus[sizeM], i, 0);
  232.  
  233.                 if ((aSize == theStyle.tsSize) && (contMode & doSize) != 0)
  234.                     {
  235.                         sizeinMenu = true;
  236.                         CheckItem(myMenus[sizeM], i, true);
  237.                     }
  238.                 else
  239.                     CheckItem(myMenus[sizeM], i, false);
  240.             }
  241.         
  242.             /*
  243.                 if it's not a size in the menu,and there is only one size in the
  244.               selection range check the other item
  245.             */
  246.             
  247.             if (!sizeinMenu && (contMode & doSize) != 0)
  248.               CheckItem(myMenus[sizeM], max, true);
  249.             else
  250.                 CheckItem(myMenus[sizeM], max, false);
  251.  
  252.             /*if this is an outline font, set the rest of the items to outline style*/
  253.             /*RealFont will ensure that the sizes are outlined*/
  254.  
  255.             oldState = GetOutlinePreferred();
  256.             SetOutlinePreferred(true);
  257.             for (i = max-4; i <= max; i++)
  258.                 {
  259.                     if (IsOutline(numer, numer) && (contMode & doFont)!= 0)
  260.                         SetItemStyle(myMenus[sizeM], i, outline);
  261.                     else
  262.                         SetItemStyle(myMenus[sizeM], i, 0);
  263.                 }
  264.                 
  265.             SetOutlinePreferred(oldState);
  266.     }
  267.  
  268. /**-----------------------------------------------------------------------
  269.     Name:       SetEditMenu
  270.     Purpose:    Set the text of the edit menu according to the state of
  271.                                 current document.
  272.   -----------------------------------------------------------------------**/
  273.  
  274. #pragma segment Utils
  275.  
  276. pascal void SetEditMenu(DPtr theDoc)
  277.     {
  278.         if (theDoc->showBorders)
  279.             SetItem(myMenus[editM], cBorders, (unsigned char *)"\pHide Borders");
  280.         else
  281.             SetItem(myMenus[editM], cBorders, (unsigned char *)"\pShow Borders");
  282.     }  /* SetEditMenu */
  283.             
  284. /**-----------------------------------------------------------------------
  285.     Name:       SetFontMenu
  286.     Purpose:    Set the font menu according to the state of
  287.                                 current selection of the supplied document.
  288.   -----------------------------------------------------------------------**/
  289. #pragma segment Utils
  290.         
  291. pascal void SetFontMenu(DPtr theDoc)
  292.   {
  293.     MenuHandle        theMHandle;
  294.     short         theNumber;
  295.     short         i;
  296.     short                max;
  297.     Str255        name;
  298.     TextStyle     theStyle;
  299.         short         contMode;
  300.  
  301.         theMHandle = GetMHandle(mfontID);
  302.  
  303.         if (gFontMItem)
  304.       CheckItem(theMHandle, gFontMItem, false);
  305.             
  306.         max = CountMItems(theMHandle);
  307.  
  308.         contMode = doFont;
  309.         TEContinuousStyle(&contMode,&theStyle,theDoc->theText);
  310.  
  311.         gFontMItem = 0;
  312.         
  313.     if (contMode & doFont)
  314.             for (i=1; i<=max; i++)
  315.                 {
  316.                     GetItem(theMHandle, i, (unsigned char *)&name);
  317.                     GetFNum(name, &theNumber);
  318.                     if (theNumber == theStyle.tsFont)
  319.                         gFontMItem = i;
  320.                 }
  321.  
  322.     if (gFontMItem)
  323.       CheckItem(theMHandle, gFontMItem, true);
  324.             
  325.         SetSizeMenu(theDoc);
  326.         SetStyleMenu(theDoc);
  327.     }
  328.  
  329. /**-----------------------------------------------------------------------
  330.     Name:       GetTempFileName
  331.     Purpose:    Fills newstring with a temporary file name.
  332.   -----------------------------------------------------------------------**/
  333.  
  334. #pragma segment Utils
  335.  
  336. pascal void GetTempFileName(DPtr aDoc,
  337.                             Str255 newString)
  338.  
  339.     {
  340.        Str255        s;
  341.      Str255        fileName;
  342.  
  343.         if (aDoc->everSaved == false)
  344.           PLstrcpy(fileName, (unsigned char *)"\pTEXTra");
  345.         else
  346.             PLstrcpy(fileName, aDoc->theFileName);
  347.  
  348.     /*generate a unique(ish) temporary filename*/
  349.         
  350.         if (fileName[0] > 21)
  351.           fileName[0] = 21;
  352.                 
  353.         NumToString(TickCount(), s);
  354.         
  355.         PLstrcat(fileName, s);
  356.         
  357.         PLstrcpy(newString,fileName);
  358.     }
  359.  
  360. /**-----------------------------------------------------------------------
  361.     Name:       SetText
  362.     Purpose:    Sets the text of the supplied itemNo in aDialog to 
  363.                                 theString and select it.
  364.   -----------------------------------------------------------------------**/
  365.  
  366. #pragma segment Utils
  367.  
  368. pascal void SetText(DialogPtr aDialog,
  369.                     short     itemNo,
  370.                     Str255    theString)
  371.   {
  372.     Handle      itemHandle;
  373.     Rect        box;
  374.     short       kind;
  375.     TEHandle    theTEHandle;
  376.  
  377.         GetDItem(aDialog, itemNo, &kind, &itemHandle, &box);
  378.         SetIText(itemHandle, theString);
  379.         
  380.         theTEHandle = ((DialogPeek)aDialog)->textH;
  381.  
  382.         /*set all the text to be selected*/
  383.         if (theTEHandle)
  384.             TESetSelect(0, 255, theTEHandle);
  385.     }
  386.             
  387. /**-----------------------------------------------------------------------
  388.     Name:       RetrieveText
  389.     Purpose:    Returns the text of anItem in aDialog in aString.
  390.   -----------------------------------------------------------------------**/
  391.  
  392. #pragma segment Utils
  393.  
  394. pascal void RetrieveText(DialogPtr aDialog,
  395.                                                short     anItem,
  396.                                                Str255    aString)
  397.   {
  398.      short      kind;
  399.      Rect       box;
  400.      Handle     itemHandle;
  401.  
  402.          GetDItem(aDialog, anItem, &kind, &itemHandle, &box);
  403.          GetIText(itemHandle, aString);
  404.   }
  405.  
  406. /**-----------------------------------------------------------------------
  407.     Name:       DrawDefaultOutline
  408.     Purpose:    Draws an outline around theItem.
  409.                                 Called as a useritem Proc by the dialog manager.
  410.                                 To use place a useritem over the default item in the
  411.                                 dialog and install the address of this proc as the item
  412.                                 handle.
  413.   -----------------------------------------------------------------------**/
  414.  
  415. #pragma segment Utils
  416.  
  417. pascal void DrawDefaultOutline(DialogPtr theDialog, short theItem)
  418.   {
  419.       short       kind;
  420.     Handle      itemHandle;
  421.     Rect        box;
  422.                 
  423.     GetDItem(theDialog, theItem, &kind, &itemHandle, &box);
  424.     PenSize(3, 3);
  425.     InsetRect(&box, - 4, - 4);
  426.     FrameRoundRect(&box, 16, 16);
  427.     PenNormal();
  428.         
  429.     }  /* DrawDefaultOutline */
  430.             
  431. /**-----------------------------------------------------------------------
  432.     Name:       AdornDefaultButton
  433.     Purpose:    Installs DrawDefaultOutline as the useritem proc
  434.                     for the given item.
  435.   -----------------------------------------------------------------------**/
  436.  
  437. #pragma segment Utils
  438.         
  439. pascal void AdornDefaultButton(DialogPtr theDialog,short theItem)
  440.   {
  441.       short       kind;
  442.     Handle      itemHandle;
  443.     Rect        box;
  444.  
  445.         GetDItem(theDialog, theItem, &kind, &itemHandle, &box);
  446.         SetDItem(theDialog, theItem, kind, (Handle)&DrawDefaultOutline, &box);
  447.   }
  448.  
  449.     /*-------  Determining of Gestalt is available ---------------*/
  450.     /*The following routines come from the Inside Mac VI recommendations*/
  451.     /*about how to find if a trap is available*/
  452.          /*
  453.             The glue for Gestalt will be in MPW 3.2, so if it is available we will also
  454.              need to check the system version
  455.         */
  456.  
  457. pascal void GetRectOfDialogItem(DialogPtr theDialog, short theItem, Rect *theRect)
  458.     {
  459.       short       kind;
  460.     Handle      itemHandle;
  461.         
  462.         GetDItem(theDialog, theItem, &kind, &itemHandle, theRect);
  463.     }
  464.  
  465. #pragma segment Utils
  466.  
  467. pascal short NumToolboxTraps()
  468.   {
  469.         if (NGetTrapAddress(_InitGraf, ToolTrap) == NGetTrapAddress(0xAA6E, ToolTrap))
  470.             return(0x200);
  471.         else
  472.             return(0x400);
  473.     }
  474.  
  475. #pragma segment Utils
  476.  
  477. #define TrapMask  0x0800
  478.  
  479. pascal TrapType GetTrapType(short theTrap)
  480.   {
  481.         if ((theTrap & TrapMask) > 0)
  482.             return(ToolTrap);
  483.         else
  484.             return(OSTrap);
  485.     }
  486.  
  487. #pragma segment Utils
  488.  
  489. pascal Boolean TrapAvailable(short theTrap)
  490.   {
  491.         TrapType  tType;
  492.  
  493.         tType = GetTrapType(theTrap);
  494.         if (tType == ToolTrap)
  495.             {
  496.                 theTrap = theTrap & 0x07FF;
  497.                 if (theTrap >= NumToolboxTraps())
  498.                     theTrap = _Unimplemented;
  499.             }
  500.         return(NGetTrapAddress(theTrap, tType) != NGetTrapAddress(_Unimplemented,ToolTrap));
  501.     }
  502.  
  503. #pragma segment Utils
  504.  
  505. #define _Gestalt 0xA1AD
  506.  
  507. pascal Boolean GestaltAvailable()
  508.   {
  509.         return(TrapAvailable(_Gestalt));
  510.     }
  511.  
  512. /**------  FeatureIsImplemented    ------------**/
  513. /*This is called to use Gestalt to determine if a feature is implemented.
  514.  This applies to only those referenced by OSType*/
  515.  
  516. #pragma segment Utils
  517.  
  518. pascal Boolean FeatureIsImplemented(OSType  theFeature,
  519.                                                           short   theTestBit)
  520.   {
  521.     OSErr     err;
  522.     long      result;
  523.  
  524.         err = Gestalt(theFeature, &result);
  525.         if (err == noErr)
  526.             if ((result & theTestBit) == theTestBit)
  527.                 return(true);
  528.                 
  529.       return(false);
  530.     }
  531.  
  532. #pragma segment Utils
  533.  
  534. pascal Boolean CheckEnvironment()
  535.   {
  536.         /*
  537.          first determine of Gestalt is available- if it isn't exit
  538.          as we only run under 7.0.  It could it present in 6.04 - so we need
  539.          to do some further checks for important features
  540.         */
  541.  
  542.         gGestaltAvailable = GestaltAvailable();
  543.         
  544.         if (!gGestaltAvailable)
  545.             return(false);
  546.  
  547.     /*first check if the Edition Manager is present*/
  548.                 
  549.     gEditionManagerImplemented = FeatureIsImplemented(gestaltEditionMgrAttr,
  550.                                                                                                           gestaltEditionMgrPresent);
  551.  
  552.         /*and for good measure- the Alias manager*/
  553.                 
  554.         gAliasManagerImplemented  = FeatureIsImplemented(gestaltAliasMgrAttr,
  555.                                                                                                          gestaltAliasMgrPresent);
  556.             
  557.         /*check for the AppleEvents manager - we certainly can't work without it*/
  558.         
  559.         gAppleEventsImplemented   = FeatureIsImplemented(gestaltAppleEventsAttr,
  560.                                                                                                          gestaltAppleEventsPresent);
  561.             
  562.         /*check for the Outline fonts*/
  563.         
  564.         gOutlineFontsImplemented  = FeatureIsImplemented(gestaltFontMgrAttr,
  565.                                                                                                          gestaltOutlineFonts);
  566.         
  567.         return (gEditionManagerImplemented &&
  568.                         gAliasManagerImplemented   &&
  569.                         gAppleEventsImplemented    &&
  570.                         gOutlineFontsImplemented);
  571.                                 
  572.     }  /* CheckEnvironment */
  573.             
  574.     /*
  575.         DoPageSetup returns true if the page setup of the document is altered
  576.     */
  577.     
  578.     pascal Boolean DoPageSetup(DPtr theDoc)
  579.         {
  580.             Boolean result = false;
  581.                 
  582.                 if (theDoc)
  583.                     {
  584.                         PrOpen();
  585.                         result =  PrStlDialog(theDoc->thePrintSetup);
  586.                         PrClose();
  587.                     }
  588.                     
  589.                 return(result);
  590.         }  /* DoPageSetup */
  591.  
  592. /*
  593.     Name:    CtrlKeyPressed
  594.     Purpose: Returns true if control key pressed during event
  595. */
  596. pascal Boolean CtrlKeyPressed(const EventRecord *theEvent)
  597.     {
  598.         return((theEvent->modifiers & controlKey) != 0);
  599.     }
  600.     
  601. /*
  602.     Name:    OptionKeyPressed
  603.     Purpose: Returns true if option key pressed during event
  604. */
  605. pascal Boolean OptionKeyPressed(const EventRecord *theEvent)
  606.     {
  607.         return((theEvent->modifiers & optionKey) != 0);
  608.     }
  609.