QDOffscreen.h

Go to the documentation of this file.

 
#ifndef __QDOFFSCREEN__
#define __QDOFFSCREEN__
 
#ifndef __MACERRORS__
#include <MacErrors.h>
#endif
 
#ifndef __QUICKDRAW__
#include <Quickdraw.h>
#endif
 
#if PRAGMA_ONCE
#pragma once
#endif
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#if PRAGMA_IMPORT
#pragma import on
#endif
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = mac68k
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(push, 2)
#elif PRAGMA_STRUCT_PACK
#pragma pack(2)
#endif
 
  enum
  {
    pixPurgeBit = 0,
    noNewDeviceBit = 1,
    useTempMemBit = 2,
    keepLocalBit = 3,
    useDistantHdwrMemBit = 4,
    useLocalHdwrMemBit = 5,
    pixelsPurgeableBit = 6,
    pixelsLockedBit = 7,
    mapPixBit = 16,
    newDepthBit = 17,
    alignPixBit = 18,
    newRowBytesBit = 19,
    reallocPixBit = 20,
    clipPixBit = 28,
    stretchPixBit = 29,
    ditherPixBit = 30,
    gwFlagErrBit = 31
  };
 
  enum
  {
    pixPurge = 1L << pixPurgeBit,
    noNewDevice = 1L << noNewDeviceBit,
    useTempMem = 1L << useTempMemBit,
    keepLocal = 1L << keepLocalBit,
    useDistantHdwrMem = 1L << useDistantHdwrMemBit,
    useLocalHdwrMem = 1L << useLocalHdwrMemBit,
    pixelsPurgeable = 1L << pixelsPurgeableBit,
    pixelsLocked = 1L << pixelsLockedBit,
    kAllocDirectDrawSurface = 1L << 14,
    mapPix = 1L << mapPixBit,
    newDepth = 1L << newDepthBit,
    alignPix = 1L << alignPixBit,
    newRowBytes = 1L << newRowBytesBit,
    reallocPix = 1L << reallocPixBit,
    clipPix = 1L << clipPixBit,
    stretchPix = 1L << stretchPixBit,
    ditherPix = 1L << ditherPixBit,
    gwFlagErr = 1L << gwFlagErrBit
  };
 
  typedef unsigned long GWorldFlags;
  // Type definition of a GWorldPtr
  typedef CGrafPtr GWorldPtr;
  QDErr
  NewGWorld(GWorldPtr *offscreenGWorld, short PixelDepth, const Rect *boundsRect,
            CTabHandle cTable, /* can be NULL */
            GDHandle aGDevice, /* can be NULL */
            GWorldFlags flags);
 
  /* GDevice attribute bits for Carbon and QuickTime 3.0*/
  enum
  {
    deviceIsIndirect = (1L << 0),
    deviceNeedsLock = (1L << 1),
    deviceIsStatic = (1L << 2),
    deviceIsExternalBuffer = (1L << 3),
    deviceIsDDSurface = (1L << 4),
    deviceIsDCISurface = (1L << 5),
    deviceIsGDISurface = (1L << 6),
    deviceIsAScreen = (1L << 7),
    deviceIsOverlaySurface = (1L << 8)
  };
 
#if TARGET_OS_WIN32
#if CALL_NOT_IN_CARBON
  void *
  GetGDeviceSurface(GDHandle gdh);
 
  unsigned long
  GetGDeviceAttributes(GDHandle gdh);
 
  /* to allocate non-mac-rgb GWorlds use QTNewGWorld (ImageCompression.h) */
  QDErr
  NewGWorldFromHBITMAP(GWorldPtr *offscreenGWorld, CTabHandle cTable,
                       GDHandle aGDevice, GWorldFlags flags, void *newHBITMAP,
                       void *newHDC);
 
#endif /* CALL_NOT_IN_CARBON */
 
#endif /* TARGET_OS_WIN32 */
 
  QDErr
  NewGWorldFromPtr(GWorldPtr *offscreenGWorld, unsigned long PixelFormat,
                   const Rect *boundsRect, CTabHandle cTable, GDHandle aGDevice,
                   GWorldFlags flags, Ptr newBuffer, long rowBytes);
 
  Boolean
  LockPixels(PixMapHandle pm);
 
  void
  UnlockPixels(PixMapHandle pm);
 
  GWorldFlags
  UpdateGWorld(GWorldPtr *offscreenGWorld, short pixelDepth,
               const Rect *boundsRect, CTabHandle cTable,
               GDHandle aGDevice, /* can be NULL */
               GWorldFlags flags);
 
  void
  DisposeGWorld(GWorldPtr offscreenGWorld);
 
  void
  GetGWorld(CGrafPtr *port, GDHandle *gdh);
 
  void
  SetGWorld(CGrafPtr port, GDHandle gdh);
 
  void
  CTabChanged(CTabHandle ctab);
 
  void
  PixPatChanged(PixPatHandle ppat);
 
  void
  PortChanged(GrafPtr port);
 
  void
  GDeviceChanged(GDHandle gdh);
 
  void
  AllowPurgePixels(PixMapHandle pm);
 
  void
  NoPurgePixels(PixMapHandle pm);
 
  GWorldFlags
  GetPixelsState(PixMapHandle pm);
 
  void
  SetPixelsState(PixMapHandle pm, GWorldFlags state);
 
  Ptr GetPixBaseAddr(PixMapHandle pm);
 
  long
  GetPixRowBytes(PixMapHandle pm);
 
  QDErr
  NewScreenBuffer(const Rect *globalRect, Boolean purgeable, GDHandle *gdh,
                  PixMapHandle *offscreenPixMap);
 
  void
  DisposeScreenBuffer(PixMapHandle offscreenPixMap);
 
  GDHandle
  GetGWorldDevice(GWorldPtr offscreenGWorld);
 
  Boolean
  QDDone(GrafPtr port);
 
  long
  OffscreenVersion(void);
 
  QDErr
  NewTempScreenBuffer(const Rect *globalRect, Boolean purgeable, GDHandle *gdh,
                      PixMapHandle *offscreenPixMap);
 
  Boolean
  PixMap32Bit(PixMapHandle pmHandle);
 
  PixMapHandle
  GetGWorldPixMap(GWorldPtr offscreenGWorld);
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = reset
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(pop)
#elif PRAGMA_STRUCT_PACK
#pragma pack()
#endif
 
#ifdef PRAGMA_IMPORT_OFF
#pragma import off
#elif PRAGMA_IMPORT
#pragma import reset
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif /* __QDOFFSCREEN__ */
* /*/*/ * /*/*/ * /*/*/ * /*/*/ * /*/*/ * /*/*/ * /