Macintosh-Tools
/
minivmac4ios
mirror of https://github.com/zydeco/minivmac4ios.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
minivmac4ios/Mini vMac/UIImage+DiskImageIcon.m

684 lines
25 KiB
Objective-C
Raw Permalink Blame History

//
// UIImage+DiskImageIcon.m
// Mini vMac
//
// Created by Jesús A. Álvarez on 21/05/2016.
// Copyright © 2016-2018 namedfork. All rights reserved.
//
#import "UIImage+DiskImageIcon.h"
#import "libhfs.h"
#import "res.h"
#import "mfs.h"
#import "AppDelegate.h"
#import <sys/xattr.h>
NSString *DidUpdateIconForDiskImageNotification = @"didUpdateIconForDiskImage";
static const char kDiskImageIconAttributeName[] = "net.namedfork.DiskImageIcon";
#define kDiskImageHasDC42Header 1 << 0
#define RSHORT(base, offset) ntohs(*((short *)((base) + (offset))))
#define RLONG(base, offset) ntohl(*((long *)((base) + (offset))))
#define RCSTR(base, offset) ((char *)((base) + (offset)))
@interface DiskImageIconReader : NSObject
- (UIImage *)iconForDiskImage:(NSString *)path;
@end
@implementation UIImage (DiskImageIcon)
+ (void)_didEjectDisk:(NSNotification*)notification {
NSString *path = [notification.userInfo[@"path"] stringByStandardizingPath];
[self loadIconForDiskImageAndNotify:path];
}
+ (UIImage *)imageWithIconForDiskImage:(NSString *)path {
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(_didEjectDisk:) name:[AppDelegate sharedEmulator].ejectDiskNotification object:nil];
});
// check attribute
ssize_t attrLen = getxattr(path.fileSystemRepresentation, kDiskImageIconAttributeName, NULL, 0, 0, 0);
if (attrLen == -1) {
[self loadIconForDiskImageAndNotify:path];
return nil;
}
// read data
void *attrData = malloc(attrLen);
getxattr(path.fileSystemRepresentation, kDiskImageIconAttributeName, attrData, attrLen, 0, 0);
return [UIImage imageWithData:[NSData dataWithBytesNoCopy:attrData length:attrLen freeWhenDone:YES]];
}
+ (void)loadIconForDiskImageAndNotify:(NSString *)path {
if ([NSThread isMainThread]) {
dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
[self loadIconForDiskImageAndNotify:path];
});
return;
}
// get current value
ssize_t attrLen = getxattr(path.fileSystemRepresentation, kDiskImageIconAttributeName, NULL, 0, 0, 0);
NSData *previousData = nil;
if (attrLen != -1) {
void *attrData = malloc(attrLen);
getxattr(path.fileSystemRepresentation, kDiskImageIconAttributeName, attrData, attrLen, 0, 0);
previousData = [NSData dataWithBytesNoCopy:attrData length:attrLen freeWhenDone:YES];
}
// load new icon
UIImage *icon = [[DiskImageIconReader new] iconForDiskImage:path];
NSData *newData = UIImagePNGRepresentation(icon);
if (![newData isEqualToData:previousData]) {
// save new icon and notify
setxattr(path.fileSystemRepresentation, kDiskImageIconAttributeName, newData.bytes, newData.length, 0, 0);
NSNotification *newIconNotification = [[NSNotification alloc] initWithName:DidUpdateIconForDiskImageNotification object:path userInfo:icon ? @{@"icon": icon} : nil];
[[NSNotificationCenter defaultCenter] performSelectorOnMainThread:@selector(postNotification:) withObject:newIconNotification waitUntilDone:NO];
}
}
@end
// Mac OS 1 bit palette
static uint32_t ctb1[2] = {0xFFFFFF, 0x000000};
// Mac OS 4 bit palette
static uint32_t ctb4[16] = {
0xFFFFFF, 0xFFFF00, 0xFF6600, 0xDD0000, 0xFF0099, 0x330099, 0x0000DD, 0x0099FF,
0x00BB00, 0x006600, 0x663300, 0x996633, 0xCCCCCC, 0x888888, 0x444444, 0x000000};
// Mac OS 8 bit palette
static uint32_t ctb8[256] = {
0xFFFFFF, 0xFFFFCC, 0xFFFF99, 0xFFFF66, 0xFFFF33, 0xFFFF00, 0xFFCCFF, 0xFFCCCC,
0xFFCC99, 0xFFCC66, 0xFFCC33, 0xFFCC00, 0xFF99FF, 0xFF99CC, 0xFF9999, 0xFF9966,
0xFF9933, 0xFF9900, 0xFF66FF, 0xFF66CC, 0xFF6699, 0xFF6666, 0xFF6633, 0xFF6600,
0xFF33FF, 0xFF33CC, 0xFF3399, 0xFF3366, 0xFF3333, 0xFF3300, 0xFF00FF, 0xFF00CC,
0xFF0099, 0xFF0066, 0xFF0033, 0xFF0000, 0xCCFFFF, 0xCCFFCC, 0xCCFF99, 0xCCFF66,
0xCCFF33, 0xCCFF00, 0xCCCCFF, 0xCCCCCC, 0xCCCC99, 0xCCCC66, 0xCCCC33, 0xCCCC00,
0xCC99FF, 0xCC99CC, 0xCC9999, 0xCC9966, 0xCC9933, 0xCC9900, 0xCC66FF, 0xCC66CC,
0xCC6699, 0xCC6666, 0xCC6633, 0xCC6600, 0xCC33FF, 0xCC33CC, 0xCC3399, 0xCC3366,
0xCC3333, 0xCC3300, 0xCC00FF, 0xCC00CC, 0xCC0099, 0xCC0066, 0xCC0033, 0xCC0000,
0x99FFFF, 0x99FFCC, 0x99FF99, 0x99FF66, 0x99FF33, 0x99FF00, 0x99CCFF, 0x99CCCC,
0x99CC99, 0x99CC66, 0x99CC33, 0x99CC00, 0x9999FF, 0x9999CC, 0x999999, 0x999966,
0x999933, 0x999900, 0x9966FF, 0x9966CC, 0x996699, 0x996666, 0x996633, 0x996600,
0x9933FF, 0x9933CC, 0x993399, 0x993366, 0x993333, 0x993300, 0x9900FF, 0x9900CC,
0x990099, 0x990066, 0x990033, 0x990000, 0x66FFFF, 0x66FFCC, 0x66FF99, 0x66FF66,
0x66FF33, 0x66FF00, 0x66CCFF, 0x66CCCC, 0x66CC99, 0x66CC66, 0x66CC33, 0x66CC00,
0x6699FF, 0x6699CC, 0x669999, 0x669966, 0x669933, 0x669900, 0x6666FF, 0x6666CC,
0x666699, 0x666666, 0x666633, 0x666600, 0x6633FF, 0x6633CC, 0x663399, 0x663366,
0x663333, 0x663300, 0x6600FF, 0x6600CC, 0x660099, 0x660066, 0x660033, 0x660000,
0x33FFFF, 0x33FFCC, 0x33FF99, 0x33FF66, 0x33FF33, 0x33FF00, 0x33CCFF, 0x33CCCC,
0x33CC99, 0x33CC66, 0x33CC33, 0x33CC00, 0x3399FF, 0x3399CC, 0x339999, 0x339966,
0x339933, 0x339900, 0x3366FF, 0x3366CC, 0x336699, 0x336666, 0x336633, 0x336600,
0x3333FF, 0x3333CC, 0x333399, 0x333366, 0x333333, 0x333300, 0x3300FF, 0x3300CC,
0x330099, 0x330066, 0x330033, 0x330000, 0x00FFFF, 0x00FFCC, 0x00FF99, 0x00FF66,
0x00FF33, 0x00FF00, 0x00CCFF, 0x00CCCC, 0x00CC99, 0x00CC66, 0x00CC33, 0x00CC00,
0x0099FF, 0x0099CC, 0x009999, 0x009966, 0x009933, 0x009900, 0x0066FF, 0x0066CC,
0x006699, 0x006666, 0x006633, 0x006600, 0x0033FF, 0x0033CC, 0x003399, 0x003366,
0x003333, 0x003300, 0x0000FF, 0x0000CC, 0x000099, 0x000066, 0x000033, 0xEE0000,
0xDD0000, 0xBB0000, 0xAA0000, 0x880000, 0x770000, 0x550000, 0x440000, 0x220000,
0x110000, 0x00EE00, 0x00DD00, 0x00BB00, 0x00AA00, 0x008800, 0x007700, 0x005500,
0x004400, 0x002200, 0x001100, 0x0000EE, 0x0000DD, 0x0000BB, 0x0000AA, 0x000088,
0x000077, 0x000055, 0x000044, 0x000022, 0x000011, 0xEEEEEE, 0xDDDDDD, 0xBBBBBB,
0xAAAAAA, 0x888888, 0x777777, 0x555555, 0x444444, 0x222222, 0x111111, 0x000000};
static uint8_t maskReplacement[][128] = {
{ 0x1D, 0xC7, 0xFC, 0x00, 0x3F, 0xE7, 0xFC, 0x00, 0x7F, 0xF6, 0xAC, 0x00,
0x3F, 0xF7, 0x5C, 0x00, 0x17, 0xC6, 0x0C, 0x00, 0x00, 0x02, 0xAB, 0xFE,
0x0F, 0xFF, 0x5B, 0xFE, 0x0F, 0xF9, 0xFB, 0xAA, 0x0F, 0x5D, 0xFE, 0x02,
0x0A, 0xA8, 0x01, 0xAC, 0x04, 0x00, 0x00, 0x5C, 0x02, 0xBA, 0xAA, 0x2C,
0x03, 0xD5, 0x54, 0x5C, 0x02, 0xBA, 0xAA, 0x2C, 0x7E, 0x17, 0x5C, 0x5C,
0x6A, 0xBA, 0xAA, 0x2C, 0x75, 0x55, 0x54, 0x3C, 0x7A, 0x6A, 0xEA, 0x20,
0x70, 0x95, 0xB5, 0x60, 0x1A, 0x2A, 0xAA, 0xE0, 0x1D, 0x95, 0x15, 0x60,
0x1A, 0xAB, 0x1A, 0xE0, 0x1D, 0x95, 0x15, 0x60, 0x1A, 0xAB, 0x1A, 0xE0,
0x1D, 0x95, 0x15, 0xE0, 0x3E, 0xAB, 0x1B, 0x70, 0x30, 0x45, 0x10, 0x38,
0x20, 0x08, 0x08, 0x3C, 0x68, 0x03, 0xF8, 0x16, 0xC0, 0x00, 0x00, 0x02,
0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE
}, {
0x1D, 0xC7, 0xFC, 0x00, 0x3F, 0xE7, 0xFC, 0x00, 0x7F, 0xF7, 0xFC, 0x00,
0x3F, 0xF7, 0xFC, 0x00, 0x17, 0xC7, 0xFC, 0x00, 0x00, 0x03, 0xFB, 0xFE,
0x0F, 0xFF, 0xFF, 0xFE, 0x0F, 0xFF, 0xFF, 0xFE, 0x0F, 0xFF, 0xFF, 0xFE,
0x0F, 0xFF, 0xFF, 0xFC, 0x07, 0xFF, 0xFF, 0xFC, 0x03, 0xFF, 0xFF, 0xFC,
0x03, 0xFF, 0xFF, 0xFC, 0x03, 0xFF, 0xFF, 0xFC, 0x7F, 0xFF, 0xFF, 0xFC,
0x7F, 0xFF, 0xFF, 0xFC, 0x7F, 0xFF, 0xFF, 0xFC, 0x7F, 0xFF, 0xFF, 0xE0,
0x7F, 0xFF, 0xFF, 0xE0, 0x1F, 0xFF, 0xFF, 0xE0, 0x1F, 0xFF, 0xFF, 0xE0,
0x1F, 0xFF, 0xFF, 0xE0, 0x1F, 0xFF, 0xFF, 0xE0, 0x1F, 0xFF, 0xFF, 0xE0,
0x1F, 0xFF, 0xFF, 0xE0, 0x3F, 0xFF, 0xFF, 0xF0, 0x3F, 0xFF, 0xFF, 0xF8,
0x3F, 0xFF, 0xFF, 0xFC, 0x7F, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE,
0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE
}
};
@implementation DiskImageIconReader
- (UIImage *)iconForDiskImage:(NSString *)path {
// determine format and offset of disk image
NSFileHandle *fh = [NSFileHandle fileHandleForReadingAtPath:path];
if (fh == nil) {
return nil;
}
[fh seekToFileOffset:1024];
NSData *checkHeader = [fh readDataOfLength:128];
[fh closeFile];
if (checkHeader == nil || checkHeader.length != 128) {
return nil;
}
const unsigned char *chb = [checkHeader bytes];
// determine type from header
if ((chb[0] == 0x42) && (chb[1] == 0x44)) {
/* hfs */
return [self iconForHFSDiskImage:path options:0];
} else if ((chb[0] == 0xD2) && (chb[1] == 0xD7)) {
/* mfs */
return [self iconForMFSDiskImage:path options:0];
} else if ((chb[84] == 0x42) && (chb[85] == 0x44)) {
/* hfs, dc42 header */
return [self iconForHFSDiskImage:path options:kDiskImageHasDC42Header];
} else if ((chb[84] == 0xD2) && (chb[85] == 0xD7)) {
/* mfs, dc42 header */
return [self iconForMFSDiskImage:path options:kDiskImageHasDC42Header];
}
return nil;
}
#pragma mark - MFS
- (UIImage *)iconForMFSDiskImage:(NSString *)path options:(int)options {
// open disk image
size_t offset = (options & kDiskImageHasDC42Header) ? 84 : 0;
MFSVolume *vol = mfs_vopen([path fileSystemRepresentation], (size_t)offset, 0);
if (vol == NULL) {
NSLog(@"Can't open MFS volume at %@", path);
return nil;
}
NSString *volName = [NSString stringWithCString:vol->name encoding:NSMacOSRomanStringEncoding];
NSString *volComment;
char *const volCommentBytes = mfs_comment(vol, NULL);
if (volCommentBytes) {
volComment = [NSString stringWithCString:volCommentBytes encoding:NSMacOSRomanStringEncoding];
free(volCommentBytes);
}
// find applications
MFSDirectoryRecord *rec;
NSMutableArray *apps = [NSMutableArray arrayWithCapacity:5];
for (int i = 0; vol->directory[i]; i++) {
rec = vol->directory[i];
if (ntohl(rec->flUsrWds.type) != 'APPL') {
continue;
}
[apps addObject:[NSNumber numberWithInt:i]];
}
// if there's more than one app, find one that looks matching
if ([apps count] == 0) {
return nil;
} else if ([apps count] > 1) {
rec = NULL;
for (NSNumber *num in apps) {
rec = vol->directory[[num intValue]];
NSString *appName = [[NSString alloc] initWithCString:rec->flCName encoding:NSMacOSRomanStringEncoding];
if (![self chooseApp:appName inVolume:volName hint:volComment]) {
rec = NULL;
}
if (rec) {
break;
}
}
if (rec == NULL) {
return nil;
}
} else {
rec = vol->directory[[[apps objectAtIndex:0] intValue]];
}
// open resource fork
MFSFork *rsrcFork = mfs_fkopen(vol, rec, kMFSForkRsrc, 0);
RFILE *rfile = res_open_funcs(rsrcFork, mfs_fkseek, mfs_fkread);
// get icon
UIImage *icon = [self appIconForResourceFile:rfile creator:ntohl(rec->flUsrWds.creator)];
// close stuff
res_close(rfile);
mfs_fkclose(rsrcFork);
mfs_vclose(vol);
return icon;
}
#pragma mark - HFS
- (UIImage *)iconForHFSDiskImage:(NSString *)path options:(int)options {
// open disk image
int mountFlags = HFS_MODE_RDONLY;
if (options & kDiskImageHasDC42Header) {
mountFlags |= HFS_OPT_DC42HEADER;
}
hfsvol *vol = hfs_mount([path fileSystemRepresentation], 0, mountFlags);
if (vol == NULL) {
NSLog(@"Can't open HFS volume at %@ with flags %x", path, mountFlags);
return nil;
}
// try volume icon
UIImage *volumeIcon = [self iconFromHFSVolumeIcon:vol];
if (volumeIcon) {
hfs_umount(vol);
return volumeIcon;
}
// find best application
UIImage *icon = nil;
NSString *appPath = [self findAppInHFSVolume:vol];
hfsfile *hfile = NULL;
RFILE *rfile = NULL;
if (appPath == nil) {
hfs_umount(vol);
return nil;
}
// open resource fork
hfile = hfs_open(vol, [appPath cStringUsingEncoding:NSMacOSRomanStringEncoding]);
if (hfile == NULL) {
hfs_umount(vol);
return nil;
}
hfs_setfork(hfile, 1);
rfile = res_open_funcs(hfile, (res_seek_func)hfs_seek, (res_read_func)hfs_read);
if (rfile == NULL) {
hfs_close(hfile);
hfs_umount(vol);
return nil;
}
// get icon
hfsdirent ent;
if (hfs_stat(vol, [appPath cStringUsingEncoding:NSMacOSRomanStringEncoding], &ent)) {
res_close(rfile);
hfs_close(hfile);
hfs_umount(vol);
return nil;
}
icon = [self appIconForResourceFile:rfile creator:ntohl(*(uint32_t *)ent.u.file.creator)];
// close stuff
res_close(rfile);
hfs_close(hfile);
hfs_umount(vol);
return icon;
}
- (NSString *)findAppInHFSVolume:(hfsvol *)vol {
// get disk name
hfsvolent volEnt;
hfs_vstat(vol, &volEnt);
NSString *volName = [NSString stringWithCString:volEnt.name encoding:NSMacOSRomanStringEncoding];
NSString *volComment = [self commentForHFSVolume:vol];
// find apps
NSMutableArray *apps = [[NSMutableArray alloc] initWithCapacity:5];
[self findApps:apps inDirectory:HFS_CNID_ROOTDIR ofHFSVolume:vol skipFolder:volEnt.blessed];
// decide which one to use
NSString *myApp = nil;
NSString *appName = nil;
if ([apps count] == 1) {
myApp = [apps objectAtIndex:0];
} else if ([apps count] > 1) {
for (NSString *appPath in apps) {
// choose an app
appName = [appPath componentsSeparatedByString:@":"].lastObject;
if (![self chooseApp:appName inVolume:volName hint:volComment]) {
continue;
}
myApp = appPath;
}
}
return myApp;
}
- (void)findApps:(NSMutableArray *)apps inDirectory:(unsigned long)cnid ofHFSVolume:(hfsvol *)vol skipFolder:(unsigned long)skipCNID {
if (hfs_setcwd(vol, cnid)) {
return;
}
hfsdir *dir = hfs_opendir(vol, ":");
if (dir == NULL) {
return;
}
hfsdirent ent;
while (hfs_readdir(dir, &ent) == 0) {
if (ent.flags & HFS_ISDIR && ent.cnid != skipCNID) {
[self findApps:apps inDirectory:ent.cnid ofHFSVolume:vol skipFolder:skipCNID];
} else if (ntohl(*(uint32_t *)ent.u.file.type) == 'APPL') {
// Found an app
[apps addObject:[self pathToDirEntry:&ent ofHFSVolume:vol]];
}
}
hfs_closedir(dir);
}
- (NSString *)pathToDirEntry:(const hfsdirent *)ent ofHFSVolume:(hfsvol *)vol {
NSMutableString *path = [NSMutableString stringWithCString:ent->name encoding:NSMacOSRomanStringEncoding];
NSString *entName;
char name[HFS_MAX_FLEN + 1];
unsigned long cnid = ent->parid;
while (cnid != HFS_CNID_ROOTPAR) {
if (hfs_dirinfo(vol, &cnid, name)) {
return nil;
}
entName = [[NSString alloc] initWithCString:name encoding:NSMacOSRomanStringEncoding];
[path insertString:@":" atIndex:0];
[path insertString:entName atIndex:0];
}
return path;
}
- (NSString *)commentForHFSVolume:(hfsvol *)vol {
hfsvolent vent;
hfsdirent dent;
NSString *comment = nil;
// get comment ID
if (hfs_vstat(vol, &vent) || hfs_stat(vol, ":", &dent)) {
return nil;
}
unsigned short cmtID = dent.fdcomment;
// open desktop
hfsfile *hfile = NULL;
RFILE *rfile = NULL;
hfs_chdir(vol, vent.name);
hfile = hfs_open(vol, "Desktop");
if (hfile == NULL) {
return nil;
}
hfs_setfork(hfile, 1);
rfile = res_open_funcs(hfile, (res_seek_func)hfs_seek, (res_read_func)hfs_read);
if (rfile == NULL) {
hfs_close(hfile);
return nil;
}
// read resource
unsigned char cmtLen;
size_t readBytes;
res_read(rfile, 'FCMT', cmtID, &cmtLen, 0, 1, &readBytes, NULL);
if (readBytes == 0) {
res_close(rfile);
hfs_close(hfile);
return nil;
}
char cmtBytes[256];
res_read(rfile, 'FCMT', cmtID, cmtBytes, 1, cmtLen, &readBytes, NULL);
cmtBytes[cmtLen] = '\0';
comment = [NSString stringWithCString:cmtBytes encoding:NSMacOSRomanStringEncoding];
// close
res_close(rfile);
hfs_close(hfile);
return comment;
}
- (UIImage *)iconFromHFSVolumeIcon:(hfsvol *)vol {
UIImage *icon = nil;
hfsvolent vent;
if (hfs_vstat(vol, &vent)) {
return nil;
}
// open icon file
hfs_chdir(vol, vent.name);
hfsfile *hfile = NULL;
RFILE *rfile = NULL;
hfile = hfs_open(vol, "Icon\x0D");
if (hfile == NULL) {
res_close(rfile);
return nil;
}
hfs_setfork(hfile, 1);
rfile = res_open_funcs(hfile, (res_seek_func)hfs_seek, (res_read_func)hfs_read);
if (rfile == NULL) {
if (hfile) {
hfs_close(hfile);
}
return nil;
}
// read icon family
NSDictionary *iconFamily = [self iconFamilyID:-16455 inResourceFile:rfile];
icon = [self iconImageFromFamily:iconFamily];
res_close(rfile);
if (hfile) {
hfs_close(hfile);
}
return icon;
}
#pragma mark - App Selection
- (BOOL)chooseApp:(NSString *)appName inVolume:(NSString *)volName hint:(NSString *)hint {
return ([appName hasPrefix:volName] ||
[volName hasPrefix:appName] ||
[volName isEqualToString:appName] ||
[appName isEqualToString:hint]);
}
#pragma mark - Resource Access
- (UIImage*)appIconForResourceFile:(RFILE *)rfile creator:(OSType)creator {
// load bundle
size_t numBundles;
ResAttr *bundles = res_list(rfile, 'BNDL', NULL, 0, 0, &numBundles, NULL);
void *bundle = NULL;
if (numBundles == 0 || bundles == NULL) {
return nil;
}
for (int i = 0; i < numBundles; i++) {
bundle = res_read(rfile, 'BNDL', bundles[i].ID, NULL, 0, 0, NULL, NULL);
if (bundle == NULL || ntohl(*(OSType *)bundle) == creator) {
break;
}
free(bundle);
bundle = NULL;
}
free(bundles);
if (bundle == NULL) {
return nil;
}
// read bundle
NSInteger iconID = [self iconFamilyIDForType:'APPL' inBundle:bundle inResourceFile:rfile];
free(bundle);
if (iconID == NSNotFound) {
return nil;
}
// read icon family
NSDictionary *iconFamily = [self iconFamilyID:iconID inResourceFile:rfile];
// create image
return [self iconImageFromFamily:iconFamily];
}
- (NSDictionary *)iconFamilyID:(int16_t)famID inResourceFile:(RFILE *)rfile {
NSMutableDictionary *iconFamily = [NSMutableDictionary dictionaryWithCapacity:6];
NSData *iconData, *maskData;
void *iconRsrc;
size_t resSize;
// separate resources
const uint32_t iconResourceTypes[] = {'ICN#', 'icl4', 'icl8', 'ics#', 'ics4', 'ics8', 0};
for (int i = 0; iconResourceTypes[i]; i++) {
iconRsrc = res_read(rfile, iconResourceTypes[i], famID, NULL, 0, 0, &resSize, NULL);
if (iconRsrc == NULL) {
continue;
}
[iconFamily setObject:[NSData dataWithBytes:iconRsrc length:resSize] forKey:[NSString stringWithFormat:@"%c%c%c%c", TYPECHARS(iconResourceTypes[i])]];
free(iconRsrc);
}
// mask pseudo-resources
if ((iconData = [iconFamily objectForKey:@"ICN#"])) {
maskData = [iconData subdataWithRange:NSMakeRange(0x80, 0x80)];
[iconFamily setObject:maskData forKey:@"IMK#"];
}
if ((iconData = [iconFamily objectForKey:@"ics#"])) {
maskData = [iconData subdataWithRange:NSMakeRange(0x20, 0x20)];
[iconFamily setObject:maskData forKey:@"imk#"];
}
return iconFamily;
}
- (NSInteger)iconFamilyIDForType:(OSType)type inBundle:(void *)bndl inResourceFile:(RFILE *)rfile {
short numIconFamilies = RSHORT(bndl, 0x0C) + 1;
short *iconFamily = (short *)(bndl + 0x0E);
short numFileRefs = RSHORT(bndl, (numIconFamilies * 4) + 0x12) + 1;
short *fileRef = (short *)(bndl + (numIconFamilies * 4) + 0x14);
// find FREF for APPL type
short localIconID;
void *FREF = NULL;
for (int i = 0; i < 2 * numFileRefs; i += 2) {
FREF = res_read(rfile, 'FREF', (int)ntohs(fileRef[i + 1]), NULL, 0, 0, NULL, NULL);
if (FREF == NULL || RLONG(FREF, 0) == 'APPL') {
break;
}
free(FREF);
FREF = NULL;
}
if (FREF == NULL) {
return NSNotFound;
}
// read FREF
localIconID = RSHORT(FREF, 4);
free(FREF);
// find resource ID for local ID
for (int i = 0; i < 2 * numIconFamilies; i += 2) {
if (ntohs(iconFamily[i]) == localIconID) {
return (int)ntohs(iconFamily[i + 1]);
}
}
return NSNotFound;
}
- (UIImage*)iconImageFromFamily:(NSDictionary *)iconFamily {
NSData *iconData, *iconMask;
if ((iconMask = [iconFamily objectForKey:@"IMK#"])) {
// has large mask, find best large icon
if ((iconData = [iconFamily objectForKey:@"icl8"])) {
return [self iconImageWithData:iconData mask:iconMask size:32 depth:8];
} else if ((iconData = [iconFamily objectForKey:@"icl4"])) {
return [self iconImageWithData:iconData mask:iconMask size:32 depth:4];
} else {
iconData = [iconFamily objectForKey:@"ICN#"];
}
return [self iconImageWithData:iconData mask:iconMask size:32 depth:1];
} else if ((iconMask = [iconFamily objectForKey:@"imk#"])) {
// has small mask, find best small icon
if ((iconData = [iconFamily objectForKey:@"ics8"])) {
return [self iconImageWithData:iconData mask:iconMask size:32 depth:8];
} else if ((iconData = [iconFamily objectForKey:@"ics4"])) {
return [self iconImageWithData:iconData mask:iconMask size:32 depth:4];
} else {
iconData = [iconFamily objectForKey:@"ics#"];
}
return [self iconImageWithData:iconData mask:iconMask size:32 depth:1];
}
return NULL;
}
- (UIImage*)iconImageWithData:(NSData *)iconData mask:(NSData *)iconMask size:(int)size depth:(int)depth {
if (iconData == nil || iconMask == nil) {
return NULL;
}
// convert to ARGB
#define _iSETPIXELRGB(px, py, sa, srgb) \
data[(4 * (px + (py * size))) + 0] = sa; \
data[(4 * (px + (py * size))) + 1] = ((srgb >> 16) & 0xFF); \
data[(4 * (px + (py * size))) + 2] = ((srgb >> 8) & 0xFF); \
data[(4 * (px + (py * size))) + 3] = (srgb & 0xFF)
CFMutableDataRef pixels = CFDataCreateMutable(kCFAllocatorDefault, 4 * size * size);
CFDataSetLength(pixels, 4 * size * size);
unsigned char *data = CFDataGetMutableBytePtr(pixels);
const unsigned char *pixelData = [iconData bytes];
const unsigned char *maskData = [iconMask bytes];
if (size == 32 && iconMask.length == 128) {
for (int i=0; i < sizeof(maskReplacement) / sizeof(maskReplacement[0]); i+=2) {
if (memcmp(maskData, maskReplacement[i], 128) == 0) {
maskData = maskReplacement[i+1];
break;
}
}
}
int m, mxy, pxy, rgb;
if (pixels == NULL) {
return NULL;
}
switch (depth) {
case 1:
// 1-bit
for (int y = 0; y < size; y++) {
for (int x = 0; x < size; x++) {
mxy = pxy = (y * (size / 8)) + (x / 8);
m = ((maskData[mxy] >> (7 - (x % 8))) & 0x01) ? 0xFF : 0x00;
rgb = ctb1[((pixelData[pxy] >> (7 - (x % 8))) & 0x01)];
_iSETPIXELRGB(x, y, m, rgb);
}
}
break;
case 4:
// 4-bit
for (int y = 0; y < size; y++) {
for (int x = 0; x < size; x++) {
mxy = (y * (size / 8)) + (x / 8);
pxy = (y * (size / 2)) + (x / 2);
m = ((maskData[mxy] >> (7 - (x % 8))) & 0x01) ? 0xFF : 0x00;
rgb = ctb4[(pixelData[pxy] >> 4 * (1 - x % 2)) & 0x0F];
_iSETPIXELRGB(x, y, m, rgb);
}
}
break;
case 8:
// 8-bit
for (int y = 0; y < size; y++) {
for (int x = 0; x < size; x++) {
mxy = (y * (size / 8)) + (x / 8);
pxy = (y * size) + x;
m = ((maskData[mxy] >> (7 - (x % 8))) & 0x01) ? 0xFF : 0x00;
rgb = ctb8[pixelData[pxy]];
_iSETPIXELRGB(x, y, m, rgb);
}
}
break;
}
// create image
CGDataProviderRef provider = CGDataProviderCreateWithCFData(pixels);
CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
CGImageRef cgImage = CGImageCreate(size, size, 8, 32, size * 4, colorSpace, kCGImageAlphaFirst | kCGBitmapByteOrder32Big, provider, NULL, false, kCGRenderingIntentDefault);
CGDataProviderRelease(provider);
CGColorSpaceRelease(colorSpace);
CFRelease(pixels);
UIImage *image = [UIImage imageWithCGImage:cgImage];
CGImageRelease(cgImage);
return image;
}
@end
Reference in New Issue View Git Blame Copy Permalink