//

 //  GGBLayer.m

 //  GGB-iPhone

 //

 //  Created by Jens Alfke on 3/7/08.

 //  Copyright 2008 __MyCompanyName__. All rights reserved.

 //

 #import "GGBLayer.h"

 #import "QuartzUtils.h"

 #import "GGBUtils.h"

 NSString* const GGBLayerStyleChangedNotification = @"GGBLayerStyleChanged";

 @implementation GGBLayer

 - (NSString*) description

 {

     return [NSString stringWithFormat: @"%@[(%g,%g)]", self.class,self.position.x,self.position.y];

 }

 - (void) redisplayAll

 {

     [self setNeedsDisplay];

     for( CALayer *layer in self.sublayers )

         if( [layer isKindOfClass: [GGBLayer class]] )

             ((GGBLayer*)layer).redisplayAll;

         else

             [layer setNeedsDisplay];

 }

 /*

 - (void)addAnimation:(CAAnimation *)anim forKey:(NSString *)key 

 {

     NSLog(@"%@[%p] addAnimation: %p forKey: %@",[self class],self,anim,key);

     [super addAnimation: anim forKey: key];

 }

 */

 - (void) animateAndBlock: (NSString*)keyPath from: (id)from to: (id)to duration: (NSTimeInterval)duration

 {

     //WARNING: This code works, but is a mess. I hope to find a better way to do this. --Jens 3/16/08

     CABasicAnimation *anim = [CABasicAnimation animationWithKeyPath: keyPath];

     anim.duration= duration;

     anim.fromValue = from;

     anim.toValue = to;

     anim.removedOnCompletion = YES;

     anim.delegate = self;

     [self addAnimation:anim forKey: @"animateAndBlock:"];

     _curAnimation = (id)[self animationForKey: @"animateAndBlock:"];

     [self setValue: to forKeyPath: keyPath];    // animation doesn't update the property value

     if( self.presentationLayer ) {

         // Now wait for it to finish:

         while( _curAnimation ) {

             [[NSRunLoop currentRunLoop] runMode: NSDefaultRunLoopMode//NSEventTrackingRunLoopMode

                                      beforeDate: [NSDate dateWithTimeIntervalSinceNow: 0.1]];

         }

     } else {

         _curAnimation = nil;

     }

 }

 - (void)animationDidStop:(CAAnimation *)anim finished:(BOOL)flag

 {

     if( anim==_curAnimation ) {

         _curAnimation = nil;

     }

 }

 - (void) setStyle: (NSDictionary*)style

 {

     if( style != _styleDict ) {

         if( _styleDict )

             [[NSNotificationCenter defaultCenter] removeObserver: self 

                                                             name: GGBLayerStyleChangedNotification

                                                           object: _styleDict];

         if( style )

             [[NSNotificationCenter defaultCenter] addObserver: self selector: @selector(_styleChanged)

                                                          name: GGBLayerStyleChangedNotification

                                                        object: style];

         setObj(&_styleDict,style);

     }

     [super setStyle: style];

 }

 - (void) _styleChanged

 {

     // Reapply the style, so any changes in the dict will take effect.

     [super setStyle: _styleDict];

 }

 - (void) dealloc

 {

     if( _styleDict )

         [[NSNotificationCenter defaultCenter] removeObserver: self

                                                         name: GGBLayerStyleChangedNotification

                                                       object: _styleDict];

     [super dealloc];

 }

 - (void) setValue: (id)value ofStyleProperty: (NSString*)prop

 {

     if( _styleDict ) {

         id oldValue = [_styleDict objectForKey: prop];

         if( oldValue != value ) {

             if( value )

                 [_styleDict setObject: value forKey: prop];

             else

                 [_styleDict removeObjectForKey: prop];

             [[NSNotificationCenter defaultCenter] postNotificationName: GGBLayerStyleChangedNotification

                                                                 object: _styleDict];

         }

     } else

         [self setValue: value forKey: prop];

 }

 - (void) makeSublayersPerformSelector: (SEL)selector withObject: (id)object

 {

     for( GGBLayer *layer in self.sublayers ) {

         [layer performSelector: selector withObject: object withObject: nil];

         [layer makeSublayersPerformSelector: selector withObject: object];

     }

 }

 - (void) changedTransform

 {

     [self makeSublayersPerformSelector: @selector(aggregateTransformChanged) withObject: nil];

 }

 - (void) aggregateTransformChanged

 {

 }

 - (CATransform3D) aggregateTransform

 {

     CATransform3D xform = CATransform3DIdentity;

     for( CALayer *layer=self; layer; layer=layer.superlayer ) {

         xform = CATransform3DConcat(layer.transform,xform);

         xform = CATransform3DConcat(layer.sublayerTransform,xform);

     }

     return xform;

 }

 NSString* StringFromTransform3D( CATransform3D xform )

 {

     NSMutableString *str = [NSMutableString string];

     const CGFloat *np = (const CGFloat*)&xform;

     for( int i=0; i<16; i++ ) {

         if( i>0 && (i%4)==0 )

             [str appendString: @"\n"];

         [str appendFormat: @"%7.2f ", *np++];

     }

     return str;

 }

 #if TARGET_OS_IPHONE

 #pragma mark -

 #pragma mark IPHONE VERSION:

 - (id) copyWithZone: (NSZone*)zone

 {

     GGBLayer *clone = [[[self class] alloc] init];

     clone.bounds = self.bounds;

     clone.position = self.position;

     clone.zPosition = self.zPosition;

     clone.anchorPoint = self.anchorPoint;

     clone.transform = self.transform;

     clone.hidden = self.hidden;

     clone.doubleSided = self.doubleSided;

     clone.sublayerTransform = self.sublayerTransform;

     clone.masksToBounds = self.masksToBounds;

     clone.contents = self.contents;                 // doesn't copy contents (shallow-copy)

     clone.contentsRect = self.contentsRect;

     clone.contentsGravity = self.contentsGravity;

     clone.minificationFilter = self.minificationFilter;

     clone.magnificationFilter = self.magnificationFilter;

     clone.opaque = self.opaque;

     clone.needsDisplayOnBoundsChange = self.needsDisplayOnBoundsChange;

     clone.edgeAntialiasingMask = self.edgeAntialiasingMask;

     clone.backgroundColor = self.backgroundColor;

     clone.opacity = self.opacity;

     clone.compositingFilter = self.compositingFilter;

     clone.filters = self.filters;

     clone.backgroundFilters = self.backgroundFilters;

     clone.actions = self.actions;

     clone.name = self.name;

     clone.style = self.style;

     clone.cornerRadius = self.cornerRadius;

     clone.borderWidth = self.borderWidth;

     clone.borderColor = self.borderColor;

     for( GGBLayer *sublayer in self.sublayers ) {

         sublayer = [sublayer copyWithZone: zone];

         [clone addSublayer: sublayer];

     }

     return clone;

 }

 - (CGFloat) cornerRadius    {return _cornerRadius;}

 - (CGFloat) borderWidth     {return _borderWidth;}

 - (CGColorRef) backgroundColor {return _realBGColor;}

 - (CGColorRef) borderColor  {return _borderColor;}

 - (void) setCornerRadius: (CGFloat)r

 {

     if( r != _cornerRadius ) {

         _cornerRadius = r;

         [self setNeedsDisplay];

     }

 }

 - (void) setBorderWidth: (CGFloat)w

 {

     if( w != _borderWidth ) {

         _borderWidth = w;

         self.needsDisplayOnBoundsChange = (_borderWidth>0.0 && _borderColor!=NULL);

         [self setNeedsDisplay];

     }

 }

 - (void) setBackgroundColor: (CGColorRef)color

 {

     if( color != _realBGColor ) {

         CGColorRelease(_realBGColor);

         _realBGColor = CGColorRetain(color);

         [self setNeedsDisplay];

     }

 }

 - (void) setBorderColor: (CGColorRef)color

 {

     if( color != _borderColor ) {

         CGColorRelease(_borderColor);

         _borderColor = CGColorRetain(color);

         self.needsDisplayOnBoundsChange = (_borderWidth>0.0 && _borderColor!=NULL);

         [self setNeedsDisplay];

     }

 }

 - (void)drawInContext:(CGContextRef)ctx

 {

     [super drawInContext: ctx];

     CGContextSaveGState(ctx);

     if( _realBGColor ) {

         CGRect interior = CGRectInset(self.bounds, _borderWidth,_borderWidth);

         CGContextSetFillColorWithColor(ctx, _realBGColor);

         if( _cornerRadius <= 0.0 ) {

             CGContextFillRect(ctx,interior);

         } else {

             CGContextBeginPath(ctx);

             AddRoundRect(ctx,interior,_cornerRadius);

             CGContextFillPath(ctx);

         }

     }

     if( _borderWidth > 0.0 && _borderColor!=NULL ) {

         CGRect border = CGRectInset(self.bounds, _borderWidth/2.0, _borderWidth/2.0);

         CGContextSetStrokeColorWithColor(ctx, _borderColor);

         CGContextSetLineWidth(ctx, _borderWidth);

         if( _cornerRadius <= 0.0 ) {

             CGContextStrokeRect(ctx,border);

         } else {

             CGContextBeginPath(ctx);

             AddRoundRect(ctx,border,_cornerRadius);

             CGContextStrokePath(ctx);

         }

     }

     CGContextRestoreGState(ctx);

 }

 #else

 #pragma mark -

 #pragma mark MAC OS VERSION:

 - (id) copyWithZone: (NSZone*)zone

 {

     // NSLayer isn't copyable, but it is archivable. So create a copy by archiving to

     // a temporary data block, then unarchiving a new layer from that block.

     // One complication is that, due to a bug in Core Animation, CALayer can't archive

     // a pattern-based CGColor. So as a workaround, clear the background before archiving,

     // then restore it afterwards.

     // Also, archiving a CALayer with an image in it leaks memory. (Filed as rdar://5786865 )

     // As a workaround, clear the contents before archiving, then restore.

     CGColorRef bg = CGColorRetain(self.backgroundColor);

     self.backgroundColor = NULL;

     id contents = [self.contents retain];

     self.contents = nil;

     NSData *data = [NSKeyedArchiver archivedDataWithRootObject: self];

     self.backgroundColor = bg;

     self.contents = contents;

     GGBLayer *clone = [NSKeyedUnarchiver unarchiveObjectWithData: data];

     clone.backgroundColor = bg;

     clone.contents = contents;

     CGColorRelease(bg);

     [contents release];

     return [clone retain];

 }

 #endif

 @end

 #pragma mark -

 #pragma mark UTILITIES:

 void BeginDisableAnimations(void)

 {

     [CATransaction begin];

     [CATransaction setValue:(id)kCFBooleanTrue

                      forKey:kCATransactionDisableActions];

 }

 void EndDisableAnimations(void)

 {

     [CATransaction commit];

 } 

 void ChangeSuperlayer( CALayer *layer, CALayer *newSuperlayer, int index )

 {

     // Disable actions, else the layer will move to the wrong place and then back!

     [CATransaction flush];

     BeginDisableAnimations();

     CGPoint pos = layer.position;

     if( layer.superlayer )

         pos = [newSuperlayer convertPoint: pos fromLayer: layer.superlayer];

     [layer retain];

     [layer removeFromSuperlayer];

     layer.position = pos;

     if( index >= 0 )

         [newSuperlayer insertSublayer: layer atIndex: index];

     else

         [newSuperlayer addSublayer: layer];

     [layer release];

     EndDisableAnimations();

 }

 void RemoveImmediately( CALayer *layer )

 {

     [CATransaction flush];

     BeginDisableAnimations();

     [layer removeFromSuperlayer];

     EndDisableAnimations();

 }    

 CGColorRef GetEffectiveBackground( CALayer *layer )

 {

     for( ; layer; layer=layer.superlayer ) {

         CGColorRef bg = layer.backgroundColor;

         if( bg )

             return bg;

     }

     return nil;

 }