Macintosh-Tools
/
executor
mirror of https://github.com/ctm/executor.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
executor/src/qGWorld.c

873 lines
20 KiB
C
Raw Permalink Blame History

/* Copyright 1994 - 1998 by Abacus Research and
* Development, Inc. All rights reserved.
*/
#if !defined (OMIT_RCSID_STRINGS)
char ROMlib_rcsid_qGWorld[] =
"$Id: qGWorld.c 63 2004-12-24 18:19:43Z ctm $";
#endif
#include "rsys/common.h"
#include "QuickDraw.h"
#include "CQuickDraw.h"
#include "MemoryMgr.h"
#include "rsys/cquick.h"
#include "rsys/gworld.h"
#include "rsys/host.h"
#include "rsys/mman.h"
#include "rsys/qcolor.h"
gw_info_t *gw_info_head, *gw_info_free;
void
ROMlib_InitGWorlds (void)
{
gw_info_head = NULL;
gw_info_free = NULL;
}
#define LOOKUP_GW_INFO_BY_EXPR(expr, value) \
{ \
gw_info_t *t; \
\
for (t = gw_info_head; t; t = t->next) \
{ \
if (expr == value) \
{ \
return t; \
} \
} \
return NULL; \
}
gw_info_t *
lookup_gw_info_by_gw (GWorldPtr gw)
{
LOOKUP_GW_INFO_BY_EXPR (t->gw, gw);
}
gw_info_t *
lookup_gw_info_by_gw_pixmap (PixMapHandle gw_pixmap)
{
LOOKUP_GW_INFO_BY_EXPR (t->gw_pixmap, gw_pixmap);
}
gw_info_t *
lookup_gw_info_by_gw_pixmap_baseaddr (void *baseaddr)
{
LOOKUP_GW_INFO_BY_EXPR (PIXMAP_BASEADDR (t->gw_pixmap),
baseaddr);
}
gw_info_t *
lookup_gw_info_by_gw_gd_pixmap (PixMapHandle gw_gd_pixmap)
{
LOOKUP_GW_INFO_BY_EXPR (t->gw_gd_pixmap,
gw_gd_pixmap);
}
static void
install_new_gw_info (GWorldPtr graphics_world,
GDHandle graphics_world_device,
GWorldFlags flags,
int gd_allocated_p)
{
gw_info_t *new_gw_info;
if (gw_info_free)
{
new_gw_info = gw_info_free;
gw_info_free = gw_info_free->next;
}
else
{
new_gw_info = (gw_info_t *) NewPtr (sizeof *new_gw_info);
}
new_gw_info->next = gw_info_head;
gw_info_head = new_gw_info;
new_gw_info->gw = graphics_world;
new_gw_info->gw_pixmap = CPORT_PIXMAP (graphics_world);
new_gw_info->gw_gd = graphics_world_device;
new_gw_info->gw_gd_pixmap = GD_PMAP (graphics_world_device);
new_gw_info->flags = flags;
new_gw_info->pixel_lock_count = 0;
new_gw_info->gd_allocated_p = gd_allocated_p;
}
void
delete_gw_info (gw_info_t *gw_info)
{
gw_info_t *t;
if (gw_info == gw_info_head)
{
gw_info_head = gw_info->next;
}
else
{
for (t = gw_info_head; t; t = t->next)
{
if (t->next == gw_info)
{
t->next = t->next->next;
break;
}
}
if (t == NULL)
gui_fatal ("gw_info `%p' not in info chain", gw_info);
}
gw_info->next = gw_info_free;
gw_info_free = gw_info;
}
P6 (PUBLIC pascal trap, QDErr, NewGWorld,
GWorldPtr *, graphics_world_out,
INTEGER, depth,
Rect *, bounds,
CTabHandle, ctab,
GDHandle, gw_gd,
GWorldFlags, flags)
{
PixMapHandle gw_pixmap, gd_pixmap;
GWorldPtr graphics_world;
GrafPtr save_portX;
int gd_allocated_p = FALSE;
save_portX = thePortX;
if (! depth)
{
GDHandle max_gd;
max_gd = GetMaxDevice (bounds);
if (max_gd == NULL)
return paramErr;
gw_gd = max_gd;
depth = PIXMAP_PIXEL_SIZE (GD_PMAP (max_gd));
if (bounds->top || bounds->left)
{
Rect *temp_bounds = alloca (sizeof *temp_bounds);
temp_bounds->bottom = CW (RECT_HEIGHT (bounds));
temp_bounds->right = CW (RECT_WIDTH (bounds));
temp_bounds->top = temp_bounds->left = CWC (0);
bounds = temp_bounds;
}
}
#if defined (BASIC_QD_ONLY)
gui_assert (depth == 1 && gw_gd == NULL);
#endif /* BASIC_QD_ONLY */
/* tests show that if we allocate the gdevice, then the gdevice's
baseAddr is the graphics world's locked handle.
but if the user passes the gdevice in, the pixmap is allocated
its own handle */
if (! (flags & noNewDevice))
{
Handle gd_pixmap_baseaddr;
int row_bytes;
gw_gd = NewGDevice (/* dummy */ 1,
/* don't initialize */ -1);
gd_allocated_p = TRUE;
/* set the various fields of the newly created graphics
device */
GD_RECT (gw_gd) = *bounds;
gd_pixmap = GD_PMAP (gw_gd);
row_bytes = ((RECT_WIDTH (bounds) * depth + 31) / 32) * 4;
PIXMAP_SET_ROWBYTES_X (gd_pixmap, CW (row_bytes));
gd_pixmap_baseaddr = NewHandle (row_bytes * RECT_HEIGHT (bounds));
if (MemError () != noErr)
return MemError ();
PIXMAP_BASEADDR_X (gd_pixmap) = (Ptr) RM (gd_pixmap_baseaddr);
PIXMAP_BOUNDS (gd_pixmap) = *bounds;
if (depth > 8)
{
PIXMAP_PIXEL_TYPE_X (gd_pixmap) = CWC (RGBDirect);
PIXMAP_CMP_COUNT_X (gd_pixmap) = CWC (3);
switch (depth)
{
case 16:
PIXMAP_CMP_SIZE_X (gd_pixmap) = CWC (5);
break;
case 32:
PIXMAP_CMP_SIZE_X (gd_pixmap) = CWC (8);
break;
default:
gui_fatal ("unknown pixel size");
}
}
else
{
PIXMAP_PIXEL_TYPE_X (gd_pixmap) = CWC (0);
PIXMAP_CMP_COUNT_X (gd_pixmap) = CWC (1);
PIXMAP_CMP_SIZE_X (gd_pixmap) = CW (depth);
}
PIXMAP_PIXEL_SIZE_X (gd_pixmap) = CW (depth);
if (ctab == NULL && depth <= 8)
{
int ctab_max_elt = (1 << depth) - 1;
ctab = PIXMAP_TABLE (gd_pixmap);
SetHandleSize ((Handle) ctab,
CTAB_STORAGE_FOR_SIZE (ctab_max_elt));
CTAB_SIZE_X (ctab) = CW (ctab_max_elt);
CTAB_SEED_X (ctab) = CL ((int32) depth);
CTAB_FLAGS_X (ctab) = CTAB_GDEVICE_BIT_X;
memcpy (CTAB_TABLE (ctab),
default_ctab_colors[ROMlib_log2[depth]],
sizeof (ColorSpec) << depth);
}
else if (ctab && depth <= 8)
{
ROMlib_copy_ctab (ctab, PIXMAP_TABLE (gd_pixmap));
}
/* #### if color table in the main device matches `ctab', then
we should copy the inverse color table from the main device */
MakeITable (PIXMAP_TABLE (gd_pixmap), GD_ITABLE (gw_gd),
GD_RES_PREF (gw_gd));
}
else
{
if (!gw_gd)
return paramErr;
gd_pixmap = GD_PMAP (gw_gd);
depth = PIXMAP_PIXEL_SIZE (gd_pixmap);
}
THEGDEVICE_SAVE_EXCURSION
(gw_gd,
{
/* allocate and initialize a new graphics world structure */
graphics_world = (GWorldPtr) NewPtr (sizeof (GWorld));
OpenCPort (GW_CPORT (graphics_world));
gw_pixmap = CPORT_PIXMAP (graphics_world);
if (! gd_allocated_p)
{
Handle gw_pixmap_baseaddr;
int row_bytes;
/* #### the `OpenCPort ()' initialization of `gw' sets the
default depth of `gw_pixmap' to that of the gworld,
which may not match `depth' */
row_bytes = ((RECT_WIDTH (bounds) * depth + 31) / 32) * 4;
PIXMAP_SET_ROWBYTES_X (gw_pixmap, CW (row_bytes));
gw_pixmap_baseaddr = NewHandle (row_bytes * RECT_HEIGHT (bounds));
if (MemError () != noErr)
/* ### err, i'm not sure what the mac does when this
allocation fails */
gw_pixmap_baseaddr = NewHandle (0);
PIXMAP_BASEADDR_X (gw_pixmap)
= (Ptr) RM (gw_pixmap_baseaddr);
PORT_RECT (graphics_world) = PIXMAP_BOUNDS (gw_pixmap) = *bounds;
}
/* mark as a GWorld and not a CGrafPort */
CPORT_VERSION_X (graphics_world) |= GW_FLAG_BIT_X;
install_new_gw_info (graphics_world, gw_gd, 0, gd_allocated_p);
if (flags & pixelsLocked)
LockPixels (gw_pixmap);
});
*graphics_world_out = RM (graphics_world);
thePortX = save_portX;
return noErr;
}
P1 (PUBLIC pascal trap, Boolean, LockPixels,
PixMapHandle, pixels)
{
gw_info_t *gw_info = lookup_gw_info_by_gw_pixmap (pixels);
Handle pixels_baseaddr_h;
if (gw_info)
{
if (gw_info->flags & pixelsLocked)
{
gw_info->pixel_lock_count ++;
return TRUE;
}
gw_info->flags |= pixelsLocked;
gui_assert (!gw_info->pixel_lock_count);
gw_info->pixel_lock_count = 1;
pixels_baseaddr_h = (Handle) PIXMAP_BASEADDR (pixels);
/* lock the baseaddr handle memory */
HSetState (pixels_baseaddr_h, HGetState (pixels_baseaddr_h) | LOCKBIT);
PIXMAP_BASEADDR_X (pixels) = pixels_baseaddr_h->p;
HSetState ((Handle) pixels, HGetState ((Handle) pixels) | LOCKBIT);
}
return TRUE;
}
P1 (PUBLIC pascal trap, void, UnlockPixels,
PixMapHandle, pixels)
{
gw_info_t *gw_info = lookup_gw_info_by_gw_pixmap (pixels);
Handle pixels_baseaddr_h;
Ptr pixels_baseaddr;
if (gw_info)
{
if (! (gw_info->flags & pixelsLocked))
{
warning_unexpected ("attemp to unlock unlocked pixels");
return;
}
gw_info->pixel_lock_count --;
if (gw_info->flags & pixelsLocked
&& !gw_info->pixel_lock_count)
{
gw_info->flags &= ~pixelsLocked;
pixels_baseaddr = PIXMAP_BASEADDR (pixels);
pixels_baseaddr_h = RecoverHandle (pixels_baseaddr);
HSetState (pixels_baseaddr_h,
HGetState (pixels_baseaddr_h) & ~LOCKBIT);
PIXMAP_BASEADDR_X (pixels) = (Ptr) RM (pixels_baseaddr_h);
HSetState ((Handle) pixels, HGetState ((Handle) pixels) & ~LOCKBIT);
}
}
}
P6 (PUBLIC pascal trap, GWorldFlags, UpdateGWorld,
GWorldPtr *, graphics_world,
INTEGER, depth,
Rect *, bounds,
CTabHandle, ctab,
GDHandle, a_gdevice,
GWorldFlags, flags)
{
gw_info_t *gw_info;
GWorldPtr gw;
PixMapHandle gw_pmap;
CTabHandle gw_pmap_ctab;
GDHandle gw_gd;
GDHandle max_gd = NULL;
QDErr err;
GWorldFlags retval = 0;
gw_info = lookup_gw_info_by_gw (MR (*graphics_world));
gw = gw_info->gw;
gw_pmap = gw_info->gw_pixmap;
gw_gd = gw_info->gw_gd;
gw_pmap_ctab = PIXMAP_TABLE (gw_pmap);
if (flags & ~(keepLocal | clipPix | stretchPix | ditherPix))
return paramErr;
if (! depth)
{
PixMapHandle max_gd_pixmap;
max_gd = GetMaxDevice (bounds);
max_gd_pixmap = GD_PMAP (max_gd);
ctab = PIXMAP_TABLE (max_gd_pixmap);
depth = PIXMAP_PIXEL_SIZE (GD_PMAP (max_gd));
gw_gd = max_gd;
/* #### unclear if this is correct, but it is what `NewGWorld ()'
does */
if (bounds->top || bounds->left)
{
Rect *temp_bounds = alloca (sizeof *temp_bounds);
*temp_bounds = *bounds;
OffsetRect (temp_bounds,
- CW (temp_bounds->left), - CW (temp_bounds->top));
bounds = temp_bounds;
}
}
if (ctab
&& CTAB_SEED_X (ctab) != CTAB_SEED_X (gw_pmap_ctab))
retval |= mapPix;
if (depth != PIXMAP_PIXEL_SIZE (gw_pmap))
retval |= newDepth;
if (memcmp (bounds, &PIXMAP_BOUNDS (gw_pmap),
sizeof *bounds))
{
if (flags & clipPix)
retval |= clipPix;
else if (flags & stretchPix)
retval |= stretchPix;
else
retval |= reallocPix;
}
if (retval & (mapPix | newDepth | clipPix | stretchPix | reallocPix))
{
GWorldPtr gw_ret, gw_ret_x;
PixMapHandle gw_pmap_ret;
gw_info_t *gw_info_ret;
Rect src_rect, dst_rect;
err = NewGWorld (&gw_ret_x, depth, bounds, ctab, gw_gd, flags);
if (err != noErr)
return err;
gw_ret = MR (gw_ret_x);
gw_info_ret = lookup_gw_info_by_gw (gw_ret);
gw_pmap_ret = CPORT_PIXMAP (gw_ret);
if (PIXMAP_ROWBYTES_X (gw_pmap_ret) != PIXMAP_ROWBYTES_X (gw_pmap))
retval |= newRowBytes;
LockPixels (gw_pmap_ret);
if (flags & (stretchPix | clipPix))
{
if (flags & stretchPix)
{
src_rect = PIXMAP_BOUNDS (gw_pmap);
dst_rect = PIXMAP_BOUNDS (gw_pmap_ret);
}
else /* if (flags & clipPix) */
{
Rect *gw_bounds_ret, *gw_bounds;
Rect temp_rect;
gw_bounds_ret = &PIXMAP_BOUNDS (gw_pmap_ret);
gw_bounds = &PIXMAP_BOUNDS (gw_pmap);
src_rect = *gw_bounds;
dst_rect = *gw_bounds_ret;
OffsetRect (&src_rect,
- CW (src_rect.left), - CW (src_rect.top));
OffsetRect (&dst_rect,
- CW (dst_rect.left), - CW (dst_rect.top));
SectRect (&src_rect, &dst_rect, &temp_rect);
src_rect = dst_rect = temp_rect;
OffsetRect (&src_rect,
CW (gw_bounds->left), CW (gw_bounds->top));
OffsetRect (&dst_rect,
CW (gw_bounds_ret->left), CW (gw_bounds_ret->top));
}
CopyBits (PORT_BITS_FOR_COPY (gw),
PORT_BITS_FOR_COPY (gw_ret),
&src_rect, &dst_rect,
srcCopy, NULL);
}
if (gw_info->flags & pixelsLocked)
{
gw_info_ret->flags |= pixelsLocked;
gw_info_ret->pixel_lock_count = gw_info->pixel_lock_count;
}
else
UnlockPixels (gw_pmap_ret);
DisposeGWorld (gw);
*graphics_world = gw_ret_x;
}
return retval;
}
P1 (PUBLIC pascal trap, void, DisposeGWorld,
GWorldPtr, graphics_world)
{
gw_info_t *gw_info;
if ((GrafPtr) graphics_world == thePort)
thePortX = WMgrPort;
/* FIXME: set the gdevice to something sane as well? */
gw_info = lookup_gw_info_by_gw (graphics_world);
if (! gw_info)
{
warning_unexpected ("no gw_info, no deallocation done");
return;
}
/* dispose the fbuf */
if (gw_info->flags & pixelsLocked)
{
Handle h;
h = RecoverHandle ((Ptr) (PIXMAP_BASEADDR
(gw_info->gw_pixmap)));
DisposHandle (h);
}
else
DisposHandle ((Handle) PIXMAP_BASEADDR (gw_info->gw_pixmap));
if (gw_info->gd_allocated_p)
{
DisposGDevice (gw_info->gw_gd);
}
ClosePort ((GrafPtr) graphics_world);
DisposPtr ((Ptr) graphics_world);
delete_gw_info (gw_info);
}
P2 (PUBLIC pascal trap, void, GetGWorld,
CGrafPtr *, port,
GDHandle *, graphics_device)
{
*port = theCPortX;
*graphics_device = TheGDevice;
}
P2 (PUBLIC pascal trap, void, SetGWorld,
CGrafPtr, port,
GDHandle, graphics_device)
{
if (port && GRAPHICS_WORLD_P (port))
{
gw_info_t *gw_info;
gw_info = lookup_gw_info_by_gw ((GWorldPtr) port);
gui_assert (gw_info);
TheGDevice = RM (gw_info->gw_gd);
}
else
{
if (graphics_device)
TheGDevice = RM (graphics_device);
else
{
PixMapHandle gd_pixmap;
gd_pixmap = GD_PMAP (MR (MainDevice));
if (port
&& (PIXMAP_BASEADDR_X (gd_pixmap) == PORT_BASEADDR_X (port)))
TheGDevice = MainDevice;
}
}
theCPortX = RM (port);
}
P1 (PUBLIC pascal trap, void, AllowPurgePixels,
PixMapHandle, pixels)
{
gw_info_t *gw_info;
Handle pixels_baseaddr_h;
gw_info = lookup_gw_info_by_gw_pixmap (pixels);
if (gw_info)
{
pixels_baseaddr_h = (Handle) PIXMAP_BASEADDR (pixels);
if (gw_info->flags & pixelsLocked)
pixels_baseaddr_h = RecoverHandle((Ptr) pixels_baseaddr_h);
HPurge(pixels_baseaddr_h);
gw_info->flags |= pixelsPurgeable;
}
}
P1 (PUBLIC pascal trap, void, NoPurgePixels,
PixMapHandle, pixels)
{
gw_info_t *gw_info;
Handle pixels_baseaddr_h;
gw_info = lookup_gw_info_by_gw_pixmap (pixels);
if (gw_info)
{
pixels_baseaddr_h = (Handle) PIXMAP_BASEADDR (pixels);
if (gw_info->flags & pixelsLocked)
pixels_baseaddr_h = RecoverHandle((Ptr) pixels_baseaddr_h);
HNoPurge(pixels_baseaddr_h);
gw_info->flags &= ~pixelsPurgeable;
}
}
#define FLAGMASK (pixelsPurgeable|pixelsLocked|keepLocal)
P1 (PUBLIC pascal trap, GWorldFlags, GetPixelsState,
PixMapHandle, pixels)
{
gw_info_t *gw_info;
gw_info = lookup_gw_info_by_gw_pixmap (pixels);
return gw_info ? (gw_info->flags & FLAGMASK) : 0;
}
P2 (PUBLIC pascal trap, void, SetPixelsState,
PixMapHandle, pixels,
GWorldFlags, state)
{
gw_info_t *gw_info;
if (state & pixelsPurgeable)
AllowPurgePixels(pixels);
else
NoPurgePixels(pixels);
if (state & pixelsLocked)
LockPixels(pixels);
else
UnlockPixels(pixels);
gw_info = lookup_gw_info_by_gw_pixmap (pixels);
if (gw_info)
{
if (state & keepLocal)
gw_info->flags |= keepLocal;
else
gw_info->flags &= ~keepLocal;
}
}
P1 (PUBLIC pascal trap, Ptr, GetPixBaseAddr,
PixMapHandle, pixels)
{
gw_info_t *gw_info = lookup_gw_info_by_gw_pixmap (pixels);
if (gw_info == NULL)
{
gw_info = lookup_gw_info_by_gw_gd_pixmap (pixels);
if (gw_info == NULL
/* don't dereference the screen baseaddr! */
|| gw_info->gw_gd == MR (MainDevice))
return PIXMAP_BASEADDR (pixels);
else
return STARH ((Handle) PIXMAP_BASEADDR (pixels));
}
else if (gw_info->flags & pixelsLocked)
return PIXMAP_BASEADDR (pixels);
else
return STARH ((Handle) PIXMAP_BASEADDR (pixels));
}
P4 (PUBLIC pascal trap, QDErr, NewScreenBuffer,
Rect *, global_rect,
Boolean, purgeable_p,
GDHandle *, graphics_device,
PixMapHandle *, offscreen_pixmap)
{
GDHandle max_graphics_device;
PixMapHandle pixels, gd_pixmap;
int width, height;
short rowbytes;
int bpp;
Ptr p;
max_graphics_device = GetMaxDevice (global_rect);
gd_pixmap = GD_PMAP (max_graphics_device);
pixels = NewPixMap ();
if (pixels == NULL)
return cNoMemErr;
bpp = PIXMAP_PIXEL_SIZE (gd_pixmap);
PIXMAP_PIXEL_SIZE_X (pixels) = PIXMAP_PIXEL_SIZE_X (gd_pixmap);
PIXMAP_CMP_COUNT_X (pixels) = PIXMAP_CMP_COUNT_X (gd_pixmap);
PIXMAP_CMP_SIZE_X (pixels) = PIXMAP_CMP_SIZE_X (gd_pixmap);
ROMlib_copy_ctab (PIXMAP_TABLE (gd_pixmap), PIXMAP_TABLE (pixels));
PIXMAP_BOUNDS (pixels) = *global_rect;
height = RECT_HEIGHT (global_rect);
width = RECT_WIDTH (global_rect);
rowbytes = ((width * bpp + 31) / 32) * 4;
PIXMAP_SET_ROWBYTES_X (pixels, CW (rowbytes));
/* not clear if we should be allocating a ptr or a handle for the
pixmap baseaddr */
warning_unexpected ("may be incorrectly allocating pointer");
/* an unlocked pixel map for a graphics world contains a handle to
the pixel data; not a pointer */
p = (Ptr) RM (NewPtr (rowbytes * height));
if (p == NULL)
{
DisposPixMap (pixels);
return cNoMemErr;
}
if (purgeable_p)
AllowPurgePixels (pixels);
else
NoPurgePixels (pixels);
PIXMAP_BASEADDR_X (pixels) = p;
*graphics_device = RM (max_graphics_device);
*offscreen_pixmap = RM (pixels);
return noErr;
}
P1 (PUBLIC pascal trap, void, DisposeScreenBuffer,
PixMapHandle, pixels)
{
gw_info_t *gw_info = lookup_gw_info_by_gw_pixmap (pixels);
/* It's not clear whether we should do more if no gw_info */
if (gw_info)
{
/* dispose of the actual offscreen buffer */
if (gw_info->flags & pixelsLocked)
{
Handle baseaddr;
baseaddr = RecoverHandle (PIXMAP_BASEADDR (pixels));
DisposHandle (baseaddr);
}
else
DisposHandle ((Handle) PIXMAP_BASEADDR (pixels));
/* and the pixmap */
DisposPixMap (pixels);
}
}
P1 (PUBLIC pascal trap, GDHandle, GetGWorldDevice,
GWorldPtr, graphics_world)
{
gw_info_t *gw_info = lookup_gw_info_by_gw (graphics_world);
return gw_info->gw_gd;
}
P1 (PUBLIC pascal trap, Boolean, PixMap32Bit,
PixMapHandle, pixels)
{
warning_unimplemented ("poorly implemented");
return TRUE;
/* #warning "Haven't verified that TRUE is better than 0xff or 0 in PixMap32Bit" */
}
P1 (PUBLIC pascal trap, PixMapHandle, GetGWorldPixMap,
GWorldPtr, port)
{
gw_info_t *gw_info = lookup_gw_info_by_gw (port);
if (gw_info)
return gw_info->gw_pixmap;
else
/* ultima (and others) call `GetGWorldPixMap ()' with a non-gworld
port */
return CPORT_PIXMAP (port);
}
P4 (PUBLIC pascal trap, QDErr, NewTempScreenBuffer,
Rect *, global_rect,
Boolean, purgeable_p,
GDHandle *, graphics_device,
PixMapHandle *, offscreen_pixmap)
{
gui_fatal ("unimplemented");
#if !defined (LETGCCWAIL)
return paramErr;
#endif
}
P0 (PUBLIC pascal trap, LONGINT, OffscreenVersion)
{
/* #warning OffscreenVersion not properly implemented */
warning_unimplemented ("poorly implemented");
return 0x130;
}
P1 (PUBLIC pascal trap, void, GDeviceChanged,
GDHandle, graphics_device)
{
/* #warning GDeviceChanged not implemented */
ROMlib_invalidate_conversion_tables ();
warning_unimplemented (NULL_STRING);
}
P1 (PUBLIC pascal trap, void, PortChanged,
GrafPtr, port)
{
/* #warning "PortChanged not implemented; worked around for hypercard" */
ROMlib_invalidate_conversion_tables ();
warning_unimplemented (NULL_STRING);
}
P1 (PUBLIC pascal trap, void, PixPatChanged,
PixPatHandle, pixpat)
{
/* #warning "PixPatChanged not implemented" */
ROMlib_invalidate_conversion_tables ();
warning_unimplemented (NULL_STRING);
}
P1 (PUBLIC pascal trap, void, CTabChanged,
CTabHandle, ctab)
{
/* #warning "CTabChanged not implemented" */
ROMlib_invalidate_conversion_tables ();
warning_unimplemented (NULL_STRING);
}
P1 (PUBLIC pascal trap, Boolean, QDDone,
GrafPtr, port)
{
/* #warning "QDDone not implemented" */
warning_unimplemented (NULL_STRING);
return TRUE;
}
Reference in New Issue View Git Blame Copy Permalink