diff --git a/samples/HelloLua/Resources/hello.lua b/samples/HelloLua/Resources/hello.lua
index 33efc36f3784..624992f73aff 100644
--- a/samples/HelloLua/Resources/hello.lua
+++ b/samples/HelloLua/Resources/hello.lua
@@ -22,11 +22,11 @@ local function creatDog()
     -- create dog animate
     local textureDog = CCTextureCache:sharedTextureCache():addImage("dog.png")
     local rect = CCRectMake(0, 0, frameWidth, frameHeight)
-    local frame0 = CCSpriteFrame:create(textureDog, rect)
+    local frame0 = CCSpriteFrame:createWithTexture(textureDog, rect)
     rect = CCRectMake(frameWidth, 0, frameWidth, frameHeight)
-    local frame1 = CCSpriteFrame:create(textureDog, rect)
+    local frame1 = CCSpriteFrame:createWithTexture(textureDog, rect)
 
-    local spriteDog = CCSprite:create(frame0)
+    local spriteDog = CCSprite:createWithSpriteFrame(frame0)
     spriteDog.isPaused = false
     spriteDog:setPosition(0, winSize.height / 4 * 3)
 
diff --git a/tools/tolua++/CCAction.pkg b/tools/tolua++/CCAction.pkg
index 80b9349896e7..3181a2ebba8f 100644
--- a/tools/tolua++/CCAction.pkg
+++ b/tools/tolua++/CCAction.pkg
@@ -5,29 +5,34 @@ enum {
 
 class CCAction : public CCObject
 {
-    // bool isDone(void);
-    // CCNode* getTarget(void);
+	bool isDone(void);
+    CCNode* getTarget(void);
     // void setTarget(CCNode *pTarget);
-    // CCNode* getOriginalTarget(void);
+    CCNode* getOriginalTarget(void);
     // void setOriginalTarget(CCNode *pOriginalTarget);
-    // int getTag(void);
-    // void setTag(int nTag);
-
-    // static CCAction* create();
+	// static CCAction* create();
+    int getTag(void);
+    void setTag(int nTag);
+	CCObject* copyWithZone(CCZone* pZone);
 };
 
 class CCActionInterval : public CCAction
 {
-    // float getElapsed(void);
-    // void setAmplitudeRate(CGFloat amp);
-    // CGFloat getAmplitudeRate(void);
+    float getElapsed(void);
+	bool isDone(void);
+    void setAmplitudeRate(float amp);
+    float getAmplitudeRate(void);
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
+	CCActionInterval* create(float d);
 };
 
 class CCFiniteTimeAction : public CCActionInterval
 {
-    // float getDuration(void);
-    // void setDuration(float duration);
-    // CCFiniteTimeAction* reverse(void);
+    float getDuration(void);
+    void setDuration(float duration);
+    CCFiniteTimeAction* reverse(void);
 };
 
 // CCActionInterval
@@ -35,7 +40,9 @@ class CCSpeed : public CCAction
 {
     float getSpeed(void);
     void setSpeed(float fSpeed);
-    CCAction* reverse(void);
+    CCActionInterval* reverse(void);
+	bool isDone(void);
+	CCObject* copyWithZone(CCZone* pZone);
 
     static CCSpeed* create(CCActionInterval *pAction, float fRate);
 };
@@ -44,6 +51,8 @@ class CCFollow : public CCAction
 {
     bool isBoundarySet(void);
     void setBoudarySet(bool bValue);
+	bool isDone(void);
+	CCObject* copyWithZone(CCZone* pZone);
 
     static CCFollow* create(CCNode *pFollowedNode);
     static CCFollow* create(CCNode *pFollowedNode, CCRect rect);
@@ -51,63 +60,97 @@ class CCFollow : public CCAction
 
 class CCSequence : public CCActionInterval
 {
-    static CCFiniteTimeAction* create(CCFiniteTimeAction *pActionOne, CCFiniteTimeAction *pActionTwo);
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
+    static CCFiniteTimeAction* createWithTwoActions(CCFiniteTimeAction *pActionOne, CCFiniteTimeAction *pActionTwo);
     static CCFiniteTimeAction* create(CCArray *actions);
 };
 
 class CCRepeat : public CCActionInterval
 {
+	CCObject* copyWithZone(CCZone* pZone);
+	bool isDone(void);
+	CCActionInterval* reverse(void);
+
     static CCRepeat* create(CCActionInterval *pAction, unsigned int times);
 };
 
 class CCRepeatForever : public CCActionInterval
 {
+	CCObject* copyWithZone(CCZone* pZone);
+	bool isDone(void);
+	CCActionInterval* reverse(void);
+
     static CCRepeatForever* create(CCActionInterval *pAction);
 };
 
 class CCSpawn : public CCActionInterval
 {
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
     static CCFiniteTimeAction* create(CCArray *actions);
-    static CCSpawn* create(CCFiniteTimeAction *pAction1, CCFiniteTimeAction *pAction2);
+    static CCFiniteTimeAction* create(CCFiniteTimeAction *pAction1, CCFiniteTimeAction *pAction2);
 };
 
 class CCRotateTo : public CCActionInterval
 {
+	CCObject* copyWithZone(CCZone* pZone);
+
     static CCRotateTo* create(float duration, float fDeltaAngle);
 };
 
 class CCRotateBy : public CCActionInterval
 {
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
     static CCRotateBy* create(float duration, float fDeltaAngle);
 };
 
 class CCMoveTo : public CCActionInterval
 {
+	CCObject* copyWithZone(CCZone* pZone);
+
     static CCMoveTo* create(float duration, CCPoint position);
 };
 
 class CCMoveBy : public CCActionInterval
 {
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
     static CCMoveBy* create(float duration, CCPoint position);
 };
 
 class CCSkewTo : public CCActionInterval
 {
+	CCObject* copyWithZone(CCZone* pZone);
+
     static CCSkewTo* create(float t, float sx, float sy);
 };
 
 class CCSkewBy : public CCActionInterval
 {
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
     static CCSkewBy* create(float t, float deltaSkewX, float deltaSkewY);
 };
 
 class CCJumpBy : public CCActionInterval
 {
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
     static CCJumpBy* create(float duration, CCPoint position, float height, int jumps);
 };
 
 class CCJumpTo : public CCActionInterval
 {
+	CCObject* copyWithZone(CCZone* pZone);
+
     static CCJumpTo* create(float duration, CCPoint position, float height, int jumps);
 };
 
@@ -119,112 +162,169 @@ typedef struct _ccBezierConfig {
 
 class CCBezierBy : public CCActionInterval
 {
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
     static CCBezierBy* create(float t, ccBezierConfig c);
 };
 
 class CCBezierTo : public CCActionInterval
 {
+	CCObject* copyWithZone(CCZone* pZone);
+
     static CCBezierTo* create(float t, ccBezierConfig c);
 };
 
 class CCScaleTo : public CCActionInterval
 {
+	CCObject* copyWithZone(CCZone* pZone);
+
     static CCScaleTo* create(float duration, float s);
     static CCScaleTo* create(float duration, float sx, float sy);
 };
 
 class CCScaleBy : public CCActionInterval
 {
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
     static CCScaleBy* create(float duration, float s);
     static CCScaleBy* create(float duration, float sx, float sy);
 };
 
 class CCBlink : public CCActionInterval
 {
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
     static CCBlink* create(float duration, unsigned int uBlinks);
 };
 
 class CCFadeIn : public CCActionInterval
 {
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
     static CCFadeIn* create(float d);
 };
 
 class CCFadeOut : public CCActionInterval
 {
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
     static CCFadeOut* create(float d);
 };
 
 class CCFadeTo : public CCActionInterval
 {
+	CCObject* copyWithZone(CCZone* pZone);
+
     static CCFadeTo* create(float duration, GLubyte opacity);
 };
 
 class CCTintTo : public CCActionInterval
 {
+	CCObject* copyWithZone(CCZone* pZone);
+
     static CCTintTo* create(float duration, GLubyte red, GLubyte green, GLubyte blue);
 };
 
 class CCTintBy : public CCActionInterval
 {
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
     static CCTintBy* create(float duration, GLshort deltaRed, GLshort deltaGreen, GLshort deltaBlue);
 };
 
 class CCDelayTime : public CCActionInterval
 {
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
     static CCDelayTime* create(float d);
 };
 
 class CCReverseTime : public CCActionInterval
 {
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
     static CCReverseTime* create(CCFiniteTimeAction *pAction);
 };
 
 class CCAnimate : public CCActionInterval
 {
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
     CCAnimation* getAnimation(void);
     void setAnimation(CCAnimation *pAnimation);
 
-    static CCAction* create(CCAnimation *pAnimation);
+    static CCAnimate* create(CCAnimation *pAnimation);
 };
 
-class CCProgressTo : public CCAction
+class CCTargetedAction : public CCActionInterval
 {
-    static CCAction* create(float duration, float fPercent);
-};
+	CCObject* copyWithZone(CCZone* pZone);
+	CCNode* getForcedTarget(void);
+	void setForcedTarget(CCNode* target);
 
-class CCProgressFromTo : public CCAction
-{
-    static CCAction* create(float duration, float fFromPercentage, float fToPercentage);
+	static CCTargetedAction* create(CCNode* pTarget, CCFiniteTimeAction* pAction);
 };
 
 
 // CCActionInstant
-class CCShow : public CCAction
+class CCActionInstant : public CCFiniteTimeAction
 {
-    static CCAction* create();
+	CCObject* copyWithZone(CCZone* pZone);
+	CCFiniteTimeAction* reverse(void);
+	bool isDone(void);
 };
 
-class CCHide : public CCAction
+class CCShow : public CCActionInstant
 {
-    static CCAction* create();
+	CCObject* copyWithZone(CCZone* pZone);
+	CCFiniteTimeAction* reverse(void);
+
+    static CCShow* create();
 };
 
-class CCToggleVisibility : public CCAction
+class CCHide : public CCActionInstant
 {
-    static CCAction* create();
+	CCObject* copyWithZone(CCZone* pZone);
+	CCFiniteTimeAction* reverse(void);
+
+    static CCHide* create();
 };
 
-class CCFlipX : public CCAction
+class CCToggleVisibility : public CCActionInstant
 {
-    static CCAction* create(bool x);
+	CCObject* copyWithZone(CCZone* pZone);
+
+    static CCToggleVisibility* create();
 };
 
-class CCFlipY : public CCAction
+class CCFlipX : public CCActionInstant
 {
-    static CCAction* create(bool y);
+	CCObject* copyWithZone(CCZone* pZone);
+	CCFiniteTimeAction* reverse(void);
+
+    static CCFlipX* create(bool x);
 };
 
-class CCPlace : public CCAction //<NSCopying>
+class CCFlipY : public CCActionInstant
 {
-    static CCAction* create(CCPoint pos);
+	CCObject* copyWithZone(CCZone* pZone);
+	CCFiniteTimeAction* reverse(void);
+
+    static CCFlipY* create(bool y);
+};
+
+class CCPlace : public CCActionInstant //<NSCopying>
+{
+	CCObject* copyWithZone(CCZone* pZone);
+
+    static CCPlace* create(CCPoint pos);
 };
diff --git a/tools/tolua++/CCActionCamera.pkg b/tools/tolua++/CCActionCamera.pkg
index b76d064c8c90..b10c9f7e7d7b 100644
--- a/tools/tolua++/CCActionCamera.pkg
+++ b/tools/tolua++/CCActionCamera.pkg
@@ -2,10 +2,12 @@
 class CCActionCamera : public CCActionInterval
 {
     void startWithTarget(CCNode *pTarget);
+	CCActionInterval* reverse();
 };
 
 class CCOrbitCamera : public CCActionCamera
 {
+	CCObject* copyWithZone(CCZone* pZone);
     void sphericalRadius(float *r, float *zenith, float *azimuth);
 
     static CCOrbitCamera * create(float t, float radius, float deltaRadius, float angleZ, float deltaAngleZ, float angleX, float deltaAngleX);
diff --git a/tools/tolua++/CCActionCatmullRom.pkg b/tools/tolua++/CCActionCatmullRom.pkg
new file mode 100644
index 000000000000..a8756d0a3b4f
--- /dev/null
+++ b/tools/tolua++/CCActionCatmullRom.pkg
@@ -0,0 +1,46 @@
+
+class CCPointArray : public CCNode
+{
+    bool initWithCapacity(unsigned int capacity);
+    void addControlPoint(CCPoint controlPoint);
+    void insertControlPoint(CCPoint &controlPoint, unsigned int index);
+    void replaceControlPoint(CCPoint &controlPoint, unsigned int index);
+    CCPoint getControlPointAtIndex(unsigned int index);
+    void removeControlPointAtIndex(unsigned int index);
+    unsigned int count();
+    CCPointArray* reverse();
+    void reverseInline();
+    CCObject* copyWithZone(CCZone *zone);
+    CCArray* getControlPoints();
+    void setControlPoints(CCArray *controlPoints);
+
+	static CCPointArray* create(unsigned int capacity);
+};
+
+class CCCardinalSplineTo : public CCActionInterval
+{
+	CCCardinalSplineTo* copyWithZone(CCZone* pZone);
+    CCActionInterval* reverse();
+    CCPointArray* getPoints();
+    void  setPoints(CCPointArray* points);
+
+	static CCCardinalSplineTo* create(float duration, CCPointArray* points, float tension);
+};
+
+
+class CCCardinalSplineBy : public CCCardinalSplineTo
+{
+    CCActionInterval* reverse();
+
+	static CCCardinalSplineBy* create(float duration, CCPointArray* points, float tension);
+};
+
+class CCCatmullRomTo : public CCCardinalSplineTo
+{
+	static CCCatmullRomTo* create(float dt, CCPointArray* points);
+};
+
+class CCCatmullRomBy : public CCCardinalSplineBy
+{
+    static CCCatmullRomBy* create(float dt, CCPointArray* points);
+};
diff --git a/tools/tolua++/CCActionEase.pkg b/tools/tolua++/CCActionEase.pkg
index 9455a1a7bbd1..d317f5870465 100644
--- a/tools/tolua++/CCActionEase.pkg
+++ b/tools/tolua++/CCActionEase.pkg
@@ -1,114 +1,183 @@
 
 class CCActionEase : public CCActionInterval
 {
-    static CCActionInterval* create(CCActionInterval *pAction);
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
+    static CCActionEase* create(CCActionInterval *pAction);
 };
 
-class CCEaseRateAction : public CCActionInterval
+class CCEaseRateAction : public CCActionEase
 {
-    static CCActionInterval* create(CCActionInterval* pAction, float fRate);
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
+    static CCEaseRateAction* create(CCActionInterval* pAction, float fRate);
 };
 
-class CCEaseIn : public CCActionInterval
+class CCEaseIn : public CCEaseRateAction
 {
-    static CCActionInterval* create(CCActionInterval* pAction, float fRate);
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
+    static CCEaseIn* create(CCActionInterval* pAction, float fRate);
 };
 
-class CCEaseOut : public CCActionInterval
+class CCEaseOut : public CCEaseRateAction
 {
-    static CCActionInterval* create(CCActionInterval* pAction, float fRate);
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
+    static CCEaseOut* create(CCActionInterval* pAction, float fRate);
 };
 
-class CCEaseInOut : public CCActionInterval
+class CCEaseInOut : public CCEaseRateAction
 {
-    static CCActionInterval* create(CCActionInterval* pAction, float fRate);
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
+    static CCEaseInOut* create(CCActionInterval* pAction, float fRate);
 };
 
-class CCEaseExponentialIn : public CCActionInterval
+class CCEaseExponentialIn : public CCActionEase
 {
-    static CCActionInterval* create(CCActionInterval* pAction);
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
+    static CCEaseExponentialIn* create(CCActionInterval* pAction);
 };
 
-class CCEaseExponentialOut : public CCActionInterval
+class CCEaseExponentialOut : public CCActionEase
 {
-    static CCActionInterval* create(CCActionInterval* pAction);
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
+    static CCEaseExponentialOut* create(CCActionInterval* pAction);
 };
 
-class CCEaseExponentialInOut : public CCActionInterval
+class CCEaseExponentialInOut : public CCActionEase
 {
-    static CCActionInterval* create(CCActionInterval* pAction);
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
+    static CCEaseExponentialInOut* create(CCActionInterval* pAction);
 };
 
-class CCEaseSineIn : public CCActionInterval
+class CCEaseSineIn : public CCActionEase
 {
-    static CCActionInterval* create(CCActionInterval* pAction);
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
+    static CCEaseSineIn* create(CCActionInterval* pAction);
 };
 
-class CCEaseSineOut : public CCActionInterval
+class CCEaseSineOut : public CCActionEase
 {
-    static CCActionInterval* create(CCActionInterval* pAction);
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
+    static CCEaseSineOut* create(CCActionInterval* pAction);
 };
 
-class CCEaseSineInOut : public CCActionInterval
+class CCEaseSineInOut : public CCActionEase
 {
-    static CCActionInterval* create(CCActionInterval* pAction);
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
+    static CCEaseSineInOut* create(CCActionInterval* pAction);
 };
 
-class CCEaseElastic : public CCActionInterval
+class CCEaseElastic : public CCActionEase
 {
-    static CCActionInterval* create(CCActionInterval *pAction);
-    static CCActionInterval* create(CCActionInterval *pAction, float fPeriod);
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
+	float getPeriod(void);
+	void setPeriod(float fPeriod);
+
+    static CCEaseElastic* create(CCActionInterval *pAction);
+    static CCEaseElastic* create(CCActionInterval *pAction, float fPeriod);
 };
 
-class CCEaseElasticIn : public CCActionInterval
+class CCEaseElasticIn : public CCEaseElastic
 {
-    static CCActionInterval* create(CCActionInterval *pAction);
-    static CCActionInterval* create(CCActionInterval *pAction, float fPeriod);
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
+    static CCEaseElasticIn* create(CCActionInterval *pAction);
+    static CCEaseElasticIn* create(CCActionInterval *pAction, float fPeriod);
 };
 
-class  CCEaseElasticOut : public CCActionInterval
+class  CCEaseElasticOut : public CCEaseElastic
 {
-    static CCActionInterval* create(CCActionInterval *pAction);
-    static CCActionInterval* create(CCActionInterval *pAction, float fPeriod);
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
+    static CCEaseElasticOut* create(CCActionInterval *pAction);
+    static CCEaseElasticOut* create(CCActionInterval *pAction, float fPeriod);
 };
 
-class CCEaseElasticInOut : public CCActionInterval
+class CCEaseElasticInOut : public CCEaseElastic
 {
-    static CCActionInterval* create(CCActionInterval *pAction);
-    static CCActionInterval* create(CCActionInterval *pAction, float fPeriod);
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
+    static CCEaseElasticInOut* create(CCActionInterval *pAction);
+    static CCEaseElasticInOut* create(CCActionInterval *pAction, float fPeriod);
 };
 
-class CCEaseBounce : public CCActionInterval
+class CCEaseBounce : public CCActionEase
 {
-    static CCActionInterval* create(CCActionInterval* pAction);
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
+    static CCEaseBounce* create(CCActionInterval* pAction);
 };
 
-class CCEaseBounceIn : public CCActionInterval
+class CCEaseBounceIn : public CCEaseBounce
 {
-    static CCActionInterval* create(CCActionInterval* pAction);
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
+    static CCEaseBounceIn* create(CCActionInterval* pAction);
 };
 
-class CCEaseBounceOut : public CCActionInterval
+class CCEaseBounceOut : public CCEaseBounce
 {
-    static CCActionInterval* create(CCActionInterval* pAction);
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
+    static CCEaseBounceOut* create(CCActionInterval* pAction);
 };
 
-class CCEaseBounceInOut : public CCActionInterval
+class CCEaseBounceInOut : public CCEaseBounce
 {
-    static CCActionInterval* create(CCActionInterval* pAction);
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
+    static CCEaseBounceInOut* create(CCActionInterval* pAction);
 };
 
-class CCEaseBackIn : public CCActionInterval
+class CCEaseBackIn : public CCActionEase
 {
-    static CCActionInterval* create(CCActionInterval* pAction);
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
+    static CCEaseBackIn* create(CCActionInterval* pAction);
 };
 
-class CCEaseBackOut : public CCActionInterval
+class CCEaseBackOut : public CCActionEase
 {
-    static CCActionInterval* create(CCActionInterval* pAction);
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
+    static CCEaseBackOut* create(CCActionInterval* pAction);
 };
 
-class CCEaseBackInOut : public CCActionInterval
+class CCEaseBackInOut : public CCActionEase
 {
-    static CCActionInterval* create(CCActionInterval* pAction);
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
+    static CCEaseBackInOut* create(CCActionInterval* pAction);
 };
diff --git a/tools/tolua++/CCActionGrid.pkg b/tools/tolua++/CCActionGrid.pkg
index d10e154ac93c..02d6fc7f7f97 100644
--- a/tools/tolua++/CCActionGrid.pkg
+++ b/tools/tolua++/CCActionGrid.pkg
@@ -1,6 +1,9 @@
 
 class CCGridAction : public CCActionInterval
 {
+	CCObject* copyWithZone(CCZone* pZone);
+	CCActionInterval* reverse(void);
+
     CCGridBase* getGrid(void);
 
     static CCGridAction* create(ccGridSize gridSize, float duration);
@@ -8,14 +11,38 @@ class CCGridAction : public CCActionInterval
 
 class CCAccelDeccelAmplitude : public CCActionInterval
 {
+	CCActionInterval* reverse(void);
+
     float getRate(void);
     void setRate(float fRate);
 
     static CCAccelDeccelAmplitude* create(CCAction *pAction, float duration);
 };
 
+class CCGrid3DAction : public CCGridAction
+{
+    virtual CCGridBase* getGrid(void);
+    ccVertex3F vertex(const ccGridSize& pos);
+    ccVertex3F originalVertex(const ccGridSize& pos);
+    void setVertex(const ccGridSize& pos, const ccVertex3F& vertex);
+
+    //static CCGrid3DAction* create(const ccGridSize& gridSize, float duration);
+};
+
+class CCTiledGrid3DAction : public CCGridAction
+{
+    ccQuad3 tile(ccGridSize pos);
+    ccQuad3 originalTile(ccGridSize pos);
+    void setTile(ccGridSize pos, ccQuad3 coords);
+    CCGridBase* getGrid(void);
+
+    //static CCTiledGrid3DAction* create(ccGridSize gridSize, float duration);
+};
+
 class CCAccelAmplitude : public CCActionInterval
 {
+	CCActionInterval* reverse(void);
+
     float getRate(void);
     void setRate(float fRate);
 
@@ -24,6 +51,8 @@ class CCAccelAmplitude : public CCActionInterval
 
 class CCDeccelAmplitude : public CCActionInterval
 {
+	CCActionInterval* reverse(void);
+
     float getRate(void);
     void setRate(float fRate);
 
diff --git a/tools/tolua++/CCActionGrid3D.pkg b/tools/tolua++/CCActionGrid3D.pkg
index c3fca6ebfc23..c3e32199112b 100644
--- a/tools/tolua++/CCActionGrid3D.pkg
+++ b/tools/tolua++/CCActionGrid3D.pkg
@@ -1,6 +1,8 @@
 
 class CCWaves3D : public CCGrid3DAction
 {
+	CCObject* copyWithZone(CCZone* pZone);
+
     float getAmplitude(void);
     void setAmplitude(float fAmplitude);
     float getAmplitudeRate(void);
@@ -11,16 +13,22 @@ class CCWaves3D : public CCGrid3DAction
 
 class CCFlipX3D : public CCGrid3DAction
 {
+	CCObject* copyWithZone(CCZone* pZone);
+
     static CCFlipX3D* create(float duration);
 };
 
 class CCFlipY3D : public CCFlipX3D
 {
+	CCObject* copyWithZone(CCZone* pZone);
+
     static CCFlipY3D* create(float duration);
 };
 
 class CCLens3D : public CCGrid3DAction
 {
+	CCObject* copyWithZone(CCZone* pZone);
+
     float getLensEffect(void);
     void setLensEffect(float fLensEffect);
     CCPoint getPosition(void);
@@ -31,6 +39,8 @@ class CCLens3D : public CCGrid3DAction
 
 class CCRipple3D : public CCGrid3DAction
 {
+	CCObject* copyWithZone(CCZone* pZone);
+
     CCPoint getPosition(void);
     void setPosition(CCPoint position);
     float getAmplitude(void);
@@ -43,11 +53,15 @@ class CCRipple3D : public CCGrid3DAction
 
 class CCShaky3D : public CCGrid3DAction
 {
+	CCObject* copyWithZone(CCZone* pZone);
+
     static CCShaky3D* create(int range, bool shakeZ, ccGridSize gridSize, float duration);
 };
 
 class CCLiquid : public CCGrid3DAction
 {
+	CCObject* copyWithZone(CCZone* pZone);
+
     float getAmplitude(void);
     void setAmplitude(float fAmplitude);
     float getAmplitudeRate(void);
@@ -58,6 +72,8 @@ class CCLiquid : public CCGrid3DAction
 
 class CCWaves : public CCGrid3DAction
 {
+	CCObject* copyWithZone(CCZone* pZone);
+
     float getAmplitude(void);
     void setAmplitude(float fAmplitude);
     float getAmplitudeRate(void);
@@ -68,6 +84,8 @@ class CCWaves : public CCGrid3DAction
 
 class CCTwirl : public CCGrid3DAction
 {
+	CCObject* copyWithZone(CCZone* pZone);
+
     CCPoint getPosition(void);
     void setPosition(CCPoint position);
     float getAmplitude(void);
diff --git a/tools/tolua++/CCActionManager.pkg b/tools/tolua++/CCActionManager.pkg
index 5314b85fe22a..114ad720afbe 100644
--- a/tools/tolua++/CCActionManager.pkg
+++ b/tools/tolua++/CCActionManager.pkg
@@ -18,4 +18,8 @@ class CCActionManager : public CCObject
     void pauseTarget(CCObject *pTarget);
 
     void resumeTarget(CCObject *pTarget);
+
+	CCSet* pauseAllRunningActions();
+
+	void resumeTargets(CCSet* targetsToResume);
 };
diff --git a/tools/tolua++/CCActionProgressTimer.pkg b/tools/tolua++/CCActionProgressTimer.pkg
index 6e3c911fd8ef..f4feb97fe570 100644
--- a/tools/tolua++/CCActionProgressTimer.pkg
+++ b/tools/tolua++/CCActionProgressTimer.pkg
@@ -1,10 +1,14 @@
 
 class CCProgressTo : public CCActionInterval
 {
+	CCObject* copyWithZone(CCZone* pZone);
+
     static CCProgressTo* create(float duration, float fPercent);
 };
 
 class CCProgressFromTo : public CCActionInterval
 {
+	CCObject* copyWithZone(CCZone* pZone);
+
     static CCProgressFromTo* create(float duration, float fFromPercentage, float fToPercentage);
 };
diff --git a/tools/tolua++/CCActionTiledGrid.pkg b/tools/tolua++/CCActionTiledGrid.pkg
index 5018acaa995d..48dc92f602b9 100644
--- a/tools/tolua++/CCActionTiledGrid.pkg
+++ b/tools/tolua++/CCActionTiledGrid.pkg
@@ -1,16 +1,22 @@
 
 class CCShakyTiles3D : public CCTiledGrid3DAction
 {
+	CCObject* copyWithZone(CCZone* pZone);
+
     static CCShakyTiles3D* create(int nRange, bool bShakeZ, ccGridSize gridSize, float duration);
 };
 
 class CCShatteredTiles3D : public CCTiledGrid3DAction
 {
+	CCObject* copyWithZone(CCZone* pZone);
+
     static CCShatteredTiles3D* create(int nRange, bool bShatterZ, ccGridSize gridSize, float duration);
 };
 
 class CCShuffleTiles : public CCTiledGrid3DAction
 {
+	CCObject* copyWithZone(CCZone* pZone);
+
     void shuffle(int *pArray, int nLen);
     ccGridSize getDelta(ccGridSize pos);
     void placeTile(ccGridSize pos, Tile *t);
@@ -34,6 +40,8 @@ class CCFadeOutBLTiles : public CCFadeOutTRTiles
 
 class CCFadeOutUpTiles : public CCFadeOutTRTiles
 {
+	void transformTile(ccGridSize pos, float distance);
+
     static CCFadeOutUpTiles* create(ccGridSize gridSize, float time);
 };
 
@@ -44,6 +52,8 @@ class CCFadeOutDownTiles : public CCFadeOutUpTiles
 
 class CCTurnOffTiles : public CCTiledGrid3DAction
 {
+	CCObject* copyWithZone(CCZone* pZone);
+
     void shuffle(int *pArray, int nLen);
     void turnOnTile(ccGridSize pos);
     void turnOffTile(ccGridSize pos);
@@ -54,6 +64,8 @@ class CCTurnOffTiles : public CCTiledGrid3DAction
 
 class CCWavesTiles3D : public CCTiledGrid3DAction
 {
+	CCObject* copyWithZone(CCZone* pZone);
+
     float getAmplitude(void);
     void setAmplitude(float fAmplitude);
     float getAmplitudeRate(void);
@@ -64,6 +76,8 @@ class CCWavesTiles3D : public CCTiledGrid3DAction
 
 class CCJumpTiles3D : public CCTiledGrid3DAction
 {
+	CCObject* copyWithZone(CCZone* pZone);
+
     float getAmplitude(void);
     void setAmplitude(float fAmplitude);
     float getAmplitudeRate(void);
@@ -74,10 +88,14 @@ class CCJumpTiles3D : public CCTiledGrid3DAction
 
 class CCSplitRows : public CCTiledGrid3DAction
 {
+	CCObject* copyWithZone(CCZone* pZone);
+
     static CCSplitRows* create(int nRows, float duration);
 };
 
 class CCSplitCols : public CCTiledGrid3DAction
 {
+	CCObject* copyWithZone(CCZone* pZone);
+
     static CCSplitCols* create(int nCols, float duration);
 };
diff --git a/tools/tolua++/CCAffineTransform.pkg b/tools/tolua++/CCAffineTransform.pkg
index 3bfcc39abbd0..dece0d7af9c6 100644
--- a/tools/tolua++/CCAffineTransform.pkg
+++ b/tools/tolua++/CCAffineTransform.pkg
@@ -1,11 +1,11 @@
 
 struct CCAffineTransform {
-    CCFloat a, b, c, d;
-    CCFloat tx, ty;
+    float a, b, c, d;
+    float tx, ty;
 };
 
-CCAffineTransform __CCAffineTransformMake(CCFloat a, CCFloat b, CCFloat c, CCFloat d, CCFloat tx, CCFloat ty);
-CCAffineTransform CCAffineTransformMake(CCFloat a, CCFloat b, CCFloat c, CCFloat d, CCFloat tx, CCFloat ty);
+CCAffineTransform __CCAffineTransformMake(float a, float b, float c, float d, float tx, float ty);
+CCAffineTransform CCAffineTransformMake(float a, float b, float c, float d, float tx, float ty);
 
 CCPoint __CCPointApplyAffineTransform(CCPoint point, CCAffineTransform t);
 CCPoint CCPointApplyAffineTransform(CCPoint point, CCAffineTransform t);
@@ -17,8 +17,8 @@ CCAffineTransform CCAffineTransformMakeIdentity();
 CCRect CCRectApplyAffineTransform(CCRect rect, CCAffineTransform anAffineTransform);
 
 CCAffineTransform CCAffineTransformTranslate(CCAffineTransform t, float tx, float ty);
-CCAffineTransform CCAffineTransformRotate(CCAffineTransform aTransform, CCFloat anAngle);
-CCAffineTransform CCAffineTransformScale(CCAffineTransform t, CCFloat sx, CCFloat sy);
+CCAffineTransform CCAffineTransformRotate(CCAffineTransform aTransform, float anAngle);
+CCAffineTransform CCAffineTransformScale(CCAffineTransform t, float sx, float sy);
 CCAffineTransform CCAffineTransformConcat(CCAffineTransform t1,CCAffineTransform t2);
 bool CCAffineTransformEqualToTransform(CCAffineTransform t1,CCAffineTransform t2);
 CCAffineTransform CCAffineTransformInvert(CCAffineTransform t);
diff --git a/tools/tolua++/CCAnimation.pkg b/tools/tolua++/CCAnimation.pkg
index c7c3f9de9faa..8001ec403325 100644
--- a/tools/tolua++/CCAnimation.pkg
+++ b/tools/tolua++/CCAnimation.pkg
@@ -3,9 +3,10 @@ class CCAnimationFrame : public CCObject
 {
     CCAnimationFrame();
     ~CCAnimationFrame();
-    
+	CCObject* copyWithZone(CCZone* pZone);
+
     bool initWithSpriteFrame(CCSpriteFrame* spriteFrame, float delayUnits, CCDictionary* userInfo);
-    
+
     CCSpriteFrame* getSpriteFrame();
     void setSpriteFrame(CCSpriteFrame* pSpFrame);
 
@@ -21,10 +22,11 @@ class CCAnimation : public CCObject
 {
     CCAnimation();
     ~CCAnimation(void);
+	CCObject* copyWithZone(CCZone* pZone);
 
     static CCAnimation* create(void);
-    static CCAnimation* create(CCArray* arrayOfSpriteFrameNames);
-    static CCAnimation* create(CCArray* arrayOfSpriteFrameNames, float delay);
+    static CCAnimation* createWithSpriteFrames(CCArray* arrayOfSpriteFrameNames);
+    static CCAnimation* createWithSpriteFrames(CCArray* arrayOfSpriteFrameNames, float delay);
     static CCAnimation* create(CCArray *arrayOfAnimationFrameNames, float delayPerUnit, unsigned int loops);
 
     void addSpriteFrame(CCSpriteFrame *pFrame);
diff --git a/tools/tolua++/CCAnimationCache.pkg b/tools/tolua++/CCAnimationCache.pkg
index f94ea138da7a..52def5edc5a3 100644
--- a/tools/tolua++/CCAnimationCache.pkg
+++ b/tools/tolua++/CCAnimationCache.pkg
@@ -7,4 +7,7 @@ class CCAnimationCache : public CCObject
 
     static CCAnimationCache* sharedAnimationCache(void);
     static void purgeSharedAnimationCache(void);
+
+	void addAnimationsWithDictionary(CCDictionary* dictionary);
+	void addAnimationsWithFile(const char* plist);
 };
diff --git a/tools/tolua++/CCArray.pkg b/tools/tolua++/CCArray.pkg
index 7b7a15e9da2f..80b159a030ed 100644
--- a/tools/tolua++/CCArray.pkg
+++ b/tools/tolua++/CCArray.pkg
@@ -1,10 +1,13 @@
 class CCArray : public CCObject
 {
+	CCObject* copyWithZone(CCZone* pZone);
+
     static CCArray* create();
-    static CCArray* createWithObject(CCObject* pObject);
-    static CCArray* create(const char*  pFileName);
-    static CCArray* create(unsigned int capacity);
-    static CCArray* create(CCArray* otherArray);
+
+	static CCArray* createWithObject(CCObject* pObject);
+	static CCArray* createWithArray(CCArray* otherArray);
+    static CCArray* createWithCapacity(unsigned int capacity);
+	static CCArray* createWithContentsOfFile(const char* pFileName);
 
     unsigned int count();
 
@@ -18,6 +21,8 @@ class CCArray : public CCObject
 
     CCObject* randomObject();
 
+	bool isEqualToArray(CCArray* pOtherArray);
+
     bool containsObject(CCObject* object);
 
     void addObject(CCObject* object);
diff --git a/tools/tolua++/CCAtlasNode.pkg b/tools/tolua++/CCAtlasNode.pkg
index 3b6ce53f69cf..97568e6dc2b4 100644
--- a/tools/tolua++/CCAtlasNode.pkg
+++ b/tools/tolua++/CCAtlasNode.pkg
@@ -1,9 +1,24 @@
 
 class CCAtlasNode : public CCNode
 {
-    void updateAtlasValues();
-    CCTexture2D* getTexture(void);
+	CCTextureAtlas* getTextureAtlas();
+	void setTextureAtlas(CCTextureAtlas* atlas);
+
+	CCTexture2D* getTexture(void);
     void setTexture(CCTexture2D *texture);
 
-    static CCAtlasNode * create(const char* tile,unsigned int tileWidth, unsigned int tileHeight, unsigned int itemsToRender);
+	ccColor3B getColor();
+	void setColor(ccColor3B color);
+
+	unsigned int getQuadsToDraw();
+	void setQuadsToDraw(unsigned int quadsToDraw);
+
+	GLubyte getOpacity();
+	void setOpacity(GLubyte opacity);
+
+    void updateAtlasValues();
+	bool isOpacityModifyRGB();
+	void setOpacityModifyRGB(bool isOpacityModifyRGB);
+
+    static CCAtlasNode * create(const char* tile, unsigned int tileWidth, unsigned int tileHeight, unsigned int itemsToRender);
 };
diff --git a/tools/tolua++/CCCommon.pkg b/tools/tolua++/CCCommon.pkg
index 5f01e967bec8..126b60b18bc3 100644
--- a/tools/tolua++/CCCommon.pkg
+++ b/tools/tolua++/CCCommon.pkg
@@ -1,3 +1,13 @@
+typedef enum LanguageType
+{
+    kLanguageEnglish = 0,
+    kLanguageChinese,
+    kLanguageFrench,
+    kLanguageItalian,
+    kLanguageGerman,
+    kLanguageSpanish,
+    kLanguageRussian
+} ccLanguageType;
 
 void CCLuaLog(const char * pszFormat);
 void CCMessageBox(const char * pszMsg, const char * pszTitle);
diff --git a/tools/tolua++/CCDictionary.pkg b/tools/tolua++/CCDictionary.pkg
index 218e0f5ca286..3c875532652d 100644
--- a/tools/tolua++/CCDictionary.pkg
+++ b/tools/tolua++/CCDictionary.pkg
@@ -19,8 +19,8 @@ class CCDictionary : public CCObject
     void removeAllObjects();
 
     static CCDictionary* create();
-    static CCDictionary* create(CCDictionary* srcDict);
-    static CCDictionary* create(const char *pFileName);
+    static CCDictionary* createWithDictionary(CCDictionary* srcDict);
+    static CCDictionary* createWithContentsOfFile(const char *pFileName);
 
 };
 
diff --git a/tools/tolua++/CCDirector.pkg b/tools/tolua++/CCDirector.pkg
index 28322708330f..d57327dc27b9 100644
--- a/tools/tolua++/CCDirector.pkg
+++ b/tools/tolua++/CCDirector.pkg
@@ -11,18 +11,26 @@ class CCDirector : public CCObject
     bool isPaused(void);
     unsigned int getTotalFrames(void);
 
+	CCEGLView* getOpenGLView(void);
+	bool enableRetinaDisplay(bool bEnableRetina);
+
     CCSize getWinSize(void);
     CCSize getWinSizeInPixels(void);
 
     CCPoint convertToGL(CCPoint obPoint);
     CCPoint convertToUI(CCPoint obPoint);
 
+	void pause();
+	void resume();
+	void purgeCachedData(void);
+
     void runWithScene(CCScene *pScene);
     void pushScene(CCScene *pScene);
     void popScene(void);
     void replaceScene(CCScene *pScene);
+	void endToLua();
 
-    CCFloat getContentScaleFactor(void);
+    float getContentScaleFactor(void);
 
     CCScheduler* getScheduler();
     CCActionManager* getActionManager();
diff --git a/tools/tolua++/CCDrawingPrimitives.pkg b/tools/tolua++/CCDrawingPrimitives.pkg
index af6e0e95140a..9a78396183d0 100644
--- a/tools/tolua++/CCDrawingPrimitives.pkg
+++ b/tools/tolua++/CCDrawingPrimitives.pkg
@@ -2,7 +2,15 @@
 void  ccDrawPoint(CCPoint point);
 void  ccDrawPoints(const CCPoint *points, unsigned int numberOfPoints);
 void  ccDrawLine(CCPoint origin, CCPoint destination);
-void  ccDrawPoly(const CCPoint *vertices, int numOfVertices, bool closePolygon);
+void  ccDrawRect(CCPoint origin, CCPoint destination);
+void  ccDrawSolidRect(CCPoint origin, CCPoint destination, ccColor4F color);
+void  ccDrawPoly(const CCPoint *vertices, unsigned int numOfVertices, bool closePolygon);
+void  ccDrawSolidPoly(const CCPoint* poli, unsigned int numberOfPoints, ccColor4F color);
 void  ccDrawCircle(CCPoint center, float radius, float angle, unsigned int segments, bool drawLineToCenter);
 void  ccDrawQuadBezier(CCPoint origin, CCPoint control, CCPoint destination, unsigned int segments);
 void  ccDrawCubicBezier(CCPoint origin, CCPoint control1, CCPoint control2, CCPoint destination, unsigned int segments);
+void  ccDrawCatmullRom(CCPointArray* arrayOfControlPoints, unsigned int segments);
+void  ccDrawCardinalSpline(CCPointArray* config, float tension, unsigned int segments);
+void  ccDrawColor4B(GLubyte r, GLubyte g, GLubyte b, GLubyte a);
+void  ccDrawColor4F(GLubyte r, GLubyte g, GLubyte b, GLubyte a);
+void  ccPointSize(GLfloat pointSize);
diff --git a/tools/tolua++/CCFileUtils.pkg b/tools/tolua++/CCFileUtils.pkg
index ee212bd7e00f..c6429207c395 100644
--- a/tools/tolua++/CCFileUtils.pkg
+++ b/tools/tolua++/CCFileUtils.pkg
@@ -3,4 +3,7 @@ class CCFileUtils
 {
     static CCFileUtils* sharedFileUtils();
     std::string getWriteablePath();
+	const char* fullPathFromRelativePath(const char *pszRelativePath);
+	const char* fullPathFromRelativeFile(const char *pszFilename, const char *pszRelativeFile);
+	const char* fullPathFromRelativeFile(const char *pszFilename, const char *pszRelativeFile);
 };
diff --git a/tools/tolua++/CCGeometry.pkg b/tools/tolua++/CCGeometry.pkg
index 801f5719d4c8..18c9e093d7dd 100644
--- a/tools/tolua++/CCGeometry.pkg
+++ b/tools/tolua++/CCGeometry.pkg
@@ -8,7 +8,7 @@ class CCPoint
     CCPoint();
     CCPoint(float x, float y);
 
-    static bool CCPointEqualToPoint(const CCPoint& point1, const CCPoint& point2);
+    bool equals(const CCPoint & target) const ;
 };
 
 class CCSize
@@ -18,7 +18,7 @@ class CCSize
     CCSize();
     CCSize(float width, float height);
 
-    static bool CCSizeEqualToSize(const CCSize& size1, const CCSize& size2);
+    bool equals(const CCSize & target) const;
 };
 
 class CCRect
@@ -28,15 +28,15 @@ class CCRect
     CCRect();
     CCRect(float x, float y, float width, float height);
 
-    static CGFloat CCRectGetMinX(const CCRect& rect);
-    static CGFloat CCRectGetMaxX(const CCRect& rect);
-    static CGFloat CCRectGetMidX(const CCRect& rect);
-    static CGFloat CCRectGetMinY(const CCRect& rect);
-    static CGFloat CCRectGetMaxY(const CCRect& rect);
-    static CGFloat CCRectGetMidY(const CCRect& rect);
-    static bool CCRectEqualToRect(const CCRect& rect1, const CCRect& rect2);
-    static bool CCRectContainsPoint(const CCRect& rect, const CCPoint& point);
-    static bool CCRectIntersectsRect(const CCRect& rectA, const CCRect& rectB);
+    float getMinX();
+	float getMidX();
+	float getMaxX();
+	float getMinY();
+	float getMidY();
+	float getMaxY();
+	bool equals(const CCRect & rect) const;
+	bool containsPoint(const CCPoint & point) const;
+	bool intersectsRect(const CCRect & rect) const;
 };
 
 CCPoint CCPointMake(float x, float y);
diff --git a/tools/tolua++/CCLabelBMFont.pkg b/tools/tolua++/CCLabelBMFont.pkg
index cde548f9b3a0..f2aeb918f8a0 100644
--- a/tools/tolua++/CCLabelBMFont.pkg
+++ b/tools/tolua++/CCLabelBMFont.pkg
@@ -2,7 +2,21 @@
 class CCLabelBMFont : public CCNode
 {
     void setString(const char *label);
-    const char* getString(void);
+	void setString(const char *label, bool fromUpdate);
+    void setCString(const char *label);
+	const char* getString(void);
+	void updateString(bool fromUpdate);
+
+	void setAnchorPoint(const CCPoint & var);
+	void setAlignment(CCTextAlignment alignment);
+	void setWidth(float width);
+	void setLineBreakWithoutSpace(bool breakWithoutSpace);
+	void setScale(float scale);
+	void setScaleX(float scaleX);
+	void setScaleY(float scaleY);
+
+	void setFntFile(const char* fntFile);
+	const char* getFntFile();
 
     void setColor(const ccColor3B& color);
     const ccColor3B& getColor(void);
@@ -10,8 +24,12 @@ class CCLabelBMFont : public CCNode
     GLubyte getOpacity(void);
     void setOpacity(GLubyte opacity);
 
+	bool isOpacityModifyRGB();
+    void setOpacityModifyRGB(bool isOpacityModifyRGB);
+
     tolua_property__CCOpacity   GLubyte opacity;
 
     static void purgeCachedData();
-    static CCLabelBMFont * create(const char *str, const char *fntFile);
+	static CCLabelBMFont * create();
+	static CCLabelBMFont * create(const char *str, const char *fntFile, float width = kCCLabelAutomaticWidth, CCTextAlignment alignment = kCCTextAlignmentLeft, CCPoint imageOffset = CCPointMake(0, 0));
 };
diff --git a/tools/tolua++/CCLabelTTF.pkg b/tools/tolua++/CCLabelTTF.pkg
index d8495a5cdb5f..215b889ad865 100644
--- a/tools/tolua++/CCLabelTTF.pkg
+++ b/tools/tolua++/CCLabelTTF.pkg
@@ -4,7 +4,23 @@ class CCLabelTTF : public CCSprite
     void setString(const char *label);
     const char* getString(void);
 
-    static CCLabelTTF * create(const char *label, CCSize dimensions, CCTextAlignment hAlignment,CCVerticalTextAlignment vAlignment, const char *fontName, float fontSize);
-    static CCLabelTTF * create(const char *label, CCSize dimensions, CCTextAlignment alignment, const char *fontName, float fontSize);
-    static CCLabelTTF * create(const char *label, const char *fontName, float fontSize);
+	CCTextAlignment getHorizontalAlignment();
+    void setHorizontalAlignment(CCTextAlignment alignment);
+
+    CCVerticalTextAlignment getVerticalAlignment();
+    void setVerticalAlignment(CCVerticalTextAlignment verticalAlignment);
+
+    CCSize getDimensions();
+    void setDimensions(CCSize &dim);
+
+    float getFontSize();
+    void setFontSize(float fontSize);
+
+    const char* getFontName();
+    void setFontName(const char *fontName);
+
+	static CCLabelTTF * create();
+	static CCLabelTTF * create(const char *str, const char *fontName, float fontSize);
+    static CCLabelTTF * create(const char *str, const char *fontName, float fontSize, const CCSize& dimensions, CCTextAlignment hAlignment);
+	static CCLabelTTF * create(const char *str, const char *fontName, float fontSize, const CCSize& dimensions, CCTextAlignment hAlignment, CCVerticalTextAlignment vAlignment);
 };
diff --git a/tools/tolua++/CCLayer.pkg b/tools/tolua++/CCLayer.pkg
index 25c47c2a6b01..afd68899b8d7 100644
--- a/tools/tolua++/CCLayer.pkg
+++ b/tools/tolua++/CCLayer.pkg
@@ -25,6 +25,8 @@ class CCLayerColor : public CCLayer
     void changeHeight(GLfloat h);
     void changeWidthAndHeight(GLfloat w ,GLfloat h);
 
+	void setContentSize(const CCSize & var);
+
     void setOpacity(GLubyte var);
     GLubyte getOpacity(void);
     void setColor(ccColor3B Value);
@@ -32,6 +34,9 @@ class CCLayerColor : public CCLayer
     void setBlendFunc(ccBlendFunc Value);
     ccBlendFunc getBlendFunc(void);
 
+	void setOpacityModifyRGB(bool bValue);
+    bool isOpacityModifyRGB(void);
+
     static CCLayerColor * create(ccColor4B color, GLfloat width, GLfloat height);
     static CCLayerColor * create(ccColor4B color);
 };
@@ -62,5 +67,6 @@ class CCLayerMultiplex : public CCLayer
     void switchTo(unsigned int n);
     void switchToAndReleaseMe(unsigned int n);
 
+	static CCLayerMultiplex * create(CCLayer* layer);
     static CCLayerMultiplex * createWithLayer(CCLayer* layer);
 };
diff --git a/tools/tolua++/CCMenu.pkg b/tools/tolua++/CCMenu.pkg
index 0aa98fd3f61c..42bf9f0903c4 100644
--- a/tools/tolua++/CCMenu.pkg
+++ b/tools/tolua++/CCMenu.pkg
@@ -1,5 +1,5 @@
 /*
-typedef enum  
+typedef enum
 {
     kCCMenuStateWaiting,
     kCCMenuStateTrackingTouch
@@ -19,6 +19,8 @@ class CCMenu : public CCLayer
     void alignItemsInColumns(unsigned int columns, va_list args);
     void alignItemsInRows(unsigned int rows, va_list args);
 
+	setHandlerPriority(int newPriority);
+
     void addChild(CCMenuItem* child, int zOrder = 0, int tag = -1);
 
     void setOpacity(GLubyte opacity);
@@ -26,6 +28,13 @@ class CCMenu : public CCLayer
     void setColor(ccColor3B color);
     ccColor3B getColor(void);
 
+	void setOpacityModifyRGB(bool bValue);
+    bool isOpacityModifyRGB(void);
+
+    bool isEnabled();
+    void setEnabled(bool value);
+
     static CCMenu* create();
     static CCMenu* createWithItem(CCMenuItem* item);
+	static CCMenu* createWithArray(CCArray* pArrayOfItems);
 };
diff --git a/tools/tolua++/CCMenuItem.pkg b/tools/tolua++/CCMenuItem.pkg
index 554b3229c0dd..d01b6dcf165e 100644
--- a/tools/tolua++/CCMenuItem.pkg
+++ b/tools/tolua++/CCMenuItem.pkg
@@ -21,6 +21,18 @@ class CCMenuItemLabel : public CCMenuItem
     GLubyte getOpacity();
     void setColor(ccColor3B color);
     ccColor3B getColor();
+	void setDisabledColor(const ccColor3B & color);
+	const ccColor3B & getDisabledColor();
+	void setLabel(CCNode* pLabel);
+	CCNode* getLabel();
+
+	void activate();
+    void selected();
+    void unselected();
+    void setEnabled(bool enabled);
+
+	void setOpacityModifyRGB(bool bValue);
+    bool isOpacityModifyRGB(void);
 
     static CCMenuItemLabel* create(CCNode* label);
 };
@@ -37,9 +49,14 @@ class CCMenuItemAtlasFont : public CCMenuItem
 class CCMenuItemFont : public CCMenuItem
 {
     static void setFontSize(int s);
-    static int fontSize();
+    static unsigned int fontSize();
     static void setFontName(const char* name);
     static const char* fontName();
+	void setFontSizeObj(unsigned int s);
+    unsigned int fontSizeObj();
+    void setFontNameObj(const char* name);
+    const char* fontNameObj();
+
     static CCMenuItemFont * create(const char* value);
 };
 
@@ -50,6 +67,20 @@ class CCMenuItemSprite : public CCMenuItem
     void setOpacity(GLubyte opacity);
     GLubyte getOpacity();
 
+	void setNormalImage(CCNode* pImage);
+	CCNode* getNormalImage();
+	void setSelectedImage(CCNode* pImage);
+	CCNode* getSelectedImage();
+	void setDisabledImage(CCNode* pImage);
+	CCNode* getDisabledImage();
+
+	void selected();
+    void unselected();
+    void setEnabled(bool bEnabled);
+
+    void setOpacityModifyRGB(bool bValue);
+    bool isOpacityModifyRGB(void);
+
     static CCMenuItemSprite * create(CCNode* normalSprite,
                                                    CCNode* selectedSprite);
     static CCMenuItemSprite * create(CCNode* normalSprite,
@@ -64,6 +95,11 @@ class CCMenuItemImage : public CCMenuItem
     void setOpacity(GLubyte opacity);
     GLubyte getOpacity();
 
+	void setNormalSpriteFrame(CCSpriteFrame* frame);
+    void setSelectedSpriteFrame(CCSpriteFrame* frame);
+    void setDisabledSpriteFrame(CCSpriteFrame* frame);
+
+	static CCMenuItemImage* create();
     static CCMenuItemImage* create(const char* normalImage,
                                                 const char* selectedImage);
     static CCMenuItemImage* create(const char* normalImage,
@@ -73,8 +109,25 @@ class CCMenuItemImage : public CCMenuItem
 
 class CCMenuItemToggle : public CCMenuItem
 {
-    void addSubItem(CCMenuItem *item);
+    void setColor(ccColor3B color);
+    ccColor3B getColor();
+    void setOpacity(GLubyte opacity);
+    GLubyte getOpacity();
+	void setSelectedIndex(unsigned int index);
+	unsigned int getSelectedIndex();
+	void setSubItems(CCArray* pArrayOfItems);
+	CCArray* getSubItems();
+
+	void addSubItem(CCMenuItem *item);
     CCMenuItem* selectedItem();
 
+	void activate();
+    void selected();
+    void unselected();
+    void setEnabled(bool var);
+
+    void setOpacityModifyRGB(bool bValue);
+    bool isOpacityModifyRGB(void);
+
     static CCMenuItemToggle* create(CCMenuItem *item);
 };
diff --git a/tools/tolua++/CCNode.pkg b/tools/tolua++/CCNode.pkg
index 9fc60990af94..4b05f2767d79 100644
--- a/tools/tolua++/CCNode.pkg
+++ b/tools/tolua++/CCNode.pkg
@@ -1,3 +1,6 @@
+enum {
+    kCCNodeTagInvalid = -1,
+};
 
 enum {
     kCCNodeOnEnter,
@@ -22,6 +25,7 @@ class CCNode : public CCObject
     float   getPositionX();
     float   getPositionY();
     void    setPosition(float x, float y);
+	void 	setPosition(CCPoint pos);
     void    setPositionX(float x);
     void    setPositionY(float y);
     float   getSkewX();
@@ -33,7 +37,7 @@ class CCNode : public CCObject
     CCPoint getAnchorPoint();
     void    setAnchorPoint(CCPoint point);
     CCSize  getContentSize();
-    void    setContentSize(CCSize size);
+    void    setContentSize(const CCSize & size);
     int     getTag();
     void    setTag(int var);
 
@@ -61,6 +65,7 @@ class CCNode : public CCObject
     //CCPoint getAnchorPointInPixels();
     //CCSize  getContentSizeInPixels();
     //void    setContentSizeInPixels(CCSize sz);
+	CCPoint getAnchorPointInPoints();
     bool    isRunning();
     CCNode* getParent();
     void    setParent(CCNode * var);
@@ -68,6 +73,18 @@ class CCNode : public CCObject
     void    ignoreAnchorPointForPosition(bool newValue);
     void*   getUserData();
     void    setUserData(void *var);
+	CCObject* getUserObject();
+	void    setUserObject(CCObject* pObject);
+	CCGLProgram* getShaderProgram();
+	void    setShaderProgram(CCGLProgram* pShaderProgram);
+	int     getOrderOfArrival();
+	void    setOrderOfArrival(int order);
+	ccGLServerState getGLServerState();
+	void    setGLServerState(ccGLServerState state);
+	CCActionManager* getActionManager();
+	void    setActionManager(CCActionManager* pActionMgr);
+	CCScheduler* getScheduler();
+	void    setScheduler(CCScheduler* pScheduler);
     void    addChild(CCNode * child);
     void    addChild(CCNode * child, int zOrder);
     void    addChild(CCNode * child, int zOrder, int tag);
diff --git a/tools/tolua++/CCObject.pkg b/tools/tolua++/CCObject.pkg
index 88773d3fd826..a03ef9dfaf35 100644
--- a/tools/tolua++/CCObject.pkg
+++ b/tools/tolua++/CCObject.pkg
@@ -6,4 +6,6 @@ class CCObject
     bool isSingleReference(void);
     unsigned int retainCount(void);
     bool isEqual(const CCObject* pObject);
+	CCObject* copy();
+	CCObject* autorelease();
 };
diff --git a/tools/tolua++/CCParticleBatchNode.pkg b/tools/tolua++/CCParticleBatchNode.pkg
index f30ecec06eae..1f5a23416035 100644
--- a/tools/tolua++/CCParticleBatchNode.pkg
+++ b/tools/tolua++/CCParticleBatchNode.pkg
@@ -1,7 +1,7 @@
 class CCParticleBatchNode : public CCNode, public CCTextureProtocol
 {
 public:
-    static CCParticleBatchNode* create(CCTexture2D *tex, unsigned int capacity = kCCParticleDefaultCapacity);
+    static CCParticleBatchNode* createWithTexture(CCTexture2D *tex, unsigned int capacity = kCCParticleDefaultCapacity);
     static CCParticleBatchNode* create(const char* fileImage, unsigned int capacity = kCCParticleDefaultCapacity);
 
     virtual void addChild(CCNode * child);
diff --git a/tools/tolua++/CCParticleSystem.pkg b/tools/tolua++/CCParticleSystem.pkg
index b7bb78437566..9f24e037a9bd 100644
--- a/tools/tolua++/CCParticleSystem.pkg
+++ b/tools/tolua++/CCParticleSystem.pkg
@@ -1,9 +1,31 @@
+enum {
+    kCCParticleDurationInfinity = -1,
+    kCCParticleStartSizeEqualToEndSize = -1,
+    kCCParticleStartRadiusEqualToEndRadius = -1,
+    kParticleStartSizeEqualToEndSize = kCCParticleStartSizeEqualToEndSize,
+    kParticleDurationInfinity = kCCParticleDurationInfinity,
+};
+
+enum {
+    kCCParticleModeGravity,
+    kCCParticleModeRadius,
+};
+
+typedef enum {
+    kCCPositionTypeFree,
+    kCCPositionTypeRelative,
+    kCCPositionTypeGrouped,
+}tCCPositionType;
+
+enum {
+    kPositionTypeFree = kCCPositionTypeFree,
+    kPositionTypeGrouped = kCCPositionTypeGrouped,
+};
 
 class CCParticleSystem : public CCNode
 {
     // mode A
     const CCPoint& getGravity();
-
     void setGravity(const CCPoint& g);
     float getSpeed();
     void setSpeed(float speed);
@@ -40,6 +62,26 @@ class CCParticleSystem : public CCNode
     void updateQuadWithParticle(tCCParticle* particle, const CCPoint& newPosition);
     void postStep();
 
+	float getStartSize();
+    float getStartSizeVar();
+    float getEndSize();
+    float getEndSizeVar();
+    const ccColor4F & getStartColor();
+    const ccColor4F & getStartColorVar();
+    const ccColor4F & getEndColor();
+    const ccColor4F & getEndColorVar();
+    float getStartSpin();
+    float getStartSpinVar();
+    float getEndSpin();
+    float getEndSpinVar();
+    float getEmissionRate();
+    unsigned int getTotalParticles();
+
+	bool isAutoRemoveOnFinish();
+	void setAutoRemoveOnFinish(bool var);
+	int  getEmitterMode();
+	void setEmitterMode(int mode);
+
     CCTexture2D* getTexture(void);
     void setTexture(CCTexture2D* var);
 
@@ -50,7 +92,7 @@ class CCParticleSystem : public CCNode
     void setRotation(float newRotation);
     void setScaleX(float newScaleX);
     void setScaleY(float newScaleY);
-    
+
     bool isActive();
     bool isBlendAdditive();
     void setBlendAdditive(bool value);
@@ -58,7 +100,20 @@ class CCParticleSystem : public CCNode
     static CCParticleSystem * create(const char *plistFile);
 };
 
-class CCParticleSystemQuad : public CCParticleSystem {
+class CCParticleSystemQuad : public CCParticleSystem
+{
+	void postStep();
+	void setDisplayFrame(CCSpriteFrame* spriteFrame);
+	void setTexture(CCTexture2D* texture);
+	void setTextureWithRect(CCTexture2D *texture, const CCRect& rect);
+	void setBatchNode(CCParticleBatchNode* batchNode);
+	void setTotalParticles(unsigned int tp);
+
+    void updateQuadWithParticle(tCCParticle* particle, const CCPoint& newPosition);
+    void postStep();
+    void setTotalParticles(unsigned int tp);
+
+	static CCParticleSystemQuad * create();
     static CCParticleSystemQuad * create(const char *plistFile);
 };
 
diff --git a/tools/tolua++/CCPointExtension.pkg b/tools/tolua++/CCPointExtension.pkg
index 19c067854693..3aea350a14d7 100644
--- a/tools/tolua++/CCPointExtension.pkg
+++ b/tools/tolua++/CCPointExtension.pkg
@@ -12,6 +12,7 @@ static  CCPoint ccpProject(const CCPoint& v1, const CCPoint& v2);
 static  CCPoint ccpRotate(const CCPoint& v1, const CCPoint& v2);
 static  CCPoint ccpUnrotate(const CCPoint& v1, const CCPoint& v2);
 static  CGFloat ccpLengthSQ(const CCPoint& v);
+static  CGFloat ccpDistanceSQ(const CCPoint p1, const CCPoint p2);
 CGFloat ccpLength(const CCPoint& v);
 CGFloat ccpDistance(const CCPoint& v1, const CCPoint& v2);
 CCPoint ccpNormalize(const CCPoint& v);
diff --git a/tools/tolua++/CCScheduler.pkg b/tools/tolua++/CCScheduler.pkg
index 33b526a663b4..4c4032b34e15 100644
--- a/tools/tolua++/CCScheduler.pkg
+++ b/tools/tolua++/CCScheduler.pkg
@@ -4,6 +4,8 @@ class CCTimer : public CCObject
     float getInterval(void);
     void setInterval(float fInterval);
     void update(float dt);
+
+	static CCTimer* timerWithScriptHandler(LUA_FUNCTION funcID, float fSeconds);
 };
 
 class CCScheduler : public CCObject
@@ -21,6 +23,8 @@ class CCScheduler : public CCObject
     void unscheduleAllSelectorsForTarget(CCObject *pTarget);
     void unscheduleAllSelectors(void);
 
+	void unscheduleAllSelectorsWithMinPriority(int nMinPriority);
+
     void pauseTarget(CCObject *pTarget);
     void resumeTarget(CCObject *pTarget);
     bool isTargetPaused(CCObject *pTarget);
diff --git a/tools/tolua++/CCSprite.pkg b/tools/tolua++/CCSprite.pkg
index 550bc8ecb054..ea65eb74f4d7 100644
--- a/tools/tolua++/CCSprite.pkg
+++ b/tools/tolua++/CCSprite.pkg
@@ -37,7 +37,7 @@ class CCSprite : public CCNode
 	void setBlendFunc(ccBlendFunc blendFunc);
 	ccBlendFunc getBlendFunc(void);
 
-	//CCPoint getOffsetPositionInPixels(void);
+	CCPoint getOffsetPosition(void);
 
 	void setDirtyRecursively(bool bValue);
 	void ignoreAnchorPointForPosition(bool newValue);
@@ -47,6 +47,24 @@ class CCSprite : public CCNode
 	bool isFlipY(void);
 	void updateColor(void);
 
+	void removeChild(CCNode* pChild, bool bCleanUp);
+	void removeAllChildrenWithCleanup(bool bCleanup);
+	void reorderChild(CCNode* pChild, int zOrder);
+	void addChild(CCNode* pChild);
+	void addChild(CCNode* pChild, int zOrder);
+	void addChild(CCNode* pChild, int zOrder, int tag);
+	void sortAllChildren();
+	//void setPosition(CCPoint pos);
+	void setRotation(float rotation);
+	void setSkewX(float sx);
+	void setSkewY(float sy);
+	void setScale(float fScale);
+	void setScaleX(float fScaleX);
+	void setScaleY(float fScaleY);
+	void setVertexZ(float fVertexZ);
+	void setAnchorPoint(const CCPoint & anchor);
+	void setVisible(bool bVisible);
+
 	void setOpacity(GLubyte opacity);
 	GLubyte getOpacity(void);
 
@@ -62,20 +80,22 @@ class CCSprite : public CCNode
 
 	void updateTransform(void);
 	//void useSelfRender(void);
-        void setTextureRect(CCRect rect);
-	//void setTextureRectInPixels(CCRect rect, bool rotated, CCSize size);
+	void setTextureRect(CCRect rect);
+	void setTextureRect(CCRect rect, bool rotated, CCSize size);
+	void setVertexRect(CCRect rect);
 	//void useBatchNode(CCSpriteBatchNode *batchNode);
 	void setDisplayFrame(CCSpriteFrame *pNewFrame);
 	bool isFrameDisplayed(CCSpriteFrame *pFrame);
-	//CCSpriteFrame* displayedFrame(void);
+	CCSpriteFrame* displayFrame(void);
+	void setBatchNode(CCSpriteBatchNode* pBatchNode);
+	CCSpriteBatchNode* getBatchNode();
 	void setDisplayFrameWithAnimationName(const char *animationName, int frameIndex);
 
-	static CCSprite* create(CCTexture2D *pTexture);
-	static CCSprite* create(CCTexture2D *pTexture, CCRect rect);
-//	static CCSprite* spriteWithTexture(CCTexture2D *pTexture, CCRect rect, CCPoint offset);
-	static CCSprite* create(CCSpriteFrame *pSpriteFrame);
+	static CCSprite* createWithTexture(CCTexture2D *pTexture);
+	static CCSprite* createWithTexture(CCTexture2D *pTexture, CCRect rect);
+	static CCSprite* createWithSpriteFrame(CCSpriteFrame *pSpriteFrame);
 	static CCSprite* createWithSpriteFrameName(const char *pszSpriteFrameName);
-        static CCSprite* create(const char *pszFileName);
+	static CCSprite* create();
+	static CCSprite* create(const char *pszFileName);
 	static CCSprite* create(const char *pszFileName, CCRect rect);
-	//static CCSprite* spriteWithBatchNode(CCSpriteBatchNode *batchNode, CCRect rect);
 };
diff --git a/tools/tolua++/CCSpriteBatchNode.pkg b/tools/tolua++/CCSpriteBatchNode.pkg
index d644d657835b..cf6ad522a836 100644
--- a/tools/tolua++/CCSpriteBatchNode.pkg
+++ b/tools/tolua++/CCSpriteBatchNode.pkg
@@ -8,6 +8,7 @@ class CCSpriteBatchNode : public CCNode
     void increaseAtlasCapacity();
     void removeChildAtIndex(unsigned int index, bool doCleanup);
     void insertChild(CCSprite *child, unsigned int index);
+	void appendChild(CCSprite *child);
     void removeSpriteFromAtlas(CCSprite *sprite);
 
     unsigned int rebuildIndexInOrder(CCSprite *parent, unsigned int index);
@@ -15,13 +16,23 @@ class CCSpriteBatchNode : public CCNode
     unsigned int lowestAtlasIndexInChild(CCSprite *sprite);
     unsigned int atlasIndexForChild(CCSprite *sprite, int z);
 
+	void reorderBatch(bool reorder);
     void setTexture(CCTexture2D *texture);
     CCTexture2D* getTexture(void);
     void setBlendFunc(ccBlendFunc blendFunc);
     ccBlendFunc getBlendFunc(void);
 
-    static CCSpriteBatchNode* create(CCTexture2D *tex);
-    static CCSpriteBatchNode* create(CCTexture2D* tex, unsigned int capacity);
+	void addChild(CCNode * child);
+    void addChild(CCNode * child, int zOrder);
+    void addChild(CCNode * child, int zOrder, int tag);
+    void reorderChild(CCNode * child, int zOrder);
+
+    void removeChild(CCNode* child, bool cleanup);
+    void removeAllChildrenWithCleanup(bool cleanup);
+    void sortAllChildren();
+
+    static CCSpriteBatchNode* createWithTexture(CCTexture2D *tex);
+    static CCSpriteBatchNode* createWithTexture(CCTexture2D* tex, unsigned int capacity);
     static CCSpriteBatchNode* create(const char* fileImage);
     static CCSpriteBatchNode* create(const char* fileImage, unsigned int capacity);
 };
diff --git a/tools/tolua++/CCSpriteFrame.pkg b/tools/tolua++/CCSpriteFrame.pkg
index 10e7047f106b..337f1a77b686 100644
--- a/tools/tolua++/CCSpriteFrame.pkg
+++ b/tools/tolua++/CCSpriteFrame.pkg
@@ -16,11 +16,17 @@ class CCSpriteFrame : public CCObject
     CCSize getOriginalSizeInPixels(void);
     void setOriginalSizeInPixels(CCSize sizeInPixels);
 
-    CCTexture2D* getTexture(void);
+	const CCSize & getOriginalSize();
+	void setOriginalSize(const CCSize & size);
+
+	CCTexture2D* getTexture(void);
     void setTexture(CCTexture2D* pobTexture);
 
-    static CCSpriteFrame* create(CCTexture2D* pobTexture, CCRect rect);
-    static CCSpriteFrame* create(CCTexture2D* pobTexture, CCRect rect, bool rotated, CCPoint offset, CCSize originalSize);
-    static CCSpriteFrame* create(const char* filename, CCRect rect);
+	const CCPoint & getOffset();
+	void setOffset(const CCPoint & offsets);
+
+	static CCSpriteFrame* create(const char* filename, CCRect rect);
     static CCSpriteFrame* create(const char* filename, CCRect rect, bool rotated, CCPoint offset, CCSize originalSize);
+    static CCSpriteFrame* createWithTexture(CCTexture2D* pobTexture, CCRect rect);
+    static CCSpriteFrame* createWithTexture(CCTexture2D* pobTexture, CCRect rect, bool rotated, CCPoint offset, CCSize originalSize);
 };
diff --git a/tools/tolua++/CCString.pkg b/tools/tolua++/CCString.pkg
index 714e34af7584..1950324a1334 100644
--- a/tools/tolua++/CCString.pkg
+++ b/tools/tolua++/CCString.pkg
@@ -9,10 +9,11 @@ class CCString : public CCObject
     const char* getCString() const;
     unsigned int length() const;
 
+	int compare(const char* str) const;
     bool isEqual(const CCObject* pObject);
 
     static CCString* create(const char* pStr);
-    static CCString* create(unsigned char* pData, unsigned long nLen);
+    static CCString* createWithData(unsigned char* pData, unsigned long nLen);
     static CCString* createWithContentsOfFile(const char* pszFileName);
 };
 
diff --git a/tools/tolua++/CCTMXLayer.pkg b/tools/tolua++/CCTMXLayer.pkg
index 758735f357f9..b76dbec9d800 100644
--- a/tools/tolua++/CCTMXLayer.pkg
+++ b/tools/tolua++/CCTMXLayer.pkg
@@ -22,10 +22,9 @@ class CCTMXLayer : public CCSpriteBatchNode
     void releaseMap();
 
     CCSprite* tileAt(CCPoint tileCoordinate);
-    unsigned int  tileGIDAt(CCPoint tileCoordinate);
-    unsigned int  tileGIDAt(CCPoint tileCoordinate, ccTMXTileFlags* flags);
-    void setTileGID(unsigned int gid, CCPoint tileCoordinate);
-    void setTileGID(unsigned int gid, CCPoint tileCoordinate, ccTMXTileFlags flags);
+    unsigned int tileGIDAt(const CCPoint& tileCoordinate);
+    void setTileGID(unsigned int gid, const CCPoint& tileCoordinate);
+    void setTileGID(unsigned int gid, const CCPoint& tileCoordinate, ccTMXTileFlags flags);
     void removeTileAt(CCPoint tileCoordinate);
     CCPoint positionAt(CCPoint tileCoordinate);
     CCString *propertyNamed(const char *propertyName);
diff --git a/tools/tolua++/CCTMXTiledMap.pkg b/tools/tolua++/CCTMXTiledMap.pkg
index b01e9764b33f..88cc6e5ffce9 100644
--- a/tools/tolua++/CCTMXTiledMap.pkg
+++ b/tools/tolua++/CCTMXTiledMap.pkg
@@ -32,4 +32,5 @@ class CCTMXTiledMap : public CCNode
     CCDictionary *propertiesForGID(int GID);
 
     static CCTMXTiledMap * create(const char *tmxFile);
+	static CCTMXTiledMap* createWithXML(const char* tmxString, const char* resourcePath);
 };
diff --git a/tools/tolua++/CCTMXXMLParser.pkg b/tools/tolua++/CCTMXXMLParser.pkg
index b01ac217ab88..f41e999bc0e1 100644
--- a/tools/tolua++/CCTMXXMLParser.pkg
+++ b/tools/tolua++/CCTMXXMLParser.pkg
@@ -15,6 +15,14 @@ enum {
     TMXPropertyTile
 };
 
+typedef enum ccTMXTileFlags_ {
+    kCCTMXTileHorizontalFlag        = 0x80000000,
+    kCCTMXTileVerticalFlag            = 0x40000000,
+    kCCTMXTileDiagonalFlag            = 0x20000000,
+    kCCFlipedAll                    = (kCCTMXTileHorizontalFlag|kCCTMXTileVerticalFlag|kCCTMXTileDiagonalFlag),
+    kCCFlippedMask                    = ~(kCCFlipedAll)
+} ccTMXTileFlags;
+
 class CCTMXLayerInfo : public CCObject
 {
     CCDictionary* getProperties();
@@ -61,6 +69,8 @@ class CCTMXMapInfo : public CCObject
     void endElement(void *ctx, const char *name);
     void textHandler(void *ctx, const char *ch, int len);
     bool parseXMLFile(const char *xmlFilename);
+	bool parseXMLString(const char *xmlString);
 
     static CCTMXMapInfo * formatWithTMXFile(const char *tmxFile);
+	static CCTMXMapInfo * formatWithXML(const char *tmxString, const char* resourcePath);
 };
diff --git a/tools/tolua++/CCTexture2D.pkg b/tools/tolua++/CCTexture2D.pkg
index 5585f964f5b8..a667d9fa3844 100644
--- a/tools/tolua++/CCTexture2D.pkg
+++ b/tools/tolua++/CCTexture2D.pkg
@@ -38,6 +38,9 @@ typedef enum {
 
 class CCTexture2D : public CCObject
 {
+	void releaseData(void* data);
+	void* keepData(void* data, unsigned int length);
+
     CCTexture2DPixelFormat getPixelFormat();
 
     unsigned int getPixelsWide();
@@ -66,7 +69,9 @@ class CCTexture2D : public CCObject
     void setAliasTexParameters();
     void generateMipmap();
 
-    int bitsPerPixelForFormat();
+	const char* stringForFormat();
+    unsigned int bitsPerPixelForFormat();
+	unsigned int bitsPerPixelForFormat(CCTexture2DPixelFormat format);
 
     static void setDefaultAlphaPixelFormat(CCTexture2DPixelFormat format);
     static CCTexture2DPixelFormat defaultAlphaPixelFormat();
diff --git a/tools/tolua++/CCTextureAtlas.pkg b/tools/tolua++/CCTextureAtlas.pkg
index 680bdd0d847a..e255e1a52f32 100644
--- a/tools/tolua++/CCTextureAtlas.pkg
+++ b/tools/tolua++/CCTextureAtlas.pkg
@@ -19,8 +19,12 @@ class CCTextureAtlas : public CCObject
     void drawNumberOfQuads(unsigned int n);
     void drawNumberOfQuads(unsigned int n, unsigned int start);
 
+	void increaseTotalQuadsWith(unsigned int amount);
+    void moveQuadsFromIndex(unsigned int oldIndex, unsigned int amount, unsigned int newIndex);
+    void moveQuadsFromIndex(unsigned int index, unsigned int newIndex);
+    void fillWithEmptyQuadsFromIndex(unsigned int index, unsigned int amount);
     void drawQuads();
 
     static CCTextureAtlas* create(const char* file , unsigned int capacity);
-    static CCTextureAtlas* create(CCTexture2D *texture, unsigned int capacity);
+    static CCTextureAtlas* createWithTexture(CCTexture2D *texture, unsigned int capacity);
 };
diff --git a/tools/tolua++/CCTextureCache.pkg b/tools/tolua++/CCTextureCache.pkg
index 267912bd12dc..3feb401a6177 100644
--- a/tools/tolua++/CCTextureCache.pkg
+++ b/tools/tolua++/CCTextureCache.pkg
@@ -5,6 +5,8 @@ class CCTextureCache : public CCObject
     CCTexture2D* addUIImage(CCImage *image, const char *key);
     CCTexture2D* textureForKey(const char* key);
 
+	CCTexture2D* addPVRImage(const char* filename);
+
     void removeAllTextures();
     void removeUnusedTextures();
     void removeTexture(CCTexture2D* texture);
diff --git a/tools/tolua++/CCTileMapAtlas.pkg b/tools/tolua++/CCTileMapAtlas.pkg
index 4125983ee9d5..6eafdd11bbff 100644
--- a/tools/tolua++/CCTileMapAtlas.pkg
+++ b/tools/tolua++/CCTileMapAtlas.pkg
@@ -10,5 +10,7 @@ class CCTileMapAtlas : public CCAtlasNode
     void setTile(ccColor3B tile, ccGridSize position);
     void releaseMap();
 
+	ccColor3B tileAt(const ccGridSize & pos);
+
     static CCTileMapAtlas * create(const char *tile, const char *mapFile, int tileWidth, int tileHeight);
 };
diff --git a/tools/tolua++/CCTouch.pkg b/tools/tolua++/CCTouch.pkg
index 4f6c9577d51c..24e60e9c08d4 100644
--- a/tools/tolua++/CCTouch.pkg
+++ b/tools/tolua++/CCTouch.pkg
@@ -8,8 +8,13 @@ enum {
 
 class CCTouch : public CCObject
 {
-    CCPoint locationInView();
-    CCPoint previousLocationInView();
+	CCPoint getLocation() const;
+    CCPoint getPreviousLocation() const;
+    CCPoint getDelta() const;
+    CCPoint getLocationInView() const;
+    CCPoint getPreviousLocationInView() const;
+
+	void setTouchInfo(int id, float x, float y);
     int getID();
 };
 
diff --git a/tools/tolua++/CCUserDefault.pkg b/tools/tolua++/CCUserDefault.pkg
index e7183f753283..d095b2a67c4e 100644
--- a/tools/tolua++/CCUserDefault.pkg
+++ b/tools/tolua++/CCUserDefault.pkg
@@ -15,6 +15,8 @@ class CCUserDefault
     void	setDoubleForKey(const char* pKey, double value);
     void	setStringForKey(const char* pKey, std::string value);
 
+	void flush();
+
     static CCUserDefault* sharedUserDefault();
     static void purgeSharedUserDefault();
     const static std::string& getXMLFilePath();
diff --git a/tools/tolua++/Cocos2d.pkg b/tools/tolua++/Cocos2d.pkg
index 9479c1d8e933..47aa1deb0f9c 100644
--- a/tools/tolua++/Cocos2d.pkg
+++ b/tools/tolua++/Cocos2d.pkg
@@ -3,6 +3,7 @@ $#include "LuaCocos2d.h"
 
 $pfile "CCAction.pkg"
 $pfile "CCActionCamera.pkg"
+$pfile "CCActionCatmullRom.pkg"
 $pfile "CCActionEase.pkg"
 $pfile "CCActionGrid.pkg"
 $pfile "CCActionGrid3D.pkg"
diff --git a/tools/tolua++/basic.lua b/tools/tolua++/basic.lua
index dcfff784f9f8..89976106233b 100644
--- a/tools/tolua++/basic.lua
+++ b/tools/tolua++/basic.lua
@@ -25,6 +25,10 @@ local CCObjectTypes = {
     "CCAccelDeccelAmplitude",
     "CCActionCamera",
     "CCOrbitCamera",
+	"CCCardinalSplineTo",
+	"CCCardinalSplineBy",
+	"CCCatmullRomTo",
+	"CCCatmullRomBy",
     "CCActionEase",
     "CCEaseBackIn",
     "CCEaseBackInOut",
diff --git a/tools/tolua++/ccTypes.pkg b/tools/tolua++/ccTypes.pkg
index d86f19fd6a7d..69e9088f6071 100644
--- a/tools/tolua++/ccTypes.pkg
+++ b/tools/tolua++/ccTypes.pkg
@@ -11,30 +11,31 @@ typedef float			 GLfloat;
 
 typedef struct _ccColor3B
 {
-    GLubyte	r;
-    GLubyte	g;
+    GLubyte r;
+    GLubyte g;
     GLubyte b;
 } ccColor3B;
 
 static ccColor3B ccc3(const GLubyte r, const GLubyte g, const GLubyte b);
 
-// static const ccColor3B ccWHITE;
+//! White color (255,255,255)
+//static const ccColor3B ccWHITE={255,255,255};
 //! Yellow color (255,255,0)
-// static const ccColor3B ccYELLOW;
+//static const ccColor3B ccYELLOW={255,255,0};
 //! Blue color (0,0,255)
-// static const ccColor3B ccBLUE;
+//static const ccColor3B ccBLUE={0,0,255};
 //! Green Color (0,255,0)
-// static const ccColor3B ccGREEN;
+//static const ccColor3B ccGREEN={0,255,0};
 //! Red Color (255,0,0,)
-// static const ccColor3B ccRED;
+//static const ccColor3B ccRED={255,0,0};
 //! Magenta Color (255,0,255)
-// static const ccColor3B ccMAGENTA;
+//static const ccColor3B ccMAGENTA={255,0,255};
 //! Black Color (0,0,0)
-// static const ccColor3B ccBLACK;
+//static const ccColor3B ccBLACK={0,0,0};
 //! Orange Color (255,127,0)
-// static const ccColor3B ccORANGE;
+//static const ccColor3B ccORANGE={255,127,0};
 //! Gray Color (166,166,166)
-// static const ccColor3B ccGRAY;
+//static const ccColor3B ccGRAY={166,166,166};
 
 /** RGBA color composed of 4 bytes
 @since v0.8
@@ -47,7 +48,7 @@ typedef struct _ccColor4B
     GLubyte a;
 } ccColor4B;
 //! helper macro that creates an ccColor4B type
-static  ccColor4B ccc4(const GLubyte r, const GLubyte g, const GLubyte b, const GLubyte o);
+static ccColor4B ccc4(const GLubyte r, const GLubyte g, const GLubyte b, const GLubyte o);
 
 
 /** RGBA color composed of 4 floats
@@ -60,10 +61,15 @@ typedef struct _ccColor4F {
     GLfloat a;
 } ccColor4F;
 
+
 /** Returns a ccColor4F from a ccColor3B. Alpha will be 1.
  @since v0.99.1
  */
-static  ccColor4F ccc4FFromccc3B(ccColor3B c);
+static ccColor4F ccc4FFromccc3B(ccColor3B c);
+
+//! helper that creates a ccColor4f type
+static ccColor4F ccc4f(const GLfloat r, const GLfloat g, const GLfloat b, const GLfloat a);
+
 /** Returns a ccColor4F from a ccColor4B.
  @since v0.99.1
  */
@@ -83,7 +89,7 @@ typedef struct _ccVertex2F
     GLfloat y;
 } ccVertex2F;
 
-static  ccVertex2F vertex2(const float x, const float y);
+static ccVertex2F vertex2(const float x, const float y);
 
 
 /** A vertex composed of 2 floats: x, y
@@ -96,129 +102,128 @@ typedef struct _ccVertex3F
     GLfloat z;
 } ccVertex3F;
 
-static  ccVertex3F vertex3(const float x, const float y, const float z);
+static ccVertex3F vertex3(const float x, const float y, const float z);
 
 /** A texcoord composed of 2 floats: u, y
  @since v0.8
  */
 typedef struct _ccTex2F {
-    GLfloat u;
-    GLfloat v;
+     GLfloat u;
+     GLfloat v;
 } ccTex2F;
 
-static  ccTex2F tex2(const float u, const float v);
-
+static ccTex2F tex2(const float u, const float v);
 
 
 //! Point Sprite component
 typedef struct _ccPointSprite
 {
-    ccVertex2F	pos;		// 8 bytes
-    ccColor4B	color;		// 4 bytes
-    GLfloat		size;		// 4 bytes
+    ccVertex2F    pos;        // 8 bytes
+    ccColor4B    color;        // 4 bytes
+    GLfloat        size;        // 4 bytes
 } ccPointSprite;
 
-//!	A 2D Quad. 4 * 2 floats
+//!    A 2D Quad. 4 * 2 floats
 typedef struct _ccQuad2 {
-    ccVertex2F		tl;
-    ccVertex2F		tr;
-    ccVertex2F		bl;
-    ccVertex2F		br;
+    ccVertex2F        tl;
+    ccVertex2F        tr;
+    ccVertex2F        bl;
+    ccVertex2F        br;
 } ccQuad2;
 
 
-//!	A 3D Quad. 4 * 3 floats
+//!    A 3D Quad. 4 * 3 floats
 typedef struct _ccQuad3 {
-    ccVertex3F		bl;
-    ccVertex3F		br;
-    ccVertex3F		tl;
-    ccVertex3F		tr;
+    ccVertex3F        bl;
+    ccVertex3F        br;
+    ccVertex3F        tl;
+    ccVertex3F        tr;
 } ccQuad3;
 
 //! A 2D grid size
 typedef struct _ccGridSize
 {
-    int	x;
-    int	y;
+    int    x;
+    int    y;
 } ccGridSize;
 
 //! helper function to create a ccGridSize
-static  ccGridSize ccg(const int x, const int y);
+static ccGridSize ccg(const int x, const int y);
 
 //! a Point with a vertex point, a tex coord point and a color 4B
 typedef struct _ccV2F_C4B_T2F
 {
     //! vertices (2F)
-    ccVertex2F		vertices;
+    ccVertex2F        vertices;
     //! colors (4B)
-    ccColor4B		colors;
+    ccColor4B        colors;
     //! tex coords (2F)
-    ccTex2F			texCoords;
+    ccTex2F            texCoords;
 } ccV2F_C4B_T2F;
 
 //! a Point with a vertex point, a tex coord point and a color 4F
 typedef struct _ccV2F_C4F_T2F
 {
     //! vertices (2F)
-    ccVertex2F		vertices;
+    ccVertex2F        vertices;
     //! colors (4F)
-    ccColor4F		colors;
+    ccColor4F        colors;
     //! tex coords (2F)
-    ccTex2F			texCoords;
+    ccTex2F            texCoords;
 } ccV2F_C4F_T2F;
 
 //! a Point with a vertex point, a tex coord point and a color 4B
 typedef struct _ccV3F_C4B_T2F
 {
     //! vertices (3F)
-    ccVertex3F		vertices;			// 12 bytes
-//	char __padding__[4];
+    ccVertex3F        vertices;            // 12 bytes
+//    char __padding__[4];
 
     //! colors (4B)
-    ccColor4B		colors;				// 4 bytes
-//	char __padding2__[4];
+    ccColor4B        colors;                // 4 bytes
+//    char __padding2__[4];
 
     // tex coords (2F)
-    ccTex2F			texCoords;			// 8 byts
+    ccTex2F            texCoords;            // 8 byts
 } ccV3F_C4B_T2F;
 
 //! 4 ccVertex2FTex2FColor4B Quad
 typedef struct _ccV2F_C4B_T2F_Quad
 {
     //! bottom left
-    ccV2F_C4B_T2F	bl;
+    ccV2F_C4B_T2F    bl;
     //! bottom right
-    ccV2F_C4B_T2F	br;
+    ccV2F_C4B_T2F    br;
     //! top left
-    ccV2F_C4B_T2F	tl;
+    ccV2F_C4B_T2F    tl;
     //! top right
-    ccV2F_C4B_T2F	tr;
+    ccV2F_C4B_T2F    tr;
 } ccV2F_C4B_T2F_Quad;
 
 //! 4 ccVertex3FTex2FColor4B
 typedef struct _ccV3F_C4B_T2F_Quad
 {
     //! top left
-    ccV3F_C4B_T2F	tl;
+    ccV3F_C4B_T2F    tl;
     //! bottom left
-    ccV3F_C4B_T2F	bl;
+    ccV3F_C4B_T2F    bl;
     //! top right
-    ccV3F_C4B_T2F	tr;
+    ccV3F_C4B_T2F    tr;
     //! bottom right
-    ccV3F_C4B_T2F	br;
+    ccV3F_C4B_T2F    br;
 } ccV3F_C4B_T2F_Quad;
 
 //! 4 ccVertex2FTex2FColor4F Quad
 typedef struct _ccV2F_C4F_T2F_Quad
 {
     //! bottom left
-    ccV2F_C4F_T2F	bl;
+    ccV2F_C4F_T2F    bl;
     //! bottom right
-    ccV2F_C4F_T2F	br;
+    ccV2F_C4F_T2F    br;
     //! top left
-    ccV2F_C4F_T2F	tl;
+    ccV2F_C4F_T2F    tl;
     //! top right
-    ccV2F_C4F_T2F	tr;
+    ccV2F_C4F_T2F    tr;
 } ccV2F_C4F_T2F_Quad;
 
 //! Blend Function used for textures
@@ -230,11 +235,8 @@ typedef struct _ccBlendFunc
     GLenum dst;
 } ccBlendFunc;
 
-//! delta time type
-//! if you want more resolution redefine it as a double
-
-//typedef double float;
-
+// XXX: If any of these enums are edited and/or reordered, udpate CCTexture2D.m
+//! Vertical text alignment type
 typedef enum
 {
     kCCVerticalTextAlignmentTop,
@@ -251,3 +253,25 @@ typedef enum
     kCCTextAlignmentRight,
 } CCTextAlignment;
 
+// types for animation in particle systems
+
+// texture coordinates for a quad
+typedef struct _ccT2F_Quad
+{
+    //! bottom left
+    ccTex2F    bl;
+    //! bottom right
+    ccTex2F    br;
+    //! top left
+    ccTex2F    tl;
+    //! top right
+    ccTex2F    tr;
+} ccT2F_Quad;
+
+// struct that holds the size in pixels, texture coordinates and delays for animated CCParticleSystemQuad
+typedef struct
+{
+    ccT2F_Quad texCoords;
+    float delay;
+    CCSize size;
+} ccAnimationFrameData;