IAPDemo/Libraries/redream/UIEditBoxLoader.cpp

#include "UIEditBoxLoader.h"
#include "REDSelectorResolver.h"

using namespace std;
using namespace cocos2d;
using namespace cocos2d::ui;

namespace redream {
#define PROPERTY_PLACEHOLDER        "placeHolder"
#define PROPERTY_TEXT               "text"
#define PROPERTY_INPUTMODE          "inputMode"
#define PROPERTY_FONTNAME           "fontName"
#define PROPERTY_PASSWORD           "password"
#define PROPERTY_BACKGROUND         "background"
#define PROPERTY_FONTCOLOR          "fontColor"
#define PROPERTY_FONTSIZE           "fontSize"
#define PROPERTY_INSERTLEFT         "insetLeft"
#define PROPERTY_INSERTTOP          "insetTop"
#define PROPERTY_INSERTRIGHT        "insetRight"
#define PROPERTY_INSERTBOTTOM       "insetBottom"
#define PROPERTY_MAXLENGTH          "maxLength"
#define PROPERTY_TEXTCHANGEDEVENT   "textChangedEvent"
#define PROPERTY_RETURNEVENT        "returnEvent"


void EditBoxLoader::onHandlePropTypeString(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, const char * pString, REDReader * ccbReader) {
    if (strcmp(pPropertyName, PROPERTY_PLACEHOLDER) == 0) {
        ((REDEditBox *)pNode)->setPlaceHolder(pString);
    }
    else if (strcmp(pPropertyName, PROPERTY_TEXT) == 0) {
        ((REDEditBox *)pNode)->setText(pString);
    }
    else {
        WidgetLoader::onHandlePropTypeString(pNode, pParent, pPropertyName, pString, ccbReader);
    }
}

void EditBoxLoader::onHandlePropTypeIntegerLabeled(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, int pIntegerLabeled, REDReader * ccbReader) {
    if (strcmp(pPropertyName, PROPERTY_INPUTMODE) == 0) {
        ((REDEditBox *)pNode)->setInputMode((EditBox::InputMode)pIntegerLabeled);
    }
    else {
        WidgetLoader::onHandlePropTypeIntegerLabeled(pNode, pParent, pPropertyName, pIntegerLabeled, ccbReader);
    }
}

void EditBoxLoader::onHandlePropTypeFontTTF(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, const char * pFontTTF, REDReader * ccbReader) {
    if (strcmp(pPropertyName, PROPERTY_FONTNAME) == 0) {
        ((REDEditBox *)pNode)->setFontName(pFontTTF);
    }
    else {
        WidgetLoader::onHandlePropTypeFontTTF(pNode, pParent, pPropertyName, pFontTTF, ccbReader);
    }
}

void EditBoxLoader::onHandlePropTypeCheck(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, bool pCheck, REDReader * ccbReader) {
    if (strcmp(pPropertyName, PROPERTY_PASSWORD) == 0) {
        if (pCheck) {
            ((REDEditBox *)pNode)->setInputFlag(EditBox::InputFlag::PASSWORD);
        }
    }
    else {
        WidgetLoader::onHandlePropTypeCheck(pNode, pParent, pPropertyName, pCheck, ccbReader);
    }
}

void EditBoxLoader::onHandlePropTypeFrameSet(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, std::vector<FramePath> pFrameSet, REDReader * ccbReader) {
    if (strcmp(pPropertyName, PROPERTY_BACKGROUND) == 0) {
        ((REDEditBox *)pNode)->loadBackgroundTexture(pFrameSet.at(0).path, pFrameSet.at(0).texType);
    }
    else {
        WidgetLoader::onHandlePropTypeFrameSet(pNode, pParent, pPropertyName, pFrameSet, ccbReader);
    }
}

void EditBoxLoader::onHandlePropTypeColor4(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, cocos2d::Color4B pColor4, REDReader * ccbReader) {
    if (strcmp(pPropertyName, PROPERTY_FONTCOLOR) == 0) {
        ((REDEditBox *)pNode)->setFontColor(pColor4);
    }
    else {
        WidgetLoader::onHandlePropTypeColor4(pNode, pParent, pPropertyName, pColor4, ccbReader);
    }
}

void EditBoxLoader::onHandlePropTypeFloatScale(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, float pFloatScale, REDReader * ccbReader) {
    if (strcmp(pPropertyName, PROPERTY_FONTSIZE) == 0) {
        ((REDEditBox *)pNode)->setFontSize(int(pFloatScale));
    }
    else {
        WidgetLoader::onHandlePropTypeFloatScale(pNode, pParent, pPropertyName, pFloatScale, ccbReader);
    }
}

void EditBoxLoader::onHandlePropTypeFloat(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, float pFloat, REDReader * ccbReader) {
    if (strcmp(pPropertyName, PROPERTY_INSERTLEFT) == 0) {
        ((REDEditBox *)pNode)->setInsetLeft(pFloat);
    }
    else if (strcmp(pPropertyName, PROPERTY_INSERTRIGHT) == 0) {
        ((REDEditBox *)pNode)->setInsetRight(pFloat);
    }
    else if (strcmp(pPropertyName, PROPERTY_INSERTTOP) == 0) {
        ((REDEditBox *)pNode)->setInsetTop(pFloat);
    }
    else if (strcmp(pPropertyName, PROPERTY_INSERTBOTTOM) == 0) {
        ((REDEditBox *)pNode)->setInsetBottom(pFloat);
    }
    else {
        WidgetLoader::onHandlePropTypeFloat(pNode, pParent, pPropertyName, pFloat, ccbReader);
    }
}

void EditBoxLoader::onHandlePropTypeInteger(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, int pInteger, REDReader * ccbReader) {
    if (strcmp(pPropertyName, PROPERTY_MAXLENGTH) == 0) {
        ((REDEditBox *)pNode)->setMaxLength(pInteger);
    }
    else {
        WidgetLoader::onHandlePropTypeInteger(pNode, pParent, pPropertyName, pInteger, ccbReader);
    }
}

void EditBoxLoader::onHandlePropTypeCallbacks(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, CallbacksData * pCallbacksData, REDReader * ccbReader) {
    REDEditBoxDelegate::ccEditBoxCallback event = 0;
    
    if (pCallbacksData != nullptr) {
        cocos2d::Ref * target = pCallbacksData->_target;
        std::string selectorName = pCallbacksData->selectorName;
        
        REDSelectorResolver * targetAsREDSelectorResolver = dynamic_cast<REDSelectorResolver *>(target);
        
        if(targetAsREDSelectorResolver != nullptr)
        {
            auto handler = targetAsREDSelectorResolver->onResolveREDUIEditBoxSelector(target, selectorName.c_str());
            if (handler != 0) {
                event = std::function<void(Ref *)>(std::bind(handler, target, std::placeholders::_1));
            }
        }

        if(event == 0)
        {
            REDSelectorResolver * ccbSelectorResolver = ccbReader->getREDSelectorResolver();
            if(ccbSelectorResolver != nullptr)
            {
                auto handler = ccbSelectorResolver->onResolveREDUIEditBoxSelector(target, selectorName.c_str());
                if (handler != 0) {
                    event = std::function<void(Ref *)>(std::bind(handler, target, std::placeholders::_1));
                }
            }
        }
    }
    else {
        return;
    }
    
    EditBoxDelegate * delegate = ((REDEditBox *)pNode)->getDelegate();
    if (delegate == nullptr) {
        delegate = new REDEditBoxDelegate();
    }
    
    if (strcmp(pPropertyName, PROPERTY_TEXTCHANGEDEVENT) == 0) {
        ((REDEditBoxDelegate *)delegate)->setTextChangeEvent(event);
        ((REDEditBox *)pNode)->setDelegate(delegate);
    }
    else if (strcmp(pPropertyName, PROPERTY_RETURNEVENT) == 0) {
        ((REDEditBoxDelegate *)delegate)->setReturnEvent(event);
        ((REDEditBox *)pNode)->setDelegate(delegate);
    }
    else {
        WidgetLoader::onHandlePropTypeCallbacks(pNode, pParent, pPropertyName, pCallbacksData, ccbReader);
    }
}

}