home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / Libraries / BSDOffscreenLib 1.0.2 / BSDOffscreenLib.cp < prev    next >
Encoding:
Text File  |  1997-07-29  |  11.9 KB  |  408 lines  |  [TEXT/CWIE]
  1. /*
  2.      File:        BSDOffscreenLib.cp
  3.  
  4.      Contains:    Easy CopyBits & GWorld Routines.
  5.  
  6.      Version:    Technology:    Torture Chamber v1.0
  7.                  Package:    BSDOffscreenLib v1.0.2
  8.  
  9.      Copyright:    © 1997, BuggySoft™ Development.
  10.                  By Scott Dunbar
  11. */
  12.  
  13. #include "BSDOffscreenLib.h"
  14.  
  15. /*
  16.     public variables
  17. */
  18.  
  19. Pattern        none;
  20. GrafPtr        oldPort;
  21.  
  22. /*
  23.     private variables
  24. */
  25.  
  26. GWorldPtr    oldGWorld, curGWorld;
  27. GDHandle    oldDevice;
  28.  
  29. /*
  30.     private prototypes
  31. */
  32.  
  33. Boolean ValidGrafPtr (GrafPtr validateMe);
  34. Boolean ValidGWorld (GWorldPtr validateMe);
  35. Boolean    ValidGrafPtrGWorld (GrafPtr gPort, GWorldPtr gWorld);
  36. Boolean    ValidGWorldGWorld (GWorldPtr gWorld1, GWorldPtr gWorld2);
  37. Boolean    ValidGrafPtrGrafPtr (GrafPtr gPort1, GrafPtr gPort2);
  38.  
  39.  
  40. /*
  41.     private routines
  42. */
  43.  
  44. Boolean ValidGrafPtr (GrafPtr validateMe) {
  45.     if (validateMe != nil) return(true);
  46.     return(false);
  47. }
  48.  
  49. Boolean ValidGWorld (GWorldPtr validateMe) {
  50.     if (validateMe != nil) return(true);
  51.     return(false);
  52. }
  53.  
  54. Boolean    ValidGrafPtrGWorld (GrafPtr gPort, GWorldPtr gWorld) {
  55.     if (ValidGrafPtr(gPort) && ValidGWorld(gWorld)) return(true);
  56.     return(false);
  57. }
  58.  
  59. Boolean    ValidGWorldGWorld (GWorldPtr gWorld1, GWorldPtr gWorld2) {
  60.     if (ValidGWorld(gWorld1) && ValidGWorld(gWorld2)) return(true);
  61.     return(false);
  62. }
  63.  
  64. Boolean    ValidGrafPtrGrafPtr (GrafPtr gPort1, GrafPtr gPort2) {
  65.     if (ValidGrafPtr(gPort1) && ValidGrafPtr(gPort2)) return(true);
  66.     return(false);
  67. }
  68.  
  69. /*
  70.     Window To GWorld
  71. */
  72.  
  73. void Window2GWorld (GrafPtr srcPort, GWorldPtr destPort, short mode) {
  74. CGrafPtr    oldPort;
  75. GDHandle    curDevice;
  76.     
  77.     if (ValidGrafPtrGWorld(srcPort, destPort)) {
  78.         GetGWorld(&oldPort, &curDevice);
  79.         SetGWorld(destPort, nil);
  80.         LockPixels(destPort->portPixMap);
  81.         CopyBits(&srcPort->portBits, (BitMap*)*GetGWorldPixMap(destPort), &srcPort->portRect, &destPort->portRect, mode, nil);
  82.         UnlockPixels(destPort->portPixMap);
  83.         SetGWorld(oldPort, curDevice);
  84.     }
  85. }
  86.  
  87. void Window2GWorldRect (GrafPtr srcPort, GWorldPtr destPort, Rect srcRect, Rect destRect, short mode) {
  88. CGrafPtr    oldPort;
  89. GDHandle    curDevice;
  90.  
  91.     if (ValidGrafPtrGWorld(srcPort, destPort)) {
  92.         GetGWorld(&oldPort, &curDevice);
  93.         SetGWorld(destPort, nil);
  94.         LockPixels(destPort->portPixMap);
  95.         CopyBits(&srcPort->portBits, (BitMap*)*GetGWorldPixMap(destPort), &srcRect, &destRect, mode, nil);
  96.         UnlockPixels(destPort->portPixMap);
  97.         SetGWorld(oldPort, curDevice);
  98.     }
  99. }
  100.  
  101. void Window2GWorldRgn (GrafPtr srcPort, GWorldPtr destPort, short mode, RgnHandle clip) {
  102. CGrafPtr    oldPort;
  103. GDHandle    curDevice;
  104.  
  105.     if (ValidGrafPtrGWorld(srcPort, destPort)) {
  106.         GetGWorld(&oldPort, &curDevice);
  107.         SetGWorld(destPort, nil);
  108.         LockPixels(destPort->portPixMap);
  109.         CopyBits(&srcPort->portBits, (BitMap*)*GetGWorldPixMap(destPort), &srcPort->portRect, &destPort->portRect, mode, clip);
  110.         UnlockPixels(destPort->portPixMap);
  111.         SetGWorld(oldPort, curDevice);
  112.     }
  113. }
  114.  
  115. void Window2GWorldRectRgn (GrafPtr srcPort, GWorldPtr destPort, Rect srcRect, Rect destRect, short mode, RgnHandle clip) {
  116. CGrafPtr    oldPort;
  117. GDHandle    curDevice;
  118.  
  119.     if (ValidGrafPtrGWorld(srcPort, destPort)) {
  120.         GetGWorld(&oldPort, &curDevice);
  121.         SetGWorld(destPort, nil);
  122.         LockPixels(destPort->portPixMap);
  123.         CopyBits(&srcPort->portBits, (BitMap*)*GetGWorldPixMap(destPort), &srcRect, &destRect, mode, clip);
  124.         UnlockPixels(destPort->portPixMap);
  125.         SetGWorld(oldPort, curDevice);
  126.     }
  127. }
  128.  
  129.  
  130. /*
  131.     GWorld To Window
  132. */
  133.  
  134. void GWorld2Window (GWorldPtr srcPort, GrafPtr destPort, short mode) {
  135. CGrafPtr    oldPort;
  136. GDHandle    curDevice;
  137.     
  138.     if (ValidGrafPtrGWorld(destPort, srcPort)) {
  139.         GetGWorld(&oldPort, &curDevice);
  140.         SetGWorld((CGrafPtr)destPort, nil);
  141.         CopyBits((BitMap*)*(srcPort)->portPixMap, &destPort->portBits, &srcPort->portRect, &destPort->portRect, mode, nil);
  142.         SetGWorld(oldPort, curDevice);
  143.     }
  144. }
  145.  
  146. void GWorld2WindowRgn (GWorldPtr srcPort, GrafPtr destPort, short mode, RgnHandle clip) {
  147. CGrafPtr    oldPort;
  148. GDHandle    curDevice;
  149.     
  150.     if (ValidGrafPtrGWorld(destPort, srcPort)) {
  151.         GetGWorld(&oldPort, &curDevice);
  152.         SetGWorld((CGrafPtr)destPort, nil);
  153.         CopyBits((BitMap*)*(srcPort)->portPixMap, &destPort->portBits, &srcPort->portRect, &destPort->portRect, mode, clip);
  154.         SetGWorld(oldPort, curDevice);
  155.     }
  156. }
  157.  
  158. void GWorld2WindowRect (GWorldPtr srcPort, GrafPtr destPort, Rect srcRect, Rect destRect, short mode) {
  159. CGrafPtr    oldPort;
  160. GDHandle    curDevice;
  161.     
  162.     if (ValidGrafPtrGWorld(destPort, srcPort)) {
  163.         GetGWorld(&oldPort, &curDevice);
  164.         SetGWorld((CGrafPtr)destPort, nil);
  165.         CopyBits((BitMap*)*(srcPort)->portPixMap, &destPort->portBits, &srcRect, &destRect, mode, nil);
  166.         SetGWorld(oldPort, curDevice);
  167.     }
  168. }
  169.  
  170. void GWorld2WindowRectRgn (GWorldPtr srcPort, GrafPtr destPort, Rect srcRect, Rect destRect, short mode, RgnHandle clip) {
  171. CGrafPtr    oldPort;
  172. GDHandle    curDevice;
  173.     
  174.     if (ValidGrafPtrGWorld(destPort, srcPort)) {
  175.         GetGWorld(&oldPort, &curDevice);
  176.         SetGWorld((CGrafPtr)destPort, nil);
  177.         CopyBits((BitMap*)*(srcPort)->portPixMap, &destPort->portBits, &srcRect, &destRect, mode, clip);
  178.         SetGWorld(oldPort, curDevice);
  179.     }
  180. }
  181.  
  182.  
  183. /*
  184.     Window To Window
  185. */
  186.  
  187. void Window2Window (GrafPtr srcPort, GrafPtr destPort, short mode) {
  188. CGrafPtr    oldPort;
  189. GDHandle    curDevice;
  190.     
  191.     if (ValidGrafPtrGrafPtr(destPort, srcPort)) {
  192.         GetGWorld(&oldPort, &curDevice);
  193.         SetGWorld((CGrafPtr)destPort, nil);
  194.         CopyBits(&srcPort->portBits, &destPort->portBits, &srcPort->portRect, &destPort->portRect, mode, nil);
  195.         SetGWorld(oldPort, curDevice);
  196.     }
  197. }
  198.  
  199. void Window2WindowRect (GrafPtr srcPort, GrafPtr destPort, Rect srcRect, Rect destRect, short mode) {
  200. CGrafPtr    oldPort;
  201. GDHandle    curDevice;
  202.     
  203.     if (ValidGrafPtrGrafPtr(destPort, srcPort)) {
  204.         GetGWorld(&oldPort, &curDevice);
  205.         SetGWorld((CGrafPtr)destPort, nil);
  206.         CopyBits(&srcPort->portBits, &destPort->portBits, &srcRect, &destRect, mode, nil);
  207.         SetGWorld(oldPort, curDevice);
  208.     }
  209. }
  210.  
  211. void Window2WindowRgn (GrafPtr srcPort, GrafPtr destPort, short mode, RgnHandle clip) {
  212. CGrafPtr    oldPort;
  213. GDHandle    curDevice;
  214.     
  215.     if (ValidGrafPtrGrafPtr(destPort, srcPort)) {
  216.         GetGWorld(&oldPort, &curDevice);
  217.         SetGWorld((CGrafPtr)destPort, nil);
  218.         CopyBits(&srcPort->portBits, &destPort->portBits, &srcPort->portRect, &destPort->portRect, mode, clip);
  219.         SetGWorld(oldPort, curDevice);
  220.     }
  221. }
  222.  
  223. void Window2WindowRectRgn (GrafPtr srcPort, GrafPtr destPort, Rect srcRect, Rect destRect, short mode, RgnHandle clip) {
  224. CGrafPtr    oldPort;
  225. GDHandle    curDevice;
  226.     
  227.     if (ValidGrafPtrGrafPtr(destPort, srcPort)) {
  228.         GetGWorld(&oldPort, &curDevice);
  229.         SetGWorld((CGrafPtr)destPort, nil);
  230.         CopyBits(&srcPort->portBits, &destPort->portBits, &srcRect, &destRect, mode, clip);
  231.         SetGWorld(oldPort, curDevice);
  232.     }
  233. }
  234.  
  235.  
  236. /*
  237.     GWorld To GWorld
  238. */
  239.  
  240. void GWorld2GWorld (GWorldPtr srcPort, GWorldPtr destPort, short mode) {
  241. CGrafPtr    oldPort;
  242. GDHandle    curDevice;
  243.     
  244.     if (ValidGWorldGWorld(destPort, srcPort)) {
  245.         GetGWorld(&oldPort, &curDevice);
  246.         SetGWorld(destPort, nil);
  247.         LockPixels(destPort->portPixMap);
  248.         CopyBits((BitMap*)*(srcPort)->portPixMap, (BitMap*)*(destPort)->portPixMap, &srcPort->portRect, &destPort->portRect, mode, nil);
  249.         UnlockPixels(destPort->portPixMap);
  250.         SetGWorld(oldPort, curDevice);
  251.     }
  252. }
  253.  
  254. void GWorld2GWorldRect (GWorldPtr srcPort, GWorldPtr destPort, Rect srcRect, Rect destRect, short mode) {
  255. CGrafPtr    oldPort;
  256. GDHandle    curDevice;
  257.     
  258.     if (ValidGWorldGWorld(destPort, srcPort)) {
  259.         GetGWorld(&oldPort, &curDevice);
  260.         SetGWorld(destPort, nil);
  261.         LockPixels(destPort->portPixMap);
  262.         CopyBits((BitMap*)*(srcPort)->portPixMap, (BitMap*)*(destPort)->portPixMap, &srcRect, &destRect, mode, nil);
  263.         UnlockPixels(destPort->portPixMap);
  264.         SetGWorld(oldPort, curDevice);
  265.     }
  266. }
  267.  
  268. void GWorld2GWorldRgn (GWorldPtr srcPort, GWorldPtr destPort, short mode, RgnHandle clip) {
  269. CGrafPtr    oldPort;
  270. GDHandle    curDevice;
  271.     
  272.     if (ValidGWorldGWorld(destPort, srcPort)) {
  273.         GetGWorld(&oldPort, &curDevice);
  274.         SetGWorld(destPort, nil);
  275.         LockPixels(destPort->portPixMap);
  276.         CopyBits((BitMap*)*(srcPort)->portPixMap, (BitMap*)*(destPort)->portPixMap, &srcPort->portRect, &destPort->portRect, mode, clip);
  277.         UnlockPixels(destPort->portPixMap);
  278.         SetGWorld(oldPort, curDevice);
  279.     }
  280. }
  281.  
  282. void GWorld2GWorldRectRgn (GWorldPtr srcPort, GWorldPtr destPort, Rect srcRect, Rect destRect, short mode, RgnHandle clip) {
  283. CGrafPtr    oldPort;
  284. GDHandle    curDevice;
  285.     
  286.     if (ValidGWorldGWorld(destPort, srcPort)) {
  287.         GetGWorld(&oldPort, &curDevice);
  288.         SetGWorld(destPort, nil);
  289.         LockPixels(destPort->portPixMap);
  290.         CopyBits((BitMap*)*(srcPort)->portPixMap, (BitMap*)*(destPort)->portPixMap, &srcRect, &destRect, mode, clip);
  291.         UnlockPixels(destPort->portPixMap);
  292.         SetGWorld(oldPort, curDevice);
  293.     }
  294. }
  295.  
  296. void Screen2GWorld (GWorldPtr destPort, short mode) {
  297. CGrafPtr    oldPort;
  298. GDHandle    curDevice;
  299.     
  300.     if (ValidGWorld(destPort)) {
  301.         GetGWorld(&oldPort, &curDevice);
  302.         SetGWorld(destPort, nil);
  303.         CopyBits(&qd.screenBits, (BitMap*)*(destPort)->portPixMap, &qd.screenBits.bounds, &destPort->portRect, mode, nil);
  304.         SetGWorld(oldPort, curDevice);
  305.     }
  306. }
  307.  
  308. GWorldPtr QuickGWorld (Rect rect) {
  309.     return(CreateGWorld(0, rect, nil, nil, 0, nil, none));
  310. }
  311.  
  312. GWorldPtr CreateGWorldEmpty (short depth, Rect rect) {
  313.     return(CreateGWorld(depth, rect, nil, nil, 0, nil, none));
  314. }
  315.  
  316. GWorldPtr CreateGWorldPattern (short depth, Rect rect, Pattern pat) {
  317.     return(CreateGWorld(depth, rect, nil, nil, 0, nil, pat));
  318. }
  319.  
  320. GWorldPtr CreateGWorldPict (short depth, Rect rect, PicHandle pict) {
  321.     return(CreateGWorld(depth, rect, nil, nil, 0, pict, none));
  322. }
  323.  
  324. GWorldPtr CreateGWorld (short depth, Rect rect, CTabHandle ctab, GDHandle device, GWorldFlags flags, PicHandle pict, Pattern pat) {
  325. GWorldPtr    oldPort, tempGWorld;
  326. GDHandle    oldDevice;
  327.  
  328.     GetGWorld(&oldPort, &oldDevice);
  329.     NewGWorld(&tempGWorld, depth, &rect, ctab, device, 0);
  330.     SetGWorld(tempGWorld, nil);
  331.     LockPixels(GetGWorldPixMap(tempGWorld));
  332.     EraseRect(&tempGWorld->portRect);
  333.     if (pict != nil) DrawPicture(pict, &tempGWorld->portRect);
  334.     if (sizeof(pat) <= 0) FillRect(&tempGWorld->portRect, &pat);
  335.     UnlockPixels(GetGWorldPixMap(tempGWorld));
  336.     SetGWorld(oldPort, oldDevice);
  337.     
  338.     return(tempGWorld);
  339. }
  340.  
  341. void OpenGWorld (GWorldPtr gWorld) {
  342.     if (ValidGWorld(gWorld)) {
  343.         curGWorld = gWorld;
  344.         GetGWorld(&oldGWorld, &oldDevice);
  345.         SetGWorld(curGWorld, nil);
  346.         LockPixels(GetGWorldPixMap(curGWorld));
  347.     }
  348. }
  349.  
  350. void CloseGWorld (void) {
  351.     if (ValidGWorld(curGWorld)) {
  352.         UnlockPixels(GetGWorldPixMap(curGWorld));
  353.         SetGWorld(oldGWorld, oldDevice);
  354.         curGWorld = nil;
  355.     }
  356. }
  357.  
  358. void GWorld2GWorldMask (GWorldPtr srcPort, GWorldPtr maskPort, GWorldPtr destPort, Rect srcRect, Rect destRect) {
  359. CGrafPtr    oldPort;
  360. GDHandle    curDevice;
  361.     
  362.     if (ValidGWorldGWorld(srcPort, maskPort) && ValidGWorld(destPort)) {
  363.         GetGWorld(&oldPort, &curDevice);
  364.         SetGWorld(destPort, nil);
  365.         LockPixels(destPort->portPixMap);
  366.         CopyMask((BitMap*)*(srcPort)->portPixMap, (BitMap*)*(maskPort)->portPixMap, (BitMap*)*(destPort)->portPixMap, &srcRect, &srcRect, &destRect);
  367.         UnlockPixels(destPort->portPixMap);
  368.         SetGWorld(oldPort, curDevice);
  369.     }
  370. }
  371.  
  372. void GWorld2WindowMask (GWorldPtr srcPort, GWorldPtr maskPort, GrafPtr destPort, Rect srcRect, Rect destRect) {
  373. CGrafPtr    oldPort;
  374. GDHandle    curDevice;
  375.     
  376.     if (ValidGWorldGWorld(srcPort, maskPort) && ValidGrafPtr(destPort)) {
  377.         GetGWorld(&oldPort, &curDevice);
  378.         SetGWorld((CGrafPtr)destPort, nil);
  379.         CopyMask((BitMap*)*(srcPort)->portPixMap, (BitMap*)*(maskPort)->portPixMap, &destPort->portBits, &srcRect, &srcRect, &destRect);
  380.         SetGWorld(oldPort, curDevice);
  381.     }
  382. }
  383.  
  384. void Window2WindowMask (GrafPtr srcPort, GWorldPtr maskPort, GrafPtr destPort, Rect srcRect, Rect destRect) {
  385. CGrafPtr    oldPort;
  386. GDHandle    curDevice;
  387.     
  388.     if (ValidGWorld(maskPort) && ValidGrafPtrGrafPtr(srcPort, destPort)) {
  389.         GetGWorld(&oldPort, &curDevice);
  390.         SetGWorld((CGrafPtr)destPort, nil);
  391.         CopyMask(&srcPort->portBits, (BitMap*)*(maskPort)->portPixMap, &destPort->portBits, &srcRect, &srcRect, &destRect);
  392.         SetGWorld(oldPort, curDevice);
  393.     }
  394. }
  395.  
  396. void Window2GWorldMask (GrafPtr srcPort, GWorldPtr maskPort, GWorldPtr destPort, Rect srcRect, Rect destRect) {
  397. CGrafPtr    oldPort;
  398. GDHandle    curDevice;
  399.     
  400.     if (ValidGWorldGWorld(destPort, maskPort) && ValidGrafPtr(srcPort)) {
  401.         GetGWorld(&oldPort, &curDevice);
  402.         SetGWorld(destPort, nil);
  403.         CopyMask(&srcPort->portBits, (BitMap*)*(maskPort)->portPixMap, (BitMap*)*(destPort)->portPixMap, &srcRect, &srcRect, &destRect);
  404.         SetGWorld(oldPort, curDevice);
  405.     }
  406. }
  407.  
  408.