- (void)drawRect:(CGRect)rect 
{
		// Get the Render Context
	CGContextRef ctx = UIGraphicsGetCurrentContext();
 
	// Measure the font size, so the line fits the text.
	// Could be that "titleLabel" is something else in other classes like UILable, dont know.
	// So make sure you fix it here if you are enhancing UILabel or something else..
	CGSize fontSize =[self.titleLabel.text sizeWithFont:self.titleLabel.font 
											   forWidth:self.bounds.size.width
										  lineBreakMode:UILineBreakModeTailTruncation];
	// Get the fonts color. 
	const float * colors = CGColorGetComponents(self.titleLabel.textColor.CGColor);
	// Sets the color to draw the line
	CGContextSetRGBStrokeColor(ctx, colors[0], colors[1], colors[2], 1.0f); // Format : RGBA
 
	// Line Width : make thinner or bigger if you want
	CGContextSetLineWidth(ctx, 1.0f);
 
	// Calculate the starting point (left) and target (right)	
	float fontLeft = self.titleLabel.center.x - fontSize.width/2.0;
	float fontRight = self.titleLabel.center.x + fontSize.width/2.0;
 
	// Add Move Command to point the draw cursor to the starting point
	CGContextMoveToPoint(ctx, fontLeft, self.bounds.size.height - 1);
 
	// Add Command to draw a Line
	CGContextAddLineToPoint(ctx, fontRight, self.bounds.size.height - 1);
 
	// Actually draw the line.
	CGContextStrokePath(ctx);
 
	// should be nothing, but who knows...
	[super drawRect:rect];   
}

//////////////////////////////////////////////
// CLIENT SIDE CODE
//////////////////////////////////////////////
- (void)application:(UIApplication *)app didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)devToken 
{
    NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults];
 
    // to make sure your device will be just registered once, we store
    // the state in userDefaults.
 
    if ( ![userDefaults boolForKey:@"DeviceTokenRegistered"] )  //if ( null, nil or "false" )
    {
        [userDefaults setBool:YES forKey:@"DeviceTokenRegistered"]; 
        NSLog(@"Device Token: %@", devToken); // log the device token as ascii
 
        // send it somehow to your server - apple says the best way is to
        // send it as bytes : ( assuming you wrote a "sendProviderDeviceToken" method )
        [self sendProviderDeviceToken: [devToken bytes]];
    }
}
 
- (void) applicationDidFinishLaunching:(UIApplication*)application
{
    /*
    UIRemoteNotificationTypeNone
    UIRemoteNotificationTypeBadge
    UIRemoteNotificationTypeSound
    UIRemoteNotificationTypeAlert 
    */
    [[UIApplication sharedApplication] registerForRemoteNotificationTypes:(UIRemoteNotificationTypeBadge | UIRemoteNotificationTypeSound | UIRemoteNotificationTypeAlert)]; 
}

$ctx = stream_context_create(); 
//////////////////////////////////////////////
// SERVER SIDE CODE
//////////////////////////////////////////////
 
// send our authentification file
stream_context_set_option($ctx, 'ssl', 'local_cert', 'apns-dev.pem'); 
 
// open a connection to the sandbox server
$apnsConnection = stream_socket_client('ssl://gateway.sandbox.push.apple.com:2195', $err, $errstr, 60, STREAM_CLIENT_CONNECT, $ctx); 
 
// creating the notification message (256 Byte max)
 
// your device token here
$deviceToken = 'e6636942 e1d5cf29 924628c3 115004af 1caba414 d4e52098 023fef08 07954d6a'; 
 
// your message goes here
$message = "Your push notification text goes here.";
 
// define a sound file if you want here
$sound = 'mySoundFile.caf'; //name of the sound file inside the XCode project.
 
// Construct the notification payload
$body = array();
$body['aps'] = array('alert' => $message);
$badge = (int)$argv[2]; // a number which will be displayed over the apps icon
if ($badge)
{
  $body['aps']['badge'] = $badge;
}
if ($sound)
{
  $body['aps']['sound'] = $sound;
}
$payload = json_encode($body);
 
// remove blanks and pack it.
$msg = chr(0) . pack("n",32) . pack('H*', str_replace(' ', '', $deviceToken)) . pack("n",strlen($payload)) . $payload;
 
// push the message through APNS
fwrite($apnsConnection, $msg); 
 
//close APNS connection
fclose($apnsConnection);

Windows Registry Editor Version 5.00
 
[HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\8.0\NativeDE\StepOver]
"no boost"="boost\\:\\:.*=NoStepInto"
"no stl"="std\\:\\:.*=NoStepInto"

class my_singleton {
public:
  static my_singleton& instance() {
    static my_singleton instance;
    return instance;
  }
private:
  my_singleton() {};
  // since the destructor is also private we don't have to
  // declare the copy constructor as private but it underlines the idea.
  my_singleton( const my_singleton& );
  ~my_singleton() {};
};

template<class derived_T>
class singleton {
public:
  static derived_T& instance() {
    static derived_T instance;
    return instance;
  }
protected:
  singleton () {};
  singleton( const singleton& );
  ~singleton () {};
};
 
// example of an class using this pattern.
// we use CRTP to inherit from the singleton template.
class my_consumer : public singleton<my_consumer> {
  friend class singleton<my_consumer>;
public:
  void do_something_amazing() {};
private:
  my_consumer() {}
};

 
// -- header file 1
#include <singleton.hpp> // our singleton template
 
class database_connection_pool : public singleton<database_connection_pool> {
  friend class singleton<database_connection_pool>;
public: 
  shared_connection_type connect( const std::string& connection_string ) {
     // ...
  }
private:
  database_connection_pool() {}
};
 
// -- header file 2
#include <singleton.hpp> // our singleton template
#include "database_connection_pool.hpp"
 
class object_serializer : public singleton<object_serializer> {
  friend class singleton<object_serializer>;
public:
  template<class object_T>
  void serialize( const object_T& obj ) {
    database_connection_pool& db_pool = database_connection_pool::instance();    
    // ...
  }
 
private:
  object_serializer() {}
};

 
namespace policy {
  class no_dependency {
  };
 
  template<class dep1_T>
  class singleton_dependency {
  public:
    singleton_dependency() {
      dep1_T& dep1 = dep1_T::instance();
    }
  };
 
  template<class dep1_T, class dep2_T>
  class singleton_dependency_2 {
  public:
    singleton_dependency_2() {
      dep1_T& dep1 = dep1_T::instance();
      dep2_T& dep2 = dep2_T::instance();
    }
  };
}
 
template<class derived_T, class dependency_T = policy::no_dependency >
class singleton {
public:
  static derived_T& instance() {
    static dependency_T dependency;
    static derived_T instance;
    return instance;
  }
protected:
  singleton () {};
  singleton( const singleton& );
  ~singleton () {};
};

 
class call_before_test : public singleton<call_before_test> {
  friend class singleton<call_before_test>;
public:
  // ...
private:
  call_before_test() {
    std::cout << "before_test constructor called" << std::endl;
  }
};
 
class test : public singleton<test, policy::singleton_dependency<call_before_test> > {
  friend class singleton<test, policy::singleton_dependency<call_before_test> >;
public:
  // ...
private:
  test() {
    std::cout << "test constructor called" << std::endl;
  }
};
 
int main( int argc, char * argv[] ) {
  test::instance();
  return 0;
}

#include <iostream>
 
namespace policy {
	class no_dependency {
	};
 
	template<class dep1_T>
	class singleton_dependency {
	public:
		singleton_dependency() {
			dep1_T& dep1 = dep1_T::instance();
		}
	};
 
	template<class dep1_T, class dep2_T>
	class singleton_dependency_2 {
	public:
		singleton_dependency_2() {
			dep1_T& dep1 = dep1_T::instance();
			dep2_T& dep2 = dep2_T::instance();
		}
	};
}
 
template<class derived_T, class dependency_T = policy::no_dependency >
class singleton {
public:
	static derived_T& instance() {
		static dependency_T dependency;
		static derived_T instance;
		return instance;
	}
protected:
	singleton () {};
        singleton( const singleton& );
	~singleton () {};
};
 
class call_before_test : public singleton<call_before_test> {
	friend class singleton<call_before_test>;
public:
	// ...
private:
	call_before_test() {
		std::cout << "call_before_test constructor called" << std::endl;
	}
	~call_before_test() {
		std::cout << "call_before_test destructor called" << std::endl;
	}
};
 
class test : public singleton<test, policy::singleton_dependency<call_before_test> > {
	friend class singleton<test, policy::singleton_dependency<call_before_test> >;
public:
	// ...
private:
	test() {
		std::cout << "test constructor called" << std::endl;
	}
	~test() {
		std::cout << "test destructor called" << std::endl;
	}
};
 
int main( int argc, char * argv[] ) {
	test::instance();
	return 0;
}

// assuming we are implementing an update routine 
// for an extended CCSprite class, lets say: CCSpriteExt.m
-(void) onUpdate:(ccTime) delta
{
	for (CCNode * you in children)
	{
		if ( you == self) continue;
 
		if ( [self isCollidingWithObject:you] ) 
		{
			// collision detected !
			[collisionDelegate performSelector:collisionSelector withObject:self withObject:you];
		}
	}
}

// assuming we are implementing an udate routine in a CCScene or CCLayer class
..
for (int idxMe=0; idxMe < [children_ count]; idxMe++ )
{
	CCNode * me = (CCNode *) [children_ objectAtIndex:idxMe];
	for (int idxYou=idxMe+1; idxYou < [children_ count]; idxYou++ )
	{		
		CCNode * you = (CCNode *) [children_ objectAtIndex:idxYou];
 
		if ( [self isCollidingObject:Me WithObject:you] ) 
		{
			// collision detected !
			[collisionDelegate performSelector:collisionSelector withObject:me withObject:you];
		}
	}
}

// assuming we are implementing an udate routine in a CCScene or CCLayer class
..
for (int idxMe=0; idxMe < [children_ count]; idxMe++ )
{
	CCNode * meNode = (CCNode*) [children_ objectAtIndex:idxMe];
 
	if ( ! [meNode isKindOfClass:[CCSpriteExt class]] )
	{
		continue;
	}
 
	CCSpriteExt * me = (CCSpriteExt *) meNode;
 
	for (int idxYou=idxMe+1; idxYou < [children_ count]; idxYou++ )
	{		
		CCNode * youNode = (CCNode*) [children_ objectAtIndex:idxYou];
		if ( ! [youNode isKindOfClass:[CCSpriteExt class]] )
		{
			continue;
		}
 
		CCSpriteExt * you = (CCSpriteExt *) youNode;
 
		if ( (me.collisionID == you.collisionID) && 
		    [self isCollidingObject:Me WithObject:you] )
		{
			// collision detected !
			[collisionDelegate performSelector:collisionSelector withObject:me withObject:you];
		}
	}
}

-(BOOL) isCollidingObject:(CCSpriteExt*)obj1 WithObject:(CCSpriteExt*) obj2
{
	if ( obj1.collisionID == obj1.collisionID )
	{
		if ( obj1.collisionBodyType != obj2.collisionBodyType) 
		{
			// not supported yet.
			return NO;
		}
		switch (obj1.collisionBodyType )
		{
			case BOUNDING_BOX : 
			return [self isCollidingBox:obj1 WithBox:obj2]; 
 
			case BOUNDING_SPHERE :
			return [self isCollidingBox:obj1 WithBox:obj2] && // first boxed test!
			[self isCollidingSphere:obj1 WithSphere:obj2];
 
			case POLYGON : 
			return [self isCollidingBox:obj1 WithBox:obj2] && // first boxed test!
			[self isCollidingPolygon:obj1 WithPolygon:obj2];
 
			case PIXEL : 
			return [self isCollidingBox:obj1 WithBox:obj2] && // first boxed test!
			[self isCollidingPixel:obj1 WithPixel:obj2];
 
			default:
			// not supported type
			break;
		}
	}
	return NO;
}

-(BOOL) isCollidingBox : (CCSpriteExt *) obj1 WithBox: (CCSpriteExt *) obj2 
{	
	float dx = fabs(obj2.position.x - obj1.position.x);
	float dy = fabs(obj2.position.y - obj1.position.y);	
 
	float dx1;
	float dx2;
 
	if (obj2.position.x > obj1.position.x) 
	{
		dx1 = (1-obj1.collisionSprite.anchorPoint.x) * obj1.collisionSprite.contentSize.width * obj1.collisionSprite.scaleX;
		dx2 = obj2.collisionSprite.anchorPoint.x * obj2.collisionSprite.contentSize.width * obj2.collisionSprite.scaleX;
	}
	else 
	{
		dx1 = (obj1.collisionSprite.anchorPoint.x) *  obj1.collisionSprite.contentSize.width * obj1.collisionSprite.scaleX;
		dx2 = (1-obj2.collisionSprite.anchorPoint.x) *obj2.collisionSprite.contentSize.width * obj2.collisionSprite.scaleX;
	}
 
	float dy1;
	float dy2;
 
	if (obj2.position.y < obj1.position.y) 
	{
		dy1 = obj1.collisionSprite.anchorPoint.y * obj1.collisionSprite.contentSize.height * obj1.collisionSprite.scaleY;
		dy2 = (1 - obj2.collisionSprite.anchorPoint.y) * obj2.collisionSprite.contentSize.height * you.collisionSprite.scaleY;
	}
	else 
	{
		dy1 = (1 - obj1.collisionSprite.anchorPoint.y) * obj1.collisionSprite.contentSize.height * obj1.collisionSprite.scaleY;
		dy2 = (obj2.collisionSprite.anchorPoint.y) * obj2.collisionSprite.contentSize.height * obj2.collisionSprite.scaleY;
	}
 
	return !((dx > (dx1+dx2)) || (dy > (dy1+dy2)));
}

-(BOOL) isCollidingBox : (CCSpriteExt *) obj1 WithBox: (CCSpriteExt *) obj2 
{
	return !CGRectIsNull( CGRectIntersection(obj1.boundingBox, obj2.boundingBox) );	
}

-(BOOL) isCollidingSphere:(CCSpriteExt*) obj1 WithSphere:(CCSprite *) obj2
{
	float minDistance = object.radius + self.radius;
	float dx = obj2.position.x - obj1.position.x;
	float dy = obj2.position.y - obj1.position.y;
	if (! (dx > minDistance || dy > minDistance) )
	{
		float actualDistance = sqrt( dx * dx + dy * dy );
		return (actualDistance < = minDistance);
	}
	return NO;
}

//
//  CCCollisionBody.h
//
 
/**
 * collision body types
 * @version 1.0
 */
#define COLLISIONBODYTYPE_NONE		0
#define COLLISIONBODYTYPE_POINT		1
#define COLLISIONBODYTYPE_LINE		2
#define COLLISIONBODYTYPE_SPHERE	3
#define COLLISIONBODYTYPE_RECT		4
#define COLLISIONBODYTYPE_POLY		5
#define COLLISIONBODYTYPE_PIXEL		6
 
@class CCNode; // pre decleration of CCNode, import will be in .m file
/** 
 * A class to define the collision body for a proxy game object.
 * collisionbodys are classified by types. Not all types are yet defined to collide with each other.
 * please use sphere and rect collisionbodys only to ensure proper functionallity
 */
@interface CCCollisionBody : NSObject 
{
	CCNode * proxy; // proxy object 
	uint type; // defines the collision body type (see above)
	CGSize size; // if used by the type : defines the dimensions of the collision body.
	float radius; // if used by the type : defines the radial dimensions of the collision body.
	BOOL disabled; // if true the collions are deactivated otherwise collisions with this body will be checked.
	int collisionGroupID; // collision group ID - only objects of the same group IDs will collide
}
@property (nonatomic, assign) int collisionGroupID;
@property (nonatomic, assign) bool disabled;
@property (nonatomic, retain) CCNode * proxy;
@property (nonatomic, assign) uint type;
@property (nonatomic, assign) CGSize size;
@property (nonatomic, assign) float radius;
 
/**
 * creates a spherical collision body specified by a given radius and a proxy game object.
 */
-(id) initAsSphereWithProxy:(CCNode*) proxyObject Radius: (float) sphereRadius;
 
/**
 * creates a rectangle collision body specified by a given size and a proxy game object.
 */
-(id) initAsRectWithProxy:(CCNode*) proxyObject Size:(CGSize) rectSize;
 
/**
 * returns if a collision body collides with another collision body.
 * v1.0 only supports sphereical and rectangle collisionbodys.
 */
-(bool) collidesWith:(CollisionBody*) object;
 
@end

//
//  CollisionBody.m
//
 
#import "CCCollisionBody.h"
#import "cocos2d.h"
 
#pragma mark -
#pragma mark CCCollisionBody Implementation
@implementation CCCollisionBody
@synthesize radius, size, type, proxy, disabled, collisionGroupID;
 
#pragma mark -
#pragma mark Initialisierung
 
#pragma mark  
#pragma mark COLLISIONBODYTYPE_NONE : no collision
 
-(id) initWithProxy:(CCNode*) proxyObject
{
	self = [super init];
	if (self)
	{
		self.type = COLLISIONBODYTYPE_NONE;
		self.proxy = proxyObject;
	}
	return self;
}
 
#pragma mark  
#pragma mark COLLISIONBODYTYPE_RECT : bounding box
-(id) initAsRectWithProxy:(CCNode*) proxyObject Size:(CGSize) rectSize
{
	if ([self initWithProxy:proxyObject])
	{
		self.size = rectSize;
		self.type = COLLISIONBODYTYPE_RECT;
	}
	return self;
}
 
#pragma mark  
#pragma mark COLLISIONBODYTYPE_SPHERE : bounding sphere
-(id) initAsSphereWithProxy:(CCNode*) proxyObject Radius: (float) sphereRadius;
{
	if ([self initWithProxy:proxyObject])
	{
		self.radius = sphereRadius;
		self.type = COLLISIONBODYTYPE_SPHERE;
	}
	return self;
}
 
#pragma mark -
#pragma mark cleanup
 
-(void) dealloc
{
	self.proxy = nil;
	[super dealloc];
}
 
#pragma mark -
#pragma mark collision tests
 
#pragma mark  
#pragma mark Rect-Rect collision 
-(bool) isRectRectIntersection:(CollisionBody*) object
{
	return !CGRectIsNull( CGRectIntersection(proxy.boundingBox, object.proxy.boundingBox) );	
}
 
#pragma mark  
#pragma mark Sphere-Sphere collision 
-(bool) isSphereSphereIntersection:(CollisionBody*) object
{
	float minDistance = object.radius + self.radius;
	float dx = object.proxy.position.x - self.proxy.position.x;
	float dy = object.proxy.position.y - self.proxy.position.y;
	if (! (dx > minDistance || dy > minDistance) )
	{
		float actualDistance = sqrt( dx * dx + dy * dy );
		return (actualDistance < = minDistance);
	}
	return false;
}
 
 
 
#pragma mark  
#pragma mark main collision detection
-(bool) collidesWith:(CollisionBody*) object
{
	if (!self.disabled && !object.disabled && self.collisionGroupID == object.collisionGroupID)
	{
		if (self.type == COLLISIONBODYTYPE_RECT && object.type == COLLISIONBODYTYPE_RECT)
		{
			return [self isRectRectIntersection:object];
		}
 
		if (self.type == COLLISIONBODYTYPE_SPHERE && object.type == COLLISIONBODYTYPE_SPHERE)
		{
			return [self isSphereSphereIntersection:object];
		}
 
		// NOT SUPPORTED COLLISION TYPE!
	}
 
	return NO;
}
 
@end

CCSpriteFrameCache * cache = [CCSpriteFrameCache sharedSpriteFrameCache];
[cache addSpriteFramesWithFile:@"blob.plist"];
 
CCAnimation * animation = [[CCAnimation alloc] initWithName:@"idle" delay:1/24.0];
for ( int i=1; i < 25; ++i )
{
	// frame name format: blob_idle_01.png .. blob_idle_24.png
	NSString * fname = [NSString stringWithFormat:@"blob_idle_%02i.png", i];
	[animation addFrame:[cache spriteFrameByName: fname]];
}
CCSprite * blob = [CCSprite spriteWithSpriteFrameName:@"blob_idle_01.png"];
// deprecated since 0.9: CCSprite * blob = [cache createSpriteWithFrameName:@"blob_idle_01.png"];
id action = [CCRepeatForever actionWithAction:[CCAnimate actionWithAnimation:animation]];
[blob runAction:action];
 
// position our blob
blob.position = ccp( 160, 240 );
 
// add blob to scene ( self should be a visible CCLayer or CCScene )
[self addChild:blob];

#import "MyScene.h"
@implementation MyScene
-(void) onButton1Pressed:(id) sender
{
	// TODO: something phenomenal 
}
 
-(void) onButton2Pressed:(id) sender
{
	// TODO: something even more phenomenal 
}
 
-(void) setupMenu
{
	CCMenuItemImage * button1 = [CCMenuItemImage itemFromNormalImage:@"b1_up.png" selectedImage:@"b1_down.png" target:self selector:@selector(onButton1Pressed:)];
 
	CCMenuItemImage * button2 = [CCMenuItemImage itemFromNormalImage:@"b2_up.png" selectedImage:@"b2_down.png" disabledImage:"b2_disabled.png" target:self selector:@selector(onButton2Pressed:)];
}

#import "MyScene.h"
@implementation MyScene
-(void) onButton1Pressed:(id) sender
{
	// TODO: something phenomenal 
}
 
-(void) onButton2Pressed:(id) sender
{
	// TODO: something even more phenomenal 
}
 
-(void) setupMenu
{
	CCMenuItemImage * button1 = [CCMenuItemImage itemFromNormalImage:@"b1_up.png" selectedImage:@"b1_down.png" target:self selector:@selector(onButton1Pressed:)];
 
	CCMenuItemImage * button2 = [CCMenuItemImage itemFromNormalImage:@"b2_up.png" selectedImage:@"b2_down.png" disabledImage:"b2_disabled.png" target:self selector:@selector(onButton2Pressed:)];
 
	CCMenu * menu = [CCMenue menueWithItems:button1 , button2, nil]; // you have to terminate the list with nil
 
	menu.position = ccp ( 160, 240 );
	[menu alignItemsHorizontallyWithPadding:10.0f];
	[self addChild: menu];
}

//
//  CCRadioMenu.h
//  Cocos2d Version used: 0.9.0 alpha
//  Created by Hans Hamm on 24.11.09.  
//
 
#import "cocos2d.h"
 
 
@interface CCRadioMenu : CCMenu {
	int selectedItemIndex; // will be the current targeted item 
	int fallBackItemIndex; // will be our fall back item (previously selected one)
}
 
@property int selectedItemIndex;
 
-(CCMenuItem *) itemForTouch: (UITouch *) touch; // will retrieve the current item for the touch
 
@end

//
//  CCRadioMenu.m
// 
//  Cocos2d Version used: 0.9.0 alpha
//  Created by Hans Hamm on 24.11.09.  
//
 
#import "CCRadioMenu.h"
 
@implementation CCRadioMenu
 
@synthesize selectedItemIndex;
 
/**
 * will be called if a touch started.
 */
-(BOOL) ccTouchBegan:(UITouch *)touch withEvent:(UIEvent *)event
{
	if( state != kMenuStateWaiting ) return NO; // do not track events if menu is busy
 
	selectedItem = [self itemForTouch:touch]; // any of our items was selected?
 
	if( selectedItem ) // if one of our items was selected
	{
		[selectedItem selected]; // make it be selected
		state = kMenuStateTrackingTouch; // mark menu as busy
		return YES; // say : "yes, we want more events from this touch"
	}
	return NO; // none of our items was selected, so we dont want to hear from this touch event anymore
}
 
/**
 * will be called if a touch event ended.
 */
-(void) ccTouchEnded:(UITouch *)touch withEvent:(UIEvent *)event
{
	NSAssert(state == kMenuStateTrackingTouch, @"[Menu ccTouchEnded] -- invalid state");
 
	for( CCMenuItem* item in children ) // unselect all items
	{
		[item unselected];	
	}
 
	if (selectedItem) // if we have selected an item:
	{
		[selectedItem selected]; // make it selected
		[selectedItem activate]; // an execute it
		fallBackItemIndex = selectedItemIndex; // the new fall back item is the current target
	}
	else // there is none selected
	{
		self.selectedItemIndex = fallBackItemIndex; // so just fall back to the old one
	}	
 
	state = kMenuStateWaiting; // we are not busy anymore
}
 
/**
 * will be called if a touch event was canceled. Normaly the user dont want
 * to execute the last selected one, so just fall back to the old one here.
 */
-(void) ccTouchCancelled:(UITouch *)touch withEvent:(UIEvent *)event
{
	NSAssert(state == kMenuStateTrackingTouch, @"[Menu ccTouchCancelled] -- invalid state");
 
	for( CCMenuItem* item in children ) // unselect all items
	{
		[item unselected];	
	}
	// on cancel just fall back to the old one :
	self.selectedItemIndex = fallBackItemIndex;
 
	// we are not busy anymore
	state = kMenuStateWaiting;
}
 
/**
 * will be called if a touch event moved.
 */
-(void) ccTouchMoved:(UITouch *)touch withEvent:(UIEvent *)event
{
	NSAssert(state == kMenuStateTrackingTouch, @"[Menu ccTouchMoved] -- invalid state");
 
	// still one of our items selected?
	CCMenuItem * currentItem = [self itemForTouch:touch]; 
 
	// if not, what was the fallback item again?
	CCMenuItem * fallBackItem = (CCMenuItem *) [children objectAtIndex:fallBackItemIndex];
 
	// if the new selected item changed and is not our fallback item
	if (currentItem != selectedItem && currentItem != fallBackItem)
	{				
		[selectedItem unselected]; // unselect the previous one
		selectedItem = currentItem; // this is our new targeted one ( could be nil ! ) 
 
		if (selectedItem) // if there is a new one ( touch could be outside the menu )
		{		
			[selectedItem selected]; // select this new one
		}
		else // there is no new one, so just fall back to the old one
		{
			[[children objectAtIndex:fallBackItemIndex]selected];
		}
 
	}
}
 
/**
 * Returns the first menu item hit by a touch event.
 * Also we could update the selectedItemIndex here.
 */
-(CCMenuItem *) itemForTouch: (UITouch *) touch
{
	CGPoint touchLocation = [touch locationInView: [touch view]]; // touch location
	touchLocation = [[CCDirector sharedDirector] convertToGL: touchLocation]; // in gl coordinates
	int idx = -1; // helper variable to determine the index of the item ( 0 = first item )
 
	for( CCMenuItem* item in children ) 
	{
		idx++; // in first step this would be zero ( 0 )
 
		// convert the touch to the local coordinates of the current item
		// and check if the location is inside the rect of it
 
		CGPoint local = [item convertToNodeSpace:touchLocation]; 		
		CGRect r = [item rect];  
		r.origin = CGPointZero;
 
		if( CGRectContainsPoint( r, local ) ) // if touch is inside it
		{
			selectedItemIndex = idx;  // save the itemIndex and..
			return item;	 // .. return the item
		}
	}
 
	// we found not item hit by that touch:
	return nil;
}
 
/**
 * returns the current selected Item Index.
 */
-(int) selectedItemIndex
{
	return selectedItemIndex;
}
 
/**
 *  sets the current Selected Item Index ( but does not activate it )
 */
- (void)setSelectedItemIndex:(int) value 
{
	for( CCMenuItem* item in children )  // unselect all
	{
		[item unselected];	
	}
 
	selectedItemIndex = value;	// store new index
	selectedItem = [children objectAtIndex:selectedItemIndex]; // get the item for that index	
	fallBackItemIndex = selectedItemIndex; // store as fallBackIndex, too.	
	[selectedItem selected]; // mark as selected.
}
 
@end

menu.selectedItemIndex = 0; // first Item should be initially selected

#import "MyScene.h"
#import "CCRadioMenu.h"
 
@implementation MyScene
-(void) onButton1Pressed:(id) sender
{
	// TODO: something phenomenal 
}
 
-(void) onButton2Pressed:(id) sender
{
	// TODO: something even more phenomenal 
}
 
-(void) setupMenu
{
	CCMenuItemImage * button1 = [CCMenuItemImage itemFromNormalImage:@"b1_up.png" selectedImage:@"b1_down.png" target:self selector:@selector(onButton1Pressed:)];
 
	CCMenuItemImage * button2 = [CCMenuItemImage itemFromNormalImage:@"b2_up.png" selectedImage:@"b2_down.png" disabledImage:"b2_disabled.png" target:self selector:@selector(onButton2Pressed:)];
 
	CCRadioMenu * menu = [CCRadioMenu menueWithItems:button1 , button2, nil]; // you have to terminate the list with nil
 
	menu.selectedItemIndex = 0; // first Item should be initially selected
 
	menu.position = ccp ( 160, 240 );
	[menu alignItemsHorizontallyWithPadding:10.0f];
	[self addChild: menu];
}

#import "CCRadioMenu.h"
 
@implementation CCRadioMenu
 
@synthesize selectedItemIndex;
 
-(BOOL) ccTouchBegan:(UITouch *)touch withEvent:(UIEvent *)event
{
	if( state != kMenuStateWaiting ) return NO;
 
	selectedItem = [self itemForTouch:touch];
 
	if( selectedItem ) 
	{
		[selectedItem selected];
		state = kMenuStateTrackingTouch;
		return YES;
	}
	return NO;
}
 
-(void) ccTouchEnded:(UITouch *)touch withEvent:(UIEvent *)event
{
	NSAssert(state == kMenuStateTrackingTouch, @"[Menu ccTouchEnded] -- invalid state");
 
	for( CCMenuItem* item in children_ ) 
	{
		[item unselected];	
	}
 
	if (selectedItem)
	{
		[selectedItem selected];
		[selectedItem activate];
		fallBackItemIndex = selectedItemIndex;
	}
	else
	{
		self.selectedItemIndex = fallBackItemIndex;
	}	
 
	state = kMenuStateWaiting;
}
 
-(void) ccTouchCancelled:(UITouch *)touch withEvent:(UIEvent *)event
{
	NSAssert(state == kMenuStateTrackingTouch, @"[Menu ccTouchCancelled] -- invalid state");
 
	for( CCMenuItem* item in children_ ) 
	{
		[item unselected];	
	}
 
	self.selectedItemIndex = fallBackItemIndex;
 
	state = kMenuStateWaiting;
}
 
-(void) ccTouchMoved:(UITouch *)touch withEvent:(UIEvent *)event
{
	NSAssert(state == kMenuStateTrackingTouch, @"[Menu ccTouchMoved] -- invalid state");
 
	CCMenuItem * currentItem = [self itemForTouch:touch];
	CCMenuItem * fallBackItem = (CCMenuItem *) [children_ objectAtIndex:fallBackItemIndex];
	if (currentItem != selectedItem && currentItem != fallBackItem) 
	{				
		[selectedItem unselected];
		selectedItem = currentItem;
 
		if (selectedItem)
		{		
			[selectedItem selected];
		}
		else
		{
			[[children_ objectAtIndex:fallBackItemIndex]selected];
		}
 
	}
}
 
-(CCMenuItem *) itemForTouch: (UITouch *) touch
{
	CGPoint touchLocation = [touch locationInView: [touch view]];
	touchLocation = [[CCDirector sharedDirector] convertToGL: touchLocation];
	int idx = -1;
 
	for( CCMenuItem* item in children_ ) 
	{
		idx++;
		CGPoint local = [item convertToNodeSpace:touchLocation];
 
		CGRect r = [item rect];
		r.origin = CGPointZero;
 
		if( CGRectContainsPoint( r, local ) )
		{
			selectedItemIndex = idx;
			return item;
		}
	}
 
	return nil;
}
 
-(int) selectedItemIndex
{
	return selectedItemIndex;
}
 
- (void)setSelectedItemIndex:(int) value 
{
	for( CCMenuItem* item in children_ ) 
	{
		[item unselected];	
	}
 
	selectedItemIndex = value;	
	selectedItem = [children_ objectAtIndex:selectedItemIndex];
 
	fallBackItemIndex = selectedItemIndex;
 
	[selectedItem selected];      
}
 
@end

CCSprite * mySprite = [CCSprite spriteWithFile:@"myFile.png"];
mySprite.position = CGPointMake(160, 240);
mySprite.rotation = 45; // Degrees
[self addChild:mySprite];

CCSprite * tveffect = [CCSprite spriteWithFile:@"televisionStreak.png"]; 
ccBlendFunc additiveBlendFunction = {GL_SRC_ALPHA, GL_ONE};
tveffect.blendFunc = additiveBlendFunction;
 
tveffect.position = ccp(160,0);	
[tveffect setOpacity:0];
 
id fadeAction = [CCSequence actions:
				 [CCFadeTo actionWithDuration:0.5 opacity:255],
				 [CCDelayTime actionWithDuration:1.0],
				 [CCFadeTo actionWithDuration:0.5 opacity:0],
				 nil];
 
id moveAction = [CCSequence actions:
				 [CCMoveTo actionWithDuration:0 position:ccp(160, 0)],
				 [CCMoveTo actionWithDuration:2 position:ccp(160, 480],
				 nil];
 
[tveffect runAction:[CCRepeatForever actionWithAction: [CCSpawn actions:fadeAction,moveAction, nil]]];