cocos2d-X 节点（CCMenuItem.h）API

 本文来自http://blog.csdn.net/runaying ，引用必须注明出处！

cocos2d-X 节点（CCMenuItem.h）API

为菜单项创建各种类型的 item 
    1.启用/禁用 item，是否选择 item 
    2.MenuItemLabel、MenuItemAtlasFont、MenuItemFont、MenuItemSprite、MenuItemImage、MenuItemToggle 和 CCMenuItem 相关的类 

///cocos2d-x-3.0alpha0/cocos2dx/menu_nodes
#ifndef __CCMENU_ITEM_H__
#define __CCMENU_ITEM_H__

// C++ includes
#include <functional>

// cocos2d includes
#include "base_nodes/CCNode.h"
#include "CCProtocols.h"
#include "cocoa/CCArray.h"

NS_CC_BEGIN

typedef std::function<void(Object*)> ccMenuCallback;

class LabelTTF;
class LabelAtlas;
class Sprite;
class SpriteFrame;
#define kItemSize 32
    
/**
 * @addtogroup GUI
 * @{
 * @addtogroup menu
 * @{
 */

/** @brief MenuItem base class
 *
 *  子类菜单项（或任意一个子类）来创建自定义MenuItem对象。
 */
class CC_DLL MenuItem : public NodeRGBA
{
public:
    /** 创建一个没有 target/selector  的菜单项*/
    static MenuItem* create();
    /** 已过时建议使用新的 API 使用 target/selector 创建一个菜单项 */
    CC_DEPRECATED_ATTRIBUTE static MenuItem* create(Object *rec, SEL_MenuHandler selector);
    /** 使用 target/selector 创建一个菜单项 */
    static MenuItem* create(const ccMenuCallback& callback);
    /**
     * @js ctor
     */
    MenuItem()
    : _selected(false)
    , _enabled(false)            
	, _callback(nullptr)
    , _target(NULL)
    {}
    /**
     * @js NA
     * @lua NA
     */
    virtual ~MenuItem();

    /** 使用一个 target/selector 初始化一个菜单项
    * @js NA
    * @lua NA
    */
    bool initWithCallback(const ccMenuCallback& callback);
    /** 已过时建议使用新的 API 使用一个 target/selector 初始化一个菜单项
    * @js NA
    * @lua NA
    */
    CC_DEPRECATED_ATTRIBUTE bool initWithTarget( Object *rec, SEL_MenuHandler selector);

    /** Returns 最外面的框 */
    Rect rect() const;
    /** 激活 item */
    virtual void activate();
    /**  item 已经被选择了 (没有激活), 类似 "mouse-over" */
    virtual void selected();
    /** The item was unselected */
    virtual void unselected();
    /** returns 是否启用 item */
    virtual bool isEnabled() const;
    /** item 的启用或禁用 */
    virtual void setEnabled(bool value);
    /** returns item 是否被选择 */
    virtual bool isSelected() const;

    /** 设置 item 的回调
    * @code
    * 在 js 里面，可以包含两个参数，第二个参数是 jsptr
    * @endcode
    * @lua NA
    */
    void setCallback(const ccMenuCallback& callback);
    /** 已过时建议使用新的 API  设置菜单项的 target/selector
    * @js NA
    * @lua NA
    */
    CC_DEPRECATED_ATTRIBUTE void setTarget(Object *rec, SEL_MenuHandler selector);

protected:
    bool            _selected;
    bool            _enabled;
	// 回调
	ccMenuCallback _callback;
	// 如果使用旧的 API，_target需要 retained / released
	Object		*_target;
};

MenuItemLabel简要

/** @brief 一个 "label" MenuItemLabel items 的抽象类
 支持的 LabelProtocol 协议的任何节点可以添加进来。
 Supported nodes:
 - BitmapFontAtlas
 - LabelAtlas
 - LabelTTF
 */
class CC_DLL MenuItemLabel : public MenuItem
{
public:
    /** 已过时建议使用新的 API ;使用一个 Label, target 和 selector 创建一个 MenuItemLabel */
    CC_DEPRECATED_ATTRIBUTE static MenuItemLabel * create(Node*label, Object* target, SEL_MenuHandler selector);

	/** 使用一个标签和一个回调，创建一个MenuItemLabel */
    static MenuItemLabel * create(Node*label, const ccMenuCallback& callback);

    /** 使用一个 Label 创建一个 MenuItemLabel. Target 和 selector 将是 nil */
    static MenuItemLabel* create(Node *label);
    /**
     * @js ctor
     */
    MenuItemLabel()
    : _originalScale(0.0)
    , _label(NULL)
    {}
    /**
     * @js NA
     * @lua NA
     */
    virtual ~MenuItemLabel();

	/** 使用一个 Label, target 和 selector 初始化一个 MenuItemLabel */
    bool initWithLabel(Node* label, const ccMenuCallback& callback);

    /** 已过时建议使用新的 API 使用一个 Label, target 和 selector 初始化一个 MenuItemLabel
     */
    CC_DEPRECATED_ATTRIBUTE bool initWithLabel(Node* label, Object* target, SEL_MenuHandler selector);

    /** 为内置的 label 设置一个新的 string */
    void setString(const char * label);

    /** Gets 用于禁用的 item 颜色 */
    inline const Color3B& getDisabledColor() const { return _disabledColor; };

    /** Sets 用于禁用的 item 颜色 */
    inline void setDisabledColor(const Color3B& color) { _disabledColor = color; };
    
    /** Gets Label 显示的内容. */
    inline Node* getLabel() const { return _label; };
    
    /** Sets Label 显示的内容. */
    void setLabel(Node* node);
    
    // Overrides
    virtual void activate() override;
    virtual void selected() override;
    virtual void unselected() override;
    virtual void setEnabled(bool enabled) override;
    
protected:
    Color3B    _colorBackup;
    float      _originalScale;

    /** 用于禁用的 item 颜色em */
    Color3B _disabledColor;
    /** Label 显示的内容. 它可以是任何实现LabelProtocol 协议的节点    */
    Node* _label;
};

MenuItemAtlasFont简要

/** @brief 一个 MenuItemAtlasFont 助手类; 使用一个 LabelAtlas 创建一个 MenuItemLabel
 */
class CC_DLL MenuItemAtlasFont : public MenuItemLabel
{
public:
    /** 使用一个 string 、 atlas 、 target/selector 创建一个菜单项 */    //地图集
    static MenuItemAtlasFont* create(const char *value, const char *charMapFile, int itemWidth, int itemHeight, char startCharMap);
    /** 已过时建议使用新的 API 使用一个 string 、 atlas 创建一个菜单项. 在 MenuItemToggle 里面使用 */
    CC_DEPRECATED_ATTRIBUTE static MenuItemAtlasFont* create(const char *value, const char *charMapFile, int itemWidth, int itemHeight, char startCharMap, Object* target, SEL_MenuHandler selector);
    /** 使用一个 string 、 atlas 创建一个菜单项. 在 MenuItemToggle 里面使用 */
    static MenuItemAtlasFont* create(const char *value, const char *charMapFile, int itemWidth, int itemHeight, char startCharMap, const ccMenuCallback& callback);
    /**
     * @js ctor
     */
    MenuItemAtlasFont(){}
    /**
     * @js NA
     * @lua NA
     */
    virtual ~MenuItemAtlasFont(){}

    /** 已过时建议使用新的 API 使用一个 string 、 atlas 、 target/selector 初始化一个菜单项 */
    CC_DEPRECATED_ATTRIBUTE bool initWithString(const char *value, const char *charMapFile, int itemWidth, int itemHeight, char startCharMap, Object* target, SEL_MenuHandler selector);
    /** 使用一个 string 、 atlas 、 target/selector 初始化一个菜单项 */
    bool initWithString(const char *value, const char *charMapFile, int itemWidth, int itemHeight, char startCharMap, const ccMenuCallback& callback);
};

MenuItemFont简要

/** @brief 一个 MenuItemFont 助手类 ，使用一个 Label 创建一个 MenuItemLabel
 */
class CC_DLL MenuItemFont : public MenuItemLabel
{
public:
    /** 不使用 target/selector 值使用一个 String 创建一个菜单项. 在 MenuItemToggle 里面使用 */
    static MenuItemFont * create(const char *value);
    /** 已过时建议使用新的 API 使用一个 string 、 target/selector 创建一个菜单项 */
    CC_DEPRECATED_ATTRIBUTE static MenuItemFont * create(const char *value, Object* target, SEL_MenuHandler selector);
    /** 使用一个 string 、 target/selector 创建一个菜单项 */
    static MenuItemFont * create(const char *value, const ccMenuCallback& callback);
    /**
     * @js ctor
     */
    MenuItemFont() : _fontSize(0), _fontName(""){}
    /**
     * @js NA
     * @lua NA
     */
    virtual ~MenuItemFont(){}

    /** 已过时建议使用新的 API 使用一个 string 、 target/selector 初始化一个菜单项 */
    CC_DEPRECATED_ATTRIBUTE bool initWithString(const char *value, Object* target, SEL_MenuHandler selector);
    /** 使用一个 string 、 target/selector 初始化一个菜单项 */
    bool initWithString(const char *value, const ccMenuCallback& callback);

    /** set 默认字体尺寸 */
    static void setFontSize(unsigned int s);
    /** get 默认字体尺寸 */
    static unsigned int getFontSize();
    /**已过时建议使用新的 API
     */
    CC_DEPRECATED_ATTRIBUTE static unsigned int fontSize() { return MenuItemFont::getFontSize(); };
    /** set 默认字体的名字 */
    static void setFontName(const char *name);
    /** get 默认字体的名字*/
    static const char *getFontName();
    /**已过时建议使用新的 API
     */
    CC_DEPRECATED_ATTRIBUTE static const char *fontName() { return MenuItemFont::getFontName(); };

    /** set 字体尺寸
     * c++ 不能重载具有相同参数类型的静态和非静态成员函数
     * 所以名称修改为 setFontSizeObj
     * @js setFontSize
     */
    void setFontSizeObj(unsigned int s);
    
    /** get 字体尺寸 
     * @js getFontSize
     */
    unsigned int getFontSizeObj() const;
    /**已过时建议使用新的 API
     */
    CC_DEPRECATED_ATTRIBUTE unsigned int fontSizeObj() const { return getFontSizeObj(); };
    
    /** set 字体的名字 
     * c++ 不能重载具有相同参数类型的静态和非静态成员函数
     * 所以名称修改为 setFontSizeObj
     * @js setFontName
     */
    void setFontNameObj(const char* name);

    /** returns 字体的名字
     * @js getFontNameObj
     */
    const char* getFontNameObj() const;

    /** 已过时建议使用新的 API ; 使用 getFontNameObj() 代替 */
    CC_DEPRECATED_ATTRIBUTE const char* fontNameObj() const { return getFontNameObj(); }
    
protected:
    void recreateLabel();
    
    unsigned int _fontSize;
    std::string _fontName;
};

MenuItemSprite简要

/** @brief MenuItemSprite 接受像 Node<RGBAProtocol> 对象的 items.
 图像有3种不同的状态：
 - unselected image
 - selected image
 - disabled image
 
 @since v0.8.0
 */
class CC_DLL MenuItemSprite : public MenuItem
{
public:
    /** 使用 normal, selected and disabled 图片，创建一个菜单项 */
    static MenuItemSprite * create(Node* normalSprite, Node* selectedSprite, Node* disabledSprite = NULL);
    /** 已过时建议使用新的 API ; 使用 normal 、 selected 图片 和 target/selector 创建一个菜单项*/
    CC_DEPRECATED_ATTRIBUTE static MenuItemSprite * create(Node* normalSprite, Node* selectedSprite, Object* target, SEL_MenuHandler selector);
    /** 已过时建议使用新的 API : 使用 normal,selected  、 disabled 图片和 target/selector 创建一个菜单项 */
    CC_DEPRECATED_ATTRIBUTE static MenuItemSprite * create(Node* normalSprite, Node* selectedSprite, Node* disabledSprite, Object* target, SEL_MenuHandler selector);
    /** 使用 normal 、 selected 图片和一个回调函数创建一个菜单项 */
    static MenuItemSprite * create(Node* normalSprite, Node* selectedSprite, const ccMenuCallback& callback);
    /** 使用 normal 、 selected 、 disabled 图片和 target/selector 创建一个菜单项 */
    static MenuItemSprite * create(Node* normalSprite, Node* selectedSprite, Node* disabledSprite, const ccMenuCallback& callback);

    MenuItemSprite()
    :_normalImage(NULL)
    ,_selectedImage(NULL)
    ,_disabledImage(NULL)
    {}

    /** 已过时建议使用新的 API ; 使用 normal 、 selected 图片和 target/selector 初始化一个菜单项*/
    CC_DEPRECATED_ATTRIBUTE bool initWithNormalSprite(Node* normalSprite, Node* selectedSprite, Node* disabledSprite, Object* target, SEL_MenuHandler selector);
    /** 使用 normal 、 selected 、 disabled 图片和一个回调函数初始化一个菜单项 */
    bool initWithNormalSprite(Node* normalSprite, Node* selectedSprite, Node* disabledSprite, const ccMenuCallback& callback);

    /** Gets 没有选择项目时所使用的图像 */
    inline Node* getNormalImage() const { return _normalImage; };
    
    /** Sets 没有选择项目时所使用的图像 */
    void setNormalImage(Node* image);
    
    /** Gets 选择项目时使用的图像*/
    inline Node* getSelectedImage() const { return _selectedImage; };
    
    /** Sets 选择项目时使用的图像 */
    void setSelectedImage(Node* image);
    
    /** Gets 该项目被禁用时显示的图片 */
    inline Node* getDisabledImage() const { return _disabledImage; };
    
    /** Sets 该项目被禁用时显示的图片 */
    void setDisabledImage(Node* image);
    
    /**
     @since v0.99.5
     */
    virtual void selected();
    virtual void unselected();
    virtual void setEnabled(bool bEnabled);
    
protected:
    virtual void updateImagesVisibility();

    /** 没有选择项目时所使用的图像 */
    Node* _normalImage;
    /** 选择项目时使用的图像*/
    Node* _selectedImage;
    /** 该项目被禁用时显示的图片 */
    Node* _disabledImage;
};

MenuItemImage简要

/** @brief MenuItemImage 接受图像作为 items.
 图像有3种不同的状态:
 - unselected image
 - selected image
 - disabled image
 
 为了获得最佳效果，尝试所有的图片都是相同的大小
 */
class CC_DLL MenuItemImage : public MenuItemSprite
{
public:
    /** 创建一个 MenuItemImage. */
    static MenuItemImage* create();
    /** 使用 normal, selected 图片，创建一个菜单项*/
    static MenuItemImage* create(const char *normalImage, const char *selectedImage);
    /** 使用 normal, selected and disabled 图片，创建一个菜单项 */
    static MenuItemImage* create(const char *normalImage, const char *selectedImage, const char *disabledImage);
    /** 已过时建议使用新的 API 使用 normal,selected  、 disabled 图片和 target/selector 创建一个菜单项 */
    CC_DEPRECATED_ATTRIBUTE static MenuItemImage* create(const char *normalImage, const char *selectedImage, Object* target, SEL_MenuHandler selector);
    /**  使用 normal 、 selected 图片和一个回调函数创建一个菜单项 */
    static MenuItemImage* create(const char *normalImage, const char *selectedImage, const ccMenuCallback& callback);

    /** 已过时建议使用新的 API 使用 normal,selected  、 disabled 图片和 target/selector 创建一个菜单项 */
    CC_DEPRECATED_ATTRIBUTE static MenuItemImage* create(const char *normalImage, const char *selectedImage, const char *disabledImage, Object* target, SEL_MenuHandler selector);
    /** 使用 normal,selected  、 disabled 图片和一个回调函数，创建一个菜单项 */
    static MenuItemImage* create(const char *normalImage, const char *selectedImage, const char *disabledImage, const ccMenuCallback& callback);
    /**
     * @js ctor
     */
    MenuItemImage(){}
    /**
     * @js NA
     * @lua NA
     */
    virtual ~MenuItemImage(){}

    bool init();
    /** 已过时建议使用新的 API 使用 normal,selected  、 disabled 图片和 target/selector 初始化一个菜单项 */
    CC_DEPRECATED_ATTRIBUTE bool initWithNormalImage(const char *normalImage, const char *selectedImage, const char *disabledImage, Object* target, SEL_MenuHandler selector);
    /** 使用 normal,selected  、 disabled 图片和一个回调函数，初始化一个菜单项 */
    bool initWithNormalImage(const char *normalImage, const char *selectedImage, const char *disabledImage, const ccMenuCallback& callback);

    /** 设置精灵正常时候的图片 */
    void setNormalSpriteFrame(SpriteFrame* frame);
    /** 设置精灵被选择时候的图片 */
    void setSelectedSpriteFrame(SpriteFrame* frame);
    /** 设置精灵被禁用时候的图片 */
    void setDisabledSpriteFrame(SpriteFrame* frame);
};

MenuItemToggle简要

/** @brief 一个 MenuItemToggle
 一个简单的容器类 "toggles" 它内部的 items
 内部的 Items 可以是任何类型的 MenuItem
 */
class CC_DLL MenuItemToggle : public MenuItem
{
public:
    /** 使用一个 Array 数组和一个回调函数创建一个菜单 */
    static MenuItemToggle * createWithCallback(const ccMenuCallback& callback, Array* menuItems);
    /** 使用一个 items 列表和一个回调函数创建一个菜单项 */
    static MenuItemToggle* createWithCallback(const ccMenuCallback& callback, MenuItem* item, ...) CC_REQUIRES_NULL_TERMINATION;
    /** 不是用 target/selector 、items 创建一个 菜单项 */
    static MenuItemToggle* create();
    /** 使用一个 item 创建一个菜单项 */
    static MenuItemToggle* create(MenuItem *item);
    /**已过时建议使用新的 API  使用一个 Array 数组和一个 target/selector 创建一个菜单
    * @js NA
    * @lua NA
    */
    CC_DEPRECATED_ATTRIBUTE static MenuItemToggle * createWithTarget(Object* target, SEL_MenuHandler selector, Array* menuItems);
    /** 已过时建议使用新的 API 使用一个 items 列表和一个 target/selector 创建一个菜单项
    * @js NA
    * @lua NA
    */
    CC_DEPRECATED_ATTRIBUTE static MenuItemToggle* createWithTarget(Object* target, SEL_MenuHandler selector, MenuItem* item, ...)CC_REQUIRES_NULL_TERMINATION;
    /**
     * @js ctor
     */
    MenuItemToggle()
    : _selectedIndex(0)
    , _subItems(NULL)            
    {}
    /**
     * @js NA
     * @lua NA
     */
    virtual ~MenuItemToggle();

    /** 已过时建议使用新的 API 使用一个 items 列表和一个 target/selector 初始化一个菜单项
    * @js NA
    * @lua NA
    */
    CC_DEPRECATED_ATTRIBUTE bool initWithTarget(Object* target, SEL_MenuHandler selector, MenuItem* item, va_list args);
    /** 使用一个 items 列表和一个回调函数初始化一个菜单项 */
    bool initWithCallback(const ccMenuCallback& callback, MenuItem* item, va_list args);

    /** 使用一个 item 初始化一个菜单项 */
    bool initWithItem(MenuItem *item);
    /** 添加更多的菜单项 */
    void addSubItem(MenuItem *item);
    
    /** return 选择的 item */
    MenuItem* getSelectedItem();
    /** @已过时建议使用新的 API 可以使用 getSelectedItem() 代替 */
    CC_DEPRECATED_ATTRIBUTE MenuItem* selectedItem() { return getSelectedItem(); }

    /** Gets 选择的 item 索引 */
    inline unsigned int getSelectedIndex() const { return _selectedIndex; };
    
    /** Sets 选择的 item 索引 */
    void setSelectedIndex(unsigned int index);
    
    /** Gets 包含的 subitems 数组
     你可以在运行的时候 add/remove items ，你也可以使用一个新的 Array 代替
     @since v0.7.2
     * @js NA
     * @lua NA
     */

    inline Array* getSubItems() const { return _subItems; };

    /** Sets 包含的 subitems 数组. */
    inline void setSubItems(Array* items) {
        CC_SAFE_RETAIN(items);
        CC_SAFE_RELEASE(_subItems);
        _subItems = items;
    }
    
    // Overrides
    virtual void activate() override;
    virtual void selected() override;
    virtual void unselected() override;
    virtual void setEnabled(bool var) override;

protected:
    /** returns 选择的 item */
    unsigned int _selectedIndex;
    /** 包含的 subitems 数组. 你可以在运行的时候 add/remove items ，你也可以使用一个新的 Array 代替。
     @since v0.7.2
     */
    Array* _subItems;

};


// end of GUI group
/// @}
/// @}

NS_CC_END

#endif //__CCMENU_ITEM_H__