void CAUGuiGraphic::loadImagePNG ( char* pngFileName )
{
CFBundleRef bundleRef = CFBundleGetBundleWithIdentifier(CFSTR( AU_BUNDLE_IDENTIFIER ));
CGDataProviderRef provider;
if ( bundleRef )
{
SInt16 tmp = CurResFile();
CFStringRef fileName = ::CFStringCreateWithCString( NULL, pngFileName, kCFStringEncodingASCII );
if ( fileName != NULL )
{
CFURLRef url = ::CFBundleCopyResourceURL( bundleRef, fileName, NULL, NULL );
provider = CGDataProviderCreateWithURL( url );
Image = CGImageCreateWithPNGDataProvider( provider, NULL, false, kCGRenderingIntentDefault );
CGDataProviderRelease( provider );
CFRelease( url );
CFRelease( fileName );
}
else
{
Image = NULL;
}
UseResFile(tmp);
}
}
static CGImageRef GetThePoofImage()
{
CGDataProviderRef provider;
CFStringRef fileName = NULL;
CGImageRef image = NULL;
CFURLRef url = NULL;
CFBundleRef appBundle = CFBundleGetMainBundle();
if ( appBundle == NULL ) goto Bail;
fileName = CFStringCreateWithCString( NULL, "ToolbarPoof.png", kCFStringEncodingASCII ); // ToolbarPoof.png is in our Resources directory within the bundle
if ( fileName == NULL ) goto Bail;
url = CFBundleCopyResourceURL( appBundle, fileName, NULL, NULL );
if ( url == NULL ) goto Bail;
provider = CGDataProviderCreateWithURL( url );
image = CGImageCreateWithPNGDataProvider( provider, NULL, false, kCGRenderingIntentDefault );
CGDataProviderRelease( provider );
Bail:
if ( fileName != NULL ) CFRelease( fileName );
if ( url != NULL ) CFRelease( url );
return( image );
}
unsigned char* os_image_load_from_file(const char* filename, int* outWidth, int* outHeight, int* outChannels, int unused) {
const int fileHandle = open(filename, O_RDONLY);
struct stat statBuffer;
fstat(fileHandle, &statBuffer);
const size_t bytesInFile = (size_t)(statBuffer.st_size);
uint8_t* fileData = (uint8_t*)(mmap(NULL, bytesInFile, PROT_READ, MAP_SHARED, fileHandle, 0));
if (fileData == MAP_FAILED) {
fprintf(stderr, "Couldn't open file '%s' with mmap\n", filename);
return NULL;
}
CFDataRef fileDataRef = CFDataCreateWithBytesNoCopy(NULL, fileData, bytesInFile, kCFAllocatorNull);
CGDataProviderRef imageProvider = CGDataProviderCreateWithCFData(fileDataRef);
const char* suffix = strrchr(filename, '.');
if (!suffix || suffix == filename) {
suffix = "";
}
CGImageRef image;
if (strcasecmp(suffix, ".png") == 0) {
image = CGImageCreateWithPNGDataProvider(imageProvider, NULL, true, kCGRenderingIntentDefault);
} else if ((strcasecmp(suffix, ".jpg") == 0) ||
(strcasecmp(suffix, ".jpeg") == 0)) {
image = CGImageCreateWithJPEGDataProvider(imageProvider, NULL, true, kCGRenderingIntentDefault);
} else {
munmap(fileData, bytesInFile);
close(fileHandle);
CFRelease(imageProvider);
CFRelease(fileDataRef);
fprintf(stderr, "Unknown suffix for file '%s'\n", filename);
return NULL;
}
const int width = (int)CGImageGetWidth(image);
const int height = (int)CGImageGetHeight(image);
const int channels = 4;
CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
const int bytesPerRow = (width * channels);
const int bytesInImage = (bytesPerRow * height);
uint8_t* result = (uint8_t*)(malloc(bytesInImage));
const int bitsPerComponent = 8;
CGContextRef context = CGBitmapContextCreate(result, width, height,
bitsPerComponent, bytesPerRow, colorSpace,
kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big);
CGColorSpaceRelease(colorSpace);
CGContextDrawImage(context, CGRectMake(0, 0, width, height), image);
CGContextRelease(context);
CFRelease(image);
munmap(fileData, bytesInFile);
close(fileHandle);
CFRelease(imageProvider);
CFRelease(fileDataRef);
*outWidth = width;
*outHeight = height;
*outChannels = channels;
return result;
}
CGImageRef CGImageCreateWithPNGDataProvider_wrap(
CGDataProviderRef source,
objVectorOop decodeArrayOop,
bool shouldInterpolate,
uint32 colorRenderingIntent,
void* FH) {
float* decodeArray; uint32 decodeLen;
return
convertFloatObjVector( decodeArrayOop, "CGImageCreateWithPNGDataProvider", FH,
decodeArray, decodeLen)
? CGImageCreateWithPNGDataProvider( source, decodeArray, shouldInterpolate, CGColorRenderingIntent(colorRenderingIntent))
: NULL;
}
UncompressedImage
LoadPNG(Path path)
{
CGDataProviderRef data_provider = CGDataProviderCreateWithFilename(path.c_str());
if (nullptr == data_provider)
return UncompressedImage();
CGImageRef image = CGImageCreateWithPNGDataProvider(
data_provider, nullptr, false, kCGRenderingIntentDefault);
UncompressedImage result = CGImageToUncompressedImage(image);
if (nullptr != image)
CFRelease(image);
CFRelease(data_provider);
return result;
}
UncompressedImage
LoadPNG(const void *data, size_t size)
{
CGDataProviderRef data_provider = CGDataProviderCreateWithData(
nullptr, data, size, nullptr);
if (nullptr == data_provider)
return UncompressedImage();
CGImageRef image = CGImageCreateWithPNGDataProvider(
data_provider, nullptr, false, kCGRenderingIntentDefault);
UncompressedImage result = CGImageToUncompressedImage(image);
if (nullptr != image)
CFRelease(image);
CFRelease(data_provider);
return result;
}
CGImageRef nglImageCGCodec::ReadInfo(nglIStream* pIStream)
{
mpIStream = pIStream;
CGImageRef pCGImage = NULL;
const bool shouldInterpolate = true;
if (ProbePNG(pIStream))
{
pCGImage = CGImageCreateWithPNGDataProvider(mpCGProvider, NULL, shouldInterpolate, kCGRenderingIntentDefault);
}
else if (ProbeJPEG(pIStream))
{
pCGImage = CGImageCreateWithJPEGDataProvider(mpCGProvider, NULL, false, kCGRenderingIntentDefault);
}
if (pCGImage)
{
nglImageInfo info;
info.mWidth = CGImageGetWidth(pCGImage);
info.mHeight = CGImageGetHeight(pCGImage);
if (info.mWidth > 0 && info.mHeight > 0)
{
info.mBufferFormat = eImageFormatRaw;
info.mPixelFormat = eImagePixelRGBA;
info.mBytesPerPixel = 4;
info.mBitDepth = 8 * info.mBytesPerPixel;
info.mBytesPerLine = info.mWidth * info.mBytesPerPixel;
info.mPreMultAlpha = true;
info.mpBuffer = NULL;
if (!SendInfo(info))
{
CGImageRelease(pCGImage);
return NULL;
}
return pCGImage;
}
CGImageRelease(pCGImage);
}
return NULL;
}
static CGImageRef quartz_loadimage(GVJ_t * job, usershape_t *us)
{
assert(job);
assert(us);
assert(us->name);
if (us->data && us->datafree != quartz_freeimage) {
us->datafree(us); /* free incompatible cache data */
us->data = NULL;
us->datafree = NULL;
}
if (!us->data) { /* read file into cache */
if (!gvusershape_file_access(us))
return NULL;
#if __MAC_OS_X_VERSION_MIN_REQUIRED >= 1050 || __IPHONE_OS_VERSION_MIN_REQUIRED >= 20000
CGDataProviderRef data_provider = CGDataProviderCreateSequential(us->f, &file_data_provider_callbacks);
#else
CGDataProviderRef data_provider = CGDataProviderCreate(us->f, &file_data_provider_callbacks);
#endif
#if __MAC_OS_X_VERSION_MIN_REQUIRED >= 1040
/* match usershape format to a UTI for type hinting, if possible */
format_type hint_format_type;
switch (us->type) {
case FT_BMP:
hint_format_type = FORMAT_BMP;
break;
case FT_GIF:
hint_format_type = FORMAT_GIF;
break;
case FT_PNG:
hint_format_type = FORMAT_PNG;
break;
case FT_JPEG:
hint_format_type = FORMAT_JPEG;
break;
case FT_PDF:
hint_format_type = FORMAT_PDF;
break;
default:
hint_format_type = FORMAT_NONE;
break;
}
CFDictionaryRef options = hint_format_type == FORMAT_NONE ? NULL : CFDictionaryCreate(
kCFAllocatorDefault,
(const void **)&kCGImageSourceTypeIdentifierHint,
(const void **)(format_uti + hint_format_type),
1,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
/* get first image from usershape file */
CGImageSourceRef image_source = CGImageSourceCreateWithDataProvider(data_provider, options);
us->data = CGImageSourceCreateImageAtIndex(image_source, 0, NULL);
if (image_source)
CFRelease(image_source);
if (options)
CFRelease(options);
#else
switch (us->type) {
case FT_PNG:
us->data = CGImageCreateWithPNGDataProvider(data_provider, NULL, false, kCGRenderingIntentDefault);
break;
case FT_JPEG:
us->data = CGImageCreateWithJPEGDataProvider(data_provider, NULL, false, kCGRenderingIntentDefault);
break;
default:
us->data = NULL;
break;
}
#endif
/* clean up */
if (us->data)
us->datafree = quartz_freeimage;
CGDataProviderRelease(data_provider);
gvusershape_file_release(us);
}
return (CGImageRef)(us->data);
}
void MusicBoxDialog(void)
{
OSStatus err;
IBNibRef nibRef;
if (!cartOpen)
return;
err = CreateNibReference(kMacS9XCFString, &nibRef);
if (err == noErr)
{
CFURLRef iconURL;
FSRef iconFSRef;
IconRef actIcon;
WindowRef tWindowRef;
actIcon = nil;
if (musicboxmode == kMBXSoundEmulation)
iconURL = CFBundleCopyResourceURL(CFBundleGetMainBundle(), CFSTR("musicbox_ledoff"), CFSTR("icns"), nil);
else
iconURL = CFBundleCopyResourceURL(CFBundleGetMainBundle(), CFSTR("musicbox_ledon" ), CFSTR("icns"), nil);
if (iconURL)
{
if (CFURLGetFSRef(iconURL, &iconFSRef))
err = RegisterIconRefFromFSRef('~9X~', 'micn', &iconFSRef, &actIcon);
CFRelease(iconURL);
}
err = CreateWindowFromNib(nibRef, CFSTR("MusicBox"), &tWindowRef);
if (err == noErr)
{
EventHandlerRef mboxRef, paneRef;
EventHandlerUPP mboxUPP, paneUPP;
EventLoopTimerRef timeRef;
EventLoopTimerUPP timeUPP;
EventTypeSpec mboxEvents[] = { { kEventClassCommand, kEventCommandProcess },
{ kEventClassCommand, kEventCommandUpdateStatus } },
paneEvents[] = { { kEventClassControl, kEventControlDraw } };
CFStringRef sref;
CGDataProviderRef prov;
CGImageRef ipng;
CFURLRef iurl;
HIViewRef ctl, root, paneView, imageView, contentView;
HIViewID cid;
HIRect bounds;
Rect windowRect, barRect;
char drive[_MAX_DRIVE], dir[_MAX_DIR], fname[_MAX_FNAME], ext[_MAX_EXT];
mboxPause = false;
mbxFinished = false;
showIndicator = false;
so.stereo_switch = ~0;
for (int i = 0; i < MAC_MAX_PLAYERS; i++)
controlPad[i] = 0;
switch (drawingMethod)
{
case kDrawingOpenGL:
Settings.OpenGLEnable = true;
break;
case kDrawingDirect:
case kDrawingBlitGL:
Settings.OpenGLEnable = false;
}
// 107's enhanced SPC player
root = HIViewGetRoot(tWindowRef);
cid.id = 0;
if (musicboxmode == kMBXSoundEmulation)
{
cid.signature = 'HEAD';
HIViewFindByID(root, cid, &ctl);
EnableControl(ctl);
StoredAPU = new SAPU;
StoredAPURegisters = new SAPURegisters;
StoredSoundData = new SSoundData;
StoredIAPURAM = new uint8 [0x10000];
SPCPlayFreeze();
}
else
MusicBoxForceFreeze();
cid.signature = 'Kart';
HIViewFindByID(root, cid, &ctl);
SetStaticTextTrunc(ctl, truncEnd, false);
_splitpath(Memory.ROMFilename, drive, dir, fname, ext);
sref = CFStringCreateWithCString(kCFAllocatorDefault, fname, MAC_PATH_ENCODING);
if (sref)
{
SetStaticTextCFString(ctl, sref, false);
CFRelease(sref);
}
ipng = nil;
iurl = CFBundleCopyResourceURL(CFBundleGetMainBundle(), CFSTR("musicbox_indicator"), CFSTR("png"), nil);
if (iurl)
{
prov = CGDataProviderCreateWithURL(iurl);
if (prov)
{
ipng = CGImageCreateWithPNGDataProvider(prov, nil, false, kCGRenderingIntentDefault);
CGDataProviderRelease(prov);
}
CFRelease(iurl);
}
imageView = nil;
if (ipng)
{
HIViewFindByID(root, kHIViewWindowContentID, &contentView);
err = HIImageViewCreate(ipng, &imageView);
if (err == noErr)
{
bounds = CGRectMake(30, 64, CGImageGetWidth(ipng), CGImageGetHeight(ipng));
HIViewSetFrame(imageView, &bounds);
HIImageViewSetOpaque(imageView, false);
HIViewSetVisible(imageView, true);
HIViewAddSubview(contentView, imageView);
cid.signature = 'iMaG';
SetControlID(imageView, &cid);
}
CGImageRelease(ipng);
}
cid.signature = 'Pane';
HIViewFindByID(root, cid, &paneView);
HIViewGetBounds(paneView, &bounds);
mbxViewWidth = bounds.size.width;
mbxViewHeight = bounds.size.height;
mbxMarginY = (mbxViewHeight - mbxBarHeight) / 2.0;
mbxMarginX = (mbxViewWidth - ((mbxBarWidth * 8.0 + mbxBarSpace * 7.0) * 2.0 + mbxLRSpace)) / 2.0;
if (imageView)
{
HIViewSetZOrder(imageView, kHIViewZOrderBelow, paneView);
HIViewAddSubview(imageView, paneView);
}
cid.signature = 'Tr_i';
HIViewFindByID(root, cid, &ctl);
HIViewGetFrame(ctl, &bounds);
GetWindowBounds(tWindowRef, kWindowTitleBarRgn, &barRect);
mbxClosedHeight = (short) (bounds.origin.y + bounds.size.height + 7.0) + (barRect.bottom - barRect.top);
GetWindowBounds(tWindowRef, kWindowStructureRgn, &windowRect);
mbxOpenedHeight = windowRect.bottom - windowRect.top;
windowRect.bottom = windowRect.top + mbxClosedHeight;
SetWindowBounds(tWindowRef, kWindowStructureRgn, &windowRect);
paneUPP = NewEventHandlerUPP(IndicatorEventHandler);
err = InstallControlEventHandler(paneView, paneUPP, GetEventTypeCount(paneEvents), paneEvents, (void *) paneView, &paneRef);
mboxUPP = NewEventHandlerUPP(MusicBoxEventHandler);
err = InstallWindowEventHandler(tWindowRef, mboxUPP, GetEventTypeCount(mboxEvents), mboxEvents, (void *) tWindowRef, &mboxRef);
timeUPP = NewEventLoopTimerUPP(MusicBoxTimerHandler);
err = InstallEventLoopTimer(GetCurrentEventLoop(), kEventDurationNoWait, kEventDurationSecond * 2.0 / (double) Memory.ROMFramesPerSecond, timeUPP, (void *) paneView, &timeRef);
MusicBoxInitIndicator();
stopNow = false;
MacStartSound();
pthread_create(&mbxThread, nil, SoundTask, nil);
MoveWindowPosition(tWindowRef, kWindowMusicBox, true);
GetWindowBounds(tWindowRef, kWindowStructureRgn, &windowRect);
if (windowRect.bottom - windowRect.top > mbxClosedHeight)
{
showIndicator = true;
SetControl32BitValue(ctl, 1); // Tr_i
}
ShowWindow(tWindowRef);
err = RunAppModalLoopForWindow(tWindowRef);
HideWindow(tWindowRef);
SaveWindowPosition(tWindowRef, kWindowMusicBox);
stopNow = true;
pthread_join(mbxThread, nil);
MacStopSound();
err = RemoveEventLoopTimer(timeRef);
DisposeEventLoopTimerUPP(timeUPP);
err = RemoveEventHandler(mboxRef);
DisposeEventHandlerUPP(mboxUPP);
err = RemoveEventHandler(paneRef);
DisposeEventHandlerUPP(paneUPP);
ReleaseWindow(tWindowRef);
so.stereo_switch = ~0;
mbxFinished = true;
if (musicboxmode == kMBXSoundEmulation)
{
SPCPlayDefrost();
delete StoredAPU;
delete StoredAPURegisters;
delete StoredSoundData;
delete [] StoredIAPURAM;
}
else
MusicBoxForceDefrost();
Settings.OpenGLEnable = false;
}
if (actIcon)
err = UnregisterIconRef('~9X~', 'micn');
DisposeNibReference(nibRef);
}
}
void CreateIconImages (void)
{
CGDataProviderRef prov;
CGImageRef image;
CFURLRef url;
image = NULL;
memset(macIconImage, 0, sizeof(macIconImage));
#ifdef MAC_PANTHER_SUPPORT
if (systemVersion < 0x1040)
memset(macIconRef, 0, sizeof(macIconRef));
#endif
url = CFBundleCopyResourceURL(CFBundleGetMainBundle(), CFSTR("icons"), CFSTR("png"), NULL);
if (url)
{
prov = CGDataProviderCreateWithURL(url);
if (prov)
{
image = CGImageCreateWithPNGDataProvider(prov, NULL, true, kCGRenderingIntentDefault);
CGDataProviderRelease(prov);
}
CFRelease(url);
}
if (image)
{
int x, y, v = 0, n = 0;
macPadIconIndex = n;
for (y = 0; y < 8; y++)
{
for (x = 0; x < 12; x++)
SetIconImage(image, CGRectMake(x * kIconSize, v, kIconSize, kIconSize), n++);
v += kIconSize;
}
macLegendIconIndex = n;
for (x = 0; x < 2; x++)
SetIconImage(image, CGRectMake(x * kIconSize, v, kIconSize, kIconSize), n++);
v += kIconSize;
macMusicBoxIconIndex = n;
for (x = 0; x < 3; x++)
SetIconImage(image, CGRectMake(x * kIconSize, v, kIconSize, kIconSize), n++);
v += kIconSize;
macFunctionIconIndex = n;
for (x = 0; x < 17; x++)
SetIconImage(image, CGRectMake(x * kIconSize, v, kIconSize, kIconSize), n++);
CGImageRelease(image);
#ifdef MAC_PANTHER_SUPPORT
if (systemVersion < 0x1040)
{
CGColorSpaceRef color;
CGContextRef ctx;
CGRect rct;
static UInt32 data[2][kIconSize * kIconSize];
rct = CGRectMake(0, 0, kIconSize, kIconSize);
color = CGColorSpaceCreateDeviceRGB();
if (color)
{
for (int i = 0; i < 2; i++)
{
ctx = CGBitmapContextCreate(data[i], kIconSize, kIconSize, 8, kIconSize * 4, color, kCGImageAlphaNoneSkipFirst);
if (ctx)
{
PlotIconRefInContext(ctx, &rct, kAlignNone, kTransformNone, NULL, kPlotIconRefNormalFlags, macIconRef[macLegendIconIndex + i]);
CGContextRelease(ctx);
prov = CGDataProviderCreateWithData(NULL, data[i], kIconSize * kIconSize * 4, NULL);
if (prov)
{
macIconImage[macLegendIconIndex + i] = CGImageCreate(kIconSize, kIconSize, 8, 32, kIconSize * 4, color, kCGImageAlphaNoneSkipFirst, prov, NULL, 1, kCGRenderingIntentDefault);
CGDataProviderRelease(prov);
}
}
}
CGColorSpaceRelease(color);
}
}
#endif
}
}
/***********************************************************************
* create_app_icon_images
*/
CFArrayRef create_app_icon_images(void)
{
HRSRC res_info;
HGLOBAL res_data;
GRPICONDIR *icon_dir;
CFMutableArrayRef images = NULL;
int i;
TRACE("()\n");
res_info = NULL;
EnumResourceNamesW(NULL, (LPCWSTR)RT_GROUP_ICON, get_first_resource, (LONG_PTR)&res_info);
if (!res_info)
{
WARN("found no RT_GROUP_ICON resource\n");
return NULL;
}
if (!(res_data = LoadResource(NULL, res_info)))
{
WARN("failed to load RT_GROUP_ICON resource\n");
return NULL;
}
if (!(icon_dir = LockResource(res_data)))
{
WARN("failed to lock RT_GROUP_ICON resource\n");
goto cleanup;
}
images = CFArrayCreateMutable(NULL, icon_dir->idCount, &kCFTypeArrayCallBacks);
if (!images)
{
WARN("failed to create images array\n");
goto cleanup;
}
for (i = 0; i < icon_dir->idCount; i++)
{
int width = icon_dir->idEntries[i].bWidth;
int height = icon_dir->idEntries[i].bHeight;
BOOL found_better_bpp = FALSE;
int j;
LPCWSTR name;
HGLOBAL icon_res_data;
BYTE *icon_bits;
if (!width) width = 256;
if (!height) height = 256;
/* If there's another icon at the same size but with better
color depth, skip this one. We end up making CGImages that
are all 32 bits per pixel, so Cocoa doesn't get the original
color depth info to pick the best representation itself. */
for (j = 0; j < icon_dir->idCount; j++)
{
int jwidth = icon_dir->idEntries[j].bWidth;
int jheight = icon_dir->idEntries[j].bHeight;
if (!jwidth) jwidth = 256;
if (!jheight) jheight = 256;
if (j != i && jwidth == width && jheight == height &&
icon_dir->idEntries[j].wBitCount > icon_dir->idEntries[i].wBitCount)
{
found_better_bpp = TRUE;
break;
}
}
if (found_better_bpp) continue;
name = MAKEINTRESOURCEW(icon_dir->idEntries[i].nID);
res_info = FindResourceW(NULL, name, (LPCWSTR)RT_ICON);
if (!res_info)
{
WARN("failed to find RT_ICON resource %d with ID %hd\n", i, icon_dir->idEntries[i].nID);
continue;
}
icon_res_data = LoadResource(NULL, res_info);
if (!icon_res_data)
{
WARN("failed to load icon %d with ID %hd\n", i, icon_dir->idEntries[i].nID);
continue;
}
icon_bits = LockResource(icon_res_data);
if (icon_bits)
{
static const BYTE png_magic[] = { 0x89, 0x50, 0x4e, 0x47 };
CGImageRef cgimage = NULL;
if (!memcmp(icon_bits, png_magic, sizeof(png_magic)))
{
CFDataRef data = CFDataCreate(NULL, (UInt8*)icon_bits, icon_dir->idEntries[i].dwBytesInRes);
if (data)
{
CGDataProviderRef provider = CGDataProviderCreateWithCFData(data);
CFRelease(data);
if (provider)
{
cgimage = CGImageCreateWithPNGDataProvider(provider, NULL, FALSE,
kCGRenderingIntentDefault);
CGDataProviderRelease(provider);
}
}
}
if (!cgimage)
{
HICON icon;
icon = CreateIconFromResourceEx(icon_bits, icon_dir->idEntries[i].dwBytesInRes,
TRUE, 0x00030000, width, height, 0);
if (icon)
{
cgimage = create_cgimage_from_icon(icon, width, height);
DestroyIcon(icon);
}
else
WARN("failed to create icon %d from resource with ID %hd\n", i, icon_dir->idEntries[i].nID);
}
if (cgimage)
{
CFArrayAppendValue(images, cgimage);
CGImageRelease(cgimage);
}
}
else
WARN("failed to lock RT_ICON resource %d with ID %hd\n", i, icon_dir->idEntries[i].nID);
FreeResource(icon_res_data);
}
cleanup:
if (images && !CFArrayGetCount(images))
{
CFRelease(images);
images = NULL;
}
FreeResource(res_data);
return images;
}
OSStatus GenerateThumbnailForURL(void *thisInterface,
QLThumbnailRequestRef thumbnail,
CFURLRef url, CFStringRef contentTypeUTI,
CFDictionaryRef options, CGSize maxSize)
{
CGFloat minCartDrawSize = 64;
CGFloat size = fmin(maxSize.width, maxSize.height);
CGContextRef qlContext = NULL;
if (size < minCartDrawSize) {
size = 32;
qlContext = QLThumbnailRequestCreateContext(thumbnail, CGSizeMake(size,size), true, NULL);
}
else
{
qlContext = QLThumbnailRequestCreateContext(thumbnail, CGSizeMake(size,size), false, NULL);
}
if (qlContext) {
NDSHeader header;
NDSIcon icon;
int pathlen = 2047;
UInt8 path[pathlen+1];
if (CFURLGetFileSystemRepresentation(url, true, path, pathlen)) {
if (size < minCartDrawSize) { // at smaller sizes we only draw the game icon at native size and let QL do the scaling
parseNDSInfo(path, &header, &icon);
CGImageRef image = CGImageCreateWithNDSIcon(&icon);
if (image) {
CGContextDrawImage(qlContext, CGRectMake(0, 0, size, size), image);
CGImageRelease(image);
}
}
else
{
CGContextClearRect(qlContext, CGRectMake(0,0,size,size));
// draw cartridge background
CFURLRef bgURL = CFBundleCopyResourceURL(CFBundleGetBundleWithIdentifier(
CFSTR("net.mironer.nds.quicklookgenerator")), CFSTR("background"), CFSTR("png"), NULL);
if (bgURL) {
CGDataProviderRef bgPNG = CGDataProviderCreateWithURL(bgURL);
if (bgPNG) {
CGImageRef bg = CGImageCreateWithPNGDataProvider(bgPNG, NULL, true, kCGRenderingIntentDefault);
if (bg) {
CGContextDrawImage(qlContext, CGRectMake(0, 0, size, size), bg);
CGImageRelease(bg);
}
CGDataProviderRelease(bgPNG);
}
CFRelease(bgURL);
}
// draw game icon
parseNDSInfo(path, &header, &icon);
CGImageRef image = CGImageCreateWithNDSIcon(&icon);
if (image) {
CGContextDrawImage(qlContext, CGRectMake(size / 5, size / 5, size * 3 / 5, size * 3 / 5), image);
CGImageRelease(image);
}
// draw cartridge overlay
CFURLRef ovrURL = CFBundleCopyResourceURL(
CFBundleGetBundleWithIdentifier(
CFSTR("net.mironer.nds.quicklookgenerator")), CFSTR("overlay"), CFSTR("png"), NULL);
if (ovrURL) {
CGDataProviderRef ovrPNG = CGDataProviderCreateWithURL(ovrURL);
if (ovrPNG) {
CGImageRef ovr = CGImageCreateWithPNGDataProvider(ovrPNG, NULL, true, kCGRenderingIntentDefault);
if (ovr) {
CGContextDrawImage(qlContext, CGRectMake(0, 0, size, size), ovr);
CGImageRelease(ovr);
}
CGDataProviderRelease(ovrPNG);
}
CFRelease(ovrURL);
}
// draw serial number
CFStringRef serial = CFStringCreateWithSerialNumber(&header);
CFAttributedStringRef aString = CFAttributedStringCreate(kCFAllocatorDefault, serial, NULL);
CFMutableAttributedStringRef attrStr = CFAttributedStringCreateMutableCopy(kCFAllocatorDefault, 128, aString);
CFIndex len = CFAttributedStringGetLength(attrStr);
CTFontRef font = CTFontCreateWithName(CFSTR("Lucida Sans"), size / 16, NULL);
CFAttributedStringSetAttribute(attrStr, CFRangeMake(0, len), kCTFontAttributeName, font);
CTTextAlignment rightAlign = kCTRightTextAlignment;
CTParagraphStyleSetting styleSettings[] = { {kCTParagraphStyleSpecifierAlignment, sizeof(rightAlign), &rightAlign} };
CTParagraphStyleRef paragraphStyle = CTParagraphStyleCreate(styleSettings, 1);
CFAttributedStringSetAttribute(attrStr, CFRangeMake(0, len), kCTParagraphStyleAttributeName, paragraphStyle);
CTFramesetterRef framesetter = CTFramesetterCreateWithAttributedString(attrStr);
CFRelease(attrStr);
CFRelease(aString);
CFRelease(serial);
CFRelease(font);
CGMutablePathRef path = CGPathCreateMutable();
CGPathAddRect(path, NULL, CGRectMake(-size * 1.55 / 8, -size * 6.1 / 8, size, size));
CTFrameRef frame = CTFramesetterCreateFrame(framesetter, CFRangeMake(0, 0), path, NULL);
CTFrameDraw(frame, qlContext);
CFRelease(frame);
CFRelease(framesetter);
CFRelease(paragraphStyle);
CFRelease(path);
}
}
QLThumbnailRequestFlushContext(thumbnail, qlContext);
CFRelease(qlContext);
}
return noErr;
}
CGImageRef CGImageCreateWithPNGDataProvider_wrap(
CGDataProviderRef source,
bool shouldInterpolate,
uint32 colorRenderingIntent) {
return CGImageCreateWithPNGDataProvider( source, NULL, shouldInterpolate, CGColorRenderingIntent(colorRenderingIntent));
}
