From 401a461f8e9e99835495551764a02b3dbd0e9a28 Mon Sep 17 00:00:00 2001 From: Dominik Pich Date: Sat, 3 May 2014 23:28:07 +0200 Subject: [PATCH 1/3] ios & osx support -- including demos --- CTGradient-IOS/AppDelegate.h | 15 + CTGradient-IOS/AppDelegate.m | 46 + CTGradient-IOS/CTGradient-IOS-Info.plist | 59 + CTGradient-IOS/CTGradient-IOS-Prefix.pch | 16 + CTGradient-IOS/FlipsideViewController.h | 23 + CTGradient-IOS/FlipsideViewController.m | 42 + .../AppIcon.appiconset/Contents.json | 53 + .../LaunchImage.launchimage/Contents.json | 51 + CTGradient-IOS/MainViewController.h | 22 + CTGradient-IOS/MainViewController.m | 133 + CTGradient-IOS/Main_iPad.storyboard | 99 + CTGradient-IOS/Main_iPhone.storyboard | 96 + CTGradient-IOS/main.m | 18 + CTGradient-OSX/AppDelegate.h | 20 + CTGradient-OSX/AppDelegate.m | 81 + .../CTGradient-OSX-Info.plist | 14 +- CTGradient-OSX/CTGradient-OSX-Prefix.pch | 9 + CTGradient-OSX/MainMenu.nib/designable.nib | 2258 +++++++++++++++++ CTGradient-OSX/MainMenu.nib/keyedobjects.nib | Bin 0 -> 21857 bytes main.m => CTGradient-OSX/main.m | 0 CTGradient.h | 86 +- CTGradient.m | 2243 ++++++++-------- CTGradient.xcodeproj/project.pbxproj | 486 +++- .../contents.xcworkspacedata | 7 + .../xcshareddata/CTGradient.xccheckout | 41 + .../UserInterfaceState.xcuserstate | Bin 0 -> 22693 bytes .../WorkspaceSettings.xcsettings | 10 + .../xcdebugger/Breakpoints_v2.xcbkptlist | 5 + .../xcschemes/CTGradient-IOS.xcscheme | 86 + .../xcschemes/CTGradient-OSX.xcscheme | 96 + .../xcschemes/xcschememanagement.plist | 47 + CTGradientView.h | 30 +- CTGradientView.m | 116 +- English.lproj/InfoPlist.strings | Bin 208 -> 0 bytes English.lproj/MainMenu.nib/classes.nib | 12 - English.lproj/MainMenu.nib/info.nib | 23 - English.lproj/MainMenu.nib/keyedobjects.nib | Bin 22247 -> 0 bytes TieDye.icns | Bin 42317 -> 0 bytes 38 files changed, 4919 insertions(+), 1424 deletions(-) create mode 100644 CTGradient-IOS/AppDelegate.h create mode 100644 CTGradient-IOS/AppDelegate.m create mode 100644 CTGradient-IOS/CTGradient-IOS-Info.plist create mode 100644 CTGradient-IOS/CTGradient-IOS-Prefix.pch create mode 100644 CTGradient-IOS/FlipsideViewController.h create mode 100644 CTGradient-IOS/FlipsideViewController.m create mode 100644 CTGradient-IOS/Images.xcassets/AppIcon.appiconset/Contents.json create mode 100644 CTGradient-IOS/Images.xcassets/LaunchImage.launchimage/Contents.json create mode 100644 CTGradient-IOS/MainViewController.h create mode 100644 CTGradient-IOS/MainViewController.m create mode 100644 CTGradient-IOS/Main_iPad.storyboard create mode 100644 CTGradient-IOS/Main_iPhone.storyboard create mode 100644 CTGradient-IOS/main.m create mode 100644 CTGradient-OSX/AppDelegate.h create mode 100644 CTGradient-OSX/AppDelegate.m rename Info.plist => CTGradient-OSX/CTGradient-OSX-Info.plist (65%) create mode 100644 CTGradient-OSX/CTGradient-OSX-Prefix.pch create mode 100644 CTGradient-OSX/MainMenu.nib/designable.nib create mode 100644 CTGradient-OSX/MainMenu.nib/keyedobjects.nib rename main.m => CTGradient-OSX/main.m (100%) mode change 100644 => 100755 CTGradient.h mode change 100644 => 100755 CTGradient.m create mode 100644 CTGradient.xcodeproj/project.xcworkspace/contents.xcworkspacedata create mode 100644 CTGradient.xcodeproj/project.xcworkspace/xcshareddata/CTGradient.xccheckout create mode 100644 CTGradient.xcodeproj/project.xcworkspace/xcuserdata/dominik.xcuserdatad/UserInterfaceState.xcuserstate create mode 100644 CTGradient.xcodeproj/project.xcworkspace/xcuserdata/dominik.xcuserdatad/WorkspaceSettings.xcsettings create mode 100644 CTGradient.xcodeproj/xcuserdata/dominik.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist create mode 100644 CTGradient.xcodeproj/xcuserdata/dominik.xcuserdatad/xcschemes/CTGradient-IOS.xcscheme create mode 100644 CTGradient.xcodeproj/xcuserdata/dominik.xcuserdatad/xcschemes/CTGradient-OSX.xcscheme create mode 100644 CTGradient.xcodeproj/xcuserdata/dominik.xcuserdatad/xcschemes/xcschememanagement.plist delete mode 100644 English.lproj/InfoPlist.strings delete mode 100644 English.lproj/MainMenu.nib/classes.nib delete mode 100644 English.lproj/MainMenu.nib/info.nib delete mode 100644 English.lproj/MainMenu.nib/keyedobjects.nib delete mode 100644 TieDye.icns diff --git a/CTGradient-IOS/AppDelegate.h b/CTGradient-IOS/AppDelegate.h new file mode 100644 index 0000000..3dc538d --- /dev/null +++ b/CTGradient-IOS/AppDelegate.h @@ -0,0 +1,15 @@ +// +// AppDelegate.h +// CTGradient-IOS +// +// Created by Dominik Pich on 03/05/14. +// +// + +#import + +@interface AppDelegate : UIResponder + +@property (strong, nonatomic) UIWindow *window; + +@end diff --git a/CTGradient-IOS/AppDelegate.m b/CTGradient-IOS/AppDelegate.m new file mode 100644 index 0000000..a347907 --- /dev/null +++ b/CTGradient-IOS/AppDelegate.m @@ -0,0 +1,46 @@ +// +// AppDelegate.m +// CTGradient-IOS +// +// Created by Dominik Pich on 03/05/14. +// +// + +#import "AppDelegate.h" + +@implementation AppDelegate + +- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions +{ + // Override point for customization after application launch. + return YES; +} + +- (void)applicationWillResignActive:(UIApplication *)application +{ + // Sent when the application is about to move from active to inactive state. This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message) or when the user quits the application and it begins the transition to the background state. + // Use this method to pause ongoing tasks, disable timers, and throttle down OpenGL ES frame rates. Games should use this method to pause the game. +} + +- (void)applicationDidEnterBackground:(UIApplication *)application +{ + // Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later. + // If your application supports background execution, this method is called instead of applicationWillTerminate: when the user quits. +} + +- (void)applicationWillEnterForeground:(UIApplication *)application +{ + // Called as part of the transition from the background to the inactive state; here you can undo many of the changes made on entering the background. +} + +- (void)applicationDidBecomeActive:(UIApplication *)application +{ + // Restart any tasks that were paused (or not yet started) while the application was inactive. If the application was previously in the background, optionally refresh the user interface. +} + +- (void)applicationWillTerminate:(UIApplication *)application +{ + // Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:. +} + +@end diff --git a/CTGradient-IOS/CTGradient-IOS-Info.plist b/CTGradient-IOS/CTGradient-IOS-Info.plist new file mode 100644 index 0000000..cf58404 --- /dev/null +++ b/CTGradient-IOS/CTGradient-IOS-Info.plist @@ -0,0 +1,59 @@ + + + + + CFBundleDevelopmentRegion + en + CFBundleDisplayName + ${PRODUCT_NAME} + CFBundleExecutable + ${EXECUTABLE_NAME} + CFBundleIdentifier + info.pich.${PRODUCT_NAME:rfc1034identifier} + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + ${PRODUCT_NAME} + CFBundlePackageType + APPL + CFBundleShortVersionString + 1.0 + CFBundleSignature + ???? + CFBundleVersion + 1.0 + LSRequiresIPhoneOS + + UIMainStoryboardFile + Main_iPhone + UIMainStoryboardFile~ipad + Main_iPad + UIRequiredDeviceCapabilities + + armv7 + + UIStatusBarTintParameters + + UINavigationBar + + Style + UIBarStyleBlack + Translucent + + + + UISupportedInterfaceOrientations + + UIInterfaceOrientationPortrait + UIInterfaceOrientationLandscapeLeft + UIInterfaceOrientationLandscapeRight + + UISupportedInterfaceOrientations~ipad + + UIInterfaceOrientationPortrait + UIInterfaceOrientationPortraitUpsideDown + UIInterfaceOrientationLandscapeLeft + UIInterfaceOrientationLandscapeRight + + + diff --git a/CTGradient-IOS/CTGradient-IOS-Prefix.pch b/CTGradient-IOS/CTGradient-IOS-Prefix.pch new file mode 100644 index 0000000..82a2bb4 --- /dev/null +++ b/CTGradient-IOS/CTGradient-IOS-Prefix.pch @@ -0,0 +1,16 @@ +// +// Prefix header +// +// The contents of this file are implicitly included at the beginning of every source file. +// + +#import + +#ifndef __IPHONE_5_0 +#warning "This project uses features only available in iOS SDK 5.0 and later." +#endif + +#ifdef __OBJC__ + #import + #import +#endif diff --git a/CTGradient-IOS/FlipsideViewController.h b/CTGradient-IOS/FlipsideViewController.h new file mode 100644 index 0000000..b88cb5e --- /dev/null +++ b/CTGradient-IOS/FlipsideViewController.h @@ -0,0 +1,23 @@ +// +// FlipsideViewController.h +// CTGradient-IOS +// +// Created by Dominik Pich on 03/05/14. +// +// + +#import + +@class FlipsideViewController; + +@protocol FlipsideViewControllerDelegate +- (void)flipsideViewControllerDidFinish:(FlipsideViewController *)controller; +@end + +@interface FlipsideViewController : UIViewController + +@property (weak, nonatomic) id delegate; + +- (IBAction)done:(id)sender; + +@end diff --git a/CTGradient-IOS/FlipsideViewController.m b/CTGradient-IOS/FlipsideViewController.m new file mode 100644 index 0000000..d6b04be --- /dev/null +++ b/CTGradient-IOS/FlipsideViewController.m @@ -0,0 +1,42 @@ +// +// FlipsideViewController.m +// CTGradient-IOS +// +// Created by Dominik Pich on 03/05/14. +// +// + +#import "FlipsideViewController.h" + +@interface FlipsideViewController () + +@end + +@implementation FlipsideViewController + +- (void)awakeFromNib +{ + self.preferredContentSize = CGSizeMake(320.0, 480.0); + [super awakeFromNib]; +} + +- (void)viewDidLoad +{ + [super viewDidLoad]; + // Do any additional setup after loading the view, typically from a nib. +} + +- (void)didReceiveMemoryWarning +{ + [super didReceiveMemoryWarning]; + // Dispose of any resources that can be recreated. +} + +#pragma mark - Actions + +- (IBAction)done:(id)sender +{ + [self.delegate flipsideViewControllerDidFinish:self]; +} + +@end diff --git a/CTGradient-IOS/Images.xcassets/AppIcon.appiconset/Contents.json b/CTGradient-IOS/Images.xcassets/AppIcon.appiconset/Contents.json new file mode 100644 index 0000000..91bf9c1 --- /dev/null +++ b/CTGradient-IOS/Images.xcassets/AppIcon.appiconset/Contents.json @@ -0,0 +1,53 @@ +{ + "images" : [ + { + "idiom" : "iphone", + "size" : "29x29", + "scale" : "2x" + }, + { + "idiom" : "iphone", + "size" : "40x40", + "scale" : "2x" + }, + { + "idiom" : "iphone", + "size" : "60x60", + "scale" : "2x" + }, + { + "idiom" : "ipad", + "size" : "29x29", + "scale" : "1x" + }, + { + "idiom" : "ipad", + "size" : "29x29", + "scale" : "2x" + }, + { + "idiom" : "ipad", + "size" : "40x40", + "scale" : "1x" + }, + { + "idiom" : "ipad", + "size" : "40x40", + "scale" : "2x" + }, + { + "idiom" : "ipad", + "size" : "76x76", + "scale" : "1x" + }, + { + "idiom" : "ipad", + "size" : "76x76", + "scale" : "2x" + } + ], + "info" : { + "version" : 1, + "author" : "xcode" + } +} \ No newline at end of file diff --git a/CTGradient-IOS/Images.xcassets/LaunchImage.launchimage/Contents.json b/CTGradient-IOS/Images.xcassets/LaunchImage.launchimage/Contents.json new file mode 100644 index 0000000..6f870a4 --- /dev/null +++ b/CTGradient-IOS/Images.xcassets/LaunchImage.launchimage/Contents.json @@ -0,0 +1,51 @@ +{ + "images" : [ + { + "orientation" : "portrait", + "idiom" : "iphone", + "extent" : "full-screen", + "minimum-system-version" : "7.0", + "scale" : "2x" + }, + { + "orientation" : "portrait", + "idiom" : "iphone", + "subtype" : "retina4", + "extent" : "full-screen", + "minimum-system-version" : "7.0", + "scale" : "2x" + }, + { + "orientation" : "portrait", + "idiom" : "ipad", + "extent" : "full-screen", + "minimum-system-version" : "7.0", + "scale" : "1x" + }, + { + "orientation" : "landscape", + "idiom" : "ipad", + "extent" : "full-screen", + "minimum-system-version" : "7.0", + "scale" : "1x" + }, + { + "orientation" : "portrait", + "idiom" : "ipad", + "extent" : "full-screen", + "minimum-system-version" : "7.0", + "scale" : "2x" + }, + { + "orientation" : "landscape", + "idiom" : "ipad", + "extent" : "full-screen", + "minimum-system-version" : "7.0", + "scale" : "2x" + } + ], + "info" : { + "version" : 1, + "author" : "xcode" + } +} \ No newline at end of file diff --git a/CTGradient-IOS/MainViewController.h b/CTGradient-IOS/MainViewController.h new file mode 100644 index 0000000..4e0173e --- /dev/null +++ b/CTGradient-IOS/MainViewController.h @@ -0,0 +1,22 @@ +// +// MainViewController.h +// CTGradient-IOS +// +// Created by Dominik Pich on 03/05/14. +// +// + +#import "FlipsideViewController.h" +#import "CTGradientView.h" + +@interface MainViewController : UIViewController + +@property (strong, nonatomic) UIPopoverController *flipsidePopoverController; + +@property (assign) IBOutlet CTGradientView *gradientView; + +//- (IBAction)changeType:(id)sender; +//- (IBAction)changeAngle:(id)sender; +//- (IBAction)changeStyle:(id)sender; + +@end diff --git a/CTGradient-IOS/MainViewController.m b/CTGradient-IOS/MainViewController.m new file mode 100644 index 0000000..2ecbc0a --- /dev/null +++ b/CTGradient-IOS/MainViewController.m @@ -0,0 +1,133 @@ +// +// MainViewController.m +// CTGradient-IOS +// +// Created by Dominik Pich on 03/05/14. +// +// + +#import "MainViewController.h" + +@interface MainViewController () + +@end + +@implementation MainViewController + +- (void)viewDidLoad +{ + [super viewDidLoad]; + // Do any additional setup after loading the view, typically from a nib. + + self.gradientView.angle = 45; + self.gradientView.radial = NO; + self.gradientView.gradient = [CTGradient rainbowGradient]; +} + +- (void)didReceiveMemoryWarning +{ + [super didReceiveMemoryWarning]; + // Dispose of any resources that can be recreated. +} + +#pragma mark - Flipside View Controller + +- (void)flipsideViewControllerDidFinish:(FlipsideViewController *)controller +{ + if ([[UIDevice currentDevice] userInterfaceIdiom] == UIUserInterfaceIdiomPhone) { + [self dismissViewControllerAnimated:YES completion:nil]; + } else { + [self.flipsidePopoverController dismissPopoverAnimated:YES]; + } +} + +- (void)popoverControllerDidDismissPopover:(UIPopoverController *)popoverController +{ + self.flipsidePopoverController = nil; +} + +- (void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender +{ + if ([[segue identifier] isEqualToString:@"showAlternate"]) { + [[segue destinationViewController] setDelegate:self]; + + if ([[UIDevice currentDevice] userInterfaceIdiom] == UIUserInterfaceIdiomPad) { + UIPopoverController *popoverController = [(UIStoryboardPopoverSegue *)segue popoverController]; + self.flipsidePopoverController = popoverController; + popoverController.delegate = self; + } + } +} + +- (IBAction)togglePopover:(id)sender +{ + if (self.flipsidePopoverController) { + [self.flipsidePopoverController dismissPopoverAnimated:YES]; + self.flipsidePopoverController = nil; + } else { + [self performSegueWithIdentifier:@"showAlternate" sender:sender]; + } +} + +#pragma mark - + +//- (IBAction)changeAngle:(id)sender { +// self.gradientView.angle = 90.0 - [sender floatValue]; +//} +// +//- (IBAction)changeType:(id)sender { +// BOOL isRadial; +// +// if ([[[sender selectedCell] title] isEqualToString:@"Axial"]) +// isRadial = NO; +// else +// isRadial = YES; +// +// self.gradientView.radial = isRadial; +//} +// +//- (IBAction)changeStyle:(id)sender { +// CTGradient *myGradient; +// +// switch ([sender indexOfSelectedItem]) { +// case 0: myGradient = [CTGradient rainbowGradient]; +// break; +// +// case 1: myGradient = [CTGradient aquaSelectedGradient]; +// break; +// +// case 2: myGradient = [CTGradient aquaNormalGradient]; +// break; +// +// case 3: myGradient = [CTGradient aquaPressedGradient]; +// break; +// +// case 4: myGradient = [CTGradient unifiedSelectedGradient]; +// break; +// +// case 5: myGradient = [CTGradient unifiedNormalGradient]; +// break; +// +// case 6: myGradient = [CTGradient unifiedPressedGradient]; +// break; +// +// case 7: myGradient = [CTGradient unifiedDarkGradient]; +// break; +// +// case 8: myGradient = [CTGradient sourceListSelectedGradient]; +// break; +// +// case 9: myGradient = [CTGradient sourceListUnselectedGradient]; +// break; +// +// case 10: myGradient = [CTGradient hydrogenSpectrumGradient]; +// break; +// +// default: myGradient = [CTGradient gradientWithBeginningColor:[NSColor blackColor] +// endingColor:[NSColor whiteColor]]; +// } +// +// self.gradientView.gradient = myGradient; +//} + +@end diff --git a/CTGradient-IOS/Main_iPad.storyboard b/CTGradient-IOS/Main_iPad.storyboard new file mode 100644 index 0000000..c1a14a4 --- /dev/null +++ b/CTGradient-IOS/Main_iPad.storyboard @@ -0,0 +1,99 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/CTGradient-IOS/Main_iPhone.storyboard b/CTGradient-IOS/Main_iPhone.storyboard new file mode 100644 index 0000000..e135980 --- /dev/null +++ b/CTGradient-IOS/Main_iPhone.storyboard @@ -0,0 +1,96 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/CTGradient-IOS/main.m b/CTGradient-IOS/main.m new file mode 100644 index 0000000..03ac110 --- /dev/null +++ b/CTGradient-IOS/main.m @@ -0,0 +1,18 @@ +// +// main.m +// CTGradient-IOS +// +// Created by Dominik Pich on 03/05/14. +// +// + +#import + +#import "AppDelegate.h" + +int main(int argc, char * argv[]) +{ + @autoreleasepool { + return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class])); + } +} diff --git a/CTGradient-OSX/AppDelegate.h b/CTGradient-OSX/AppDelegate.h new file mode 100644 index 0000000..70b15a5 --- /dev/null +++ b/CTGradient-OSX/AppDelegate.h @@ -0,0 +1,20 @@ +// +// AppDelegate.h +// CTGradient-OSX +// +// Created by Dominik Pich on 03/05/14. +// +// + +#import +#import "CTGradientView.h" + +@interface AppDelegate : NSObject + +@property (assign) IBOutlet CTGradientView *gradientView; + +- (IBAction)changeType:(id)sender; +- (IBAction)changeAngle:(id)sender; +- (IBAction)changeStyle:(id)sender; + +@end diff --git a/CTGradient-OSX/AppDelegate.m b/CTGradient-OSX/AppDelegate.m new file mode 100644 index 0000000..8d985d9 --- /dev/null +++ b/CTGradient-OSX/AppDelegate.m @@ -0,0 +1,81 @@ +// +// AppDelegate.m +// CTGradient-OSX +// +// Created by Dominik Pich on 03/05/14. +// +// + +#import "AppDelegate.h" + +@implementation AppDelegate + +- (void)applicationDidFinishLaunching:(NSNotification *)aNotification +{ + [[NSNotificationCenter defaultCenter] addObserverForName:NSWindowWillCloseNotification object:nil queue:nil usingBlock:^(NSNotification *note) { + [NSApp terminate:nil]; + }]; +} + +#pragma mark - + +- (IBAction)changeAngle:(id)sender { + self.gradientView.angle = 90.0 - [sender floatValue]; +} + +- (IBAction)changeType:(id)sender { + BOOL isRadial; + + if ([[[sender selectedCell] title] isEqualToString:@"Axial"]) + isRadial = NO; + else + isRadial = YES; + + self.gradientView.radial = isRadial; +} + +- (IBAction)changeStyle:(id)sender { + CTGradient *myGradient; + + switch ([sender indexOfSelectedItem]) { + case 0: myGradient = [CTGradient rainbowGradient]; + break; + + case 1: myGradient = [CTGradient aquaSelectedGradient]; + break; + + case 2: myGradient = [CTGradient aquaNormalGradient]; + break; + + case 3: myGradient = [CTGradient aquaPressedGradient]; + break; + + case 4: myGradient = [CTGradient unifiedSelectedGradient]; + break; + + case 5: myGradient = [CTGradient unifiedNormalGradient]; + break; + + case 6: myGradient = [CTGradient unifiedPressedGradient]; + break; + + case 7: myGradient = [CTGradient unifiedDarkGradient]; + break; + + case 8: myGradient = [CTGradient sourceListSelectedGradient]; + break; + + case 9: myGradient = [CTGradient sourceListUnselectedGradient]; + break; + + case 10: myGradient = [CTGradient hydrogenSpectrumGradient]; + break; + + default: myGradient = [CTGradient gradientWithBeginningColor:[NSColor blackColor] + endingColor:[NSColor whiteColor]]; + } + + self.gradientView.gradient = myGradient; +} + +@end diff --git a/Info.plist b/CTGradient-OSX/CTGradient-OSX-Info.plist similarity index 65% rename from Info.plist rename to CTGradient-OSX/CTGradient-OSX-Info.plist index 072d7cb..cc31078 100644 --- a/Info.plist +++ b/CTGradient-OSX/CTGradient-OSX-Info.plist @@ -1,25 +1,29 @@ - + CFBundleDevelopmentRegion - English + en CFBundleExecutable ${EXECUTABLE_NAME} CFBundleIconFile - TieDye + CFBundleIdentifier - com.cotingent.CTGradient + info.pich.${PRODUCT_NAME:rfc1034identifier} CFBundleInfoDictionaryVersion 6.0 CFBundleName ${PRODUCT_NAME} CFBundlePackageType APPL + CFBundleShortVersionString + 1.0 CFBundleSignature ???? CFBundleVersion - 1.0 + 1 + LSMinimumSystemVersion + ${MACOSX_DEPLOYMENT_TARGET} NSMainNibFile MainMenu NSPrincipalClass diff --git a/CTGradient-OSX/CTGradient-OSX-Prefix.pch b/CTGradient-OSX/CTGradient-OSX-Prefix.pch new file mode 100644 index 0000000..35d7640 --- /dev/null +++ b/CTGradient-OSX/CTGradient-OSX-Prefix.pch @@ -0,0 +1,9 @@ +// +// Prefix header +// +// The contents of this file are implicitly included at the beginning of every source file. +// + +#ifdef __OBJC__ + #import +#endif diff --git a/CTGradient-OSX/MainMenu.nib/designable.nib b/CTGradient-OSX/MainMenu.nib/designable.nib new file mode 100644 index 0000000..b15168b --- /dev/null +++ b/CTGradient-OSX/MainMenu.nib/designable.nib @@ -0,0 +1,2258 @@ + + + + 1090 + 13C1021 + 5056 + 1265.19 + 697.40 + + com.apple.InterfaceBuilder.CocoaPlugin + 5056 + + + NSButtonCell + NSCustomObject + NSCustomView + NSMatrix + NSMenu + NSMenuItem + NSPopUpButton + NSPopUpButtonCell + NSSlider + NSSliderCell + NSTextField + NSTextFieldCell + NSView + NSWindowTemplate + + + com.apple.InterfaceBuilder.CocoaPlugin + + + PluginDependencyRecalculationVersion + + + + + + NSApplication + + + + FirstResponder + + + NSApplication + + + 15 + 2 + {{702, 602}, {198, 64}} + 1886914560 + CTGradient + NSWindow + + View + + + + + 256 + + + + 274 + {198, 64} + + CTGradientView + NSView + + + {198, 64} + + + {{0, 0}, {1680, 1028}} + {10000000000000, 10000000000000} + YES + + + MainMenu + + + + NewApplication + + 1048576 + 2147483647 + + NSImage + NSMenuCheckmark + + + NSImage + NSMenuMixedState + + submenuAction: + + + NewApplication + + + + About CTGradient + + 2147483647 + + + + + + YES + YES + + + 1048576 + 2147483647 + + + + + + Preferences… + , + 1048576 + 2147483647 + + + + + + YES + YES + + + 1048576 + 2147483647 + + + + + + Services + + 1048576 + 2147483647 + + + submenuAction: + + + + Services + + + _NSServicesMenu + + + + + YES + YES + + + 1048576 + 2147483647 + + + + + + Hide CTGradient + h + 1048576 + 2147483647 + + + + + + Hide Others + h + 1572864 + 2147483647 + + + + + + Show All + + 1048576 + 2147483647 + + + + + + YES + YES + + + 1048576 + 2147483647 + + + + + + Quit NewApplication + q + 1048576 + 2147483647 + + + + + _NSAppleMenu + + + + + File + + 1048576 + 2147483647 + + + submenuAction: + + + + File + + + + + New + n + 1048576 + 2147483647 + + + + + + Open... + o + 1048576 + 2147483647 + + + + + + Open Recent + + 1048576 + 2147483647 + + + submenuAction: + + + + Open Recent + + + + + Clear Menu + + 1048576 + 2147483647 + + + + + _NSRecentDocumentsMenu + + + + + YES + YES + + + 1048576 + 2147483647 + + + + + + Close + w + 1048576 + 2147483647 + + + + + + Save + s + 1048576 + 2147483647 + + + + + + Save As… + S + 1048576 + 2147483647 + + + + + + Revert + + 2147483647 + + + + + + YES + YES + + + 1048576 + 2147483647 + + + + + + Page Setup… + P + 1048576 + 2147483647 + + + + + + Print… + p + 1048576 + 2147483647 + + + + + + + + + Edit + + 1048576 + 2147483647 + + + submenuAction: + + + + Edit + + + + + Undo + z + 1048576 + 2147483647 + + + + + + Redo + Z + 1048576 + 2147483647 + + + + + + YES + YES + + + 1048576 + 2147483647 + + + + + + Cut + x + 1048576 + 2147483647 + + + + + + Copy + c + 1048576 + 2147483647 + + + + + + Paste + v + 1048576 + 2147483647 + + + + + + Paste and Match Style + V + 1572864 + 2147483647 + + + + + + Delete + + 1048576 + 2147483647 + + + + + + Select All + a + 1048576 + 2147483647 + + + + + + YES + YES + + + 1048576 + 2147483647 + + + + + + Find + + 1048576 + 2147483647 + + + submenuAction: + + + + Find + + + + + Find… + f + 1048576 + 2147483647 + + + 1 + + + + Find Next + g + 1048576 + 2147483647 + + + 2 + + + + Find Previous + G + 1048576 + 2147483647 + + + 3 + + + + Use Selection for Find + e + 1048576 + 2147483647 + + + 7 + + + + Jump to Selection + j + 1048576 + 2147483647 + + + + + + + + + Spelling + + 1048576 + 2147483647 + + + submenuAction: + + + Spelling + + + + Spelling… + : + 1048576 + 2147483647 + + + + + + Check Spelling + ; + 1048576 + 2147483647 + + + + + + Check Spelling as You Type + + 1048576 + 2147483647 + + + + + + + + + + + + Window + + 1048576 + 2147483647 + + + submenuAction: + + + + Window + + + + + Minimize + m + 1048576 + 2147483647 + + + + + + Zoom + + 1048576 + 2147483647 + + + + + + YES + YES + + + 1048576 + 2147483647 + + + + + + Bring All to Front + + 1048576 + 2147483647 + + + + + _NSWindowsMenu + + + + _NSMainMenu + + + 145 + 2 + {{702, 488}, {198, 81}} + -260569088 + Settings + NSPanel + + View + + + + + 256 + + + + 256 + {{59, 6}, {18, 20}} + + YES + + 67371264 + 131072 + + + + + Helvetica + 12 + 16 + + + 360 + 0.0 + 0.0 + 0.0 + 0 + 1 + YES + NO + 1 + + NO + + + + 256 + {{17, 10}, {39, 14}} + + + YES + + 67108864 + 71434240 + Angle: + + .LucidaGrandeUI + 11 + 3100 + + + + 6 + System + controlColor + + 3 + MC42NjY2NjY2NjY3AA + + + + 6 + System + controlTextColor + + 3 + MAA + + + + NO + 1 + + + + 256 + {{58, 52}, {123, 22}} + + + YES + + -2076180416 + 133120 + + + 109199360 + 1 + + LucidaGrande + 11 + 16 + + + + + + 400 + 75 + + YES + + + OtherViews + + + + + rainbow + + 1048576 + 2147483647 + + + _popUpItemAction: + + + + + AquaSelected + + 1048576 + 2147483647 + + + _popUpItemAction: + 2 + + + + + AquaNormal + + 1048576 + 2147483647 + + + _popUpItemAction: + + + + + AquaPressed + + 1048576 + 2147483647 + + + _popUpItemAction: + + + + + UnifiedSelected + + 1048576 + 2147483647 + + + _popUpItemAction: + + + + + UnifiedNormal + + 1048576 + 2147483647 + + + _popUpItemAction: + + + + + UnifiedPressed + + 1048576 + 2147483647 + + + _popUpItemAction: + + + + + UnifiedDark + + 1048576 + 2147483647 + + + _popUpItemAction: + + + + + sourceListSelected + + 1048576 + 2147483647 + + + _popUpItemAction: + + + + + sourceListUnselected + + 1048576 + 2147483647 + + + _popUpItemAction: + + + + + hydrogenSpectrum + + 1048576 + 2147483647 + + + _popUpItemAction: + + + + + -1 + 3 + YES + YES + 1 + + NO + + + + 256 + {{17, 57}, {39, 14}} + + + YES + + 67108864 + 71434240 + Style: + + + + + + NO + 1 + + + + 256 + {{17, 33}, {39, 14}} + + + YES + + 67108864 + 71434240 + Type: + + + + + + NO + 1 + + + + 256 + {{57, 32}, {114, 16}} + + + YES + NO + 1 + 2 + + + -2080374784 + 131072 + Axial + + + 1211912448 + 2 + + NSImage + NSRadioButton + + + NSRadioButton + + + + + + 200 + 25 + + + 67108864 + 131072 + Radial + + + 1211912448 + 0 + + 549453824 + {14, 15} + + + + + + TU0AKgAAA1AAAAAAAAAAAAAAAAAAAAAhDAwMdicnJ8krKyvwNTU18CMjI8kaGhp2AgICIQAAAAAAAAAA +AAAAAAAAAAAAAAAABAQEOD4+PsKhoaH/4ODg//7+/v/+/v7/39/f/6SkpP9JSUnCBgYGOAAAAAAAAAAA +AAAAAAMDAypHR0fIsrKy//n5+f///////////////////////////7+/v/9XV1fIBgYGKgAAAAAAAAAJ +NjY2kKKiov/b29v/+/v7//v7+//6+vr/+fn5//r6+v/7+/v/5+fn/6ysrP9CQkKQAAAACQEBASF5eXnb +w8PD/9fX1//q6ur/8fHx//Hx8f/x8fH/8fHx/+7u7v/b29v/xsbG/35+ftsBAQEhAwMDNqurq/zR0dH/ +29vb/+Li4v/m5ub/6Ojo/+np6f/m5ub/4+Pj/9ra2v/T09P/sbGx/AMDAzYEBARAvr6+/9ra2v/h4eH/ +5+fn/+rq6v/r6+v/6enp/+np6f/l5eX/4uLi/93d3f/BwcH/BAQEQAMDAz6vr6/z5ubm/+fn5//t7e3/ +8PDw//Hx8f/x8fH/8PDw/+7u7v/o6Oj/5+fn/6ysrPMDAwM+AQEBLX5+ftXr6+v/7e3t//Ly8v/39/f/ ++/v7//r6+v/5+fn/9vb2/+/v7//s7Oz/enp61QEBAS0AAAAUJycnkczMzP/8/Pz/+/v7//7+/v////// +///////////8/Pz//////87Ozv8mJiaRAAAAFAAAAAIAAAA5QEBAvtnZ2f////////////////////// +///////////d3d3/QEBAvgAAADkAAAACAAAAAAAAAAgAAABHLi4uuJubm/XZ2dn////////////Z2dn/ +m5ub9TAwMLgAAABHAAAACAAAAAAAAAAAAAAAAAAAAAkAAAA4BwcHgAAAAJ8AAACzAAAAswAAAJ8HBweA +AAAAOAAAAAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAATAAAAJwAAADUAAAA1AAAAJwAAABMAAAAD +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAADgEAAAMAAAABAA4AAAEBAAMAAAABAA8AAAECAAMAAAAEAAAD/gEDAAMAAAABAAEAAAEG +AAMAAAABAAIAAAERAAQAAAABAAAACAESAAMAAAABAAEAAAEVAAMAAAABAAQAAAEWAAMAAAABAA8AAAEX +AAQAAAABAAADSAEcAAMAAAABAAEAAAFSAAMAAAABAAEAAAFTAAMAAAAEAAAEBodzAAcAAAPUAAAEDgAA +AAAACAAIAAgACAABAAEAAQABAAAD1GFwcGwCAAAAbW50clJHQiBYWVogB9UADAAeABAAOwAYYWNzcEFQ +UEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPbWAAEAAAAA0y1hcHBs9BXCfMSz7rlhs/vpvGnUSQAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOclhZWgAAASwAAAAUZ1hZWgAAAUAAAAAUYlhZWgAA +AVQAAAAUd3RwdAAAAWgAAAAUY2hhZAAAAXwAAAAsclRSQwAAAagAAAAOZ1RSQwAAAbgAAAAOYlRSQwAA +AcgAAAAOdmNndAAAAdgAAAAwbmRpbgAAAggAAAA4ZGVzYwAAAkAAAABvZHNjbQAAArAAAADMbW1vZAAA +A3wAAAAoY3BydAAAA6QAAAAtWFlaIAAAAAAAAHObAAA8xgAAAl5YWVogAAAAAAAAWtQAAKmoAAAWo1hZ +WiAAAAAAAAAoZwAAGacAALolWFlaIAAAAAAAAPPYAAEAAAABFghzZjMyAAAAAAABC7cAAAWW///zVwAA +BykAAP3X///7t////aYAAAPaAADA9mN1cnYAAAAAAAAAAQHNAABjdXJ2AAAAAAAAAAEBzQAAY3VydgAA +AAAAAAABAc0AAHZjZ3QAAAAAAAAAAQAA0XQAAAAAAAEAAAAA0XQAAAAAAAEAAAAA0XQAAAAAAAEAAG5k +aW4AAAAAAAAAMAAApAAAAFcAAABNAAAAmcAAACcXAAAWuwAAUEAAAFRAAAIzMwACMzMAAjMzZGVzYwAA +AAAAAAAVQXBwbGUgQ2luZW1hIERpc3BsYXkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG1sdWMAAAAAAAAABAAA +AAxlc0VTAAAAOgAAAEBlblVTAAAAKAAAAHpmckZSAAAAKgAAAKJkZURFAAAAKAAAAHoAUABhAG4AdABh +AGwAbABhACAAQQBwAHAAbABlACAAQwBpAG4AZQBtAGEAIABEAGkAcwBwAGwAYQB5AEEAcABwAGwAZQAg +AEMAaQBuAGUAbQBhACAARABpAHMAcABsAGEAeQBNAG8AbgBpAHQAZQB1AHIAIABBAHAAcABsAGUAIABD +AGkAbgBlAG0AYW1tb2QAAAAAAAAGEAAAkhICAAAmtK6jgAAAAAAAAAAAAAAAAAAAAAB0ZXh0AAAAAENv +cHlyaWdodCBBcHBsZSBDb21wdXRlciwgSW5jLiwgMjAwNQAAAAA + + + + + + 3 + MCAwAA + + + + + 400 + 75 + + + {55, 16} + {4, 2} + 1143472128 + NSActionCell + + 67108864 + 131072 + bla + + 1211912448 + 0 + + + + 400 + 75 + + + + + 3 + MQA + + + .LucidaGrandeUI + 13 + 1044 + + + + {198, 81} + + + {{0, 0}, {1680, 1028}} + {10000000000000, 10000000000000} + YES + + + AppDelegate + + + + + + + delegate + + + + 286 + + + + terminate: + + + + 139 + + + + orderFrontStandardAboutPanel: + + + + 142 + + + + hideOtherApplications: + + + + 146 + + + + hide: + + + + 152 + + + + unhideAllApplications: + + + + 153 + + + + performMiniaturize: + + + + 37 + + + + arrangeInFront: + + + + 39 + + + + print: + + + + 86 + + + + runPageLayout: + + + + 87 + + + + clearRecentDocuments: + + + + 127 + + + + cut: + + + + 175 + + + + paste: + + + + 176 + + + + redo: + + + + 178 + + + + selectAll: + + + + 179 + + + + undo: + + + + 180 + + + + copy: + + + + 181 + + + + showGuessPanel: + + + + 188 + + + + checkSpelling: + + + + 190 + + + + toggleContinuousSpellChecking: + + + + 192 + + + + performClose: + + + + 193 + + + + delete: + + + + 195 + + + + performZoom: + + + + 198 + + + + performFindPanelAction: + + + + 199 + + + + performFindPanelAction: + + + + 200 + + + + performFindPanelAction: + + + + 201 + + + + performFindPanelAction: + + + + 202 + + + + centerSelectionInVisibleArea: + + + + 203 + + + + pasteAsPlainText: + + + + 205 + + + + delegate + + + + 285 + + + + changeStyle: + + + + 287 + + + + changeType: + + + + 288 + + + + changeAngle: + + + + 289 + + + + gradientView + + + + 290 + + + + + + 0 + + + + + + -2 + + + File's Owner + + + -1 + + + First Responder + + + 29 + + + + + + + + + MainMenu + + + 19 + + + + + + + + 24 + + + + + + + + + + + 5 + + + + + 23 + + + + + 92 + + + + + 197 + + + + + 56 + + + + + + + + 57 + + + + + + + + + + + + + + + + + + 58 + + + + + 129 + + + + + 131 + + + + + + + + 130 + + + + + 134 + + + + + 136 + + + + + 143 + + + + + 144 + + + + + 145 + + + + + 149 + + + + + 150 + + + + + 196 + + + + + 83 + + + + + + + + 81 + + + + + + + + + + + + + + + + + + 72 + + + + + 73 + + + + + 74 + + + + + 75 + + + + + 77 + + + + + 78 + + + + + 79 + + + + + 80 + + + + + 82 + + + + + 112 + + + + + 124 + + + + + + + + 125 + + + + + + + + 126 + + + + + 163 + + + + + + + + 169 + + + + + + + + + + + + + + + + + + + 156 + + + + + 157 + + + + + 158 + + + + + 160 + + + + + 164 + + + + + 168 + + + + + + + + 159 + + + + + + + + + + + + 154 + + + + + 155 + + + + + 161 + + + + + 162 + + + + + 167 + + + + + 171 + + + + + 172 + + + + + 173 + + + + + 174 + + + + + 184 + + + + + + + + 185 + + + + + + + + + + 187 + + + + + 189 + + + + + 191 + + + + + 204 + + + + + 209 + + + + + + Panel + + + 210 + + + + + + + + + + + + + 211 + + + + + + + + 213 + + + + + + + + 218 + + + + + + + + 227 + + + + + + + + 259 + + + + + + + + 263 + + + + + + + + + + 267 + + + + + 268 + + + + + 278 + + + + + 279 + + + + + 280 + + + + + + + + 281 + + + + + 282 + + + + + 283 + + + + + 219 + + + + + + + + + + + + + + + + + + 275 + + + + + 274 + + + + + 273 + + + + + 272 + + + + + 226 + + + + + 225 + + + + + 224 + + + + + 223 + + + + + 222 + + + + + 221 + + + + + 220 + + + + + -3 + + + Application + + + 284 + + + + + 214 + + + + + + Window + + + 215 + + + + + + + + 246 + + + + + + + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + com.apple.InterfaceBuilder.CocoaPlugin + + + + + + 290 + + + + + AppDelegate + NSObject + + id + id + id + + + + changeAngle: + id + + + changeStyle: + id + + + changeType: + id + + + + CTGradientView + UIWindow + + + + gradientView + CTGradientView + + + window + UIWindow + + + + IBProjectSource + ./Classes/AppDelegate.h + + + + CTGradientView + NSView + + IBProjectSource + ./Classes/CTGradientView.h + + + + NSDocument + + id + id + id + id + id + id + id + id + id + id + id + id + id + id + + + + browseDocumentVersions: + id + + + duplicateDocument: + id + + + lockDocument: + id + + + moveDocument: + id + + + moveDocumentToUbiquityContainer: + id + + + printDocument: + id + + + renameDocument: + id + + + revertDocumentToSaved: + id + + + runPageLayout: + id + + + saveDocument: + id + + + saveDocumentAs: + id + + + saveDocumentTo: + id + + + saveDocumentToPDF: + id + + + unlockDocument: + id + + + + IBProjectSource + ./Classes/NSDocument.h + + + + UIResponder + NSObject + + IBProjectSource + ./Classes/UIResponder.h + + + + UIView + UIResponder + + IBProjectSource + ./Classes/UIView.h + + + + UIWindow + UIView + + IBProjectSource + ./Classes/UIWindow.h + + + + + 0 + IBCocoaFramework + YES + + com.apple.InterfaceBuilder.CocoaPlugin.macosx + + + + com.apple.InterfaceBuilder.CocoaPlugin.InterfaceBuilder3 + + + YES + 3 + + {11, 11} + {10, 3} + {16, 15} + + + diff --git a/CTGradient-OSX/MainMenu.nib/keyedobjects.nib b/CTGradient-OSX/MainMenu.nib/keyedobjects.nib new file mode 100644 index 0000000000000000000000000000000000000000..3ee2c2b76ca68762a8d00811cedb32a15d830623 GIT binary patch literal 21857 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%0D& zj4O?w8rK@XG_E&pG;T3&H|{jQ>X*^>*Z~V!4$@rV`n(?ObZ{t1V n{ahwjmdoZUa@*#H<)-9j=DNP*MUn53!Go)FzBm5Q?ficLq(bvX literal 0 HcmV?d00001 diff --git a/main.m b/CTGradient-OSX/main.m similarity index 100% rename from main.m rename to CTGradient-OSX/main.m diff --git a/CTGradient.h b/CTGradient.h old mode 100644 new mode 100755 index ffb7883..5a94854 --- a/CTGradient.h +++ b/CTGradient.h @@ -5,36 +5,68 @@ // Writtin by Chad Weider. // // Released into public domain on 4/10/08. -// +// // Version: 1.8 - +#if !__has_feature(objc_arc) +#error This class requires automatic reference counting +#endif + +#if TARGET_OS_IPHONE +#import + +#define Color UIColor +#define Rect CGRect +#define BezierPath UIBezierPath + +#define MinX CGRectGetMinX +#define MidX CGRectGetMidX +#define MaxX CGRectGetMaxX +#define MinY CGRectGetMinY +#define MidY CGRectGetMidY +#define MaxY CGRectGetMaxY +#define Width CGRectGetWidth +#define Height CGRectGetHeight +#else #import -typedef struct _CTGradientElement - { +#define Color NSColor +#define Rect NSRect +#define BezierPath NSBezierPath + +#define MinX NSMinX +#define MidX NSMidX +#define MaxX NSMaxX +#define MinY NSMinY +#define MidY NSMidY +#define MaxY NSMaxY +#define Width NSWidth +#define Height NSHeight +#endif + +typedef struct _CTGradientElement +{ CGFloat red, green, blue, alpha; CGFloat position; - + struct _CTGradientElement *nextElement; - } CTGradientElement; +} CTGradientElement; -typedef enum _CTBlendingMode - { +typedef enum _CTBlendingMode { CTLinearBlendingMode, CTChromaticBlendingMode, CTInverseChromaticBlendingMode - } CTGradientBlendingMode; +} CTGradientBlendingMode; @interface CTGradient : NSObject - { - CTGradientElement* elementList; +{ + CTGradientElement *elementList; CTGradientBlendingMode blendingMode; - + CGFunctionRef gradientFunction; - } +} -+ (id)gradientWithBeginningColor:(NSColor *)begin endingColor:(NSColor *)end; ++ (id)gradientWithBeginningColor:(Color *)begin endingColor:(Color *)end; + (id)aquaSelectedGradient; + (id)aquaNormalGradient; @@ -51,23 +83,23 @@ typedef enum _CTBlendingMode + (id)rainbowGradient; + (id)hydrogenSpectrumGradient; -- (CTGradient *)gradientWithAlphaComponent:(float)alpha; +- (CTGradient *)gradientWithAlphaComponent:(CGFloat)alpha; -- (CTGradient *)addColorStop:(NSColor *)color atPosition:(float)position; //positions given relative to [0,1] -- (CTGradient *)removeColorStopAtIndex:(unsigned)index; -- (CTGradient *)removeColorStopAtPosition:(float)position; +- (CTGradient *)addColorStop:(Color *)color atPosition:(CGFloat)position; //positions given relative to [0,1] +- (CTGradient *)removeColorStopAtIndex:(NSUInteger)index; +- (CTGradient *)removeColorStopAtPosition:(CGFloat)position; - (CTGradientBlendingMode)blendingMode; -- (NSColor *)colorStopAtIndex:(unsigned)index; -- (NSColor *)colorAtPosition:(float)position; +- (Color *)colorStopAtIndex:(NSUInteger)index; +- (Color *)colorAtPosition:(CGFloat)position; -- (void)drawSwatchInRect:(NSRect)rect; -- (void)fillRect:(NSRect)rect angle:(float)angle; //fills rect with axial gradient - // angle in degrees -- (void)radialFillRect:(NSRect)rect; //fills rect with radial gradient - // gradient from center outwards -- (void)fillBezierPath:(NSBezierPath *)path angle:(float)angle; -- (void)radialFillBezierPath:(NSBezierPath *)path; +- (void)drawSwatchInRect:(Rect)rect; +- (void)fillRect:(Rect)rect angle:(CGFloat)angle; //fills rect with axial gradient +// angle in degrees +- (void)radialFillRect:(Rect)rect; //fills rect with radial gradient +// gradient from center outwards +- (void)fillBezierPath:(BezierPath *)path angle:(CGFloat)angle; +- (void)radialFillBezierPath:(BezierPath *)path; @end diff --git a/CTGradient.m b/CTGradient.m old mode 100644 new mode 100755 index 7057e64..6482573 --- a/CTGradient.m +++ b/CTGradient.m @@ -13,1014 +13,990 @@ @interface CTGradient (Private) - (void)_commonInit; - (void)setBlendingMode:(CTGradientBlendingMode)mode; -- (void)addElement:(CTGradientElement*)newElement; +- (void)addElement:(CTGradientElement *)newElement; -- (CTGradientElement *)elementAtIndex:(unsigned)index; +- (CTGradientElement *)elementAtIndex:(NSUInteger)index; -- (CTGradientElement)removeElementAtIndex:(unsigned)index; -- (CTGradientElement)removeElementAtPosition:(float)position; +- (CTGradientElement)removeElementAtIndex:(NSUInteger)index; +- (CTGradientElement)removeElementAtPosition:(CGFloat)position; @end //C Fuctions for color blending -static void linearEvaluation (void *info, const float *in, float *out); -static void chromaticEvaluation(void *info, const float *in, float *out); -static void inverseChromaticEvaluation(void *info, const float *in, float *out); -static void transformRGB_HSV(float *components); -static void transformHSV_RGB(float *components); -static void resolveHSV(float *color1, float *color2); +static void linearEvaluation(void *info, const CGFloat *in, CGFloat *out); +static void chromaticEvaluation(void *info, const CGFloat *in, CGFloat *out); +static void inverseChromaticEvaluation(void *info, const CGFloat *in, CGFloat *out); +static void transformRGB_HSV(CGFloat *components); +static void transformHSV_RGB(CGFloat *components); +static void resolveHSV(CGFloat *color1, CGFloat *color2); @implementation CTGradient /////////////////////////////////////Initialization Type Stuff -- (id)init - { - self = [super init]; - - if (self != nil) - { - [self _commonInit]; - [self setBlendingMode:CTLinearBlendingMode]; - } - return self; - } - -- (void)_commonInit - { - elementList = nil; - } - -- (void)dealloc - { - CGFunctionRelease(gradientFunction); - - CTGradientElement *elementToRemove = elementList; - while(elementList != nil) - { - elementToRemove = elementList; - elementList = elementList->nextElement; - free(elementToRemove); +- (id)init { + self = [super init]; + + if (self != nil) { + [self _commonInit]; + [self setBlendingMode:CTLinearBlendingMode]; } - - [super dealloc]; - } - -- (id)copyWithZone:(NSZone *)zone - { - CTGradient *copy = [[[self class] allocWithZone:zone] init]; - - //now just copy my elementlist - CTGradientElement *currentElement = elementList; - while(currentElement != nil) - { - [copy addElement:currentElement]; - currentElement = currentElement->nextElement; + return self; +} + +- (void)_commonInit { + elementList = nil; +} + +- (void)dealloc { + CGFunctionRelease(gradientFunction); + + CTGradientElement *elementToRemove = elementList; + while (elementList != nil) { + elementToRemove = elementList; + elementList = elementList->nextElement; + free(elementToRemove); } - - [copy setBlendingMode:blendingMode]; - - return copy; - } - -- (void)encodeWithCoder:(NSCoder *)coder - { - if([coder allowsKeyedCoding]) - { - unsigned count = 0; +} + +- (id)copyWithZone:(NSZone *)zone { + CTGradient *copy = [[[self class] allocWithZone:zone] init]; + + //now just copy my elementlist CTGradientElement *currentElement = elementList; - while(currentElement != nil) - { - [coder encodeValueOfObjCType:@encode(float) at:&(currentElement->red)]; - [coder encodeValueOfObjCType:@encode(float) at:&(currentElement->green)]; - [coder encodeValueOfObjCType:@encode(float) at:&(currentElement->blue)]; - [coder encodeValueOfObjCType:@encode(float) at:&(currentElement->alpha)]; - [coder encodeValueOfObjCType:@encode(float) at:&(currentElement->position)]; - - count++; + while (currentElement != nil) { + [copy addElement:currentElement]; currentElement = currentElement->nextElement; + } + + [copy setBlendingMode:blendingMode]; + + return copy; +} + +- (void)encodeWithCoder:(NSCoder *)coder { + if ([coder allowsKeyedCoding]) { + NSUInteger count = 0; + CTGradientElement *currentElement = elementList; + while (currentElement != nil) { + [coder encodeValueOfObjCType:@encode(CGFloat) at:&(currentElement->red)]; + [coder encodeValueOfObjCType:@encode(CGFloat) at:&(currentElement->green)]; + [coder encodeValueOfObjCType:@encode(CGFloat) at:&(currentElement->blue)]; + [coder encodeValueOfObjCType:@encode(CGFloat) at:&(currentElement->alpha)]; + [coder encodeValueOfObjCType:@encode(CGFloat) at:&(currentElement->position)]; + + count++; + currentElement = currentElement->nextElement; } - [coder encodeInt:count forKey:@"CTGradientElementCount"]; - [coder encodeInt:blendingMode forKey:@"CTGradientBlendingMode"]; + [coder encodeInteger:count forKey:@"CTGradientElementCount"]; + [coder encodeInteger:blendingMode forKey:@"CTGradientBlendingMode"]; } - else - [NSException raise:NSInvalidArchiveOperationException format:@"Only supports NSKeyedArchiver coders"]; - } - -- (id)initWithCoder:(NSCoder *)coder - { - [self _commonInit]; - - [self setBlendingMode:[coder decodeIntForKey:@"CTGradientBlendingMode"]]; - unsigned count = [coder decodeIntForKey:@"CTGradientElementCount"]; - - while(count != 0) - { - CTGradientElement newElement; - - [coder decodeValueOfObjCType:@encode(float) at:&(newElement.red)]; - [coder decodeValueOfObjCType:@encode(float) at:&(newElement.green)]; - [coder decodeValueOfObjCType:@encode(float) at:&(newElement.blue)]; - [coder decodeValueOfObjCType:@encode(float) at:&(newElement.alpha)]; - [coder decodeValueOfObjCType:@encode(float) at:&(newElement.position)]; - - count--; - [self addElement:&newElement]; + else + [NSException raise:NSInvalidArchiveOperationException format:@"Only supports NSKeyedArchiver coders"]; +} + +- (id)initWithCoder:(NSCoder *)coder { + [self _commonInit]; + + [self setBlendingMode:[coder decodeIntForKey:@"CTGradientBlendingMode"]]; + NSUInteger count = [coder decodeIntForKey:@"CTGradientElementCount"]; + + while (count != 0) { + CTGradientElement newElement; + + [coder decodeValueOfObjCType:@encode(CGFloat) at:&(newElement.red)]; + [coder decodeValueOfObjCType:@encode(CGFloat) at:&(newElement.green)]; + [coder decodeValueOfObjCType:@encode(CGFloat) at:&(newElement.blue)]; + [coder decodeValueOfObjCType:@encode(CGFloat) at:&(newElement.alpha)]; + [coder decodeValueOfObjCType:@encode(CGFloat) at:&(newElement.position)]; + + count--; + [self addElement:&newElement]; } - return self; - } + return self; +} + #pragma mark - #pragma mark Creation -+ (id)gradientWithBeginningColor:(NSColor *)begin endingColor:(NSColor *)end - { - id newInstance = [[[self class] alloc] init]; - - CTGradientElement color1; - CTGradientElement color2; - - [[begin colorUsingColorSpaceName:NSCalibratedRGBColorSpace] getRed:&color1.red - green:&color1.green - blue:&color1.blue - alpha:&color1.alpha]; - - [[end colorUsingColorSpaceName:NSCalibratedRGBColorSpace] getRed:&color2.red - green:&color2.green - blue:&color2.blue - alpha:&color2.alpha]; - color1.position = 0; - color2.position = 1; - - [newInstance addElement:&color1]; - [newInstance addElement:&color2]; - - return [newInstance autorelease]; - } - -+ (id)aquaSelectedGradient - { - id newInstance = [[[self class] alloc] init]; - - CTGradientElement color1; - color1.red = 0.58; - color1.green = 0.86; - color1.blue = 0.98; - color1.alpha = 1.00; - color1.position = 0; - - CTGradientElement color2; - color2.red = 0.42; - color2.green = 0.68; - color2.blue = 0.90; - color2.alpha = 1.00; - color2.position = 11.5/23; - - CTGradientElement color3; - color3.red = 0.64; - color3.green = 0.80; - color3.blue = 0.94; - color3.alpha = 1.00; - color3.position = 11.5/23; - - CTGradientElement color4; - color4.red = 0.56; - color4.green = 0.70; - color4.blue = 0.90; - color4.alpha = 1.00; - color4.position = 1; - - [newInstance addElement:&color1]; - [newInstance addElement:&color2]; - [newInstance addElement:&color3]; - [newInstance addElement:&color4]; - - return [newInstance autorelease]; - } - -+ (id)aquaNormalGradient - { - id newInstance = [[[self class] alloc] init]; - - CTGradientElement color1; - color1.red = color1.green = color1.blue = 0.95; - color1.alpha = 1.00; - color1.position = 0; - - CTGradientElement color2; - color2.red = color2.green = color2.blue = 0.83; - color2.alpha = 1.00; - color2.position = 11.5/23; - - CTGradientElement color3; - color3.red = color3.green = color3.blue = 0.95; - color3.alpha = 1.00; - color3.position = 11.5/23; - - CTGradientElement color4; - color4.red = color4.green = color4.blue = 0.92; - color4.alpha = 1.00; - color4.position = 1; - - [newInstance addElement:&color1]; - [newInstance addElement:&color2]; - [newInstance addElement:&color3]; - [newInstance addElement:&color4]; - - return [newInstance autorelease]; - } - -+ (id)aquaPressedGradient - { - id newInstance = [[[self class] alloc] init]; - - CTGradientElement color1; - color1.red = color1.green = color1.blue = 0.80; - color1.alpha = 1.00; - color1.position = 0; - - CTGradientElement color2; - color2.red = color2.green = color2.blue = 0.64; - color2.alpha = 1.00; - color2.position = 11.5/23; - - CTGradientElement color3; - color3.red = color3.green = color3.blue = 0.80; - color3.alpha = 1.00; - color3.position = 11.5/23; - - CTGradientElement color4; - color4.red = color4.green = color4.blue = 0.77; - color4.alpha = 1.00; - color4.position = 1; - - [newInstance addElement:&color1]; - [newInstance addElement:&color2]; - [newInstance addElement:&color3]; - [newInstance addElement:&color4]; - - return [newInstance autorelease]; - } - -+ (id)unifiedSelectedGradient - { - id newInstance = [[[self class] alloc] init]; - - CTGradientElement color1; - color1.red = color1.green = color1.blue = 0.85; - color1.alpha = 1.00; - color1.position = 0; - - CTGradientElement color2; - color2.red = color2.green = color2.blue = 0.95; - color2.alpha = 1.00; - color2.position = 1; - - [newInstance addElement:&color1]; - [newInstance addElement:&color2]; - - return [newInstance autorelease]; - } - -+ (id)unifiedNormalGradient - { - id newInstance = [[[self class] alloc] init]; - - CTGradientElement color1; - color1.red = color1.green = color1.blue = 0.75; - color1.alpha = 1.00; - color1.position = 0; - - CTGradientElement color2; - color2.red = color2.green = color2.blue = 0.90; - color2.alpha = 1.00; - color2.position = 1; - - [newInstance addElement:&color1]; - [newInstance addElement:&color2]; - - return [newInstance autorelease]; - } - -+ (id)unifiedPressedGradient - { - id newInstance = [[[self class] alloc] init]; - - CTGradientElement color1; - color1.red = color1.green = color1.blue = 0.60; - color1.alpha = 1.00; - color1.position = 0; - - CTGradientElement color2; - color2.red = color2.green = color2.blue = 0.75; - color2.alpha = 1.00; - color2.position = 1; - - [newInstance addElement:&color1]; - [newInstance addElement:&color2]; - - return [newInstance autorelease]; - } - -+ (id)unifiedDarkGradient - { - id newInstance = [[[self class] alloc] init]; - - CTGradientElement color1; - color1.red = color1.green = color1.blue = 0.68; - color1.alpha = 1.00; - color1.position = 0; - - CTGradientElement color2; - color2.red = color2.green = color2.blue = 0.83; - color2.alpha = 1.00; - color2.position = 1; - - [newInstance addElement:&color1]; - [newInstance addElement:&color2]; - - return [newInstance autorelease]; - } - -+ (id)sourceListSelectedGradient - { - id newInstance = [[[self class] alloc] init]; - - CTGradientElement color1; - color1.red = 0.06; - color1.green = 0.37; - color1.blue = 0.85; - color1.alpha = 1.00; - color1.position = 0; - - CTGradientElement color2; - color2.red = 0.30; - color2.green = 0.60; - color2.blue = 0.92; - color2.alpha = 1.00; - color2.position = 1; - - [newInstance addElement:&color1]; - [newInstance addElement:&color2]; - - return [newInstance autorelease]; - } - -+ (id)sourceListUnselectedGradient - { - id newInstance = [[[self class] alloc] init]; - - CTGradientElement color1; - color1.red = 0.43; - color1.green = 0.43; - color1.blue = 0.43; - color1.alpha = 1.00; - color1.position = 0; - - CTGradientElement color2; - color2.red = 0.60; - color2.green = 0.60; - color2.blue = 0.60; - color2.alpha = 1.00; - color2.position = 1; - - [newInstance addElement:&color1]; - [newInstance addElement:&color2]; - - return [newInstance autorelease]; - } - -+ (id)rainbowGradient - { - id newInstance = [[[self class] alloc] init]; - - CTGradientElement color1; - color1.red = 1.00; - color1.green = 0.00; - color1.blue = 0.00; - color1.alpha = 1.00; - color1.position = 0.0; - - CTGradientElement color2; - color2.red = 0.54; - color2.green = 0.00; - color2.blue = 1.00; - color2.alpha = 1.00; - color2.position = 1.0; - - [newInstance addElement:&color1]; - [newInstance addElement:&color2]; - - [newInstance setBlendingMode:CTChromaticBlendingMode]; - - return [newInstance autorelease]; - } - -+ (id)hydrogenSpectrumGradient - { - id newInstance = [[[self class] alloc] init]; - - struct {float hue; float position; float width;} colorBands[4]; - - colorBands[0].hue = 22; - colorBands[0].position = .145; - colorBands[0].width = .01; - - colorBands[1].hue = 200; - colorBands[1].position = .71; - colorBands[1].width = .008; - - colorBands[2].hue = 253; - colorBands[2].position = .885; - colorBands[2].width = .005; - - colorBands[3].hue = 275; - colorBands[3].position = .965; - colorBands[3].width = .003; - - int i; - ///////////////////////////// - for(i = 0; i < 4; i++) - { - float color[4]; - color[0] = colorBands[i].hue - 180*colorBands[i].width; - color[1] = 1; - color[2] = 0.001; - color[3] = 1; - transformHSV_RGB(color); - CTGradientElement fadeIn; - fadeIn.red = color[0]; - fadeIn.green = color[1]; - fadeIn.blue = color[2]; - fadeIn.alpha = color[3]; - fadeIn.position = colorBands[i].position - colorBands[i].width; - - - color[0] = colorBands[i].hue; - color[1] = 1; - color[2] = 1; - color[3] = 1; - transformHSV_RGB(color); - CTGradientElement band; - band.red = color[0]; - band.green = color[1]; - band.blue = color[2]; - band.alpha = color[3]; - band.position = colorBands[i].position; - - color[0] = colorBands[i].hue + 180*colorBands[i].width; - color[1] = 1; - color[2] = 0.001; - color[3] = 1; - transformHSV_RGB(color); - CTGradientElement fadeOut; - fadeOut.red = color[0]; - fadeOut.green = color[1]; - fadeOut.blue = color[2]; - fadeOut.alpha = color[3]; - fadeOut.position = colorBands[i].position + colorBands[i].width; - - - [newInstance addElement:&fadeIn]; - [newInstance addElement:&band]; - [newInstance addElement:&fadeOut]; ++ (id)gradientWithBeginningColor:(Color *)begin endingColor:(Color *)end { + id newInstance = [[[self class] alloc] init]; + + CTGradientElement color1; + CTGradientElement color2; + +#if TARGET_OS_IPHONE + //if it isnt RGB we are screwed +#else + begin = [begin colorUsingColorSpaceName:NSCalibratedRGBColorSpace]; + end = [end colorUsingColorSpaceName:NSCalibratedRGBColorSpace]; +#endif + + [begin getRed:&color1.red + green:&color1.green + blue:&color1.blue + alpha:&color1.alpha]; + + [end getRed:&color2.red + green:&color2.green + blue:&color2.blue + alpha:&color2.alpha]; + color1.position = 0; + color2.position = 1; + + [newInstance addElement:&color1]; + [newInstance addElement:&color2]; + + return newInstance; +} + ++ (id)aquaSelectedGradient { + id newInstance = [[[self class] alloc] init]; + + CTGradientElement color1; + color1.red = 0.58; + color1.green = 0.86; + color1.blue = 0.98; + color1.alpha = 1.00; + color1.position = 0; + + CTGradientElement color2; + color2.red = 0.42; + color2.green = 0.68; + color2.blue = 0.90; + color2.alpha = 1.00; + color2.position = 11.5 / 23; + + CTGradientElement color3; + color3.red = 0.64; + color3.green = 0.80; + color3.blue = 0.94; + color3.alpha = 1.00; + color3.position = 11.5 / 23; + + CTGradientElement color4; + color4.red = 0.56; + color4.green = 0.70; + color4.blue = 0.90; + color4.alpha = 1.00; + color4.position = 1; + + [newInstance addElement:&color1]; + [newInstance addElement:&color2]; + [newInstance addElement:&color3]; + [newInstance addElement:&color4]; + + return newInstance; +} + ++ (id)aquaNormalGradient { + id newInstance = [[[self class] alloc] init]; + + CTGradientElement color1; + color1.red = color1.green = color1.blue = 0.95; + color1.alpha = 1.00; + color1.position = 0; + + CTGradientElement color2; + color2.red = color2.green = color2.blue = 0.83; + color2.alpha = 1.00; + color2.position = 11.5 / 23; + + CTGradientElement color3; + color3.red = color3.green = color3.blue = 0.95; + color3.alpha = 1.00; + color3.position = 11.5 / 23; + + CTGradientElement color4; + color4.red = color4.green = color4.blue = 0.92; + color4.alpha = 1.00; + color4.position = 1; + + [newInstance addElement:&color1]; + [newInstance addElement:&color2]; + [newInstance addElement:&color3]; + [newInstance addElement:&color4]; + + return newInstance; +} + ++ (id)aquaPressedGradient { + id newInstance = [[[self class] alloc] init]; + + CTGradientElement color1; + color1.red = color1.green = color1.blue = 0.80; + color1.alpha = 1.00; + color1.position = 0; + + CTGradientElement color2; + color2.red = color2.green = color2.blue = 0.64; + color2.alpha = 1.00; + color2.position = 11.5 / 23; + + CTGradientElement color3; + color3.red = color3.green = color3.blue = 0.80; + color3.alpha = 1.00; + color3.position = 11.5 / 23; + + CTGradientElement color4; + color4.red = color4.green = color4.blue = 0.77; + color4.alpha = 1.00; + color4.position = 1; + + [newInstance addElement:&color1]; + [newInstance addElement:&color2]; + [newInstance addElement:&color3]; + [newInstance addElement:&color4]; + + return newInstance; +} + ++ (id)unifiedSelectedGradient { + id newInstance = [[[self class] alloc] init]; + + CTGradientElement color1; + color1.red = color1.green = color1.blue = 0.85; + color1.alpha = 1.00; + color1.position = 0; + + CTGradientElement color2; + color2.red = color2.green = color2.blue = 0.95; + color2.alpha = 1.00; + color2.position = 1; + + [newInstance addElement:&color1]; + [newInstance addElement:&color2]; + + return newInstance; +} + ++ (id)unifiedNormalGradient { + id newInstance = [[[self class] alloc] init]; + + CTGradientElement color1; + color1.red = color1.green = color1.blue = 0.75; + color1.alpha = 1.00; + color1.position = 0; + + CTGradientElement color2; + color2.red = color2.green = color2.blue = 0.90; + color2.alpha = 1.00; + color2.position = 1; + + [newInstance addElement:&color1]; + [newInstance addElement:&color2]; + + return newInstance; +} + ++ (id)unifiedPressedGradient { + id newInstance = [[[self class] alloc] init]; + + CTGradientElement color1; + color1.red = color1.green = color1.blue = 0.60; + color1.alpha = 1.00; + color1.position = 0; + + CTGradientElement color2; + color2.red = color2.green = color2.blue = 0.75; + color2.alpha = 1.00; + color2.position = 1; + + [newInstance addElement:&color1]; + [newInstance addElement:&color2]; + + return newInstance; +} + ++ (id)unifiedDarkGradient { + id newInstance = [[[self class] alloc] init]; + + CTGradientElement color1; + color1.red = color1.green = color1.blue = 0.68; + color1.alpha = 1.00; + color1.position = 0; + + CTGradientElement color2; + color2.red = color2.green = color2.blue = 0.83; + color2.alpha = 1.00; + color2.position = 1; + + [newInstance addElement:&color1]; + [newInstance addElement:&color2]; + + return newInstance; +} + ++ (id)sourceListSelectedGradient { + id newInstance = [[[self class] alloc] init]; + + CTGradientElement color1; + color1.red = 0.06; + color1.green = 0.37; + color1.blue = 0.85; + color1.alpha = 1.00; + color1.position = 0; + + CTGradientElement color2; + color2.red = 0.30; + color2.green = 0.60; + color2.blue = 0.92; + color2.alpha = 1.00; + color2.position = 1; + + [newInstance addElement:&color1]; + [newInstance addElement:&color2]; + + return newInstance; +} + ++ (id)sourceListUnselectedGradient { + id newInstance = [[[self class] alloc] init]; + + CTGradientElement color1; + color1.red = 0.43; + color1.green = 0.43; + color1.blue = 0.43; + color1.alpha = 1.00; + color1.position = 0; + + CTGradientElement color2; + color2.red = 0.60; + color2.green = 0.60; + color2.blue = 0.60; + color2.alpha = 1.00; + color2.position = 1; + + [newInstance addElement:&color1]; + [newInstance addElement:&color2]; + + return newInstance; +} + ++ (id)rainbowGradient { + id newInstance = [[[self class] alloc] init]; + + CTGradientElement color1; + color1.red = 1.00; + color1.green = 0.00; + color1.blue = 0.00; + color1.alpha = 1.00; + color1.position = 0.0; + + CTGradientElement color2; + color2.red = 0.54; + color2.green = 0.00; + color2.blue = 1.00; + color2.alpha = 1.00; + color2.position = 1.0; + + [newInstance addElement:&color1]; + [newInstance addElement:&color2]; + + [newInstance setBlendingMode:CTChromaticBlendingMode]; + + return newInstance; +} + ++ (id)hydrogenSpectrumGradient { + id newInstance = [[[self class] alloc] init]; + + struct { CGFloat hue; CGFloat position; CGFloat width; } colorBands[4]; + + colorBands[0].hue = 22; + colorBands[0].position = .145; + colorBands[0].width = .01; + + colorBands[1].hue = 200; + colorBands[1].position = .71; + colorBands[1].width = .008; + + colorBands[2].hue = 253; + colorBands[2].position = .885; + colorBands[2].width = .005; + + colorBands[3].hue = 275; + colorBands[3].position = .965; + colorBands[3].width = .003; + + int i; + ///////////////////////////// + for (i = 0; i < 4; i++) { + CGFloat color[4]; + color[0] = colorBands[i].hue - 180 * colorBands[i].width; + color[1] = 1; + color[2] = 0.001; + color[3] = 1; + transformHSV_RGB(color); + CTGradientElement fadeIn; + fadeIn.red = color[0]; + fadeIn.green = color[1]; + fadeIn.blue = color[2]; + fadeIn.alpha = color[3]; + fadeIn.position = colorBands[i].position - colorBands[i].width; + + + color[0] = colorBands[i].hue; + color[1] = 1; + color[2] = 1; + color[3] = 1; + transformHSV_RGB(color); + CTGradientElement band; + band.red = color[0]; + band.green = color[1]; + band.blue = color[2]; + band.alpha = color[3]; + band.position = colorBands[i].position; + + color[0] = colorBands[i].hue + 180 * colorBands[i].width; + color[1] = 1; + color[2] = 0.001; + color[3] = 1; + transformHSV_RGB(color); + CTGradientElement fadeOut; + fadeOut.red = color[0]; + fadeOut.green = color[1]; + fadeOut.blue = color[2]; + fadeOut.alpha = color[3]; + fadeOut.position = colorBands[i].position + colorBands[i].width; + + + [newInstance addElement:&fadeIn]; + [newInstance addElement:&band]; + [newInstance addElement:&fadeOut]; } - - [newInstance setBlendingMode:CTChromaticBlendingMode]; - - return [newInstance autorelease]; - } + + [newInstance setBlendingMode:CTChromaticBlendingMode]; + + return newInstance; +} #pragma mark - #pragma mark Modification -- (CTGradient *)gradientWithAlphaComponent:(float)alpha - { - id newInstance = [[[self class] alloc] init]; - - CTGradientElement *curElement = elementList; - CTGradientElement tempElement; - - while(curElement != nil) - { - tempElement = *curElement; - tempElement.alpha = alpha; - [newInstance addElement:&tempElement]; - - curElement = curElement->nextElement; +- (CTGradient *)gradientWithAlphaComponent:(CGFloat)alpha { + id newInstance = [[[self class] alloc] init]; + + CTGradientElement *curElement = elementList; + CTGradientElement tempElement; + + while (curElement != nil) { + tempElement = *curElement; + tempElement.alpha = alpha; + [newInstance addElement:&tempElement]; + + curElement = curElement->nextElement; } - - return [newInstance autorelease]; - } - -- (CTGradient *)gradientWithBlendingMode:(CTGradientBlendingMode)mode - { - CTGradient *newGradient = [self copy]; - - [newGradient setBlendingMode:mode]; - - return [newGradient autorelease]; - } + + return newInstance; +} +- (CTGradient *)gradientWithBlendingMode:(CTGradientBlendingMode)mode { + CTGradient *newGradient = [self copy]; + + [newGradient setBlendingMode:mode]; + + return newGradient; +} //Adds a color stop with at in elementList //(if two elements are at the same position then added imediatly after the one that was there already) -- (CTGradient *)addColorStop:(NSColor *)color atPosition:(float)position - { - CTGradient *newGradient = [self copy]; - CTGradientElement newGradientElement; - - //put the components of color into the newGradientElement - must make sure it is a RGB color (not Gray or CMYK) - [[color colorUsingColorSpaceName:NSCalibratedRGBColorSpace] getRed:&newGradientElement.red - green:&newGradientElement.green - blue:&newGradientElement.blue - alpha:&newGradientElement.alpha]; - newGradientElement.position = position; - - //Pass it off to addElement to take care of adding it to the elementList - [newGradient addElement:&newGradientElement]; - - return [newGradient autorelease]; - } - +- (CTGradient *)addColorStop:(Color *)color atPosition:(CGFloat)position { + CTGradient *newGradient = [self copy]; + CTGradientElement newGradientElement; + + //put the components of color into the newGradientElement - must make sure it is a RGB color (not Gray or CMYK) +#if TARGET_OS_IPHONE + //if it isnt RGB we are screwed +#else + color = [color colorUsingColorSpaceName:NSCalibratedRGBColorSpace]; +#endif + + [color getRed:&newGradientElement.red + green:&newGradientElement.green + blue:&newGradientElement.blue + alpha:&newGradientElement.alpha]; + newGradientElement.position = position; + + //Pass it off to addElement to take care of adding it to the elementList + [newGradient addElement:&newGradientElement]; + + return newGradient; +} //Removes the color stop at from elementList -- (CTGradient *)removeColorStopAtPosition:(float)position - { - CTGradient *newGradient = [self copy]; - CTGradientElement removedElement = [newGradient removeElementAtPosition:position]; - - if(isnan(removedElement.position)) - [NSException raise:NSRangeException format:@"-[%@ removeColorStopAtPosition:]: no such colorStop at position (%f)", [self class], position]; - - return [newGradient autorelease]; - } - -- (CTGradient *)removeColorStopAtIndex:(unsigned)index - { - CTGradient *newGradient = [self copy]; - CTGradientElement removedElement = [newGradient removeElementAtIndex:index]; - - if(isnan(removedElement.position)) - [NSException raise:NSRangeException format:@"-[%@ removeColorStopAtIndex:]: index (%i) beyond bounds", [self class], index]; - - return [newGradient autorelease]; - } +- (CTGradient *)removeColorStopAtPosition:(CGFloat)position { + CTGradient *newGradient = [self copy]; + CTGradientElement removedElement = [newGradient removeElementAtPosition:position]; + + if (isnan(removedElement.position)) + [NSException raise:NSRangeException format:@"-[%@ removeColorStopAtPosition:]: no such colorStop at position (%f)", [self class], position]; + + return newGradient; +} + +- (CTGradient *)removeColorStopAtIndex:(NSUInteger)index { + CTGradient *newGradient = [self copy]; + CTGradientElement removedElement = [newGradient removeElementAtIndex:index]; + + if (isnan(removedElement.position)) + [NSException raise:NSRangeException format:@"-[%@ removeColorStopAtIndex:]: index (%lu) beyond bounds", [self class], (unsigned long)index]; + + return newGradient; +} + #pragma mark - #pragma mark Information -- (CTGradientBlendingMode)blendingMode - { - return blendingMode; - } +- (CTGradientBlendingMode)blendingMode { + return blendingMode; +} //Returns color at in gradient -- (NSColor *)colorStopAtIndex:(unsigned)index - { - CTGradientElement *element = [self elementAtIndex:index]; - - if(element != nil) - return [NSColor colorWithCalibratedRed:element->red - green:element->green - blue:element->blue - alpha:element->alpha]; - - [NSException raise:NSRangeException format:@"-[%@ removeColorStopAtIndex:]: index (%i) beyond bounds", [self class], index]; - - return nil; - } - -- (NSColor *)colorAtPosition:(float)position - { - float components[4]; - - switch(blendingMode) - { - case CTLinearBlendingMode: - linearEvaluation(&elementList, &position, components); break; - case CTChromaticBlendingMode: - chromaticEvaluation(&elementList, &position, components); break; - case CTInverseChromaticBlendingMode: - inverseChromaticEvaluation(&elementList, &position, components); break; +- (Color *)colorStopAtIndex:(NSUInteger)index { + CTGradientElement *element = [self elementAtIndex:index]; + + if (element != nil) +#if TARGET_OS_IPHONE + return [Color colorWithRed:element->red + green:element->green + blue:element->blue + alpha:element->alpha]; +#else + return [Color colorWithCalibratedRed:element->red + green:element->green + blue:element->blue + alpha:element->alpha]; +#endif + + [NSException raise:NSRangeException format:@"-[%@ removeColorStopAtIndex:]: index (%lu) beyond bounds", [self class], (unsigned long)index]; + + return nil; +} + +- (Color *)colorAtPosition:(CGFloat)position { + CGFloat components[4]; + + switch (blendingMode) { + case CTLinearBlendingMode: + linearEvaluation(&elementList, &position, components); + break; + + case CTChromaticBlendingMode: + chromaticEvaluation(&elementList, &position, components); + break; + + case CTInverseChromaticBlendingMode: + inverseChromaticEvaluation(&elementList, &position, components); + break; } - - - return [NSColor colorWithCalibratedRed:components[0]/components[3] //undo premultiplication that CG requires - green:components[1]/components[3] - blue:components[2]/components[3] - alpha:components[3]]; - } + + +#if TARGET_OS_IPHONE + return [Color colorWithRed:components[0] / components[3] //undo premultiplication that CG requires + green:components[1] / components[3] + blue:components[2] / components[3] + alpha:components[3]]; +#else + return [Color colorWithCalibratedRed:components[0] / components[3] //undo premultiplication that CG requires + green:components[1] / components[3] + blue:components[2] / components[3] + alpha:components[3]]; +#endif +} + #pragma mark - #pragma mark Drawing -- (void)drawSwatchInRect:(NSRect)rect - { - [self fillRect:rect angle:45]; - } - -- (void)fillRect:(NSRect)rect angle:(float)angle - { - //First Calculate where the beginning and ending points should be - CGPoint startPoint; - CGPoint endPoint; - - if(angle == 0) //screw the calculations - we know the answer - { - startPoint = CGPointMake(NSMinX(rect), NSMinY(rect)); //right of rect - endPoint = CGPointMake(NSMaxX(rect), NSMinY(rect)); //left of rect - } - else if(angle == 90) //same as above - { - startPoint = CGPointMake(NSMinX(rect), NSMinY(rect)); //bottom of rect - endPoint = CGPointMake(NSMinX(rect), NSMaxY(rect)); //top of rect - } - else //ok, we'll do the calculations now - { - float x,y; - float sina, cosa, tana; - - float length; - float deltax, - deltay; - - float rangle = angle * pi/180; //convert the angle to radians - - if(fabsf(tan(rangle))<=1) //for range [-45,45], [135,225] - { - x = NSWidth(rect); - y = NSHeight(rect); - - sina = sin(rangle); - cosa = cos(rangle); - tana = tan(rangle); - - length = x/fabsf(cosa)+(y-x*fabsf(tana))*fabsf(sina); - - deltax = length*cosa/2; - deltay = length*sina/2; +- (void)drawSwatchInRect:(Rect)rect { + [self fillRect:rect angle:45]; +} + +- (void)fillRect:(Rect)rect angle:(CGFloat)angle { + //First Calculate where the beginning and ending points should be + CGPoint startPoint; + CGPoint endPoint; + + if (angle == 0) { //screw the calculations - we know the answer + startPoint = CGPointMake(MinX(rect), MinY(rect)); //right of rect + endPoint = CGPointMake(MaxX(rect), MinY(rect)); //left of rect + } + else if (angle == 90) { //same as above + startPoint = CGPointMake(MinX(rect), MinY(rect)); //bottom of rect + endPoint = CGPointMake(MinX(rect), MaxY(rect)); //top of rect + } + else { //ok, we'll do the calculations now + CGFloat x, y; + CGFloat sina, cosa, tana; + + CGFloat length; + CGFloat deltax, + deltay; + + CGFloat rangle = angle * M_PI / 180; //convert the angle to radians + + if (fabsf(tan(rangle)) <= 1) { //for range [-45,45], [135,225] + x = Width(rect); + y = Height(rect); + + sina = sin(rangle); + cosa = cos(rangle); + tana = tan(rangle); + + length = x / fabsf(cosa) + (y - x * fabsf(tana)) * fabsf(sina); + + deltax = length * cosa / 2; + deltay = length * sina / 2; } - else //for range [45,135], [225,315] - { - x = NSHeight(rect); - y = NSWidth(rect); - - sina = sin(rangle - 90*pi/180); - cosa = cos(rangle - 90*pi/180); - tana = tan(rangle - 90*pi/180); - - length = x/fabsf(cosa)+(y-x*fabsf(tana))*fabsf(sina); - - deltax =-length*sina/2; - deltay = length*cosa/2; + else { //for range [45,135], [225,315] + x = Height(rect); + y = Width(rect); + + sina = sin(rangle - 90 * M_PI / 180); + cosa = cos(rangle - 90 * M_PI / 180); + tana = tan(rangle - 90 * M_PI / 180); + + length = x / fabsf(cosa) + (y - x * fabsf(tana)) * fabsf(sina); + + deltax = -length * sina / 2; + deltay = length * cosa / 2; } - - startPoint = CGPointMake(NSMidX(rect)-deltax, NSMidY(rect)-deltay); - endPoint = CGPointMake(NSMidX(rect)+deltax, NSMidY(rect)+deltay); + + startPoint = CGPointMake(MidX(rect) - deltax, MidY(rect) - deltay); + endPoint = CGPointMake(MidX(rect) + deltax, MidY(rect) + deltay); } - - //Calls to CoreGraphics - CGContextRef currentContext = (CGContextRef)[[NSGraphicsContext currentContext] graphicsPort]; - CGContextSaveGState(currentContext); - #if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_4 - CGColorSpaceRef colorspace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB); - #else - CGColorSpaceRef colorspace = CGColorSpaceCreateDeviceRGB(); - #endif - CGShadingRef myCGShading = CGShadingCreateAxial(colorspace, startPoint, endPoint, gradientFunction, false, false); - - CGContextClipToRect (currentContext, *(CGRect *)&rect); //This is where the action happens - CGContextDrawShading(currentContext, myCGShading); - - CGShadingRelease(myCGShading); - CGColorSpaceRelease(colorspace ); - CGContextRestoreGState(currentContext); - } - -- (void)radialFillRect:(NSRect)rect - { - CGPoint startPoint, endPoint; - float startRadius, endRadius; - float scalex, scaley, transx, transy; - - startPoint = endPoint = CGPointMake(NSMidX(rect), NSMidY(rect)); - - startRadius = -1; - if(NSHeight(rect)>NSWidth(rect)) - { - scalex = NSWidth(rect)/NSHeight(rect); - transx = (NSHeight(rect)-NSWidth(rect))/2; - scaley = 1; - transy = 1; - endRadius = NSHeight(rect)/2; + +#if TARGET_OS_IPHONE + //Calls to CoreGraphics + CGContextRef currentContext = UIGraphicsGetCurrentContext(); + CGColorSpaceRef colorspace = CGColorSpaceCreateDeviceRGB(); +#else + //Calls to CoreGraphics + CGContextRef currentContext = (CGContextRef)[[NSGraphicsContext currentContext] graphicsPort]; +#if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_4 + CGColorSpaceRef colorspace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB); +#else + CGColorSpaceRef colorspace = CGColorSpaceCreateDeviceRGB(); +#endif +#endif + CGShadingRef myCGShading = CGShadingCreateAxial(colorspace, startPoint, endPoint, gradientFunction, false, false); + CGContextSaveGState(currentContext); + + CGContextClipToRect(currentContext, *(CGRect *)&rect); //This is where the action happens + CGContextDrawShading(currentContext, myCGShading); + + CGContextRestoreGState(currentContext); + CGShadingRelease(myCGShading); + CGColorSpaceRelease(colorspace); +} + +- (void)radialFillRect:(Rect)rect { + CGPoint startPoint, endPoint; + CGFloat startRadius, endRadius; + CGFloat scalex, scaley, transx, transy; + + startPoint = endPoint = CGPointMake(MidX(rect), MidY(rect)); + + startRadius = -1; + if (Height(rect) > Width(rect)) { + scalex = Width(rect) / Height(rect); + transx = (Height(rect) - Width(rect)) / 2; + scaley = 1; + transy = 1; + endRadius = Height(rect) / 2; } - else - { - scalex = 1; - transx = 1; - scaley = NSHeight(rect)/NSWidth(rect); - transy = (NSWidth(rect)-NSHeight(rect))/2; - endRadius = NSWidth(rect)/2; + else { + scalex = 1; + transx = 1; + scaley = Height(rect) / Width(rect); + transy = (Width(rect) - Height(rect)) / 2; + endRadius = Width(rect) / 2; } - - //Calls to CoreGraphics - CGContextRef currentContext = (CGContextRef)[[NSGraphicsContext currentContext] graphicsPort]; - CGContextSaveGState(currentContext); - #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4 - CGColorSpaceRef colorspace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB); - #else - CGColorSpaceRef colorspace = CGColorSpaceCreateDeviceRGB(); - #endif - CGShadingRef myCGShading = CGShadingCreateRadial(colorspace, startPoint, startRadius, endPoint, endRadius, gradientFunction, true, true); - - CGContextClipToRect (currentContext, *(CGRect *)&rect); - CGContextScaleCTM (currentContext, scalex, scaley); - CGContextTranslateCTM(currentContext, transx, transy); - CGContextDrawShading (currentContext, myCGShading); //This is where the action happens - - CGShadingRelease(myCGShading); - CGColorSpaceRelease(colorspace); - CGContextRestoreGState(currentContext); - } - -- (void)fillBezierPath:(NSBezierPath *)path angle:(float)angle - { - NSGraphicsContext *currentContext = [NSGraphicsContext currentContext]; - [currentContext saveGraphicsState]; - NSAffineTransform *transform = [[NSAffineTransform alloc] init]; - - [transform rotateByDegrees:-angle]; - [path transformUsingAffineTransform:transform]; - [transform invert]; - [transform concat]; - + +#if TARGET_OS_IPHONE + CGContextRef currentContext = UIGraphicsGetCurrentContext(); + CGColorSpaceRef colorspace = CGColorSpaceCreateDeviceRGB(); +#else + CGContextRef currentContext = (CGContextRef)[[NSGraphicsContext currentContext] graphicsPort]; +#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4 + CGColorSpaceRef colorspace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB); +#else + CGColorSpaceRef colorspace = CGColorSpaceCreateDeviceRGB(); +#endif +#endif + CGShadingRef myCGShading = CGShadingCreateRadial(colorspace, startPoint, startRadius, endPoint, endRadius, gradientFunction, true, true); + CGContextSaveGState(currentContext); + + CGContextClipToRect(currentContext, *(CGRect *)&rect); + CGContextScaleCTM(currentContext, scalex, scaley); + CGContextTranslateCTM(currentContext, transx, transy); + CGContextDrawShading(currentContext, myCGShading); //This is where the action happens + + CGShadingRelease(myCGShading); + CGColorSpaceRelease(colorspace); + CGContextRestoreGState(currentContext); +} + +- (void)fillBezierPath:(BezierPath *)path angle:(CGFloat)angle { +#if TARGET_OS_IPHONE + CGContextRef currentContext = UIGraphicsGetCurrentContext(); +#else + CGContextRef currentContext = [[NSGraphicsContext currentContext] graphicsPort]; +#endif + CGContextSaveGState(currentContext); + [path addClip]; - [self fillRect:[path bounds] angle:0]; - [path transformUsingAffineTransform:transform]; - [transform release]; - [currentContext restoreGraphicsState]; - } -- (void)radialFillBezierPath:(NSBezierPath *)path - { - NSGraphicsContext *currentContext = [NSGraphicsContext currentContext]; - [currentContext saveGraphicsState]; + [self fillRect:path.bounds angle:angle]; + + CGContextRestoreGState(currentContext); +} + +- (void)radialFillBezierPath:(BezierPath *)path { +#if TARGET_OS_IPHONE + CGContextRef currentContext = UIGraphicsGetCurrentContext(); +#else + CGContextRef currentContext = [[NSGraphicsContext currentContext] graphicsPort]; +#endif + CGContextSaveGState(currentContext); + [path addClip]; [self radialFillRect:[path bounds]]; - [currentContext restoreGraphicsState]; - } + + CGContextRestoreGState(currentContext); +} + #pragma mark - #pragma mark Private Methods - (void)setBlendingMode:(CTGradientBlendingMode)mode; - { - blendingMode = mode; - - //Choose what blending function to use - void *evaluationFunction; - switch(blendingMode) - { - case CTLinearBlendingMode: - evaluationFunction = &linearEvaluation; break; - case CTChromaticBlendingMode: - evaluationFunction = &chromaticEvaluation; break; - case CTInverseChromaticBlendingMode: - evaluationFunction = &inverseChromaticEvaluation; break; +{ + blendingMode = mode; + + //Choose what blending function to use + void *evaluationFunction; + switch (blendingMode) { + case CTLinearBlendingMode: + evaluationFunction = &linearEvaluation; + break; + + case CTChromaticBlendingMode: + evaluationFunction = &chromaticEvaluation; + break; + + case CTInverseChromaticBlendingMode: + evaluationFunction = &inverseChromaticEvaluation; + break; } - - //replace the current CoreGraphics Function with new one - if(gradientFunction != NULL) - CGFunctionRelease(gradientFunction); - - CGFunctionCallbacks evaluationCallbackInfo = {0 , evaluationFunction, NULL}; //Version, evaluator function, cleanup function - - static const CGFloat input_value_range [2] = { 0, 1 }; //range for the evaluator input - static const CGFloat output_value_ranges [8] = { 0, 1, 0, 1, 0, 1, 0, 1 }; //ranges for the evaluator output (4 returned values) - - gradientFunction = CGFunctionCreate(&elementList, //the two transition colors - 1, input_value_range , //number of inputs (just fraction of progression) - 4, output_value_ranges, //number of outputs (4 - RGBa) - &evaluationCallbackInfo); //info for using the evaluator function - } - -- (void)addElement:(CTGradientElement *)newElement - { - if(elementList == nil || newElement->position < elementList->position) //inserting at beginning of list - { - CTGradientElement *tmpNext = elementList; - elementList = malloc(sizeof(CTGradientElement)); - *elementList = *newElement; - elementList->nextElement = tmpNext; + + //replace the current CoreGraphics Function with new one + if (gradientFunction != NULL) + CGFunctionRelease(gradientFunction); + + CGFunctionCallbacks evaluationCallbackInfo = { 0, evaluationFunction, NULL }; //Version, evaluator function, cleanup function + + static const CGFloat input_value_range[2] = { 0, 1 }; //range for the evaluator input + static const CGFloat output_value_ranges[8] = { 0, 1, 0, 1, 0, 1, 0, 1 }; //ranges for the evaluator output (4 returned values) + + gradientFunction = CGFunctionCreate(&elementList, //the two transition colors + 1, input_value_range, //number of inputs (just fraction of progression) + 4, output_value_ranges, //number of outputs (4 - RGBa) + &evaluationCallbackInfo); //info for using the evaluator function +} + +- (void)addElement:(CTGradientElement *)newElement { + if (elementList == nil || newElement->position < elementList->position) { //inserting at beginning of list + CTGradientElement *tmpNext = elementList; + elementList = malloc(sizeof(CTGradientElement)); + *elementList = *newElement; + elementList->nextElement = tmpNext; } - else //inserting somewhere inside list - { - CTGradientElement *curElement = elementList; - - while(curElement->nextElement != nil && !((curElement->position <= newElement->position) && (newElement->position < curElement->nextElement->position))) - { - curElement = curElement->nextElement; + else { //inserting somewhere inside list + CTGradientElement *curElement = elementList; + + while (curElement->nextElement != nil && !((curElement->position <= newElement->position) && (newElement->position < curElement->nextElement->position))) { + curElement = curElement->nextElement; } - - CTGradientElement *tmpNext = curElement->nextElement; - curElement->nextElement = malloc(sizeof(CTGradientElement)); - *(curElement->nextElement) = *newElement; - curElement->nextElement->nextElement = tmpNext; + + CTGradientElement *tmpNext = curElement->nextElement; + curElement->nextElement = malloc(sizeof(CTGradientElement)); + *(curElement->nextElement) = *newElement; + curElement->nextElement->nextElement = tmpNext; } - } - -- (CTGradientElement)removeElementAtIndex:(unsigned)index - { - CTGradientElement removedElement; - - if(elementList != nil) - { - if(index == 0) - { - CTGradientElement *tmpNext = elementList; - elementList = elementList->nextElement; - - removedElement = *tmpNext; - free(tmpNext); - - return removedElement; - } - - unsigned count = 1; //we want to start one ahead - CTGradientElement *currentElement = elementList; - while(currentElement->nextElement != nil) - { - if(count == index) - { - CTGradientElement *tmpNext = currentElement->nextElement; - currentElement->nextElement = currentElement->nextElement->nextElement; - +} + +- (CTGradientElement)removeElementAtIndex:(NSUInteger)index { + CTGradientElement removedElement; + + if (elementList != nil) { + if (index == 0) { + CTGradientElement *tmpNext = elementList; + elementList = elementList->nextElement; + removedElement = *tmpNext; free(tmpNext); - + return removedElement; - } - - count++; - currentElement = currentElement->nextElement; - } - } - - //element is not found, return empty element - removedElement.red = 0.0; - removedElement.green = 0.0; - removedElement.blue = 0.0; - removedElement.alpha = 0.0; - removedElement.position = NAN; - removedElement.nextElement = nil; - - return removedElement; - } - -- (CTGradientElement)removeElementAtPosition:(float)position - { - CTGradientElement removedElement; - - if(elementList != nil) - { - if(elementList->position == position) - { - CTGradientElement *tmpNext = elementList; - elementList = elementList->nextElement; - - removedElement = *tmpNext; - free(tmpNext); - - return removedElement; } - else - { - CTGradientElement *curElement = elementList; - while(curElement->nextElement != nil) - { - if(curElement->nextElement->position == position) - { - CTGradientElement *tmpNext = curElement->nextElement; - curElement->nextElement = curElement->nextElement->nextElement; - + + NSUInteger count = 1; //we want to start one ahead + CTGradientElement *currentElement = elementList; + while (currentElement->nextElement != nil) { + if (count == index) { + CTGradientElement *tmpNext = currentElement->nextElement; + currentElement->nextElement = currentElement->nextElement->nextElement; + removedElement = *tmpNext; free(tmpNext); - + return removedElement; + } + + count++; + currentElement = currentElement->nextElement; + } + } + + //element is not found, return empty element + removedElement.red = 0.0; + removedElement.green = 0.0; + removedElement.blue = 0.0; + removedElement.alpha = 0.0; + removedElement.position = NAN; + removedElement.nextElement = nil; + + return removedElement; +} + +- (CTGradientElement)removeElementAtPosition:(CGFloat)position { + CTGradientElement removedElement; + + if (elementList != nil) { + if (elementList->position == position) { + CTGradientElement *tmpNext = elementList; + elementList = elementList->nextElement; + + removedElement = *tmpNext; + free(tmpNext); + + return removedElement; + } + else { + CTGradientElement *curElement = elementList; + while (curElement->nextElement != nil) { + if (curElement->nextElement->position == position) { + CTGradientElement *tmpNext = curElement->nextElement; + curElement->nextElement = curElement->nextElement->nextElement; + + removedElement = *tmpNext; + free(tmpNext); + + return removedElement; } } } } - - //element is not found, return empty element - removedElement.red = 0.0; - removedElement.green = 0.0; - removedElement.blue = 0.0; - removedElement.alpha = 0.0; - removedElement.position = NAN; - removedElement.nextElement = nil; - - return removedElement; - } - - -- (CTGradientElement *)elementAtIndex:(unsigned)index; - { - unsigned count = 0; - CTGradientElement *currentElement = elementList; - - while(currentElement != nil) - { - if(count == index) - return currentElement; - - count++; - currentElement = currentElement->nextElement; + + //element is not found, return empty element + removedElement.red = 0.0; + removedElement.green = 0.0; + removedElement.blue = 0.0; + removedElement.alpha = 0.0; + removedElement.position = NAN; + removedElement.nextElement = nil; + + return removedElement; +} + +- (CTGradientElement *)elementAtIndex:(NSUInteger)index; +{ + NSUInteger count = 0; + CTGradientElement *currentElement = elementList; + + while (currentElement != nil) { + if (count == index) + return currentElement; + + count++; + currentElement = currentElement->nextElement; } - - return nil; - } + + return nil; +} #pragma mark - #pragma mark Core Graphics //////////////////////////////////////Blending Functions///////////////////////////////////// -void linearEvaluation (void *info, const float *in, float *out) - { - float position = *in; - - if(*(CTGradientElement **)info == nil) //if elementList is empty return clear color - { - out[0] = out[1] = out[2] = out[3] = 1; - return; +void linearEvaluation(void *info, const CGFloat *in, CGFloat *out) { + CGFloat position = *in; + + if (*(CTGradientElement **)info == nil) { //if elementList is empty return clear color + out[0] = out[1] = out[2] = out[3] = 1; + return; } - - //This grabs the first two colors in the sequence - CTGradientElement *color1 = *(CTGradientElement **)info; - CTGradientElement *color2 = color1->nextElement; - - //make sure first color and second color are on other sides of position - while(color2 != nil && color2->position < position) - { - color1 = color2; - color2 = color1->nextElement; - } - //if we don't have another color then make next color the same color - if(color2 == nil) - { - color2 = color1; - } - - //----------FailSafe settings---------- - //color1->red = 1; color2->red = 0; - //color1->green = 1; color2->green = 0; - //color1->blue = 1; color2->blue = 0; - //color1->alpha = 1; color2->alpha = 1; - //color1->position = .5; - //color2->position = .5; - //------------------------------------- - - if(position <= color1->position) //Make all below color color1's position equal to color1 - { - out[0] = color1->red; - out[1] = color1->green; - out[2] = color1->blue; - out[3] = color1->alpha; - } - else if (position >= color2->position) //Make all above color color2's position equal to color2 - { - out[0] = color2->red; - out[1] = color2->green; - out[2] = color2->blue; - out[3] = color2->alpha; - } - else //Interpolate color at postions between color1 and color1 - { - //adjust position so that it goes from 0 to 1 in the range from color 1 & 2's position - position = (position-color1->position)/(color2->position - color1->position); - - out[0] = (color2->red - color1->red )*position + color1->red; - out[1] = (color2->green - color1->green)*position + color1->green; - out[2] = (color2->blue - color1->blue )*position + color1->blue; - out[3] = (color2->alpha - color1->alpha)*position + color1->alpha; + + //This grabs the first two colors in the sequence + CTGradientElement *color1 = *(CTGradientElement **)info; + CTGradientElement *color2 = color1->nextElement; + + //make sure first color and second color are on other sides of position + while (color2 != nil && color2->position < position) { + color1 = color2; + color2 = color1->nextElement; } - - //Premultiply the color by the alpha. - out[0] *= out[3]; - out[1] *= out[3]; - out[2] *= out[3]; - } - - - - -//Chromatic Evaluation - -// This blends colors by their Hue, Saturation, and Value(Brightness) right now I just + //if we don't have another color then make next color the same color + if (color2 == nil) { + color2 = color1; + } + + //----------FailSafe settings---------- + //color1->red = 1; color2->red = 0; + //color1->green = 1; color2->green = 0; + //color1->blue = 1; color2->blue = 0; + //color1->alpha = 1; color2->alpha = 1; + //color1->position = .5; + //color2->position = .5; + //------------------------------------- + + if (position <= color1->position) { //Make all below color color1's position equal to color1 + out[0] = color1->red; + out[1] = color1->green; + out[2] = color1->blue; + out[3] = color1->alpha; + } + else if (position >= color2->position) { //Make all above color color2's position equal to color2 + out[0] = color2->red; + out[1] = color2->green; + out[2] = color2->blue; + out[3] = color2->alpha; + } + else { //Interpolate color at postions between color1 and color1 + //adjust position so that it goes from 0 to 1 in the range from color 1 & 2's position + position = (position - color1->position) / (color2->position - color1->position); + + out[0] = (color2->red - color1->red) * position + color1->red; + out[1] = (color2->green - color1->green) * position + color1->green; + out[2] = (color2->blue - color1->blue) * position + color1->blue; + out[3] = (color2->alpha - color1->alpha) * position + color1->alpha; + } + + //Premultiply the color by the alpha. + out[0] *= out[3]; + out[1] *= out[3]; + out[2] *= out[3]; +} + +//Chromatic Evaluation - +// This blends colors by their Hue, Saturation, and Value(Brightness) right now I just // transform the RGB values stored in the CTGradientElements to HSB, in the future I may // streamline it to avoid transforming in and out of HSB colorspace *for later* // @@ -1028,241 +1004,232 @@ void linearEvaluation (void *info, const float *in, float *out) // this we will add to the hue's angle (if we subtract we'll be doing the inverse // chromatic...scroll down more for that). All we need to do is keep adding to the hue // until we wrap around the colorwheel and get to color2. -void chromaticEvaluation(void *info, const float *in, float *out) - { - float position = *in; - - if(*(CTGradientElement **)info == nil) //if elementList is empty return clear color - { - out[0] = out[1] = out[2] = out[3] = 1; - return; +void chromaticEvaluation(void *info, const CGFloat *in, CGFloat *out) { + CGFloat position = *in; + + if (*(CTGradientElement **)info == nil) { //if elementList is empty return clear color + out[0] = out[1] = out[2] = out[3] = 1; + return; + } + + //This grabs the first two colors in the sequence + CTGradientElement *color1 = *(CTGradientElement **)info; + CTGradientElement *color2 = color1->nextElement; + + CGFloat c1[4]; + CGFloat c2[4]; + + //make sure first color and second color are on other sides of position + while (color2 != nil && color2->position < position) { + color1 = color2; + color2 = color1->nextElement; } - - //This grabs the first two colors in the sequence - CTGradientElement *color1 = *(CTGradientElement **)info; - CTGradientElement *color2 = color1->nextElement; - - float c1[4]; - float c2[4]; - - //make sure first color and second color are on other sides of position - while(color2 != nil && color2->position < position) - { - color1 = color2; - color2 = color1->nextElement; - } - //if we don't have another color then make next color the same color - if(color2 == nil) - { - color2 = color1; - } - - - c1[0] = color1->red; - c1[1] = color1->green; - c1[2] = color1->blue; - c1[3] = color1->alpha; - - c2[0] = color2->red; - c2[1] = color2->green; - c2[2] = color2->blue; - c2[3] = color2->alpha; - - transformRGB_HSV(c1); - transformRGB_HSV(c2); - resolveHSV(c1,c2); - - if(c1[0] > c2[0]) //if color1's hue is higher than color2's hue then - c2[0] += 360; // we need to move c2 one revolution around the wheel - - - if(position <= color1->position) //Make all below color color1's position equal to color1 - { - out[0] = c1[0]; - out[1] = c1[1]; - out[2] = c1[2]; - out[3] = c1[3]; - } - else if (position >= color2->position) //Make all above color color2's position equal to color2 - { - out[0] = c2[0]; - out[1] = c2[1]; - out[2] = c2[2]; - out[3] = c2[3]; - } - else //Interpolate color at postions between color1 and color1 - { - //adjust position so that it goes from 0 to 1 in the range from color 1 & 2's position - position = (position-color1->position)/(color2->position - color1->position); - - out[0] = (c2[0] - c1[0])*position + c1[0]; - out[1] = (c2[1] - c1[1])*position + c1[1]; - out[2] = (c2[2] - c1[2])*position + c1[2]; - out[3] = (c2[3] - c1[3])*position + c1[3]; - } - - transformHSV_RGB(out); - - //Premultiply the color by the alpha. - out[0] *= out[3]; - out[1] *= out[3]; - out[2] *= out[3]; - } - - - -//Inverse Chromatic Evaluation - + //if we don't have another color then make next color the same color + if (color2 == nil) { + color2 = color1; + } + + + c1[0] = color1->red; + c1[1] = color1->green; + c1[2] = color1->blue; + c1[3] = color1->alpha; + + c2[0] = color2->red; + c2[1] = color2->green; + c2[2] = color2->blue; + c2[3] = color2->alpha; + + transformRGB_HSV(c1); + transformRGB_HSV(c2); + resolveHSV(c1, c2); + + if (c1[0] > c2[0]) //if color1's hue is higher than color2's hue then + c2[0] += 360; // we need to move c2 one revolution around the wheel + + + if (position <= color1->position) { //Make all below color color1's position equal to color1 + out[0] = c1[0]; + out[1] = c1[1]; + out[2] = c1[2]; + out[3] = c1[3]; + } + else if (position >= color2->position) { //Make all above color color2's position equal to color2 + out[0] = c2[0]; + out[1] = c2[1]; + out[2] = c2[2]; + out[3] = c2[3]; + } + else { //Interpolate color at postions between color1 and color1 + //adjust position so that it goes from 0 to 1 in the range from color 1 & 2's position + position = (position - color1->position) / (color2->position - color1->position); + + out[0] = (c2[0] - c1[0]) * position + c1[0]; + out[1] = (c2[1] - c1[1]) * position + c1[1]; + out[2] = (c2[2] - c1[2]) * position + c1[2]; + out[3] = (c2[3] - c1[3]) * position + c1[3]; + } + + transformHSV_RGB(out); + + //Premultiply the color by the alpha. + out[0] *= out[3]; + out[1] *= out[3]; + out[2] *= out[3]; +} + +//Inverse Chromatic Evaluation - // Inverse Chromatic is about the same story as Chromatic Blend, but here the Hue // is strictly decreasing, that is we need to get from color1 to color2 by decreasing // the 'angle' (i.e. 90¼ -> 180¼ would be done by subtracting 270¼ and getting -180¼... // which is equivalent to 180¼ mod 360¼ -void inverseChromaticEvaluation(void *info, const float *in, float *out) - { - float position = *in; - - if(*(CTGradientElement **)info == nil) //if elementList is empty return clear color - { - out[0] = out[1] = out[2] = out[3] = 1; - return; +void inverseChromaticEvaluation(void *info, const CGFloat *in, CGFloat *out) { + CGFloat position = *in; + + if (*(CTGradientElement **)info == nil) { //if elementList is empty return clear color + out[0] = out[1] = out[2] = out[3] = 1; + return; + } + + //This grabs the first two colors in the sequence + CTGradientElement *color1 = *(CTGradientElement **)info; + CTGradientElement *color2 = color1->nextElement; + + CGFloat c1[4]; + CGFloat c2[4]; + + //make sure first color and second color are on other sides of position + while (color2 != nil && color2->position < position) { + color1 = color2; + color2 = color1->nextElement; + } + //if we don't have another color then make next color the same color + if (color2 == nil) { + color2 = color1; + } + + c1[0] = color1->red; + c1[1] = color1->green; + c1[2] = color1->blue; + c1[3] = color1->alpha; + + c2[0] = color2->red; + c2[1] = color2->green; + c2[2] = color2->blue; + c2[3] = color2->alpha; + + transformRGB_HSV(c1); + transformRGB_HSV(c2); + resolveHSV(c1, c2); + + if (c1[0] < c2[0]) //if color1's hue is higher than color2's hue then + c1[0] += 360; // we need to move c2 one revolution back on the wheel + + + if (position <= color1->position) { //Make all below color color1's position equal to color1 + out[0] = c1[0]; + out[1] = c1[1]; + out[2] = c1[2]; + out[3] = c1[3]; + } + else if (position >= color2->position) { //Make all above color color2's position equal to color2 + out[0] = c2[0]; + out[1] = c2[1]; + out[2] = c2[2]; + out[3] = c2[3]; } - - //This grabs the first two colors in the sequence - CTGradientElement *color1 = *(CTGradientElement **)info; - CTGradientElement *color2 = color1->nextElement; - - float c1[4]; - float c2[4]; - - //make sure first color and second color are on other sides of position - while(color2 != nil && color2->position < position) - { - color1 = color2; - color2 = color1->nextElement; - } - //if we don't have another color then make next color the same color - if(color2 == nil) - { - color2 = color1; - } - - c1[0] = color1->red; - c1[1] = color1->green; - c1[2] = color1->blue; - c1[3] = color1->alpha; - - c2[0] = color2->red; - c2[1] = color2->green; - c2[2] = color2->blue; - c2[3] = color2->alpha; - - transformRGB_HSV(c1); - transformRGB_HSV(c2); - resolveHSV(c1,c2); - - if(c1[0] < c2[0]) //if color1's hue is higher than color2's hue then - c1[0] += 360; // we need to move c2 one revolution back on the wheel - - - if(position <= color1->position) //Make all below color color1's position equal to color1 - { - out[0] = c1[0]; - out[1] = c1[1]; - out[2] = c1[2]; - out[3] = c1[3]; - } - else if (position >= color2->position) //Make all above color color2's position equal to color2 - { - out[0] = c2[0]; - out[1] = c2[1]; - out[2] = c2[2]; - out[3] = c2[3]; - } - else //Interpolate color at postions between color1 and color1 - { - //adjust position so that it goes from 0 to 1 in the range from color 1 & 2's position - position = (position-color1->position)/(color2->position - color1->position); - - out[0] = (c2[0] - c1[0])*position + c1[0]; - out[1] = (c2[1] - c1[1])*position + c1[1]; - out[2] = (c2[2] - c1[2])*position + c1[2]; - out[3] = (c2[3] - c1[3])*position + c1[3]; - } - - transformHSV_RGB(out); - - //Premultiply the color by the alpha. - out[0] *= out[3]; - out[1] *= out[3]; - out[2] *= out[3]; - } - - -void transformRGB_HSV(float *components) //H,S,B -> R,G,B - { - float H, S, V; - float R = components[0], - G = components[1], - B = components[2]; - - float MAX = R > G ? (R > B ? R : B) : (G > B ? G : B), - MIN = R < G ? (R < B ? R : B) : (G < B ? G : B); - - if(MAX == MIN) + else { //Interpolate color at postions between color1 and color1 + //adjust position so that it goes from 0 to 1 in the range from color 1 & 2's position + position = (position - color1->position) / (color2->position - color1->position); + + out[0] = (c2[0] - c1[0]) * position + c1[0]; + out[1] = (c2[1] - c1[1]) * position + c1[1]; + out[2] = (c2[2] - c1[2]) * position + c1[2]; + out[3] = (c2[3] - c1[3]) * position + c1[3]; + } + + transformHSV_RGB(out); + + //Premultiply the color by the alpha. + out[0] *= out[3]; + out[1] *= out[3]; + out[2] *= out[3]; +} + +void transformRGB_HSV(CGFloat *components) { //H,S,B -> R,G,B + CGFloat H, S, V; + CGFloat R = components[0], + G = components[1], + B = components[2]; + + CGFloat MAX = R > G ? (R > B ? R : B) : (G > B ? G : B), + MIN = R < G ? (R < B ? R : B) : (G < B ? G : B); + + if (MAX == MIN) H = NAN; - else if(MAX == R) - if(G >= B) - H = 60*(G-B)/(MAX-MIN)+0; + else if (MAX == R) + if (G >= B) + H = 60 * (G - B) / (MAX - MIN) + 0; else - H = 60*(G-B)/(MAX-MIN)+360; - else if(MAX == G) - H = 60*(B-R)/(MAX-MIN)+120; - else if(MAX == B) - H = 60*(R-G)/(MAX-MIN)+240; - - S = MAX == 0 ? 0 : 1 - MIN/MAX; + H = 60 * (G - B) / (MAX - MIN) + 360; + else if (MAX == G) + H = 60 * (B - R) / (MAX - MIN) + 120; + else if (MAX == B) + H = 60 * (R - G) / (MAX - MIN) + 240; + + S = MAX == 0 ? 0 : 1 - MIN / MAX; V = MAX; - + components[0] = H; components[1] = S; components[2] = V; - } +} -void transformHSV_RGB(float *components) //H,S,B -> R,G,B - { - float R, G, B; - float H = fmodf(components[0],359), //map to [0,360) - S = components[1], - V = components[2]; - - int Hi = (int)floorf(H/60.) % 6; - float f = H/60-Hi, - p = V*(1-S), - q = V*(1-f*S), - t = V*(1-(1-f)*S); - - switch (Hi) - { - case 0: R=V;G=t;B=p; break; - case 1: R=q;G=V;B=p; break; - case 2: R=p;G=V;B=t; break; - case 3: R=p;G=q;B=V; break; - case 4: R=t;G=p;B=V; break; - case 5: R=V;G=p;B=q; break; - } - +void transformHSV_RGB(CGFloat *components) { //H,S,B -> R,G,B + CGFloat R = 0, G = 0, B = 0; + CGFloat H = fmodf(components[0], 359), //map to [0,360) + S = components[1], + V = components[2]; + + int Hi = (int)floorf(H / 60.) % 6; + CGFloat f = H / 60 - Hi, + p = V * (1 - S), + q = V * (1 - f * S), + t = V * (1 - (1 - f) * S); + + switch (Hi) { + case 0: R = V; G = t; B = p; + break; + + case 1: R = q; G = V; B = p; + break; + + case 2: R = p; G = V; B = t; + break; + + case 3: R = p; G = q; B = V; + break; + + case 4: R = t; G = p; B = V; + break; + + case 5: R = V; G = p; B = q; + break; + } + components[0] = R; components[1] = G; components[2] = B; - } +} -void resolveHSV(float *color1, float *color2) //H value may be undefined (i.e. graycale color) - { // we want to fill it with a sensible value - if(isnan(color1[0]) && isnan(color2[0])) +void resolveHSV(CGFloat *color1, CGFloat *color2) { //H value may be undefined (i.e. graycale color) + // we want to fill it with a sensible value + if (isnan(color1[0]) && isnan(color2[0])) color1[0] = color2[0] = 0; - else if(isnan(color1[0])) + else if (isnan(color1[0])) color1[0] = color2[0]; - else if(isnan(color2[0])) + else if (isnan(color2[0])) color2[0] = color1[0]; - } +} @end diff --git a/CTGradient.xcodeproj/project.pbxproj b/CTGradient.xcodeproj/project.pbxproj index 00f0fb0..dfc01d3 100644 --- a/CTGradient.xcodeproj/project.pbxproj +++ b/CTGradient.xcodeproj/project.pbxproj @@ -3,144 +3,201 @@ archiveVersion = 1; classes = { }; - objectVersion = 42; + objectVersion = 46; objects = { /* Begin PBXBuildFile section */ - 8D11072A0486CEB800E47090 /* MainMenu.nib in Resources */ = {isa = PBXBuildFile; fileRef = 29B97318FDCFA39411CA2CEA /* MainMenu.nib */; }; - 8D11072B0486CEB800E47090 /* InfoPlist.strings in Resources */ = {isa = PBXBuildFile; fileRef = 089C165CFE840E0CC02AAC07 /* InfoPlist.strings */; }; - 8D11072D0486CEB800E47090 /* main.m in Sources */ = {isa = PBXBuildFile; fileRef = 29B97316FDCFA39411CA2CEA /* main.m */; settings = {ATTRIBUTES = (); }; }; - 8D11072F0486CEB800E47090 /* Cocoa.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 1058C7A1FEA54F0111CA2CBB /* Cocoa.framework */; }; - A89BD8D4097A55BA00104C29 /* CTGradient.m in Sources */ = {isa = PBXBuildFile; fileRef = A89BD8D3097A55BA00104C29 /* CTGradient.m */; }; - A89BD8D7097A55C400104C29 /* CTGradientView.m in Sources */ = {isa = PBXBuildFile; fileRef = A89BD8D6097A55C400104C29 /* CTGradientView.m */; }; - A8F011870A7375B6000A0400 /* TieDye.icns in Resources */ = {isa = PBXBuildFile; fileRef = A8F011860A7375B6000A0400 /* TieDye.icns */; }; + B427FC0119158C3600077A59 /* Cocoa.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = B427FC0019158C3600077A59 /* Cocoa.framework */; }; + B427FC3A19158C7800077A59 /* AppDelegate.m in Sources */ = {isa = PBXBuildFile; fileRef = B427FC3319158C7800077A59 /* AppDelegate.m */; }; + B427FC3D19158C7800077A59 /* main.m in Sources */ = {isa = PBXBuildFile; fileRef = B427FC3719158C7800077A59 /* main.m */; }; + B427FC3E19158C7800077A59 /* MainMenu.nib in Resources */ = {isa = PBXBuildFile; fileRef = B427FC3819158C7800077A59 /* MainMenu.nib */; }; + B427FC4419158C9000077A59 /* CTGradient.m in Sources */ = {isa = PBXBuildFile; fileRef = B427FC4119158C9000077A59 /* CTGradient.m */; }; + B427FC4519158C9000077A59 /* CTGradientView.m in Sources */ = {isa = PBXBuildFile; fileRef = B427FC4319158C9000077A59 /* CTGradientView.m */; }; + B427FC4C19158F0E00077A59 /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = B427FC4B19158F0E00077A59 /* Foundation.framework */; }; + B427FC4E19158F0E00077A59 /* CoreGraphics.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = B427FC4D19158F0E00077A59 /* CoreGraphics.framework */; }; + B427FC5019158F0E00077A59 /* UIKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = B427FC4F19158F0E00077A59 /* UIKit.framework */; }; + B427FC5C19158F0E00077A59 /* AppDelegate.m in Sources */ = {isa = PBXBuildFile; fileRef = B427FC5B19158F0E00077A59 /* AppDelegate.m */; }; + B427FC6519158F0E00077A59 /* MainViewController.m in Sources */ = {isa = PBXBuildFile; fileRef = B427FC6419158F0E00077A59 /* MainViewController.m */; }; + B427FC6819158F0E00077A59 /* FlipsideViewController.m in Sources */ = {isa = PBXBuildFile; fileRef = B427FC6719158F0E00077A59 /* FlipsideViewController.m */; }; + B427FC6A19158F0E00077A59 /* Images.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = B427FC6919158F0E00077A59 /* Images.xcassets */; }; + B427FC83191592E100077A59 /* CTGradient.m in Sources */ = {isa = PBXBuildFile; fileRef = B427FC4119158C9000077A59 /* CTGradient.m */; }; + B427FC84191592E100077A59 /* CTGradientView.m in Sources */ = {isa = PBXBuildFile; fileRef = B427FC4319158C9000077A59 /* CTGradientView.m */; }; + B427FC8B191594E700077A59 /* Main_iPad.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = B427FC87191594E700077A59 /* Main_iPad.storyboard */; }; + B427FC8C191594E700077A59 /* Main_iPhone.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = B427FC88191594E700077A59 /* Main_iPhone.storyboard */; }; + B427FC8D191594E700077A59 /* main.m in Sources */ = {isa = PBXBuildFile; fileRef = B427FC89191594E700077A59 /* main.m */; }; /* End PBXBuildFile section */ /* Begin PBXFileReference section */ - 089C165DFE840E0CC02AAC07 /* English */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = English; path = English.lproj/InfoPlist.strings; sourceTree = ""; }; - 1058C7A1FEA54F0111CA2CBB /* Cocoa.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Cocoa.framework; path = /System/Library/Frameworks/Cocoa.framework; sourceTree = ""; }; - 13E42FB307B3F0F600E4EEF1 /* CoreData.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreData.framework; path = /System/Library/Frameworks/CoreData.framework; sourceTree = ""; }; - 29B97316FDCFA39411CA2CEA /* main.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = main.m; sourceTree = ""; }; - 29B97319FDCFA39411CA2CEA /* English */ = {isa = PBXFileReference; lastKnownFileType = wrapper.nib; name = English; path = English.lproj/MainMenu.nib; sourceTree = ""; }; - 29B97324FDCFA39411CA2CEA /* AppKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = AppKit.framework; path = /System/Library/Frameworks/AppKit.framework; sourceTree = ""; }; - 29B97325FDCFA39411CA2CEA /* Foundation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Foundation.framework; path = /System/Library/Frameworks/Foundation.framework; sourceTree = ""; }; - 8D1107310486CEB800E47090 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist; path = Info.plist; sourceTree = ""; }; - 8D1107320486CEB800E47090 /* CTGradient.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = CTGradient.app; sourceTree = BUILT_PRODUCTS_DIR; }; - A89BD8D2097A55BA00104C29 /* CTGradient.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = CTGradient.h; sourceTree = ""; }; - A89BD8D3097A55BA00104C29 /* CTGradient.m */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.objc; path = CTGradient.m; sourceTree = ""; }; - A89BD8D5097A55C400104C29 /* CTGradientView.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = CTGradientView.h; sourceTree = ""; }; - A89BD8D6097A55C400104C29 /* CTGradientView.m */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.objc; path = CTGradientView.m; sourceTree = ""; }; - A8F011860A7375B6000A0400 /* TieDye.icns */ = {isa = PBXFileReference; lastKnownFileType = image.icns; path = TieDye.icns; sourceTree = ""; }; + B427FBFD19158C3600077A59 /* CTGradient-OSX.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = "CTGradient-OSX.app"; sourceTree = BUILT_PRODUCTS_DIR; }; + B427FC0019158C3600077A59 /* Cocoa.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Cocoa.framework; path = Library/Frameworks/Cocoa.framework; sourceTree = DEVELOPER_DIR; }; + B427FC0319158C3600077A59 /* AppKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = AppKit.framework; path = Library/Frameworks/AppKit.framework; sourceTree = SDKROOT; }; + B427FC0419158C3600077A59 /* CoreData.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreData.framework; path = Library/Frameworks/CoreData.framework; sourceTree = SDKROOT; }; + B427FC0519158C3600077A59 /* Foundation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Foundation.framework; path = Library/Frameworks/Foundation.framework; sourceTree = SDKROOT; }; + B427FC1F19158C3600077A59 /* XCTest.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = XCTest.framework; path = Library/Frameworks/XCTest.framework; sourceTree = DEVELOPER_DIR; }; + B427FC3219158C7800077A59 /* AppDelegate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AppDelegate.h; sourceTree = ""; }; + B427FC3319158C7800077A59 /* AppDelegate.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = AppDelegate.m; sourceTree = ""; }; + B427FC3419158C7800077A59 /* CTGradient-OSX-Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = "CTGradient-OSX-Info.plist"; sourceTree = ""; }; + B427FC3519158C7800077A59 /* CTGradient-OSX-Prefix.pch */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "CTGradient-OSX-Prefix.pch"; sourceTree = ""; }; + B427FC3719158C7800077A59 /* main.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = main.m; sourceTree = ""; }; + B427FC3819158C7800077A59 /* MainMenu.nib */ = {isa = PBXFileReference; lastKnownFileType = wrapper.nib; path = MainMenu.nib; sourceTree = ""; }; + B427FC4019158C9000077A59 /* CTGradient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CTGradient.h; sourceTree = ""; }; + B427FC4119158C9000077A59 /* CTGradient.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = CTGradient.m; sourceTree = ""; }; + B427FC4219158C9000077A59 /* CTGradientView.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CTGradientView.h; sourceTree = ""; }; + B427FC4319158C9000077A59 /* CTGradientView.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = CTGradientView.m; sourceTree = ""; }; + B427FC4A19158F0E00077A59 /* CTGradient-IOS.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = "CTGradient-IOS.app"; sourceTree = BUILT_PRODUCTS_DIR; }; + B427FC4B19158F0E00077A59 /* Foundation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Foundation.framework; path = Library/Frameworks/Foundation.framework; sourceTree = DEVELOPER_DIR; }; + B427FC4D19158F0E00077A59 /* CoreGraphics.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreGraphics.framework; path = Library/Frameworks/CoreGraphics.framework; sourceTree = DEVELOPER_DIR; }; + B427FC4F19158F0E00077A59 /* UIKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = UIKit.framework; path = Library/Frameworks/UIKit.framework; sourceTree = DEVELOPER_DIR; }; + B427FC5A19158F0E00077A59 /* AppDelegate.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = AppDelegate.h; sourceTree = ""; }; + B427FC5B19158F0E00077A59 /* AppDelegate.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = AppDelegate.m; sourceTree = ""; }; + B427FC6319158F0E00077A59 /* MainViewController.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = MainViewController.h; sourceTree = ""; }; + B427FC6419158F0E00077A59 /* MainViewController.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = MainViewController.m; sourceTree = ""; }; + B427FC6619158F0E00077A59 /* FlipsideViewController.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = FlipsideViewController.h; sourceTree = ""; }; + B427FC6719158F0E00077A59 /* FlipsideViewController.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = FlipsideViewController.m; sourceTree = ""; }; + B427FC6919158F0E00077A59 /* Images.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Images.xcassets; sourceTree = ""; }; + B427FC85191594E700077A59 /* CTGradient-IOS-Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = "CTGradient-IOS-Info.plist"; sourceTree = ""; }; + B427FC86191594E700077A59 /* CTGradient-IOS-Prefix.pch */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "CTGradient-IOS-Prefix.pch"; sourceTree = ""; }; + B427FC87191594E700077A59 /* Main_iPad.storyboard */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = file.storyboard; path = Main_iPad.storyboard; sourceTree = ""; }; + B427FC88191594E700077A59 /* Main_iPhone.storyboard */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = file.storyboard; path = Main_iPhone.storyboard; sourceTree = ""; }; + B427FC89191594E700077A59 /* main.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = main.m; sourceTree = ""; }; /* End PBXFileReference section */ /* Begin PBXFrameworksBuildPhase section */ - 8D11072E0486CEB800E47090 /* Frameworks */ = { + B427FBFA19158C3600077A59 /* Frameworks */ = { isa = PBXFrameworksBuildPhase; buildActionMask = 2147483647; files = ( - 8D11072F0486CEB800E47090 /* Cocoa.framework in Frameworks */, + B427FC0119158C3600077A59 /* Cocoa.framework in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + B427FC4719158F0E00077A59 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + B427FC4E19158F0E00077A59 /* CoreGraphics.framework in Frameworks */, + B427FC5019158F0E00077A59 /* UIKit.framework in Frameworks */, + B427FC4C19158F0E00077A59 /* Foundation.framework in Frameworks */, ); runOnlyForDeploymentPostprocessing = 0; }; /* End PBXFrameworksBuildPhase section */ /* Begin PBXGroup section */ - 080E96DDFE201D6D7F000001 /* Classes */ = { - isa = PBXGroup; - children = ( - A89BD8D2097A55BA00104C29 /* CTGradient.h */, - A89BD8D3097A55BA00104C29 /* CTGradient.m */, - A89BD8D5097A55C400104C29 /* CTGradientView.h */, - A89BD8D6097A55C400104C29 /* CTGradientView.m */, - ); - name = Classes; - sourceTree = ""; - }; - 1058C7A0FEA54F0111CA2CBB /* Linked Frameworks */ = { - isa = PBXGroup; - children = ( - 1058C7A1FEA54F0111CA2CBB /* Cocoa.framework */, - ); - name = "Linked Frameworks"; - sourceTree = ""; - }; - 1058C7A2FEA54F0111CA2CBB /* Other Frameworks */ = { + 29B97314FDCFA39411CA2CEA /* CTGradient */ = { isa = PBXGroup; children = ( - 29B97324FDCFA39411CA2CEA /* AppKit.framework */, - 13E42FB307B3F0F600E4EEF1 /* CoreData.framework */, - 29B97325FDCFA39411CA2CEA /* Foundation.framework */, + B427FC4019158C9000077A59 /* CTGradient.h */, + B427FC4119158C9000077A59 /* CTGradient.m */, + B427FC4219158C9000077A59 /* CTGradientView.h */, + B427FC4319158C9000077A59 /* CTGradientView.m */, + B427FC0619158C3600077A59 /* CTGradient-OSX */, + B427FC5119158F0E00077A59 /* CTGradient-IOS */, + B427FBFF19158C3600077A59 /* Frameworks */, + B427FBFE19158C3600077A59 /* Products */, ); - name = "Other Frameworks"; + name = CTGradient; sourceTree = ""; }; - 19C28FACFE9D520D11CA2CBB /* Products */ = { + B427FBFE19158C3600077A59 /* Products */ = { isa = PBXGroup; children = ( - 8D1107320486CEB800E47090 /* CTGradient.app */, + B427FBFD19158C3600077A59 /* CTGradient-OSX.app */, + B427FC4A19158F0E00077A59 /* CTGradient-IOS.app */, ); name = Products; sourceTree = ""; }; - 29B97314FDCFA39411CA2CEA /* CTGradient */ = { + B427FBFF19158C3600077A59 /* Frameworks */ = { isa = PBXGroup; children = ( - 080E96DDFE201D6D7F000001 /* Classes */, - 29B97315FDCFA39411CA2CEA /* Other Sources */, - 29B97317FDCFA39411CA2CEA /* Resources */, - 29B97323FDCFA39411CA2CEA /* Frameworks */, - 19C28FACFE9D520D11CA2CBB /* Products */, + B427FC0019158C3600077A59 /* Cocoa.framework */, + B427FC1F19158C3600077A59 /* XCTest.framework */, + B427FC4B19158F0E00077A59 /* Foundation.framework */, + B427FC4D19158F0E00077A59 /* CoreGraphics.framework */, + B427FC4F19158F0E00077A59 /* UIKit.framework */, + B427FC0219158C3600077A59 /* Other Frameworks */, ); - name = CTGradient; + name = Frameworks; sourceTree = ""; }; - 29B97315FDCFA39411CA2CEA /* Other Sources */ = { + B427FC0219158C3600077A59 /* Other Frameworks */ = { isa = PBXGroup; children = ( - 29B97316FDCFA39411CA2CEA /* main.m */, + B427FC0319158C3600077A59 /* AppKit.framework */, + B427FC0419158C3600077A59 /* CoreData.framework */, + B427FC0519158C3600077A59 /* Foundation.framework */, ); - name = "Other Sources"; + name = "Other Frameworks"; sourceTree = ""; }; - 29B97317FDCFA39411CA2CEA /* Resources */ = { + B427FC0619158C3600077A59 /* CTGradient-OSX */ = { isa = PBXGroup; children = ( - A8F011860A7375B6000A0400 /* TieDye.icns */, - 8D1107310486CEB800E47090 /* Info.plist */, - 089C165CFE840E0CC02AAC07 /* InfoPlist.strings */, - 29B97318FDCFA39411CA2CEA /* MainMenu.nib */, + B427FC3419158C7800077A59 /* CTGradient-OSX-Info.plist */, + B427FC3519158C7800077A59 /* CTGradient-OSX-Prefix.pch */, + B427FC3819158C7800077A59 /* MainMenu.nib */, + B427FC3719158C7800077A59 /* main.m */, + B427FC3219158C7800077A59 /* AppDelegate.h */, + B427FC3319158C7800077A59 /* AppDelegate.m */, ); - name = Resources; + path = "CTGradient-OSX"; sourceTree = ""; }; - 29B97323FDCFA39411CA2CEA /* Frameworks */ = { + B427FC5119158F0E00077A59 /* CTGradient-IOS */ = { isa = PBXGroup; children = ( - 1058C7A0FEA54F0111CA2CBB /* Linked Frameworks */, - 1058C7A2FEA54F0111CA2CBB /* Other Frameworks */, + B427FC85191594E700077A59 /* CTGradient-IOS-Info.plist */, + B427FC86191594E700077A59 /* CTGradient-IOS-Prefix.pch */, + B427FC87191594E700077A59 /* Main_iPad.storyboard */, + B427FC88191594E700077A59 /* Main_iPhone.storyboard */, + B427FC89191594E700077A59 /* main.m */, + B427FC5A19158F0E00077A59 /* AppDelegate.h */, + B427FC5B19158F0E00077A59 /* AppDelegate.m */, + B427FC6319158F0E00077A59 /* MainViewController.h */, + B427FC6419158F0E00077A59 /* MainViewController.m */, + B427FC6619158F0E00077A59 /* FlipsideViewController.h */, + B427FC6719158F0E00077A59 /* FlipsideViewController.m */, + B427FC6919158F0E00077A59 /* Images.xcassets */, ); - name = Frameworks; + path = "CTGradient-IOS"; sourceTree = ""; }; /* End PBXGroup section */ /* Begin PBXNativeTarget section */ - 8D1107260486CEB800E47090 /* CTGradient */ = { + B427FBFC19158C3600077A59 /* CTGradient-OSX */ = { isa = PBXNativeTarget; - buildConfigurationList = C01FCF4A08A954540054247B /* Build configuration list for PBXNativeTarget "CTGradient" */; + buildConfigurationList = B427FC2C19158C3600077A59 /* Build configuration list for PBXNativeTarget "CTGradient-OSX" */; buildPhases = ( - 8D1107290486CEB800E47090 /* Resources */, - 8D11072C0486CEB800E47090 /* Sources */, - 8D11072E0486CEB800E47090 /* Frameworks */, + B427FBF919158C3600077A59 /* Sources */, + B427FBFA19158C3600077A59 /* Frameworks */, + B427FBFB19158C3600077A59 /* Resources */, ); buildRules = ( ); dependencies = ( ); - name = CTGradient; - productInstallPath = "$(HOME)/Applications"; - productName = CTGradient; - productReference = 8D1107320486CEB800E47090 /* CTGradient.app */; + name = "CTGradient-OSX"; + productName = "CTGradient-OSX"; + productReference = B427FBFD19158C3600077A59 /* CTGradient-OSX.app */; + productType = "com.apple.product-type.application"; + }; + B427FC4919158F0E00077A59 /* CTGradient-IOS */ = { + isa = PBXNativeTarget; + buildConfigurationList = B427FC7D19158F0E00077A59 /* Build configuration list for PBXNativeTarget "CTGradient-IOS" */; + buildPhases = ( + B427FC4619158F0E00077A59 /* Sources */, + B427FC4719158F0E00077A59 /* Frameworks */, + B427FC4819158F0E00077A59 /* Resources */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = "CTGradient-IOS"; + productName = "CTGradient-IOS"; + productReference = B427FC4A19158F0E00077A59 /* CTGradient-IOS.app */; productType = "com.apple.product-type.application"; }; /* End PBXNativeTarget section */ @@ -148,90 +205,255 @@ /* Begin PBXProject section */ 29B97313FDCFA39411CA2CEA /* Project object */ = { isa = PBXProject; + attributes = { + LastUpgradeCheck = 0510; + }; buildConfigurationList = C01FCF4E08A954540054247B /* Build configuration list for PBXProject "CTGradient" */; + compatibilityVersion = "Xcode 3.2"; + developmentRegion = English; hasScannedForEncodings = 1; + knownRegions = ( + en, + Base, + ); mainGroup = 29B97314FDCFA39411CA2CEA /* CTGradient */; + productRefGroup = B427FBFE19158C3600077A59 /* Products */; projectDirPath = ""; + projectRoot = ""; targets = ( - 8D1107260486CEB800E47090 /* CTGradient */, + B427FBFC19158C3600077A59 /* CTGradient-OSX */, + B427FC4919158F0E00077A59 /* CTGradient-IOS */, ); }; /* End PBXProject section */ /* Begin PBXResourcesBuildPhase section */ - 8D1107290486CEB800E47090 /* Resources */ = { + B427FBFB19158C3600077A59 /* Resources */ = { isa = PBXResourcesBuildPhase; buildActionMask = 2147483647; files = ( - 8D11072A0486CEB800E47090 /* MainMenu.nib in Resources */, - 8D11072B0486CEB800E47090 /* InfoPlist.strings in Resources */, - A8F011870A7375B6000A0400 /* TieDye.icns in Resources */, + B427FC3E19158C7800077A59 /* MainMenu.nib in Resources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + B427FC4819158F0E00077A59 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + B427FC8C191594E700077A59 /* Main_iPhone.storyboard in Resources */, + B427FC8B191594E700077A59 /* Main_iPad.storyboard in Resources */, + B427FC6A19158F0E00077A59 /* Images.xcassets in Resources */, ); runOnlyForDeploymentPostprocessing = 0; }; /* End PBXResourcesBuildPhase section */ /* Begin PBXSourcesBuildPhase section */ - 8D11072C0486CEB800E47090 /* Sources */ = { + B427FBF919158C3600077A59 /* Sources */ = { isa = PBXSourcesBuildPhase; buildActionMask = 2147483647; files = ( - 8D11072D0486CEB800E47090 /* main.m in Sources */, - A89BD8D4097A55BA00104C29 /* CTGradient.m in Sources */, - A89BD8D7097A55C400104C29 /* CTGradientView.m in Sources */, + B427FC4419158C9000077A59 /* CTGradient.m in Sources */, + B427FC3D19158C7800077A59 /* main.m in Sources */, + B427FC3A19158C7800077A59 /* AppDelegate.m in Sources */, + B427FC4519158C9000077A59 /* CTGradientView.m in Sources */, ); runOnlyForDeploymentPostprocessing = 0; }; -/* End PBXSourcesBuildPhase section */ - -/* Begin PBXVariantGroup section */ - 089C165CFE840E0CC02AAC07 /* InfoPlist.strings */ = { - isa = PBXVariantGroup; - children = ( - 089C165DFE840E0CC02AAC07 /* English */, - ); - name = InfoPlist.strings; - sourceTree = ""; - }; - 29B97318FDCFA39411CA2CEA /* MainMenu.nib */ = { - isa = PBXVariantGroup; - children = ( - 29B97319FDCFA39411CA2CEA /* English */, + B427FC4619158F0E00077A59 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + B427FC5C19158F0E00077A59 /* AppDelegate.m in Sources */, + B427FC6519158F0E00077A59 /* MainViewController.m in Sources */, + B427FC6819158F0E00077A59 /* FlipsideViewController.m in Sources */, + B427FC83191592E100077A59 /* CTGradient.m in Sources */, + B427FC8D191594E700077A59 /* main.m in Sources */, + B427FC84191592E100077A59 /* CTGradientView.m in Sources */, ); - name = MainMenu.nib; - sourceTree = ""; + runOnlyForDeploymentPostprocessing = 0; }; -/* End PBXVariantGroup section */ +/* End PBXSourcesBuildPhase section */ /* Begin XCBuildConfiguration section */ - C01FCF4B08A954540054247B /* Debug */ = { + B427FC2D19158C3600077A59 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + COMBINE_HIDPI_IMAGES = YES; + COPY_PHASE_STRIP = NO; + FRAMEWORK_SEARCH_PATHS = ( + "$(inherited)", + "$(DEVELOPER_FRAMEWORKS_DIR)", + ); + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_OBJC_EXCEPTIONS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PRECOMPILE_PREFIX_HEADER = YES; + GCC_PREFIX_HEADER = "CTGradient-OSX/CTGradient-OSX-Prefix.pch"; + GCC_PREPROCESSOR_DEFINITIONS = ( + "DEBUG=1", + "$(inherited)", + ); + GCC_SYMBOLS_PRIVATE_EXTERN = NO; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + INFOPLIST_FILE = "CTGradient-OSX/CTGradient-OSX-Info.plist"; + MACOSX_DEPLOYMENT_TARGET = 10.9; + ONLY_ACTIVE_ARCH = YES; + PRODUCT_NAME = "$(TARGET_NAME)"; + SDKROOT = macosx; + WRAPPER_EXTENSION = app; + }; + name = Debug; + }; + B427FC2E19158C3600077A59 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + COMBINE_HIDPI_IMAGES = YES; + COPY_PHASE_STRIP = YES; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + ENABLE_NS_ASSERTIONS = NO; + FRAMEWORK_SEARCH_PATHS = ( + "$(inherited)", + "$(DEVELOPER_FRAMEWORKS_DIR)", + ); + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_ENABLE_OBJC_EXCEPTIONS = YES; + GCC_PRECOMPILE_PREFIX_HEADER = YES; + GCC_PREFIX_HEADER = "CTGradient-OSX/CTGradient-OSX-Prefix.pch"; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + INFOPLIST_FILE = "CTGradient-OSX/CTGradient-OSX-Info.plist"; + MACOSX_DEPLOYMENT_TARGET = 10.9; + PRODUCT_NAME = "$(TARGET_NAME)"; + SDKROOT = macosx; + WRAPPER_EXTENSION = app; + }; + name = Release; + }; + B427FC7E19158F0E00077A59 /* Debug */ = { isa = XCBuildConfiguration; buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + ASSETCATALOG_COMPILER_LAUNCHIMAGE_NAME = LaunchImage; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer"; COPY_PHASE_STRIP = NO; + FRAMEWORK_SEARCH_PATHS = ( + "$(inherited)", + "$(DEVELOPER_FRAMEWORKS_DIR)", + ); + GCC_C_LANGUAGE_STANDARD = gnu99; GCC_DYNAMIC_NO_PIC = NO; - GCC_ENABLE_FIX_AND_CONTINUE = YES; - GCC_MODEL_TUNING = G5; GCC_OPTIMIZATION_LEVEL = 0; - INFOPLIST_FILE = Info.plist; - INSTALL_PATH = "$(HOME)/Applications"; - PRODUCT_NAME = CTGradient; + GCC_PRECOMPILE_PREFIX_HEADER = YES; + GCC_PREFIX_HEADER = "CTGradient-IOS/CTGradient-IOS-Prefix.pch"; + GCC_PREPROCESSOR_DEFINITIONS = ( + "DEBUG=1", + "$(inherited)", + ); + GCC_SYMBOLS_PRIVATE_EXTERN = NO; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + INFOPLIST_FILE = "CTGradient-IOS/CTGradient-IOS-Info.plist"; + IPHONEOS_DEPLOYMENT_TARGET = 7.1; + ONLY_ACTIVE_ARCH = YES; + PRODUCT_NAME = "$(TARGET_NAME)"; + SDKROOT = iphoneos; + TARGETED_DEVICE_FAMILY = "1,2"; WRAPPER_EXTENSION = app; - ZERO_LINK = YES; }; name = Debug; }; - C01FCF4C08A954540054247B /* Release */ = { + B427FC7F19158F0E00077A59 /* Release */ = { isa = XCBuildConfiguration; buildSettings = { - ARCHS = ( - ppc, - i386, + ALWAYS_SEARCH_USER_PATHS = NO; + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + ASSETCATALOG_COMPILER_LAUNCHIMAGE_NAME = LaunchImage; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer"; + COPY_PHASE_STRIP = YES; + ENABLE_NS_ASSERTIONS = NO; + FRAMEWORK_SEARCH_PATHS = ( + "$(inherited)", + "$(DEVELOPER_FRAMEWORKS_DIR)", ); - GCC_GENERATE_DEBUGGING_SYMBOLS = NO; - GCC_MODEL_TUNING = G5; - INFOPLIST_FILE = Info.plist; - INSTALL_PATH = "$(HOME)/Applications"; - PRODUCT_NAME = CTGradient; + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_PRECOMPILE_PREFIX_HEADER = YES; + GCC_PREFIX_HEADER = "CTGradient-IOS/CTGradient-IOS-Prefix.pch"; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + INFOPLIST_FILE = "CTGradient-IOS/CTGradient-IOS-Info.plist"; + IPHONEOS_DEPLOYMENT_TARGET = 7.1; + PRODUCT_NAME = "$(TARGET_NAME)"; + SDKROOT = iphoneos; + TARGETED_DEVICE_FAMILY = "1,2"; + VALIDATE_PRODUCT = YES; WRAPPER_EXTENSION = app; }; name = Release; @@ -241,8 +463,9 @@ buildSettings = { GCC_WARN_ABOUT_RETURN_TYPE = YES; GCC_WARN_UNUSED_VARIABLE = YES; + ONLY_ACTIVE_ARCH = YES; PREBINDING = NO; - SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk; + SDKROOT = "$(DEVELOPER_SDK_DIR)/MacOSX10.4u.sdk"; }; name = Debug; }; @@ -252,18 +475,27 @@ GCC_WARN_ABOUT_RETURN_TYPE = YES; GCC_WARN_UNUSED_VARIABLE = YES; PREBINDING = NO; - SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk; + SDKROOT = "$(DEVELOPER_SDK_DIR)/MacOSX10.4u.sdk"; }; name = Release; }; /* End XCBuildConfiguration section */ /* Begin XCConfigurationList section */ - C01FCF4A08A954540054247B /* Build configuration list for PBXNativeTarget "CTGradient" */ = { + B427FC2C19158C3600077A59 /* Build configuration list for PBXNativeTarget "CTGradient-OSX" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + B427FC2D19158C3600077A59 /* Debug */, + B427FC2E19158C3600077A59 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + B427FC7D19158F0E00077A59 /* Build configuration list for PBXNativeTarget "CTGradient-IOS" */ = { isa = XCConfigurationList; buildConfigurations = ( - C01FCF4B08A954540054247B /* Debug */, - C01FCF4C08A954540054247B /* Release */, + B427FC7E19158F0E00077A59 /* Debug */, + B427FC7F19158F0E00077A59 /* Release */, ); defaultConfigurationIsVisible = 0; defaultConfigurationName = Release; diff --git a/CTGradient.xcodeproj/project.xcworkspace/contents.xcworkspacedata b/CTGradient.xcodeproj/project.xcworkspace/contents.xcworkspacedata new file mode 100644 index 0000000..c7d59eb --- /dev/null +++ b/CTGradient.xcodeproj/project.xcworkspace/contents.xcworkspacedata @@ -0,0 +1,7 @@ + + + + + diff --git a/CTGradient.xcodeproj/project.xcworkspace/xcshareddata/CTGradient.xccheckout b/CTGradient.xcodeproj/project.xcworkspace/xcshareddata/CTGradient.xccheckout new file mode 100644 index 0000000..ce1472d --- /dev/null +++ b/CTGradient.xcodeproj/project.xcworkspace/xcshareddata/CTGradient.xccheckout @@ -0,0 +1,41 @@ + + + + + IDESourceControlProjectFavoriteDictionaryKey + + IDESourceControlProjectIdentifier + BBECC365-35CD-41BD-9026-CC7F66C5D7E6 + IDESourceControlProjectName + CTGradient + IDESourceControlProjectOriginsDictionary + + 34357E4B-D2EF-43BD-92F3-28DC0E83FD1D + ssh://github.com/Daij-Djan/CTGradient.git + + IDESourceControlProjectPath + CTGradient.xcodeproj/project.xcworkspace + IDESourceControlProjectRelativeInstallPathDictionary + + 34357E4B-D2EF-43BD-92F3-28DC0E83FD1D + ../.. + + IDESourceControlProjectURL + ssh://github.com/Daij-Djan/CTGradient.git + IDESourceControlProjectVersion + 110 + IDESourceControlProjectWCCIdentifier + 34357E4B-D2EF-43BD-92F3-28DC0E83FD1D + IDESourceControlProjectWCConfigurations + + + IDESourceControlRepositoryExtensionIdentifierKey + public.vcs.git + IDESourceControlWCCIdentifierKey + 34357E4B-D2EF-43BD-92F3-28DC0E83FD1D + IDESourceControlWCCName + CTGradient + + + + diff --git a/CTGradient.xcodeproj/project.xcworkspace/xcuserdata/dominik.xcuserdatad/UserInterfaceState.xcuserstate b/CTGradient.xcodeproj/project.xcworkspace/xcuserdata/dominik.xcuserdatad/UserInterfaceState.xcuserstate new file mode 100644 index 0000000000000000000000000000000000000000..861febee9ce2945feee4d2802a975a9decb49dca GIT binary patch literal 22693 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 WKC3t>W@ji${FICoKiz*TPW>M<_M77X literal 0 HcmV?d00001 diff --git a/CTGradient.xcodeproj/project.xcworkspace/xcuserdata/dominik.xcuserdatad/WorkspaceSettings.xcsettings b/CTGradient.xcodeproj/project.xcworkspace/xcuserdata/dominik.xcuserdatad/WorkspaceSettings.xcsettings new file mode 100644 index 0000000..bfffcfe --- /dev/null +++ b/CTGradient.xcodeproj/project.xcworkspace/xcuserdata/dominik.xcuserdatad/WorkspaceSettings.xcsettings @@ -0,0 +1,10 @@ + + + + + HasAskedToTakeAutomaticSnapshotBeforeSignificantChanges + + SnapshotAutomaticallyBeforeSignificantChanges + + + diff --git a/CTGradient.xcodeproj/xcuserdata/dominik.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist b/CTGradient.xcodeproj/xcuserdata/dominik.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist new file mode 100644 index 0000000..fe2b454 --- /dev/null +++ b/CTGradient.xcodeproj/xcuserdata/dominik.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist @@ -0,0 +1,5 @@ + + + diff --git a/CTGradient.xcodeproj/xcuserdata/dominik.xcuserdatad/xcschemes/CTGradient-IOS.xcscheme b/CTGradient.xcodeproj/xcuserdata/dominik.xcuserdatad/xcschemes/CTGradient-IOS.xcscheme new file mode 100644 index 0000000..7a1f55e --- /dev/null +++ b/CTGradient.xcodeproj/xcuserdata/dominik.xcuserdatad/xcschemes/CTGradient-IOS.xcscheme @@ -0,0 +1,86 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/CTGradient.xcodeproj/xcuserdata/dominik.xcuserdatad/xcschemes/CTGradient-OSX.xcscheme b/CTGradient.xcodeproj/xcuserdata/dominik.xcuserdatad/xcschemes/CTGradient-OSX.xcscheme new file mode 100644 index 0000000..71384f0 --- /dev/null +++ b/CTGradient.xcodeproj/xcuserdata/dominik.xcuserdatad/xcschemes/CTGradient-OSX.xcscheme @@ -0,0 +1,96 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/CTGradient.xcodeproj/xcuserdata/dominik.xcuserdatad/xcschemes/xcschememanagement.plist b/CTGradient.xcodeproj/xcuserdata/dominik.xcuserdatad/xcschemes/xcschememanagement.plist new file mode 100644 index 0000000..c8fc45f --- /dev/null +++ b/CTGradient.xcodeproj/xcuserdata/dominik.xcuserdatad/xcschemes/xcschememanagement.plist @@ -0,0 +1,47 @@ + + + + + SchemeUserState + + CTGradient-IOS.xcscheme + + orderHint + 1 + + CTGradient-OSX.xcscheme + + orderHint + 0 + + + SuppressBuildableAutocreation + + 8D1107260486CEB800E47090 + + primary + + + B427FBFC19158C3600077A59 + + primary + + + B427FC1D19158C3600077A59 + + primary + + + B427FC4919158F0E00077A59 + + primary + + + B427FC6E19158F0E00077A59 + + primary + + + + + diff --git a/CTGradientView.h b/CTGradientView.h index 58d1edd..0623ea9 100644 --- a/CTGradientView.h +++ b/CTGradientView.h @@ -6,19 +6,29 @@ // Some rights reserved: // +#if !__has_feature(objc_arc) +#error This class requires automatic reference counting +#endif + +#if TARGET_OS_IPHONE +#import +@class CTGradient; +#define View UIView +#define Rect CGRect +#define setNeedsDisplay [self setNeedsDisplay] +#else #import +#define View NSView +#define Rect NSRect +#define setNeedsDisplay [self setNeedsDisplay:YES] +#endif + #import "CTGradient.h" -@interface CTGradientView : NSView - { - CTGradient *myGradient; - - float angle; - bool isRadial; - } +@interface CTGradientView : View -- (IBAction)changeType :(id)sender; -- (IBAction)changeAngle:(id)sender; -- (IBAction)changeStyle:(id)sender; +@property(nonatomic, retain) CTGradient *gradient; +@property(nonatomic, assign) CGFloat angle; +@property(nonatomic, assign, getter = isRadial) BOOL radial; @end diff --git a/CTGradientView.m b/CTGradientView.m index 5401d9a..82e4241 100644 --- a/CTGradientView.m +++ b/CTGradientView.m @@ -10,93 +10,45 @@ @implementation CTGradientView -- (id)initWithFrame:(NSRect)frame { - self = [super initWithFrame:frame]; - if (self) - { - myGradient = [[CTGradient aquaSelectedGradient] retain]; - - angle = 90; - isRadial = NO; - } - return self; +- (id)initWithFrame:(Rect)frame { + self = [super initWithFrame:frame]; + if (self) { + _gradient = [CTGradient rainbowGradient]; + _angle = 90; + _radial = NO; + } + return self; } -- (void)dealloc - { - [myGradient release]; - [super dealloc]; - } - -- (bool)isOpaque - { - return NO; - } - -- (void)drawRect:(NSRect)rect - { - CTGradient *aGradient = [NSKeyedUnarchiver unarchiveObjectWithData:[NSKeyedArchiver archivedDataWithRootObject:myGradient]]; - - if(isRadial) - [aGradient radialFillRect:rect]; - else - [aGradient fillRect:rect angle:angle]; - //{ - //rect = NSMakeRect(346,-300,50,600); - //NSAffineTransform *transform = [[NSAffineTransform alloc] init]; - //[transform rotateByDegrees:45]; - //NSBezierPath *path = [transform transformBezierPath:[NSBezierPath bezierPathWithOvalInRect:rect]]; - //[aGradient fillBezierPath:path angle:angle]; - //} - } +#if TARGET_OS_IPHONE +#else +- (BOOL)isOpaque { + return NO; +} +#endif -- (IBAction)changeAngle:(id)sender - { - angle = 90.0 - [sender floatValue]; - - [self setNeedsDisplay:YES]; - } +- (void)drawRect:(Rect)rect { + if (self.isRadial) { + [self.gradient radialFillRect:rect]; + } + else { + [self.gradient fillRect:rect angle:self.angle]; + } +} -- (IBAction)changeType:(id)sender - { - if([[[sender selectedCell] title] isEqualToString:@"Axial"]) - isRadial = NO; - else - isRadial = YES; - - [self setNeedsDisplay:YES]; - } +- (void)setGradient:(CTGradient *)gradient { + _gradient = gradient; + setNeedsDisplay; +} -- (IBAction)changeStyle:(id)sender - { - [myGradient release]; - - switch([sender indexOfSelectedItem]) - { - case 1: myGradient = [CTGradient aquaSelectedGradient]; break; - case 2: myGradient = [CTGradient aquaNormalGradient ]; break; - case 3: myGradient = [CTGradient aquaPressedGradient ]; break; - case 4: myGradient = [CTGradient unifiedSelectedGradient]; break; - case 5: myGradient = [CTGradient unifiedNormalGradient ]; break; - case 6: myGradient = [CTGradient unifiedPressedGradient ]; break; - case 7: myGradient = [CTGradient unifiedDarkGradient ]; break; - case 8: myGradient = [CTGradient sourceListSelectedGradient ]; break; - case 9: myGradient = [CTGradient sourceListUnselectedGradient]; break; - case 10: myGradient = [CTGradient rainbowGradient]; break; - case 11: myGradient = [CTGradient hydrogenSpectrumGradient]; break; - - default: myGradient = [CTGradient gradientWithBeginningColor:[NSColor blackColor] - endingColor:[NSColor whiteColor]]; - } - - [myGradient retain]; - - [self setNeedsDisplay:YES]; - } +- (void)setAngle:(CGFloat)angle { + _angle = angle; + setNeedsDisplay; +} -- (void)windowWillClose:(NSNotification *)aNotification - { - [NSApp terminate:self]; - } +- (void)setRadial:(BOOL)radial { + _radial = radial; + setNeedsDisplay; +} @end diff --git a/English.lproj/InfoPlist.strings b/English.lproj/InfoPlist.strings deleted file mode 100644 index d2170dabeb23e068512bca32e1421e93db06f400..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 208 zcmZvW%?`m}5Jk`0Q#4(6fmqmxRW~GJ!NR&|Y3NT{B)pNA#A(+u$v5}AbLV6}Uq(a( ztf)AUa3$wO%2DrOZ)kNYN_$|>e3$+*^^m&Hx7>6urk{N(k~y%}Y*}!pkXy2Gp2$tu nyOk14sNHDfpE&o7xt#Ft - - - - IBDocumentLocation - 154 178 356 240 0 0 1440 878 - IBEditorPositions - - 29 - 110 299 291 44 0 0 1440 878 - - IBFramework Version - 446.1 - IBOpenObjects - - 214 - 209 - 29 - - IBSystem Version - 8L2127 - - diff --git a/English.lproj/MainMenu.nib/keyedobjects.nib b/English.lproj/MainMenu.nib/keyedobjects.nib deleted file mode 100644 index 1174aba127275b00b48a0851828dbdd3b284ec13..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 22247 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 aPsi;}OegyNN_Y|C{^aO)FI&Ajh5dgZEaZj& diff --git a/TieDye.icns b/TieDye.icns deleted file mode 100644 index 40d5d8b75f1dbe72760a68a53266ab32e5cf04b1..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 42317 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 From 122565f24acdc856c00849c0db217bd8e34a80e8 Mon Sep 17 00:00:00 2001 From: Dominik Pich Date: Sat, 3 May 2014 23:29:23 +0200 Subject: [PATCH 2/3] Create README.md --- README.md | 6 ++++++ 1 file changed, 6 insertions(+) create mode 100644 README.md diff --git a/README.md b/README.md new file mode 100644 index 0000000..9d18f60 --- /dev/null +++ b/README.md @@ -0,0 +1,6 @@ +CTGradient +========== + +fork that does ios & osx + +also features arc support, some style improvments AND two demos From 7f2d280372e3bfad7c297f729669f937956bee9b Mon Sep 17 00:00:00 2001 From: Dominik Pich Date: Sat, 3 May 2014 23:35:49 +0200 Subject: [PATCH 3/3] fixed analyzer warning --- CTGradient.m | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/CTGradient.m b/CTGradient.m index 6482573..aecff8d 100755 --- a/CTGradient.m +++ b/CTGradient.m @@ -49,12 +49,12 @@ - (void)_commonInit { - (void)dealloc { CGFunctionRelease(gradientFunction); - CTGradientElement *elementToRemove = elementList; - while (elementList != nil) { - elementToRemove = elementList; - elementList = elementList->nextElement; - free(elementToRemove); - } + CTGradientElement *elementToRemove; + while (elementList != nil) { + elementToRemove = elementList; + elementList = elementList->nextElement; + free(elementToRemove); + } } - (id)copyWithZone:(NSZone *)zone { @@ -1157,7 +1157,7 @@ void inverseChromaticEvaluation(void *info, const CGFloat *in, CGFloat *out) { } void transformRGB_HSV(CGFloat *components) { //H,S,B -> R,G,B - CGFloat H, S, V; + CGFloat H=0, S=0, V=0; CGFloat R = components[0], G = components[1], B = components[2];