home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1999 May: Tool Chest / Developer CD Series Tool Chest (Apple Computer)(May 1999).iso / Tool Chest / Development Kits / MPW etc / MPW-GM / MPW / Examples / CFMExamples / ModApp / ToolAPI.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-12-03  |  7.0 KB  |  265 lines  |  [TEXT/MPS ]
  1. /*
  2.     File:        ToolAPI.c
  3.  
  4.     Contains:    Interface to external tools
  5.  
  6.     Written by:    Brian Strull
  7.  
  8.     Copyright:    © 1994 by Apple Computer, Inc., all rights reserved.
  9.  
  10.     Change History (most recent first):
  11.  
  12.             8/17/94        bls        New file.  
  13.                                 
  14.     To Do:
  15. */
  16.  
  17. #ifndef __TOOLAPI___
  18.     #include "ToolAPI.h"
  19. #endif
  20.  
  21. #ifndef __MODAPP__
  22.     #include "ModApp.h"
  23. #endif
  24.  
  25. // === Mixed Mode definitions for our callback routines
  26. // We're creating these so we can have 68K tools and PowerPC tools work together
  27. // in the application without needing multiple calling sequences
  28.  
  29. enum { 
  30.     uppToolStartupProcInfo = kCStackBased 
  31.                             | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  32.                             | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(WindowPtr))),
  33.  
  34.     uppToolShutdownProcInfo = kCStackBased 
  35.                             | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(WindowPtr))),
  36.  
  37.     uppToolMenuAdjustProcInfo = kCStackBased 
  38.                             | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(WindowPtr))),
  39.  
  40.     uppToolMenuDispatchProcInfo = kCStackBased 
  41.                             | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(WindowPtr)))
  42.                             | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(short)))
  43.                             | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(short))),
  44.  
  45.     uppToolIdleProcInfo = kCStackBased 
  46.                             | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(WindowPtr))),
  47.  
  48.     uppToolUpdateProcInfo = kCStackBased 
  49.                             | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(WindowPtr))),
  50.  
  51.     uppToolWindowClickProcInfo = kCStackBased 
  52.                             | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(WindowPtr)))
  53.                             | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(EventRecord*))),
  54.  
  55.     uppToolWindowKeyProcInfo = kCStackBased 
  56.                             | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(WindowPtr)))
  57.                             | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(EventRecord*))),
  58.  
  59.     uppToolWindowMovedProcInfo = kCStackBased 
  60.                             | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(WindowPtr))),
  61.  
  62.     uppToolWindowResizedProcInfo = kCStackBased 
  63.                             | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(WindowPtr))),
  64.  
  65.     uppToolWindowActivateProcInfo = kCStackBased 
  66.                             | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(WindowPtr)))
  67.                             | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(Boolean)))
  68. };
  69.  
  70. // In the following functions, we compare the architecture of the tool with that
  71. // of the application.  If they are the same, we do a direct call.  If not, we
  72. // use mixedMode.  In a production application, you may want to cache the mixedMode
  73. // discriptors, rather than re-creating them each time.
  74.  
  75.  
  76. OSErr CallToolStartupProc (ToolStartupProcPtr proc, WindowPtr wp)
  77. {
  78.     short typeCode = ((DrawingWindowPeek)wp)->toolCodeType;
  79.     OSErr err;
  80.     
  81.     if (typeCode == GetCurrentArchitecture())
  82.     {
  83.         err = (*proc) (wp);
  84.     }
  85.     else
  86.     {        
  87.         UniversalProcPtr upp  = NewRoutineDescriptor((ProcPtr) proc, uppToolStartupProcInfo, typeCode);
  88.         err = CallUniversalProc (upp, uppToolStartupProcInfo, wp);
  89.         DisposeRoutineDescriptor (upp);
  90.     }
  91.     
  92.     return err;
  93.     
  94. }
  95.  
  96.  
  97. void  CallToolShutdownProc (ToolShutdownProcPtr proc, WindowPtr wp)
  98. {
  99.     short typeCode = ((DrawingWindowPeek)wp)->toolCodeType;
  100.     
  101.     if (typeCode == GetCurrentArchitecture())
  102.     {
  103.         (*proc) (wp);
  104.     }
  105.     else
  106.     {        
  107.         UniversalProcPtr upp  = NewRoutineDescriptor((ProcPtr) proc, uppToolShutdownProcInfo, typeCode);
  108.         CallUniversalProc (upp, uppToolShutdownProcInfo, wp);
  109.         DisposeRoutineDescriptor (upp);
  110.     }
  111.         
  112. }
  113.  
  114.  
  115. void  CallToolMenuAdjustProc (ToolMenuAdjustProcPtr proc, WindowPtr wp)
  116. {
  117.     short typeCode = ((DrawingWindowPeek)wp)->toolCodeType;
  118.     
  119.     if (typeCode == GetCurrentArchitecture())
  120.     {
  121.         (*proc) (wp);
  122.     }
  123.     else
  124.     {        
  125.         UniversalProcPtr upp  = NewRoutineDescriptor((ProcPtr) proc, uppToolMenuAdjustProcInfo, typeCode);
  126.         CallUniversalProc (upp, uppToolMenuAdjustProcInfo, wp);
  127.         DisposeRoutineDescriptor (upp);
  128.     }
  129.         
  130. }
  131.  
  132. void  CallToolMenuDispatchProc (ToolMenuDispatchProcPtr proc, WindowPtr wp, short menuID, short itemID)
  133. {
  134.     short typeCode = ((DrawingWindowPeek)wp)->toolCodeType;
  135.     
  136.     if (typeCode == GetCurrentArchitecture())
  137.     {
  138.         (*proc) (wp, menuID, itemID);
  139.     }
  140.     else
  141.     {        
  142.         UniversalProcPtr upp  = NewRoutineDescriptor((ProcPtr) proc, uppToolMenuDispatchProcInfo, typeCode);
  143.         CallUniversalProc (upp, uppToolMenuDispatchProcInfo, wp, menuID, itemID);
  144.         DisposeRoutineDescriptor (upp);
  145.     }
  146.         
  147. }
  148.  
  149.  
  150. void  CallToolIdleProc (ToolIdleProcPtr proc, WindowPtr wp)
  151. {
  152.     short typeCode = ((DrawingWindowPeek)wp)->toolCodeType;
  153.     
  154.     if (typeCode == GetCurrentArchitecture())
  155.     {
  156.         (*proc) (wp);
  157.     }
  158.     else
  159.     {        
  160.         UniversalProcPtr upp  = NewRoutineDescriptor((ProcPtr) proc, uppToolIdleProcInfo, typeCode);
  161.         CallUniversalProc (upp, uppToolIdleProcInfo, wp);
  162.         DisposeRoutineDescriptor (upp);
  163.     }
  164. }
  165.  
  166.  
  167. void  CallToolUpdateProc (ToolUpdateProcPtr proc, WindowPtr wp)
  168. {
  169.     short typeCode = ((DrawingWindowPeek)wp)->toolCodeType;
  170.     
  171.     if (typeCode == GetCurrentArchitecture())
  172.     {
  173.         (*proc) (wp);
  174.     }
  175.     else
  176.     {        
  177.         UniversalProcPtr upp  = NewRoutineDescriptor((ProcPtr) proc, uppToolUpdateProcInfo, typeCode);
  178.         CallUniversalProc (upp, uppToolUpdateProcInfo, wp);
  179.         DisposeRoutineDescriptor (upp);
  180.     }
  181. }
  182.  
  183.  
  184. void  CallToolWindowClickProc (ToolWindowClickProcPtr proc, WindowPtr wp, EventRecord *theEvent)
  185. {
  186.     short typeCode = ((DrawingWindowPeek)wp)->toolCodeType;
  187.     
  188.     if (typeCode == GetCurrentArchitecture())
  189.     {
  190.         (*proc) (wp, theEvent);
  191.     }
  192.     else
  193.     {        
  194.         UniversalProcPtr upp  = NewRoutineDescriptor((ProcPtr) proc, uppToolWindowClickProcInfo, typeCode);
  195.         CallUniversalProc (upp, uppToolWindowClickProcInfo, wp, theEvent);
  196.         DisposeRoutineDescriptor (upp);
  197.     }
  198. }
  199.  
  200.  
  201.  
  202. void  CallToolWindowKeyProc(ToolWindowClickProcPtr proc, WindowPtr wp, EventRecord *theEvent)
  203. {
  204.     short typeCode = ((DrawingWindowPeek)wp)->toolCodeType;
  205.     
  206.     if (typeCode == GetCurrentArchitecture())
  207.     {
  208.         (*proc) (wp, theEvent);
  209.     }
  210.     else
  211.     {        
  212.         UniversalProcPtr upp  = NewRoutineDescriptor((ProcPtr) proc, uppToolWindowKeyProcInfo, typeCode);
  213.         CallUniversalProc (upp, uppToolWindowKeyProcInfo, wp, theEvent);
  214.         DisposeRoutineDescriptor (upp);
  215.     }
  216. }
  217.  
  218. void  CallToolWindowMovedProc(ToolWindowMovedProcPtr proc, WindowPtr wp)
  219. {
  220.     short typeCode = ((DrawingWindowPeek)wp)->toolCodeType;
  221.     
  222.     if (typeCode == GetCurrentArchitecture())
  223.     {
  224.         (*proc) (wp);
  225.     }
  226.     else
  227.     {        
  228.         UniversalProcPtr upp  = NewRoutineDescriptor((ProcPtr) proc, uppToolWindowMovedProcInfo, typeCode);
  229.         CallUniversalProc (upp, uppToolWindowMovedProcInfo, wp);
  230.         DisposeRoutineDescriptor (upp);
  231.     }
  232. }
  233.  
  234. void  CallToolWindowResizedProc(ToolWindowResizedProcPtr proc, WindowPtr wp)
  235. {
  236.     short typeCode = ((DrawingWindowPeek)wp)->toolCodeType;
  237.     
  238.     if (typeCode == GetCurrentArchitecture())
  239.     {
  240.         (*proc) (wp);
  241.     }
  242.     else
  243.     {        
  244.         UniversalProcPtr upp  = NewRoutineDescriptor((ProcPtr) proc, uppToolWindowResizedProcInfo, typeCode);
  245.         CallUniversalProc (upp, uppToolWindowResizedProcInfo, wp);
  246.         DisposeRoutineDescriptor (upp);
  247.     }
  248. }
  249.  
  250. void  CallToolWindowActivateProc(ToolWindowActivateProcPtr proc, WindowPtr wp, Boolean activeFlag)
  251. {
  252.     short typeCode = ((DrawingWindowPeek)wp)->toolCodeType;
  253.     
  254.     if (typeCode == GetCurrentArchitecture())
  255.     {
  256.         (*proc) (wp, activeFlag);
  257.     }
  258.     else
  259.     {        
  260.         UniversalProcPtr upp  = NewRoutineDescriptor((ProcPtr) proc, uppToolWindowActivateProcInfo, typeCode);
  261.         CallUniversalProc (upp, uppToolWindowActivateProcInfo, wp, activeFlag);
  262.         DisposeRoutineDescriptor (upp);
  263.     }
  264. }
  265.