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