/*

  * Project:     RippleEffect

  * File:        AWRippler.m

  * Author:      Andrew Wellington

  *

  * License:

  * Copyright (C) 2005 Andrew Wellington.

  * All rights reserved.

  * 

  * Redistribution and use in source and binary forms, with or without

  * modification, are permitted provided that the following conditions are met:

  * 

  * 1. Redistributions of source code must retain the above copyright notice,

  * this list of conditions and the following disclaimer.

  * 2. Redistributions in binary form must reproduce the above copyright notice,

  * this list of conditions and the following disclaimer in the documentation

  * and/or other materials provided with the distribution.

  * 

  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR IMPLIED

  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO

  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;

  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,

  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR

  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF

  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

  */

 #import "AWRippler.h"

 #import <math.h>

 /* NSWindow Category for our bonus features */

 @interface NSWindow(AWRipplePrivate)

 - (int)windowNum;

 - (void)scaleX:(double)x Y:(double)y;

 @end

 @implementation NSWindow(AWRipplePrivate)

 - (int)windowNum

 {

     return _windowNum;

 }

 - (void)scaleX:(double)x Y:(double)y {

 	CGAffineTransform original;

 	NSPoint scalePoint;

 	NSRect screenFrame;

 	//NSLog(@"%@", NSStringFromRect(_frame));

 	NSPoint point = NSMakePoint(_frame.size.width / 2.0, _frame.size.height / 2.0);

 	if ([[NSScreen screens] count]) {

         screenFrame = [[[NSScreen screens] objectAtIndex:0] frame];

         scalePoint.x = _frame.origin.x + point.x;

         scalePoint.y = - ((_frame.origin.y + point.y) - screenFrame.size.height);

         original.a = 1.0 ; original.b = 0.0 ;

         original.c = 0.0 ; original.d = 1.0 ;

         original.tx = - _frame.origin.x ;

         original.ty = + _frame.origin.y + _frame.size.height - NSMaxY(screenFrame);

         original = CGAffineTransformTranslate(original, scalePoint.x, scalePoint.y);

         original = CGAffineTransformScale(original, x, y);

         original = CGAffineTransformTranslate(original, -scalePoint.x, -scalePoint.y);

         CGSSetWindowTransform(_CGSDefaultConnection(), _windowNum, original);

 	}

 }

 @end

 /* NSWindow Category implementation for easy rippling */

 @implementation NSWindow(AWRipple)

 - (void)ripple

 {

     AWRippler *rippler;

     rippler = [[AWRippler alloc] init];

     [rippler rippleWindow:self];

     [rippler release];

 }

 @end

 /* Interface for Core Image Core Graphics Server filter */

 @interface CICGSFilter : NSObject

 {

     void *_cid;

     unsigned int _filter_id;

 }

 + (id)filterWithFilter:(CIFilter *)filter connectionID:(CGSConnection)cid;

 - (id)initWithFilter:(CIFilter *)filter connectionID:(CGSConnection)cid;

 - (void)dealloc;

 - (void)setValue:(id)value forKey:(NSString *)key;

 - (void)setValuesForKeysWithDictionary:(NSDictionary *)dict;

 - (int)addToWindow:(CGSWindow)windowID flags:(unsigned int)flags;

 - (int)removeFromWindow:(CGSWindow)windowID;

 - (id)description;

 @end

 /* NSWindow subclass for our covering window */

 @interface AWRippleWindow : NSWindow {

 }

 @end

 @implementation AWRippleWindow

 - (id)initWithContentRect:(NSRect)contentRect styleMask:(unsigned int)aStyle backing:(NSBackingStoreType)bufferingType defer:(BOOL)flag {

 #pragma unused (aStyle, bufferingType, flag)

     NSWindow* result = [super initWithContentRect:contentRect styleMask:NSBorderlessWindowMask backing:NSBackingStoreBuffered defer:NO];

     [result setBackgroundColor: [NSColor clearColor]];

     [result setAlphaValue:1.0];

     [result setOpaque:NO];

     return result;

 }

 @end

 /* NSView subclass for our covering window */

 @interface AWRippleView : NSView {

 }

 @end

 @implementation AWRippleView

 -(void)drawRect:(NSRect)rect

 {

 #pragma unused (rect)

 	NSLog(@"%s", __FUNCTION__);	

 	[[NSColor clearColor] set];

     NSRectFill([self frame]);

 }

 @end

 /* CoreGraphics private stuff */

 extern CGSConnection _CGSDefaultConnection(void);

 /* The magic rippler class */

 @implementation AWRippler

 - (id)init

 {

     self = [super init];

     if (!self)

         return nil;

     win = nil;

 	startTime = 0;

 	aWindowID = 0;

 	rippleFilter = nil;

 	windowFilter = nil;

     return self;

 }

 - (void) rippleWindow:(NSWindow *)rippleWindow

 {

     CGSConnection cid = _CGSDefaultConnection();

     NSRect rect;

     NSRect rippleRect;

     NSRect screenRect;

     NSArray *screens;

     NSEnumerator *screenEnum;

     NSScreen *screen;

     if (!FLOAT_EQ(startTime, 0.0))

         return;

     rippleRect = [rippleWindow frame];

     ripplingWindow = [rippleWindow retain];

     /* create covering window */

     rect = NSMakeRect(0.0,0.0,0.0,0.0);

     screens = [NSScreen screens];

     screenEnum = [screens objectEnumerator];

     while ((screen = [screenEnum nextObject]))

     {

         rect = NSUnionRect(rect, [screen frame]);

     }

     win = [[AWRippleWindow alloc] initWithContentRect:rect

                                             styleMask:NSBorderlessWindowMask

                                               backing:NSBackingStoreNonretained

                                                 defer:NO];

 	[win setBackgroundColor:[NSColor clearColor]];

 	[win setOpaque:NO];

 	[win setHasShadow:NO];

 	[win setContentView:[[[AWRippleView alloc] initWithFrame:[win frame]] autorelease]];

 	[win orderFrontRegardless];

     [rippleWindow orderWindow:NSWindowAbove relativeTo:[win windowNum]];

     /* calculate the rectangle in the covering window */

     screenRect = [[[NSScreen screens] objectAtIndex:0] frame];

     rippleRect.origin.y = - (NSMaxY(rippleRect) - screenRect.size.height);

     /* create filter */

     rippleFilter = [[CIFilter filterWithName:@"CIShapedWaterRipple"] retain];

     [rippleFilter setDefaults];

     [rippleFilter setValue:[NSNumber numberWithFloat:40.0] forKey:@"inputCornerRadius"];

     [rippleFilter setValue:[CIVector vectorWithX:rippleRect.origin.x-40.0 Y:(rippleRect.origin.y - 40.0)] forKey:@"inputPoint0"];

     [rippleFilter setValue:[CIVector vectorWithX:(rippleRect.origin.x + rippleRect.size.width + 40.0) Y:(rippleRect.origin.y + rippleRect.size.height + 40.0)] forKey:@"inputPoint1"];

     [rippleFilter setValue:[NSNumber numberWithFloat:0.0] forKey:@"inputPhase"];

     windowFilter = [[CICGSFilter filterWithFilter:rippleFilter connectionID:cid] retain];

 	[windowFilter addToWindow:aWindowID flags:0x3001];    

     aWindowID = [win windowNum];

     [self retain];

     [NSThread detachNewThreadSelector:@selector(animationLoop:) toTarget:self withObject:self];

 }

 - (void)animationLoop:(id)sender

 {

 #pragma unused (sender)

     NSAutoreleasePool *pool;

 	CGSConnection cid = _CGSDefaultConnection();

     CICGSFilter *oldFilter = windowFilter;

     double scale;

     CFAbsoluteTime now;

     CGAffineTransform originalTransform;

     CGSGetWindowTransform(cid, [ripplingWindow windowNum], &originalTransform);

     pool = [[NSAutoreleasePool alloc] init];

     startTime = CFAbsoluteTimeGetCurrent();

     now = CFAbsoluteTimeGetCurrent();

     while (now < (startTime + 2.5) && (now >= startTime))

     {

         if (now - startTime < 1.5) {

             scale = 1.0 - exp(-2.4 * (now - startTime)) * sin(40.0/M_PI * (now - startTime)) * 0.15;

             //[ripplingWindow scaleX:scale Y:scale];

         }

         else

         {

             CGSSetWindowTransform(cid, [ripplingWindow windowNum], originalTransform);

         }

         [rippleFilter setValue:[NSNumber numberWithFloat:160*(now - startTime)] forKey:@"inputPhase"];

         windowFilter = [[CICGSFilter filterWithFilter:rippleFilter connectionID:cid] retain];

 		[windowFilter addToWindow:aWindowID flags:0x3001];

         [oldFilter removeFromWindow:aWindowID];

         now = CFAbsoluteTimeGetCurrent();

     }

     CGSSetWindowTransform(cid, [ripplingWindow windowNum], originalTransform);

     [windowFilter removeFromWindow:aWindowID];

     [rippleFilter release];

     [windowFilter release];

     [ripplingWindow release];

     [win orderOut: self];

     [win release];

     [pool release];

     startTime = 0.0;

 }

 @end