PRIVATE CTabHandle
ctab_from_surface (SDL_Surface *surfp)
{
CTabHandle retval;
int n_colors;
SDL_Color *ip;
ColorSpec *op;
int i;
retval = NULL;
n_colors = SDL_n_colors (surfp);
retval = (CTabHandle) NewHandle (CTAB_STORAGE_FOR_SIZE (n_colors-1));
CTAB_SIZE_X (retval) = CW (n_colors - 1);
CTAB_SEED_X (retval) = CL (GetCTSeed ());
CTAB_FLAGS_X (retval) = CTAB_GDEVICE_BIT_X;
for (i = 0, ip = SDL_colors (surfp), op = CTAB_TABLE (retval);
i < n_colors;
++i, ++ip, ++op)
{
op->value = CWC (0);
op->rgb.red = MAC_COLOR_COMPONENT_FROM_SDL_CC (ip->r);
op->rgb.green = MAC_COLOR_COMPONENT_FROM_SDL_CC (ip->g);
op->rgb.blue = MAC_COLOR_COMPONENT_FROM_SDL_CC (ip->b);
}
return retval;
}
OSErr EI_MakeImageDescription(ImageFramePtr frame, long colorCount, UInt8 *color, ImageDescriptionHandle *descOut)
{
OSErr err = noErr;
ImageDescriptionHandle desc = NULL;
ImageDescriptionPtr idp;
CTabHandle colors = NULL;
desc = (ImageDescriptionHandle)NewHandleClear(sizeof(ImageDescription));
if ( (err = MemError()) ) goto bail;
idp = *desc;
idp->idSize = sizeof(ImageDescription); // total size of this image description structure with extra data including color lookup tables and other per sequence data
idp->cType = FOUR_CHAR_CODE(kEI_Sig); // type of compressor component that created this compressed image data
idp->vendor = kAppleManufacturer; // identifies the developer of the compressor that created the compressed image
idp->frameCount = 1; // the number of frames in the image data associated with this description
idp->depth = frame->frameBitDepth + frame->frameAlpha; // pixel depth specified for the compressed image
idp->clutID = -1; // ID of the color table for the compressed image, -1 if the image does not use a color table
idp->hRes = idp->vRes = 72L << 16; // resolution dpi
idp->width = EndianU16_BtoN(frame->frameRect.right) - EndianU16_BtoN(frame->frameRect.left); // image width in pixels
idp->height = EndianU16_BtoN(frame->frameRect.bottom) - EndianU16_BtoN(frame->frameRect.top); // image height in pixels
idp->version = 0; // the version of the compressed data
// make up a color table, if there is one
if (colorCount > 2) {
int i;
colors = (CTabHandle)NewHandleClear(sizeof(ColorTable) + colorCount * sizeof(ColorSpec));
if ( (err = MemError()) ) goto bail;
(**colors).ctFlags = 0;
(**colors).ctSeed = GetCTSeed();
(**colors).ctSize = colorCount - 1;
for (i=0; i<colorCount; i++) {
(**colors).ctTable[i].value = i;
(**colors).ctTable[i].rgb.red = (color[0] << 8) | color[0];
(**colors).ctTable[i].rgb.green = (color[1] << 8) | color[1];
(**colors).ctTable[i].rgb.blue = (color[2] << 8) | color[2];
color += 3;
}
// copy the custom color table into the image description structure
err = SetImageDescriptionCTable(desc, colors);
if (err) goto bail;
}
bail:
if (colors)
DisposeCTable(colors);
if (desc && err) {
DisposeHandle((Handle)desc);
desc = NULL;
}
*descOut = desc;
return err;
}
CTabHandle build_macintosh_color_table(
color_table *table)
{
CTabHandle clut;
int i,n;
rgb_color *src;
ColorSpec *dst;
n=table->color_count;
if (n<0) {
n=0;
} else if (n>256) {
n=256;
}
clut=(CTabHandle)NewHandleClear(offsetof(ColorTable,ctTable)+n*sizeof (ColorSpec));
if (clut) {
(*clut)->ctSeed=GetCTSeed();
(*clut)->ctSize=n-1;
src=table->colors;
dst=(*clut)->ctTable;
for (i=0; i<n; i++) {
dst->value=i;
dst->rgb.red=src->red;
dst->rgb.green=src->green;
dst->rgb.blue=src->blue;
src++;
dst++;
}
}
return clut;
}
void dump_colors(
struct rgb_color_value *colors,
short color_count)
{
CTabHandle new_table;
Handle old_bad_clut;
struct rgb_color_value *color;
short loop;
FSSpec file;
short refnum;
file.vRefNum= -1;
file.parID= 2;
strcpy((char *)file.name, (const char *)"\pMarathon2 Clut\0");
FSpCreateResFile(&file, 'RSED', 'rsrc', smSystemScript);
refnum= FSpOpenResFile(&file, fsWrPerm);
if(refnum>=0)
{
new_table= (CTabHandle) NewHandleClear(sizeof(ColorTable)+color_count*sizeof(ColorSpec));
HLock((Handle) new_table);
(*new_table)->ctSeed= GetCTSeed();
(*new_table)->ctFlags= 0;
(*new_table)->ctSize= color_count-1;
/* Slam the colors.. */
color= colors;
for(loop=0; loop<=color_count; ++loop)
{
(*new_table)->ctTable[loop].rgb.red= color->red;
(*new_table)->ctTable[loop].rgb.green= color->green;
(*new_table)->ctTable[loop].rgb.blue= color->blue;
(*new_table)->ctTable[loop].value= loop;
color++;
}
HUnlock((Handle) new_table);
old_bad_clut= GetResource('clut', 5454);
if (old_bad_clut)
{
RmveResource((Handle) old_bad_clut);
DisposeHandle((Handle) old_bad_clut);
UpdateResFile(CurResFile());
}
AddResource((Handle) new_table, 'clut', 5454, "\pMarathon2 Color Table");
if(ResError()) dprintf("Err adding it: %d", ResError());
WriteResource((Handle) new_table);
ReleaseResource((Handle) new_table);
CloseResFile(refnum);
}
static void InitMacColorTable (int first, int last, CTabHandle *ctabptr)
{
register i;
CTabHandle ctab;
*ctabptr = ctab = (CTabHandle)
NewHandle (sizeof(ColorTable) + (last-first)*sizeof(ColorSpec));
(*ctab)->ctSize = last-first;
(*ctab)->ctSeed = GetCTSeed();
(*ctab)->ctFlags = (short) (((unsigned short)(-1))<<15);
for (i=first; i<=last; i++)
(*ctab)->ctTable[i-first].value = i;
}
static int ROM_VideoInit(_THIS, SDL_PixelFormat *vformat)
{
long info;
/* Check out some things about the system */
Gestalt(gestaltQuickdrawVersion, &info);
if ( info == gestaltOriginalQD ) {
SDL_SetError("Color Quickdraw not available");
return(-1);
}
/* Start ROMintosh events */
Mac_InitEvents(this);
/* Get a handle to the main monitor */
SDL_Display = GetMainDevice();
/* Determine the current screen size */
this->info.current_w = (**SDL_Display).gdRect.right;
this->info.current_h = (**SDL_Display).gdRect.bottom;
/* Determine pixel format */
vformat->BitsPerPixel = (**(**SDL_Display).gdPMap).pixelSize;
switch (vformat->BitsPerPixel) {
case 16: /* 5-5-5 RGB */
vformat->Rmask = 0x00007c00;
vformat->Gmask = 0x000003e0;
vformat->Bmask = 0x0000001f;
break;
default:
break;
}
/* Create our palette */
SDL_CTab = (CTabHandle)NewHandle(sizeof(ColorSpec)*256 + 8);
if ( SDL_CTab == nil ) {
SDL_OutOfMemory();
return(-1);
}
(**SDL_CTab).ctSeed = GetCTSeed();
(**SDL_CTab).ctFlags = 0;
(**SDL_CTab).ctSize = 255;
CTabChanged(SDL_CTab);
SDL_CPal = NewPalette(256, SDL_CTab, pmExplicit+pmTolerant, 0);
/* Get a list of available fullscreen modes */
SDL_modelist = (SDL_Rect **)SDL_malloc((1+1)*sizeof(SDL_Rect *));
if ( SDL_modelist ) {
SDL_modelist[0] = (SDL_Rect *)SDL_malloc(sizeof(SDL_Rect));
if ( SDL_modelist[0] ) {
SDL_modelist[0]->x = 0;
SDL_modelist[0]->y = 0;
SDL_modelist[0]->w = (**SDL_Display).gdRect.right;
SDL_modelist[0]->h = (**SDL_Display).gdRect.bottom;
}
SDL_modelist[1] = NULL;
}
/* Fill in some window manager capabilities */
this->info.wm_available = 1;
/* We're done! */
return(0);
}
static void SetUpPixmap(void) {
int i, r, g, b;
stColorTable = (CTabHandle) NewHandle(sizeof(ColorTable) + (256 * sizeof(ColorSpec)));
(*stColorTable)->ctSeed = GetCTSeed();
(*stColorTable)->ctFlags = 0;
(*stColorTable)->ctSize = 255;
/* 1-bit colors (monochrome) */
SetColorEntry(0, 65535, 65535, 65535); /* white or transparent */
SetColorEntry(1, 0, 0, 0); /* black */
/* additional colors for 2-bit color */
SetColorEntry(2, 65535, 65535, 65535); /* opaque white */
SetColorEntry(3, 32768, 32768, 32768); /* 1/2 gray */
/* additional colors for 4-bit color */
SetColorEntry( 4, 65535, 0, 0); /* red */
SetColorEntry( 5, 0, 65535, 0); /* green */
SetColorEntry( 6, 0, 0, 65535); /* blue */
SetColorEntry( 7, 0, 65535, 65535); /* cyan */
SetColorEntry( 8, 65535, 65535, 0); /* yellow */
SetColorEntry( 9, 65535, 0, 65535); /* magenta */
SetColorEntry(10, 8192, 8192, 8192); /* 1/8 gray */
SetColorEntry(11, 16384, 16384, 16384); /* 2/8 gray */
SetColorEntry(12, 24576, 24576, 24576); /* 3/8 gray */
SetColorEntry(13, 40959, 40959, 40959); /* 5/8 gray */
SetColorEntry(14, 49151, 49151, 49151); /* 6/8 gray */
SetColorEntry(15, 57343, 57343, 57343); /* 7/8 gray */
/* additional colors for 8-bit color */
/* 24 more shades of gray (does not repeat 1/8th increments) */
SetColorEntry(16, 2048, 2048, 2048); /* 1/32 gray */
SetColorEntry(17, 4096, 4096, 4096); /* 2/32 gray */
SetColorEntry(18, 6144, 6144, 6144); /* 3/32 gray */
SetColorEntry(19, 10240, 10240, 10240); /* 5/32 gray */
SetColorEntry(20, 12288, 12288, 12288); /* 6/32 gray */
SetColorEntry(21, 14336, 14336, 14336); /* 7/32 gray */
SetColorEntry(22, 18432, 18432, 18432); /* 9/32 gray */
SetColorEntry(23, 20480, 20480, 20480); /* 10/32 gray */
SetColorEntry(24, 22528, 22528, 22528); /* 11/32 gray */
SetColorEntry(25, 26624, 26624, 26624); /* 13/32 gray */
SetColorEntry(26, 28672, 28672, 28672); /* 14/32 gray */
SetColorEntry(27, 30720, 30720, 30720); /* 15/32 gray */
SetColorEntry(28, 34815, 34815, 34815); /* 17/32 gray */
SetColorEntry(29, 36863, 36863, 36863); /* 18/32 gray */
SetColorEntry(30, 38911, 38911, 38911); /* 19/32 gray */
SetColorEntry(31, 43007, 43007, 43007); /* 21/32 gray */
SetColorEntry(32, 45055, 45055, 45055); /* 22/32 gray */
SetColorEntry(33, 47103, 47103, 47103); /* 23/32 gray */
SetColorEntry(34, 51199, 51199, 51199); /* 25/32 gray */
SetColorEntry(35, 53247, 53247, 53247); /* 26/32 gray */
SetColorEntry(36, 55295, 55295, 55295); /* 27/32 gray */
SetColorEntry(37, 59391, 59391, 59391); /* 29/32 gray */
SetColorEntry(38, 61439, 61439, 61439); /* 30/32 gray */
SetColorEntry(39, 63487, 63487, 63487); /* 31/32 gray */
/* The remainder of color table defines a color cube with six steps
for each primary color. Note that the corners of this cube repeat
previous colors, but simplifies the mapping between RGB colors and
color map indices. This color cube spans indices 40 through 255.
*/
for (r = 0; r < 6; r++) {
for (g = 0; g < 6; g++) {
for (b = 0; b < 6; b++) {
i = 40 + ((36 * r) + (6 * b) + g);
SetColorEntry(i, (r * 65535) / 5, (g * 65535) / 5, (b * 65535) / 5);
}
}
}
stPixMap = NewPixMap();
(*stPixMap)->pixelType = 0; /* chunky */
(*stPixMap)->cmpCount = 1;
(*stPixMap)->pmTable = stColorTable;
}
void wxCursor::CreateFromImage(const wxImage & image)
{
m_refData = new wxCursorRefData;
int w = 16;
int h = 16;
int hotSpotX = image.GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X);
int hotSpotY = image.GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
int image_w = image.GetWidth();
int image_h = image.GetHeight();
wxASSERT_MSG( hotSpotX >= 0 && hotSpotX < image_w &&
hotSpotY >= 0 && hotSpotY < image_h,
_T("invalid cursor hot spot coordinates") );
wxImage image16(image); // final image of correct size
// if image is too small then place it in the center, resize it if too big
if ((w > image_w) && (h > image_h))
{
wxPoint offset((w - image_w)/2, (h - image_h)/2);
hotSpotX = hotSpotX + offset.x;
hotSpotY = hotSpotY + offset.y;
image16 = image.Size(wxSize(w, h), offset);
}
else if ((w != image_w) || (h != image_h))
{
hotSpotX = int(hotSpotX * double(w) / double(image_w));
hotSpotY = int(hotSpotY * double(h) / double(image_h));
image16 = image.Scale(w, h);
}
unsigned char * rgbBits = image16.GetData();
bool bHasMask = image16.HasMask() ;
#if 0
// monochrome implementation
M_CURSORDATA->m_hCursor = NewHandle( sizeof( Cursor ) ) ;
M_CURSORDATA->m_disposeHandle = true ;
HLock( (Handle) M_CURSORDATA->m_hCursor ) ;
CursPtr cp = *(CursHandle)M_CURSORDATA->m_hCursor ;
memset( cp->data , 0 , sizeof( Bits16 ) ) ;
memset( cp->mask , 0 , sizeof( Bits16 ) ) ;
unsigned char mr = image16.GetMaskRed() ;
unsigned char mg = image16.GetMaskGreen() ;
unsigned char mb = image16.GetMaskBlue() ;
for ( int y = 0 ; y < h ; ++y )
{
short rowbits = 0 ;
short maskbits = 0 ;
for ( int x = 0 ; x < w ; ++x )
{
long pos = (y * w + x) * 3;
unsigned char r = rgbBits[pos] ;
unsigned char g = rgbBits[pos+1] ;
unsigned char b = rgbBits[pos+2] ;
if ( bHasMask && r==mr && g==mg && b==mb )
{
// masked area, does not appear anywhere
}
else
{
if ( (int)r + (int)g + (int)b < 0x0200 )
{
rowbits |= ( 1 << (15-x) ) ;
}
maskbits |= ( 1 << (15-x) ) ;
}
}
cp->data[y] = rowbits ;
cp->mask[y] = maskbits ;
}
if ( !bHasMask )
{
memcpy( cp->mask , cp->data , sizeof( Bits16) ) ;
}
cp->hotSpot.h = hotSpotX ;
cp->hotSpot.v = hotSpotY ;
HUnlock( (Handle) M_CURSORDATA->m_hCursor ) ;
#else
PixMapHandle pm = (PixMapHandle) NewHandleClear( sizeof (PixMap)) ;
short extent = 16 ;
short bytesPerPixel = 1 ;
short depth = 8 ;
Rect bounds = { 0 , 0 , extent , extent } ;
CCrsrHandle ch = (CCrsrHandle) NewHandleClear ( sizeof( CCrsr ) ) ;
CTabHandle newColors = GetCTable( 8 ) ;
HandToHand((Handle *) &newColors);
// set the values to the indices
for ( int i = 0 ; i < (**newColors).ctSize ; ++i )
{
(**newColors).ctTable[i].value = i ;
}
HLock( (Handle) ch) ;
(**ch).crsrType = 0x8001 ; // color cursors
(**ch).crsrMap = pm ;
short bytesPerRow = bytesPerPixel * extent ;
(**pm).baseAddr = 0;
(**pm).rowBytes = bytesPerRow | 0x8000;
(**pm).bounds = bounds;
(**pm).pmVersion = 0;
(**pm).packType = 0;
(**pm).packSize = 0;
(**pm).hRes = 0x00480000; /* 72 DPI default res */
(**pm).vRes = 0x00480000; /* 72 DPI default res */
(**pm).pixelSize = depth;
(**pm).pixelType = 0;
(**pm).cmpCount = 1;
(**pm).cmpSize = depth;
(**pm).pmTable = newColors;
(**ch).crsrData = NewHandleClear( extent * bytesPerRow ) ;
(**ch).crsrXData = NULL ;
(**ch).crsrXValid = 0;
(**ch).crsrXHandle = NULL;
(**ch).crsrHotSpot.h = hotSpotX ;
(**ch).crsrHotSpot.v = hotSpotY ;
(**ch).crsrXTable = NULL ;
(**ch).crsrID = GetCTSeed() ;
memset( (**ch).crsr1Data , 0 , sizeof( Bits16 ) ) ;
memset( (**ch).crsrMask , 0 , sizeof( Bits16 ) ) ;
unsigned char mr = image16.GetMaskRed() ;
unsigned char mg = image16.GetMaskGreen() ;
unsigned char mb = image16.GetMaskBlue() ;
for ( int y = 0 ; y < h ; ++y )
{
short rowbits = 0 ;
short maskbits = 0 ;
for ( int x = 0 ; x < w ; ++x )
{
long pos = (y * w + x) * 3;
unsigned char r = rgbBits[pos] ;
unsigned char g = rgbBits[pos+1] ;
unsigned char b = rgbBits[pos+2] ;
RGBColor col = { 0xFFFF ,0xFFFF, 0xFFFF } ;
if ( bHasMask && r==mr && g==mg && b==mb )
{
// masked area, does not appear anywhere
}
else
{
if ( (int)r + (int)g + (int)b < 0x0200 )
{
rowbits |= ( 1 << (15-x) ) ;
}
maskbits |= ( 1 << (15-x) ) ;
col = *((RGBColor*) wxColor( r , g , b ).GetPixel()) ;
}
*((*(**ch).crsrData) + y * bytesPerRow + x) =
GetCTabIndex( newColors , &col) ;
}
(**ch).crsr1Data[y] = rowbits ;
(**ch).crsrMask[y] = maskbits ;
}
if ( !bHasMask )
{
memcpy( (**ch).crsrMask , (**ch).crsr1Data , sizeof( Bits16) ) ;
}
HUnlock((Handle) ch) ;
M_CURSORDATA->m_hCursor = ch ;
M_CURSORDATA->m_isColorCursor = true ;
#endif
}
void createOffscreen()
{
Rect rect;
Handle iclHandle;
char *image;
int row, col, index, value;
SetRect( &rect, 0, 0, 32, 32 );
/* Create offscreen pixmap image using an 'icl8' icon resource. */
iclHandle = GetResource( 'icl8', 129 );
HandToHand( &iclHandle );
HLock( iclHandle );
HNoPurge( iclHandle );
//gPixmap = (PixMapHandle)NewHandle( sizeof( PixMap ) );
gPixmap = NewPixMap();
(**gPixmap).baseAddr = *iclHandle;
(**gPixmap).rowBytes = ((32 * 8) / 8) | 0x8000;
(**gPixmap).bounds = rect;
(**gPixmap).pmVersion = 0;
(**gPixmap).packType = 0;
(**gPixmap).packSize = 0;
(**gPixmap).hRes = 72;
(**gPixmap).vRes = 72;
(**gPixmap).pixelSize = 8;
//(**gPixmap).planeBytes = 0;
//(**gPixmap).pmReserved = 0;
(**gPixmap).pixelType = 0;
(**gPixmap).cmpCount = 1;
(**gPixmap).cmpSize = 8;
(**gPixmap).pmTable = GetCTable( 8 );
(**gPixmap).pixelFormat = 0;
/* Give a unique seed for the pixmap's colortable. */
(**(**gPixmap).pmTable).ctSeed = GetCTSeed();
SetRect( &rect, 0, 0, 20, 20 );
/* Set the pointer to the beginning of the pixel image. */
image = GetPixBaseAddr( gPixmap );
/*****************************************************************/
/* For this example, let's set the pixel values of the left half */
/* of the image to half their original values. */
/*****************************************************************/
for (row = 0; row < rect.bottom; row++)
{
// Loop through the first 10 columns of the pixel image.
for (index = 0, col = 0; col < rect.right / 2; col++)
{
// Set the value at this index to half its value.
value = (unsigned char)*(image + index);
*(image + index) = value / 2;
index++;
}
// Increment the pointer to the next row of the pixel image.
image += ((**gPixmap).rowBytes & 0x7fff);
}
}
PixMapHandle get_shape_pixmap(
short shape,
boolean force_copy)
{
OSErr error;
struct collection_definition *collection;
struct low_level_shape_definition *low_level_shape;
struct bitmap_definition *bitmap;
short collection_index, low_level_shape_index, clut_index;
collection_index= GET_COLLECTION(GET_DESCRIPTOR_COLLECTION(shape));
clut_index= GET_COLLECTION_CLUT(GET_DESCRIPTOR_COLLECTION(shape));
low_level_shape_index= GET_DESCRIPTOR_SHAPE(shape);
collection= get_collection_definition(collection_index);
switch (interface_bit_depth)
{
case 8:
/* if the ctSeed of our offscreen pixmap is different from the ctSeed of the world
device then the color environment has changed since the last call to our routine,
and we just HandToHand the deviceÕs ctTable and throw away our old one. */
if ((*(*(*world_device)->gdPMap)->pmTable)->ctSeed!=(*(*hollow_pixmap)->pmTable)->ctSeed)
{
DisposeHandle((Handle)(*hollow_pixmap)->pmTable);
(*hollow_pixmap)->pmTable= (*(*world_device)->gdPMap)->pmTable;
HLock((Handle)hollow_pixmap);
error= HandToHand((Handle *)&(*hollow_pixmap)->pmTable);
HUnlock((Handle)hollow_pixmap);
assert(error==noErr);
/* this is a device color table so we donÕt clear ctFlags (well, it isnÕt a device
color table anymore, but itÕs formatted like one */
}
break;
case 16:
case 32:
if (!hollow_pixmap_color_table)
{
hollow_pixmap_color_table= (CTabHandle) NewHandle(sizeof(ColorTable)+PIXEL8_MAXIMUM_COLORS*sizeof(ColorSpec));
MoveHHi((Handle)hollow_pixmap_color_table);
HLock((Handle)hollow_pixmap_color_table);
assert(hollow_pixmap_color_table);
}
(*hollow_pixmap_color_table)->ctSeed= GetCTSeed();
(*hollow_pixmap_color_table)->ctSize= collection->color_count-NUMBER_OF_PRIVATE_COLORS-1;
(*hollow_pixmap_color_table)->ctFlags= 0;
BlockMove(get_collection_colors(collection_index, clut_index)+NUMBER_OF_PRIVATE_COLORS, &(*hollow_pixmap_color_table)->ctTable,
(collection->color_count-NUMBER_OF_PRIVATE_COLORS)*sizeof(ColorSpec));
(*hollow_pixmap)->pmTable= hollow_pixmap_color_table;
break;
default:
halt();
}
low_level_shape= get_low_level_shape_definition(collection_index, low_level_shape_index);
bitmap= get_bitmap_definition(collection_index, low_level_shape->bitmap_index);
/* setup the pixmap (canÕt wait to change this for Copland) */
SetRect(&(*hollow_pixmap)->bounds, 0, 0, bitmap->width, bitmap->height);
(*hollow_pixmap)->rowBytes= bitmap->width|0x8000;
(*hollow_pixmap)->baseAddr= (Ptr)bitmap->row_addresses[0];
if (bitmap->bytes_per_row==NONE) /* is this a compressed shape? */
{
register pixel8 *read, *write;
register short run_count;
short x;
/* for now all RLE shapes are in column-order */
assert(bitmap->flags&_COLUMN_ORDER_BIT);
/* donÕt overflow the buffer */
assert(bitmap->width*bitmap->height<=HOLLOW_PIXMAP_BUFFER_SIZE);
/* decompress column-order shape into row-order buffer */
for (x=0;x<bitmap->width;x+=1)
{
short bytes_per_row= bitmap->width;
write= hollow_data+x;
read= bitmap->row_addresses[x];
while (run_count= *((short*)read)++)
{
if (run_count<0) while ((run_count+=1)<=0) *write= iBLACK, write+= bytes_per_row; /* fill transparent areas with black */
else while ((run_count-=1)>=0) *write= *read++, write+= bytes_per_row; /* copy shape data */
}
}
(*hollow_pixmap)->baseAddr= (Ptr)hollow_data;
}
else
{
/* if this is a raw, row-order shape then only copy it if weÕve been asked to */
if (force_copy)
{
assert(bitmap->width*bitmap->height<=HOLLOW_PIXMAP_BUFFER_SIZE);
BlockMove(bitmap->row_addresses[0], hollow_data, bitmap->width*bitmap->height);
(*hollow_pixmap)->baseAddr= (Ptr)hollow_data;
}
}
return hollow_pixmap;
}
PixMapHandle editor_get_shape_pixmap(
short shape)
{
OSErr error;
struct collection_definition *collection;
struct low_level_shape_definition *low_level_shape;
struct bitmap_definition *bitmap;
short collection_index, low_level_shape_index, clut_index;
collection_index= GET_COLLECTION(GET_DESCRIPTOR_COLLECTION(shape));
clut_index= GET_COLLECTION_CLUT(GET_DESCRIPTOR_COLLECTION(shape));
low_level_shape_index= GET_DESCRIPTOR_SHAPE(shape);
collection= get_collection_definition(collection_index);
switch (interface_bit_depth)
{
case 8:
/* if the ctSeed of our offscreen pixmap is different from the ctSeed of the world
device then the color environment has changed since the last call to our routine,
and we just HandToHand the deviceÕs ctTable and throw away our old one. */
if ((*(*(*world_device)->gdPMap)->pmTable)->ctSeed!=(*(*hollow_pixmap)->pmTable)->ctSeed)
{
DisposeHandle((Handle)(*hollow_pixmap)->pmTable);
(*hollow_pixmap)->pmTable= (*(*world_device)->gdPMap)->pmTable;
HLock((Handle)hollow_pixmap);
error= HandToHand((Handle *)&(*hollow_pixmap)->pmTable);
HUnlock((Handle)hollow_pixmap);
assert(error==noErr);
/* this is a device color table so we donÕt clear ctFlags (well, it isnÕt a device
color table anymore, but itÕs formatted like one */
}
break;
case 16:
case 32:
if (!hollow_pixmap_color_table)
{
hollow_pixmap_color_table= (CTabHandle) NewHandle(sizeof(ColorTable)+PIXEL8_MAXIMUM_COLORS*sizeof(ColorSpec));
MoveHHi((Handle)hollow_pixmap_color_table);
HLock((Handle)hollow_pixmap_color_table);
assert(hollow_pixmap_color_table);
}
(*hollow_pixmap_color_table)->ctSeed= GetCTSeed();
(*hollow_pixmap_color_table)->ctSize= collection->color_count-NUMBER_OF_PRIVATE_COLORS-1;
(*hollow_pixmap_color_table)->ctFlags= 0;
BlockMove(get_collection_colors(collection_index, clut_index)+NUMBER_OF_PRIVATE_COLORS, &(*hollow_pixmap_color_table)->ctTable,
(collection->color_count-NUMBER_OF_PRIVATE_COLORS)*sizeof(ColorSpec));
(*hollow_pixmap)->pmTable= hollow_pixmap_color_table;
break;
default:
halt();
}
low_level_shape= get_low_level_shape_definition(collection_index, low_level_shape_index);
bitmap= get_bitmap_definition(collection_index, low_level_shape->bitmap_index);
/* setup the pixmap (canÕt wait to change this for Copland) */
SetRect(&(*hollow_pixmap)->bounds, 0, 0, bitmap->width, bitmap->height);
(*hollow_pixmap)->rowBytes= bitmap->width|0x8000;
(*hollow_pixmap)->baseAddr= (Ptr)bitmap->row_addresses[0];
/* Rotate if necessary */
if ((bitmap->flags&_COLUMN_ORDER_BIT) && bitmap->width==128 && bitmap->height==128)
{
static char *buffer= NULL;
if(!buffer)
{
buffer= (char *)malloc(bitmap->width*bitmap->height*sizeof(pixel8));
}
if(buffer)
{
short x, y;
pixel8 *dest= (pixel8 *) buffer;
/* decompress column-order shape into row-order buffer */
for (x=0;x<bitmap->width;x+=1)
{
for(y= 0; y<bitmap->height; y+=1)
{
*dest++= bitmap->row_addresses[y][x];
}
}
(*hollow_pixmap)->baseAddr= buffer;
}
}
return hollow_pixmap;
}
