home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 August: Tool Chest / Apple_Developer_Group_August_1996_Tool_Chest.iso / Sample Code / Interapplication Communication / MenuScripter 3.1 / Sources / MSAEUtils.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-11-20  |  6.4 KB  |  278 lines  |  [TEXT/MPS ]
  1. /*
  2.     MSAEUtils.c
  3.     
  4.     Version 3.1
  5.     
  6.     Copyright © 1995 Apple Computer, Inc., all rights reserved.
  7.     
  8.     MenuScripter by Nigel Humphreys and Jon Lansdell
  9.     AppleEvent to script extensions by Greg Sutton
  10. */
  11.  
  12. #pragma segment Main
  13.  
  14. #include "MSAEUtils.h"
  15. #include "MSUtils.h"
  16.  
  17. #include <AERegistry.h>
  18.  
  19.  
  20. /**-----------------------------------------------------------------------
  21.     Utility Routines for getting data from AEDesc's
  22.   -----------------------------------------------------------------------**/
  23.     
  24. pascal void GetRawDataFromDescriptor(const AEDesc *theDesc,
  25.                                                                          Ptr     destPtr,
  26.                                                                          Size    destMaxSize,
  27.                                                                          Size    *actSize)
  28.   {
  29.       Size copySize;
  30.  
  31.  
  32.         if (theDesc->dataHandle) 
  33.             {
  34.                 HLock((Handle)theDesc->dataHandle);
  35.                 *actSize = GetHandleSize((Handle)theDesc->dataHandle);
  36.                 
  37.                 copySize = LesserOf(*actSize, destMaxSize);
  38.                 
  39.                 BlockMove(*theDesc->dataHandle, destPtr, copySize);
  40.                 
  41.                 HUnlock((Handle)theDesc->dataHandle);
  42.             }
  43.         else
  44.             *actSize = 0;
  45.     } /*GetRawDataFromDescriptor*/
  46.  
  47. pascal OSErr GetPStringFromDescriptor(const AEDesc *sourceDesc, char *resultStr)
  48.  
  49.   {
  50.       OSErr        myErr;
  51.         OSErr                 ignoreErr;
  52.         Size         stringSize;
  53.         AEDesc       resultDesc;
  54.  
  55.         resultDesc.dataHandle = nil;
  56.         
  57.         resultStr[0] = 0;
  58.         
  59.         myErr = AECoerceDesc(sourceDesc,typeChar,&resultDesc);
  60.         
  61.         if (myErr==noErr) 
  62.             GetRawDataFromDescriptor(&resultDesc,
  63.                                                              (Ptr)&resultStr[1],
  64.                                                              255,
  65.                                                              &stringSize);
  66.         if (stringSize<256) 
  67.             resultStr[0] = (char)stringSize;
  68.         else
  69.             myErr = errAECoercionFail;
  70.             
  71.         if (resultDesc.dataHandle) 
  72.             ignoreErr = AEDisposeDesc(&resultDesc);
  73.             
  74.         return(myErr);
  75.     }
  76.  
  77. pascal OSErr GetIntegerFromDescriptor(const AEDesc *sourceDesc, short *result)
  78.   {
  79.       OSErr   myErr;
  80.         OSErr   ignoreErr;
  81.         Size    intSize;
  82.         AEDesc  resultDesc;
  83.         
  84.         *result = 0;
  85.         myErr  = AECoerceDesc(sourceDesc,typeShortInteger,&resultDesc);
  86.         
  87.         if (myErr==noErr) 
  88.             {
  89.                 GetRawDataFromDescriptor(&resultDesc,
  90.                                                                  (Ptr)result,
  91.                                                                  2,
  92.                                                                  &intSize);
  93.                 if (intSize>2) 
  94.                     myErr = errAECoercionFail;
  95.             }
  96.         
  97.         if (resultDesc.dataHandle) 
  98.             ignoreErr = AEDisposeDesc(&resultDesc);
  99.             
  100.         return(myErr);
  101.     }
  102.     
  103. pascal OSErr GetBooleanFromDescriptor(const AEDesc *sourceDesc,
  104.                                                                         Boolean *result)
  105.   {
  106.       OSErr  myErr;
  107.         OSErr  ignoreErr;
  108.         Size   boolSize;
  109.         AEDesc resultDesc;
  110.         
  111.         *result = false;
  112.         myErr = AECoerceDesc(sourceDesc,typeBoolean,&resultDesc);
  113.         
  114.         if (myErr==noErr) 
  115.             {
  116.                 GetRawDataFromDescriptor(&resultDesc,
  117.                                                                  (Ptr)result,
  118.                                                                  sizeof(Boolean),
  119.                                                                  &boolSize);
  120.                 if (boolSize>sizeof(Boolean)) 
  121.                     myErr = errAECoercionFail;
  122.             }
  123.         
  124.         if (resultDesc.dataHandle) 
  125.             ignoreErr = AEDisposeDesc(&resultDesc);
  126.             
  127.         return(myErr);
  128.     }
  129.  
  130. pascal OSErr GetLongIntFromDescriptor(const AEDesc *sourceDesc, 
  131.                                       long   *result)
  132.   {
  133.       OSErr   myErr;
  134.         OSErr   ignoreErr;
  135.         Size    intSize;
  136.         AEDesc  resultDesc;
  137.         
  138.         *result = 0;
  139.         myErr = AECoerceDesc(sourceDesc,typeLongInteger,&resultDesc);
  140.         
  141.         if (myErr==noErr) 
  142.             {
  143.                 GetRawDataFromDescriptor(&resultDesc,
  144.                                                                  (Ptr)result,
  145.                                                                  4,
  146.                                                                  &intSize);
  147.                 if (intSize>4) 
  148.                     myErr = errAECoercionFail;
  149.             }
  150.         
  151.         if (resultDesc.dataHandle) 
  152.             ignoreErr = AEDisposeDesc(&resultDesc);
  153.             
  154.         return(myErr);
  155.     } /*GetLongIntFromDescriptor*/
  156.  
  157. pascal OSErr GetRectFromDescriptor(const AEDesc *sourceDesc, Rect *result)
  158.     {
  159.         OSErr   myErr;
  160.         OSErr   ignoreErr;
  161.         Size    rectSize;
  162.         AEDesc  resultDesc;
  163.             
  164.         SetRect(result,0,0,0,0);
  165.         myErr = AECoerceDesc(sourceDesc,typeQDRectangle,&resultDesc);
  166.         
  167.         if (myErr==noErr) 
  168.             {
  169.                 GetRawDataFromDescriptor(&resultDesc,
  170.                                                                  (Ptr)result,
  171.                                                                  sizeof(Rect),
  172.                                                                  &rectSize);
  173.                 if (rectSize<sizeof(Rect)) 
  174.                     myErr = errAECoercionFail;
  175.             }
  176.         
  177.         if (resultDesc.dataHandle) 
  178.             ignoreErr = AEDisposeDesc(&resultDesc);
  179.             
  180.         return(myErr);
  181.     } /*GetRectFromDescriptor*/
  182.  
  183. pascal OSErr GetPointFromDescriptor(const AEDesc *sourceDesc,
  184.                                                                   Point  *result)
  185.   {
  186.       OSErr   myErr;
  187.         OSErr   ignoreErr;
  188.         Size    ptSize;
  189.         AEDesc  resultDesc;
  190.         
  191.         SetPt(result,0,0);
  192.         
  193.         myErr = AECoerceDesc(sourceDesc,typeQDPoint,&resultDesc);
  194.         
  195.         if (myErr==noErr) 
  196.             {
  197.                 GetRawDataFromDescriptor(&resultDesc,
  198.                                                                  (Ptr)result,
  199.                                                                  sizeof(Point),
  200.                                                                  &ptSize);
  201.                                                                  
  202.                 if (ptSize<sizeof(Point)) 
  203.                     myErr = errAECoercionFail;
  204.                     
  205.             }
  206.         
  207.         if (resultDesc.dataHandle) 
  208.             ignoreErr = AEDisposeDesc(&resultDesc);
  209.             
  210.         return(myErr);
  211.     } /*GetPointFromDescriptor*/
  212.  
  213.  
  214. /*
  215.     Name:    PutStyledTextFromDescIntoTEHandle
  216.     Purpose: Takes the text in an AEDesc containing typeIntlText and puts it in
  217.              a styled text edit record at the current insertion point.
  218.                      Looks for typeIntlText, typeStyledText, typeChar in that order.
  219. */
  220.  
  221. pascal OSErr GetStyledTextFromDescIntoTEHandle(const AEDesc *sourceTextDesc, TEHandle theHTE)
  222.     {
  223.         AEDesc styledTextDesc;
  224.         AEDesc textStyleDesc;
  225.         AEDesc rawTextDesc;
  226.         OSErr  myErr;
  227.         OSErr  ignoreErr;
  228.         
  229.         styledTextDesc.dataHandle = nil;
  230.         textStyleDesc.dataHandle  = nil;
  231.         rawTextDesc.dataHandle    = nil;
  232.     
  233.         /*
  234.             Coerce to an AERecord and then extract the parts of the
  235.             styled text - works for typeIntlText, typeStyledText
  236.         */
  237.         myErr = AECoerceDesc(sourceTextDesc, typeAERecord, &styledTextDesc);
  238.         
  239.         if (myErr==noErr)
  240.             {        
  241.                 myErr = AEGetKeyDesc(&styledTextDesc,
  242.                                                          keyAEText,
  243.                                                          typeChar,
  244.                                                          &rawTextDesc);
  245.                                                          
  246.                 myErr = AEGetKeyDesc(&styledTextDesc,
  247.                                                          keyAEStyles,
  248.                                                          typeScrapStyles,
  249.                                                          &textStyleDesc);
  250.             }
  251.         else
  252.             {
  253.                 myErr = AECoerceDesc(sourceTextDesc, typeChar, &rawTextDesc);
  254.                 
  255.                 textStyleDesc.dataHandle = nil; /* so that TEStylInsert acts like TEInsert */                
  256.             }
  257.                 
  258.         HLock((Handle)rawTextDesc.dataHandle);
  259.                                                  
  260.         TEStylInsert((const void *) (*rawTextDesc.dataHandle),
  261.                                  GetHandleSize(rawTextDesc.dataHandle),
  262.                                  (StScrpHandle) textStyleDesc.dataHandle,
  263.                                  theHTE);
  264.                                  
  265.         HUnlock((Handle)rawTextDesc.dataHandle);
  266.         
  267.         if (textStyleDesc.dataHandle)
  268.             ignoreErr = AEDisposeDesc(&textStyleDesc);
  269.  
  270.         if (rawTextDesc.dataHandle)
  271.             ignoreErr = AEDisposeDesc(&rawTextDesc);
  272.  
  273.         if (styledTextDesc.dataHandle)
  274.             ignoreErr = AEDisposeDesc(&styledTextDesc);
  275.             
  276.         return(myErr);
  277.     }
  278.