Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Browse files

merging rentzsch, re-adding the CTFURLConnection files

  • Loading branch information...
commit 1052b175efe705d398c735d52f37e1db647d60a5 2 parents d2047e3 + 4ec7893
Simone Manganelli authored
View
52 ClickToFlash.xcodeproj/project.pbxproj
@@ -45,6 +45,7 @@
6953E4360F3EDE9D0014ECF7 /* CTFMenubarMenuController.m in Sources */ = {isa = PBXBuildFile; fileRef = 6953E4340F3EDE9D0014ECF7 /* CTFMenubarMenuController.m */; };
6953E43C0F3EDEB50014ECF7 /* MenubarMenu.xib in Resources */ = {isa = PBXBuildFile; fileRef = 6953E43A0F3EDEB50014ECF7 /* MenubarMenu.xib */; };
69A26D0C0F302C10006648BC /* NSBezierPath-RoundedRectangle.m in Sources */ = {isa = PBXBuildFile; fileRef = 69A26D0B0F302C10006648BC /* NSBezierPath-RoundedRectangle.m */; };
+ 79166CBD0FF69E1800B1F69B /* CTGradient.m in Sources */ = {isa = PBXBuildFile; fileRef = 79166CBB0FF69E1800B1F69B /* CTGradient.m */; };
79A21C4D0F30B735009424B8 /* CTFWhitelistWindowController.m in Sources */ = {isa = PBXBuildFile; fileRef = 79A21C490F30B735009424B8 /* CTFWhitelistWindowController.m */; };
79C040700FF1CCE6002DA6A5 /* Sparkle.framework in CopyFiles */ = {isa = PBXBuildFile; fileRef = 79A060EB0FF1CBF50035F03A /* Sparkle.framework */; };
79E2EB930F86AAD3005CF170 /* SparkleManager.m in Sources */ = {isa = PBXBuildFile; fileRef = 79E2EB920F86AAD3005CF170 /* SparkleManager.m */; };
@@ -52,7 +53,7 @@
845704550F4792320017F3F4 /* CTFWhitelist.m in Sources */ = {isa = PBXBuildFile; fileRef = 845704540F4792320017F3F4 /* CTFWhitelist.m */; };
8457045A0F47BC170017F3F4 /* CTFUtilities.m in Sources */ = {isa = PBXBuildFile; fileRef = 845704590F47BC170017F3F4 /* CTFUtilities.m */; };
A494CC2C0F9F2446007D5EEB /* ctf.icns in Resources */ = {isa = PBXBuildFile; fileRef = A494CC2B0F9F2446007D5EEB /* ctf.icns */; };
- A4CB75010FFA209300CC819F /* CTFURLConnection.m in Sources */ = {isa = PBXBuildFile; fileRef = A4CB75000FFA209300CC819F /* CTFURLConnection.m */; };
+ A4CB766F0FFB041500CC819F /* CTFURLConnection.m in Sources */ = {isa = PBXBuildFile; fileRef = A4CB766D0FFB041500CC819F /* CTFURLConnection.m */; };
A4DEFC7A0FF33F7400CCB6A8 /* CTFPreferencesDictionary.m in Sources */ = {isa = PBXBuildFile; fileRef = A4DEFC770FF33F7400CCB6A8 /* CTFPreferencesDictionary.m */; };
A4DEFC7B0FF33F7400CCB6A8 /* CTFUserDefaultsController.m in Sources */ = {isa = PBXBuildFile; fileRef = A4DEFC790FF33F7400CCB6A8 /* CTFUserDefaultsController.m */; };
D9566D8C0F380C9F00358646 /* sifr2-addons.js in Resources */ = {isa = PBXBuildFile; fileRef = D9566C2C0F37EA0800358646 /* sifr2-addons.js */; };
@@ -142,6 +143,8 @@
6953E43B0F3EDEB50014ECF7 /* English */ = {isa = PBXFileReference; lastKnownFileType = file.xib; name = English; path = Plugin/English.lproj/MenubarMenu.xib; sourceTree = "<group>"; };
69A26D0A0F302C10006648BC /* NSBezierPath-RoundedRectangle.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = "NSBezierPath-RoundedRectangle.h"; path = "Plugin/NSBezierPath-RoundedRectangle.h"; sourceTree = "<group>"; };
69A26D0B0F302C10006648BC /* NSBezierPath-RoundedRectangle.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = "NSBezierPath-RoundedRectangle.m"; path = "Plugin/NSBezierPath-RoundedRectangle.m"; sourceTree = "<group>"; };
+ 79166CBB0FF69E1800B1F69B /* CTGradient.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = CTGradient.m; path = Plugin/CTGradient.m; sourceTree = "<group>"; };
+ 79166CBC0FF69E1800B1F69B /* CTGradient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = CTGradient.h; path = Plugin/CTGradient.h; sourceTree = "<group>"; };
79475E0C0F658D9A00FD82E3 /* Sparkle.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = Sparkle.xcodeproj; path = Plugin/Sparkle/Sparkle.xcodeproj; sourceTree = "<group>"; };
79A21C490F30B735009424B8 /* CTFWhitelistWindowController.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = CTFWhitelistWindowController.m; path = Plugin/CTFWhitelistWindowController.m; sourceTree = "<group>"; };
79A21C4A0F30B735009424B8 /* CTFWhitelistWindowController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = CTFWhitelistWindowController.h; path = Plugin/CTFWhitelistWindowController.h; sourceTree = "<group>"; };
@@ -154,8 +157,8 @@
845704580F47BC170017F3F4 /* CTFUtilities.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = CTFUtilities.h; path = Plugin/CTFUtilities.h; sourceTree = "<group>"; };
845704590F47BC170017F3F4 /* CTFUtilities.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = CTFUtilities.m; path = Plugin/CTFUtilities.m; sourceTree = "<group>"; };
A494CC2B0F9F2446007D5EEB /* ctf.icns */ = {isa = PBXFileReference; lastKnownFileType = image.icns; name = ctf.icns; path = Plugin/ctf.icns; sourceTree = "<group>"; };
- A4CB74FF0FFA209300CC819F /* CTFURLConnection.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = CTFURLConnection.h; path = Plugin/CTFURLConnection.h; sourceTree = "<group>"; };
- A4CB75000FFA209300CC819F /* CTFURLConnection.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = CTFURLConnection.m; path = Plugin/CTFURLConnection.m; sourceTree = "<group>"; };
+ A4CB766D0FFB041500CC819F /* CTFURLConnection.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = CTFURLConnection.m; path = Plugin/CTFURLConnection.m; sourceTree = "<group>"; };
+ A4CB766E0FFB041500CC819F /* CTFURLConnection.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = CTFURLConnection.h; path = Plugin/CTFURLConnection.h; sourceTree = "<group>"; };
A4DEFC760FF33F7400CCB6A8 /* CTFPreferencesDictionary.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = CTFPreferencesDictionary.h; path = Plugin/CTFPreferencesDictionary.h; sourceTree = "<group>"; };
A4DEFC770FF33F7400CCB6A8 /* CTFPreferencesDictionary.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = CTFPreferencesDictionary.m; path = Plugin/CTFPreferencesDictionary.m; sourceTree = "<group>"; };
A4DEFC780FF33F7400CCB6A8 /* CTFUserDefaultsController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = CTFUserDefaultsController.h; path = Plugin/CTFUserDefaultsController.h; sourceTree = "<group>"; };
@@ -202,14 +205,14 @@
children = (
55EB703D0E04A84F0016593D /* Plugin.m */,
55EB703C0E04A84F0016593D /* Plugin.h */,
- A4DEFC760FF33F7400CCB6A8 /* CTFPreferencesDictionary.h */,
A4DEFC770FF33F7400CCB6A8 /* CTFPreferencesDictionary.m */,
- A4DEFC780FF33F7400CCB6A8 /* CTFUserDefaultsController.h */,
+ A4DEFC760FF33F7400CCB6A8 /* CTFPreferencesDictionary.h */,
A4DEFC790FF33F7400CCB6A8 /* CTFUserDefaultsController.m */,
- A4CB74FF0FFA209300CC819F /* CTFURLConnection.h */,
- A4CB75000FFA209300CC819F /* CTFURLConnection.m */,
- 845704580F47BC170017F3F4 /* CTFUtilities.h */,
+ A4DEFC780FF33F7400CCB6A8 /* CTFUserDefaultsController.h */,
+ A4CB766D0FFB041500CC819F /* CTFURLConnection.m */,
+ A4CB766E0FFB041500CC819F /* CTFURLConnection.h */,
845704590F47BC170017F3F4 /* CTFUtilities.m */,
+ 845704580F47BC170017F3F4 /* CTFUtilities.h */,
6953E4340F3EDE9D0014ECF7 /* CTFMenubarMenuController.m */,
6953E4350F3EDE9D0014ECF7 /* CTFMenubarMenuController.h */,
844695910F46FC6600DC783A /* CTFsIFRSupport.m */,
@@ -218,20 +221,16 @@
845704530F4792320017F3F4 /* CTFWhitelist.h */,
79A21C490F30B735009424B8 /* CTFWhitelistWindowController.m */,
79A21C4A0F30B735009424B8 /* CTFWhitelistWindowController.h */,
- 69A26D0B0F302C10006648BC /* NSBezierPath-RoundedRectangle.m */,
- 69A26D0A0F302C10006648BC /* NSBezierPath-RoundedRectangle.h */,
+ 79E2EB920F86AAD3005CF170 /* SparkleManager.m */,
+ 79E2EB910F86AAD3005CF170 /* SparkleManager.h */,
+ D9FFA7650F3941C1008A8708 /* ClickToFlash_Prefix.pch */,
+ 79166CBF0FF69E2900B1F69B /* 10.4 Support */,
55EB70610E04A8D00016593D /* Info-Plugin.plist */,
6953E43A0F3EDEB50014ECF7 /* MenubarMenu.xib */,
072189BA0F30D9C3008C8944 /* ContextualMenu.xib */,
072189BC0F30D9C3008C8944 /* WhitelistPanel.xib */,
- D9FFA7650F3941C1008A8708 /* ClickToFlash_Prefix.pch */,
A494CC2B0F9F2446007D5EEB /* ctf.icns */,
- 00FBE92E0FCD68CE00BC0995 /* NSActionTemplate.png */,
D9566C2B0F37EA0800358646 /* deSIFR Resources */,
- 79E2EB910F86AAD3005CF170 /* SparkleManager.h */,
- 79E2EB920F86AAD3005CF170 /* SparkleManager.m */,
- 0038DE220FC0CCF0007B54E9 /* MATrackingArea.h */,
- 0038DE230FC0CCF0007B54E9 /* MATrackingArea.m */,
);
name = Plugin;
sourceTree = "<group>";
@@ -246,6 +245,20 @@
name = Frameworks;
sourceTree = "<group>";
};
+ 79166CBF0FF69E2900B1F69B /* 10.4 Support */ = {
+ isa = PBXGroup;
+ children = (
+ 69A26D0B0F302C10006648BC /* NSBezierPath-RoundedRectangle.m */,
+ 69A26D0A0F302C10006648BC /* NSBezierPath-RoundedRectangle.h */,
+ 0038DE230FC0CCF0007B54E9 /* MATrackingArea.m */,
+ 0038DE220FC0CCF0007B54E9 /* MATrackingArea.h */,
+ 79166CBB0FF69E1800B1F69B /* CTGradient.m */,
+ 79166CBC0FF69E1800B1F69B /* CTGradient.h */,
+ 00FBE92E0FCD68CE00BC0995 /* NSActionTemplate.png */,
+ );
+ name = "10.4 Support";
+ sourceTree = "<group>";
+ };
79A060E40FF1CBF50035F03A /* Products */ = {
isa = PBXGroup;
children = (
@@ -408,7 +421,8 @@
0038DE240FC0CCF0007B54E9 /* MATrackingArea.m in Sources */,
A4DEFC7A0FF33F7400CCB6A8 /* CTFPreferencesDictionary.m in Sources */,
A4DEFC7B0FF33F7400CCB6A8 /* CTFUserDefaultsController.m in Sources */,
- A4CB75010FFA209300CC819F /* CTFURLConnection.m in Sources */,
+ 79166CBD0FF69E1800B1F69B /* CTGradient.m in Sources */,
+ A4CB766F0FFB041500CC819F /* CTFURLConnection.m in Sources */,
);
runOnlyForDeploymentPostprocessing = 0;
};
@@ -481,7 +495,7 @@
GCC_TREAT_WARNINGS_AS_ERRORS = YES;
GCC_WARN_ABOUT_MISSING_PROTOTYPES = YES;
GCC_WARN_SIGN_COMPARE = YES;
- PRODUCT_VERSION = 1.5b3;
+ PRODUCT_VERSION = 1.5b4;
WARNING_CFLAGS = "-Wall";
};
name = Debug;
@@ -493,7 +507,7 @@
GCC_TREAT_WARNINGS_AS_ERRORS = YES;
GCC_WARN_ABOUT_MISSING_PROTOTYPES = YES;
GCC_WARN_SIGN_COMPARE = YES;
- PRODUCT_VERSION = 1.5b3;
+ PRODUCT_VERSION = 1.5b4;
WARNING_CFLAGS = "-Wall";
};
name = Release;
View
73 Plugin/CTGradient.h
@@ -0,0 +1,73 @@
+//
+// CTGradient.h
+//
+// Created by Chad Weider on 2/14/07.
+// Writtin by Chad Weider.
+//
+// Released into public domain on 4/10/08.
+//
+// Version: 1.8
+
+#import <Cocoa/Cocoa.h>
+
+typedef struct _CTGradientElement
+ {
+ CGFloat red, green, blue, alpha;
+ CGFloat position;
+
+ struct _CTGradientElement *nextElement;
+ } CTGradientElement;
+
+typedef enum _CTBlendingMode
+ {
+ CTLinearBlendingMode,
+ CTChromaticBlendingMode,
+ CTInverseChromaticBlendingMode
+ } CTGradientBlendingMode;
+
+
+@interface CTGradient : NSObject <NSCopying, NSCoding>
+ {
+ CTGradientElement* elementList;
+ CTGradientBlendingMode blendingMode;
+
+ CGFunctionRef gradientFunction;
+ }
+
++ (id)gradientWithBeginningColor:(NSColor *)begin endingColor:(NSColor *)end;
+
++ (id)aquaSelectedGradient;
++ (id)aquaNormalGradient;
++ (id)aquaPressedGradient;
+
++ (id)unifiedSelectedGradient;
++ (id)unifiedNormalGradient;
++ (id)unifiedPressedGradient;
++ (id)unifiedDarkGradient;
+
++ (id)sourceListSelectedGradient;
++ (id)sourceListUnselectedGradient;
+
++ (id)rainbowGradient;
++ (id)hydrogenSpectrumGradient;
+
+- (CTGradient *)gradientWithAlphaComponent:(float)alpha;
+
+- (CTGradient *)addColorStop:(NSColor *)color atPosition:(float)position; //positions given relative to [0,1]
+- (CTGradient *)removeColorStopAtIndex:(unsigned)index;
+- (CTGradient *)removeColorStopAtPosition:(float)position;
+
+- (CTGradientBlendingMode)blendingMode;
+- (NSColor *)colorStopAtIndex:(unsigned)index;
+- (NSColor *)colorAtPosition:(float)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;
+
+@end
View
1,272 Plugin/CTGradient.m
@@ -0,0 +1,1272 @@
+//
+// CTGradient.m
+//
+// Created by Chad Weider on 2/14/07.
+// Writtin by Chad Weider.
+//
+// Released into public domain on 4/10/08.
+//
+// Version: 1.8
+
+#import "CTGradient.h"
+
+@interface CTGradient (Private)
+- (void)_commonInit;
+- (void)setBlendingMode:(CTGradientBlendingMode)mode;
+- (void)addElement:(CTGradientElement*)newElement;
+
+- (CTGradientElement *)elementAtIndex:(unsigned)index;
+
+- (CTGradientElement)removeElementAtIndex:(unsigned)index;
+- (CTGradientElement)removeElementAtPosition:(float)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);
+
+
+@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);
+ }
+
+ [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;
+ }
+
+ [copy setBlendingMode:blendingMode];
+
+ return copy;
+ }
+
+- (void)encodeWithCoder:(NSCoder *)coder
+ {
+ if([coder allowsKeyedCoding])
+ {
+ unsigned count = 0;
+ 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++;
+ currentElement = currentElement->nextElement;
+ }
+ [coder encodeInt:count forKey:@"CTGradientElementCount"];
+ [coder encodeInt: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];
+ }
+ 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];
+ }
+
+ [newInstance setBlendingMode:CTChromaticBlendingMode];
+
+ return [newInstance autorelease];
+ }
+
+#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;
+ }
+
+ return [newInstance autorelease];
+ }
+
+- (CTGradient *)gradientWithBlendingMode:(CTGradientBlendingMode)mode
+ {
+ CTGradient *newGradient = [self copy];
+
+ [newGradient setBlendingMode:mode];
+
+ return [newGradient autorelease];
+ }
+
+
+//Adds a color stop with <color> at <position> 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];
+ }
+
+
+//Removes the color stop at <position> 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];
+ }
+#pragma mark -
+
+
+
+#pragma mark Information
+- (CTGradientBlendingMode)blendingMode
+ {
+ return blendingMode;
+ }
+
+//Returns color at <position> 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;
+ }
+
+
+ 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]];
+ }
+#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;
+ }
+ 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;
+ }
+
+ startPoint = CGPointMake(NSMidX(rect)-deltax, NSMidY(rect)-deltay);
+ endPoint = CGPointMake(NSMidX(rect)+deltax, NSMidY(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;
+ }
+ else
+ {
+ scalex = 1;
+ transx = 1;
+ scaley = NSHeight(rect)/NSWidth(rect);
+ transy = (NSWidth(rect)-NSHeight(rect))/2;
+ endRadius = NSWidth(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];
+
+ [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];
+ [path addClip];
+ [self radialFillRect:[path bounds]];
+ [currentContext restoreGraphicsState];
+ }
+#pragma mark -
+
+
+
+#pragma mark Private Methods
+- (void)setBlendingMode:(CTGradientBlendingMode)mode;
+ {
+ blendingMode = mode;
+
+ //Choose what blending function to use
+ void *evaluationFunction = nil;
+ 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;
+ }
+ 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)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;
+
+ 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;
+
+ 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;
+ }
+
+ 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;
+ }
+
+ //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;
+ }
+
+ //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*
+//
+// For the chromatic blend we shift the hue of color1 to meet the hue of color2. To do
+// 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;
+ }
+
+ //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 -
+// 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;
+ }
+
+ //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 = 0,
+ S = 0,
+ V = 0;
+ 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)
+ H = NAN;
+ 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;
+ V = MAX;
+
+ components[0] = H;
+ components[1] = S;
+ components[2] = V;
+ }
+
+void transformHSV_RGB(float *components) //H,S,B -> R,G,B
+ {
+ float R = 0,
+ G = 0,
+ B = 0;
+ 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;
+ }
+
+ 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]))
+ color1[0] = color2[0] = 0;
+ else if(isnan(color1[0]))
+ color1[0] = color2[0];
+ else if(isnan(color2[0]))
+ color2[0] = color1[0];
+ }
+
+@end
View
140 Plugin/Plugin.m
@@ -35,6 +35,7 @@ of this software and associated documentation files (the "Software"), to deal
#import "CTFUtilities.h"
#import "CTFWhitelist.h"
#import "NSBezierPath-RoundedRectangle.h"
+#import "CTGradient.h"
#import "SparkleManager.h"
#define LOGGING_ENABLED 0
@@ -53,12 +54,6 @@ of this software and associated documentation files (the "Software"), to deal
BOOL usingMATrackingArea = NO;
-@interface NSBezierPath(MRGradientFill)
--(void)linearGradientFill:(NSRect)thisRect
- startColor:(NSColor *)startColor
- endColor:(NSColor *)endColor;
-@end
-
@interface CTFClickToFlashPlugin (Internal)
- (void) _convertTypesForFlashContainer;
- (void) _convertTypesForFlashContainerAfterDelay;
@@ -442,6 +437,7 @@ - (void) _addApplicationWhitelistToPrefsFile
@"com.riverfold.WiiTransfer",
@"com.bitcartel.pandorajam",
@"com.adobe.flexbuilder",
+ @"com.Zattoo.prefs",
nil];
[standardUserDefaults setObject:defaultWhitelist forKey:sApplicationWhitelist];
}
@@ -871,16 +867,16 @@ - (void) _drawBackground
}
else
{
- //tweak colors for better compatibility with linearGradientFill
- startingColor = [NSColor colorWithDeviceWhite:0.633 alpha:0.15];
- endingColor = [NSColor colorWithDeviceWhite:0.333 alpha:0.15];
- NSBezierPath *path = [NSBezierPath bezierPath];
-
- //Draw Gradient
- [path linearGradientFill:fillRect
- startColor:((mouseIsDown && mouseInside) ? endingColor : startingColor)
- endColor:((mouseIsDown && mouseInside) ? startingColor : endingColor)];
- [path stroke];
+ //tweak the opacity of the endingColor for compatibility with CTGradient
+ endingColor = [NSColor colorWithDeviceWhite:0.0 alpha:0.00];
+
+ gradient = [CTGradient gradientWithBeginningColor:startingColor
+ endingColor:endingColor];
+
+ //angle is reversed compared to NSGradient
+ [gradient fillBezierPath:[NSBezierPath bezierPathWithRect:fillRect] angle:-90.0 - ((mouseIsDown && mouseInside) ? 0.0 : 180.0)];
+
+ //CTGradient instances are returned autoreleased - no need for explicit release here
}
// Draw stroke
@@ -1443,116 +1439,4 @@ - (void)setLaunchedAppBundleIdentifier:(NSString *)newValue
[_launchedAppBundleIdentifier release];
_launchedAppBundleIdentifier = newValue;
}
-
-@end
-
-
-//### globals
-float start_red,
-start_green,
-start_blue,
-start_alpha;
-float end_red,
-end_green,
-end_blue,
-end_alpha;
-float d_red,
-d_green,
-d_blue,
-d_alpha;
-
-@implementation NSBezierPath(MRGradientFill)
-
-//typedef void (*CGFunctionEvaluateCallback)(void *info, const CGFloat *in, CGFloat *out);
-
-static void
-evaluate(void *info, const CGFloat *in, CGFloat *out)
-{
- // red
- *out++ = start_red + *in * d_red;
-
- // green
- *out++ = start_green + *in * d_green;
-
- // blue
- *out++ = start_blue + *in * d_blue;
-
- //alpha
- *out++ = start_alpha + *in * d_alpha;
-}
-
-float absDiff(float a, float b);
-float absDiff(float a, float b)
-{
- return (a < b) ? b-a : a-b;
-}
-
--(void)linearGradientFill:(NSRect)thisRect
- startColor:(NSColor *)startColor
- endColor:(NSColor *)endColor
-{
- CGColorSpaceRef colorspace = nil;
- CGShadingRef shading;
- static CGPoint startPoint = { 0, 0 };
- static CGPoint endPoint = { 0, 0 };
- //int k;
- CGFunctionRef function;
- //CGFunctionRef (*getFunction)(CGColorSpaceRef);
- //CGShadingRef (*getShading)(CGColorSpaceRef, CGFunctionRef);
-
- // get my context
- CGContextRef currentContext =
- (CGContextRef)[[NSGraphicsContext currentContext] graphicsPort];
-
-
- NSColor *s = [startColor colorUsingColorSpaceName:NSDeviceRGBColorSpace];
- NSColor *e = [endColor colorUsingColorSpaceName:NSDeviceRGBColorSpace];
-
- // set up colors for gradient
- start_red = [s redComponent];
- start_green = [s greenComponent];
- start_blue = [s blueComponent];
- start_alpha = [s alphaComponent];
-
- end_red = [e redComponent];
- end_green = [e greenComponent];
- end_blue = [e blueComponent];
- end_alpha = [e alphaComponent];
-
- d_red = absDiff(end_red, start_red);
- d_green = absDiff(end_green, start_green);
- d_blue = absDiff(end_blue, start_blue);
- d_alpha = absDiff(end_alpha ,start_alpha);
-
-
- // draw gradient
- colorspace = CGColorSpaceCreateDeviceRGB();
-
- size_t components;
- static const CGFloat domain[2] = { 0.0, 1.0 };
- static const CGFloat range[10] = { 0, 1, 0, 1, 0, 1, 0, 1, 0, 1 };
- static const CGFunctionCallbacks callbacks = { 0, &evaluate, NULL };
-
- components = 1 + CGColorSpaceGetNumberOfComponents(colorspace);
- function = CGFunctionCreate((void *)components, 1, domain, components,
- range, &callbacks);
-
- // function = getFunction(colorspace);
- startPoint.x = 0;
- startPoint.y = thisRect.origin.y;
- endPoint.x = 0;
- endPoint.y = NSMaxY(thisRect);
-
-
- shading = CGShadingCreateAxial(colorspace,
- startPoint, endPoint,
- function,
- NO, NO);
-
- CGContextDrawShading(currentContext, shading);
-
- CGFunctionRelease(function);
- CGShadingRelease(shading);
- CGColorSpaceRelease(colorspace);
-}
@end
View
12 README.markdown
@@ -24,6 +24,18 @@ To uninstall ClickToFlash: for versions 1.5b4 and later, go to the Settings wind
##Version History
+* **1.5b4** [download](http://s3.amazonaws.com/clicktoflash/ClickToFlash-1.5b4.zip)
+
+ * [NEW] "Play Fullscreen in QuickTime Player" contextual menu command for viewing YouTube videos in QuickTime Player (which has niceties like supporting the Apple remote). [bug 216](http://rentzsch.lighthouseapp.com/projects/24342/tickets/216) ([Simone Manganelli](http://github.com/simX/clicktoflash/commit/27dd7e5d64b5993fc492b06ec940d2820f323330))
+
+ * [NEW] Application-wide whitelisting for apps like Hulu Desktop, PandoraJam and Wii Transfer that utilize Flash. [bugs 26](http://rentzsch.lighthouseapp.com/projects/24342/tickets/216), [118](http://rentzsch.lighthouseapp.com/projects/24342/tickets/118) and [230](http://rentzsch.lighthouseapp.com/projects/24342/tickets/230) ([Simone Manganelli](http://github.com/simX/clicktoflash/commit/f2a1e755c78d6b1edd52b4bb85fb643eae3783c9))
+
+ * [NEW] User preferences now are stored in a separate file, allowing them to be shared across application. Parasitic prefs are migrated to the external file and then deleted. [bug 73](http://rentzsch.lighthouseapp.com/projects/24342/tickets/73) ([Simone Manganelli](http://github.com/simX/clicktoflash/commit/39a3ae3522e168e76f97511fa9623eff587d7580))
+
+ * [NEW] Uninstall button (with a confirmation sheet) in the settings window. [bug 226](http://rentzsch.lighthouseapp.com/projects/24342/tickets/226) ([Simone Manganelli](http://github.com/simX/clicktoflash/commit/7851b478da8ee0fa951362cd04853b035a46fb38))
+
+ * [NEW] Gradient on 10.4 now looks the same as 10.5 and 10.6. ([Kevin Hiscott](http://github.com/mbaltaks/clicktoflash/commit/566097de9e74610e7ae9819d020a404f1fc6223e))
+
* **1.5b3** [download](http://s3.amazonaws.com/clicktoflash/ClickToFlash-1.5b3.zip)
* [NEW] Additional executable architechure: `x86_64`. This addition enables ClickToFlash to work on Safari 4 on Mac OS X 10.6 Snow Leopard. ClickToFlash retains compatiblity with 10.4-and-later on both PowerPC and Intel (the full list: 10.4/ppc, 10.4/i386, 10.5/ppc, 10.5/i386 and 10.6/x86_64). ([rentzsch](http://github.com/rentzsch/clicktoflash/commit/1ea61443b8f6005dffb3d846c1ecc9eb41165472))
Please sign in to comment.
Something went wrong with that request. Please try again.