Mac font display ok.

This commit is contained in:
James Chen
2018-03-08 17:38:45 +08:00
parent 626f13ff2d
commit 4eccfbcba8
7 changed files with 324 additions and 213 deletions
@@ -57,7 +57,7 @@ public:
~CanvasRenderingContext2D();
void clearRect(float x, float y, float width, float height);
Data getImageData(float sx, float sy, float sw, float sh);
// Data getImageData(float sx, float sy, float sw, float sh);
void fillText(const std::string& text, float x, float y, float maxWidth = -1.0f);
void strokeText(const std::string& text, float x, float y, float maxWidth = -1.0f);
Size measureText(const std::string& text);
@@ -71,6 +71,10 @@ public:
void stroke();
void restore();
// callback
using CanvasBufferUpdatedCallback = std::function<void(const Data&)>;
void setCanvasBufferUpdatedCallback(const CanvasBufferUpdatedCallback& cb);
// functions for properties
void set__width(float width);
void set__height(float height);
@@ -109,6 +113,7 @@ public:
private:
CanvasBufferUpdatedCallback _canvasBufferUpdatedCB = nullptr;
CanvasRenderingContext2DImpl* _impl = nullptr;
bool _isBufferSizeDirty = true;
@@ -7,16 +7,35 @@
#include <regex>
enum class CanvasTextAlign {
LEFT,
CENTER,
RIGHT
};
enum class CanvasTextBaseline {
TOP,
MIDDLE,
BOTTOM
};
@interface CanvasRenderingContext2DImpl : NSObject {
NSFont* _font;
NSMutableDictionary* _tokenAttributesDict;
NSString* _fontName;
CGFloat _fontSize;
NSImage* _image;
cocos2d::Data _imageData;
CanvasTextAlign _textAlign;
CanvasTextBaseline _textBaseLine;
}
@property (nonatomic, strong) NSFont* font;
@property (nonatomic, strong) NSMutableDictionary* tokenAttributesDict;
@property (nonatomic, strong) NSString* fontName;
@property (nonatomic, strong) NSImage* image;
@property (nonatomic, assign) CanvasTextAlign textAlign;;
@property (nonatomic, assign) CanvasTextBaseline textBaseLine;;
@end
@@ -25,9 +44,14 @@
@synthesize font = _font;
@synthesize tokenAttributesDict = _tokenAttributesDict;
@synthesize fontName = _fontName;
@synthesize image = _image;
@synthesize textAlign = _textAlign;
@synthesize textBaseLine = _textBaseLine;
-(id) init {
if ([super init]) {
_textAlign = CanvasTextAlign::LEFT;
_textBaseLine = CanvasTextBaseline::BOTTOM;
[self updateFontWithName:@"Arial" fontSize:30];
}
@@ -38,6 +62,7 @@
self.font = nil;
self.tokenAttributesDict = nil;
self.fontName = nil;
self.image = nil;
[super dealloc];
}
@@ -69,6 +94,7 @@
NSMutableParagraphStyle* paragraphStyle = [[[NSMutableParagraphStyle alloc] init] autorelease];
paragraphStyle.lineBreakMode = NSLineBreakByTruncatingTail;
[paragraphStyle setAlignment:NSTextAlignmentCenter];
// color
NSColor* foregroundColor = [NSColor colorWithRed:1.0f
@@ -83,8 +109,8 @@
paragraphStyle, NSParagraphStyleAttributeName, nil];
}
-(void) updateTextAlignment:(NSTextAlignment) alignment {
-(void) recreateBufferWithWidth:(NSInteger) width height:(NSInteger) height {
self.image = [[NSImage alloc] initWithSize:NSMakeSize(width, height)];
}
-(NSSize) measureText:(NSString*) text {
@@ -114,43 +140,67 @@
return dim;
}
-(void) fillText:(NSString*) text x:(NSInteger) x y:(NSInteger) y width:(NSInteger) width height:(NSInteger) height {
// CGFloat xPadding = 0;
// CGFloat yPadding = 0;
//
// NSInteger POTWide = width;
// NSInteger POTHigh = height;
// NSRect textRect = NSMakeRect(0, 0,
// width, height);
//
//
// [[NSGraphicsContext currentContext] setShouldAntialias:NO];
//
// NSImage *image = [[NSImage alloc] initWithSize:NSMakeSize(POTWide, POTHigh)];
// [image lockFocus];
// // patch for mac retina display and lableTTF
// [[NSAffineTransform transform] set];
// NSAttributedString *stringWithAttributes =[[[NSAttributedString alloc] initWithString:text
// attributes:_tokenAttributesDict] autorelease];
// [stringWithAttributes drawInRect:textRect];
// NSBitmapImageRep *bitmap = [[NSBitmapImageRep alloc] initWithFocusedViewRect:NSMakeRect (0.0f, 0.0f, POTWide, POTHigh)];
// [image unlockFocus];
//
// auto data = (unsigned char*) [bitmap bitmapData]; //Use the same buffer to improve the performance.
//
// NSUInteger textureSize = POTWide * POTHigh * 4;
// auto dataNew = (unsigned char*)malloc(sizeof(unsigned char) * textureSize);
// if (dataNew) {
// memcpy(dataNew, data, textureSize);
// // output params
// info->width = static_cast<int>(POTWide);
// info->height = static_cast<int>(POTHigh);
// info->data = dataNew;
// info->isPremultipliedAlpha = true;
// ret = true;
// }
// [bitmap release];
// [image release];
-(NSPoint) convertDrawPoint:(NSPoint) point text:(NSString*) text {
NSSize textSize = [self measureText:text];
NSLog(@"textSize: %f, %f", textSize.width, textSize.height);
if (_textAlign == CanvasTextAlign::CENTER)
{
point.x -= textSize.width / 2;
}
else if (_textAlign == CanvasTextAlign::RIGHT)
{
point.x -= textSize.width;
}
if (_textBaseLine == CanvasTextBaseline::TOP)
{
point.y += textSize.height;
}
else if (_textBaseLine == CanvasTextBaseline::MIDDLE)
{
point.y += textSize.height / 2;
}
return point;
}
-(void) fillText:(NSString*) text x:(CGFloat) x y:(CGFloat) y maxWidth:(CGFloat) maxWidth {
NSPoint drawPoint = [self convertDrawPoint:NSMakePoint(x, y) text:text];
NSMutableParagraphStyle* paragraphStyle = [[[NSMutableParagraphStyle alloc] init] autorelease];
paragraphStyle.lineBreakMode = NSLineBreakByTruncatingTail;
[_tokenAttributesDict setObject:paragraphStyle forKey:NSParagraphStyleAttributeName];
[[NSGraphicsContext currentContext] setShouldAntialias:NO];
[_image lockFocus];
// patch for mac retina display and lableTTF
[[NSAffineTransform transform] set];
NSAttributedString *stringWithAttributes =[[[NSAttributedString alloc] initWithString:text
attributes:_tokenAttributesDict] autorelease];
drawPoint.y = _image.size.height - drawPoint.y;
[stringWithAttributes drawAtPoint:drawPoint];
NSBitmapImageRep *bitmap = [[NSBitmapImageRep alloc] initWithFocusedViewRect:NSMakeRect (0.0f, 0.0f, _image.size.width, _image.size.height)];
[_image unlockFocus];
unsigned char* data = [bitmap bitmapData]; //Use the same buffer to improve the performance.
NSUInteger textureSize = _image.size.width * _image.size.height * 4;
uint8_t* buffer = (uint8_t*)malloc(sizeof(uint8_t) * textureSize);
if (buffer) {
memcpy(buffer, data, textureSize);
_imageData.fastSet(buffer, textureSize);
}
[bitmap release];
}
-(const cocos2d::Data&) getDataRef {
return _imageData;
}
@end
@@ -185,11 +235,13 @@ CanvasRenderingContext2D::CanvasRenderingContext2D(float width, float height)
CanvasRenderingContext2D::~CanvasRenderingContext2D()
{
SE_LOGD("CanvasGradient destructor: %p\n", this);
[_impl release];
}
void CanvasRenderingContext2D::recreateBuffer()
{
_isBufferSizeDirty = false;
[_impl recreateBufferWithWidth: __width height:__height];
}
void CanvasRenderingContext2D::clearRect(float x, float y, float width, float height)
@@ -197,17 +249,23 @@ void CanvasRenderingContext2D::clearRect(float x, float y, float width, float he
SE_LOGD("CanvasGradient::clearRect: %p, %f, %f, %f, %f\n", this, x, y, width, height);
}
Data CanvasRenderingContext2D::getImageData(float sx, float sy, float sw, float sh)
{
SE_LOGD("CanvasGradient::getImageData: %p, %f, %f, %f, %f\n", this, sx, sy, sw, sh);
return Data();
}
//Data CanvasRenderingContext2D::getImageData(float sx, float sy, float sw, float sh)
//{
// SE_LOGD("CanvasGradient::getImageData: %p, %f, %f, %f, %f\n", this, sx, sy, sw, sh);
// assert(sx == 0 && sy == 0 && sw == __width && sh == __height); // TODO: cjh
//
// return [_impl getImageData];
//}
void CanvasRenderingContext2D::fillText(const std::string& text, float x, float y, float maxWidth)
{
SE_LOGD("CanvasRenderingContext2D::fillText: %s, %f, %f, %f\n", text.c_str(), x, y, maxWidth);
if (_isBufferSizeDirty)
recreateBuffer();
[_impl fillText:[NSString stringWithUTF8String:text.c_str()] x:x y:y maxWidth:maxWidth];
if (_canvasBufferUpdatedCB != nullptr)
_canvasBufferUpdatedCB([_impl getDataRef]);
}
void CanvasRenderingContext2D::strokeText(const std::string& text, float x, float y, float maxWidth)
@@ -215,6 +273,9 @@ void CanvasRenderingContext2D::strokeText(const std::string& text, float x, floa
SE_LOGD("CanvasRenderingContext2D::strokeText: %s, %f, %f, %f\n", text.c_str(), x, y, maxWidth);
if (_isBufferSizeDirty)
recreateBuffer();
if (_canvasBufferUpdatedCB != nullptr)
_canvasBufferUpdatedCB([_impl getDataRef]);
}
cocos2d::Size CanvasRenderingContext2D::measureText(const std::string& text)
@@ -264,6 +325,11 @@ void CanvasRenderingContext2D::restore()
}
void CanvasRenderingContext2D::setCanvasBufferUpdatedCallback(const CanvasBufferUpdatedCallback& cb)
{
_canvasBufferUpdatedCB = cb;
}
void CanvasRenderingContext2D::set__width(float width)
{
SE_LOGD("CanvasRenderingContext2D::set__width: %f\n", width);
@@ -294,15 +360,18 @@ void CanvasRenderingContext2D::set_font(const std::string& font)
{
_font = font;
// TODO: cjh implements bold
std::string bold;
std::string fontName = "Arial";
std::string fontSizeStr = "30";
std::regex re("(\\d+)px\\s+(\\w+)");
std::regex re("(bold)?\\s*(\\d+)px\\s+(\\w+)");
std::match_results<std::string::const_iterator> results;
if (std::regex_search(_font.cbegin(), _font.cend(), results, re))
{
fontName = results[2].str();
fontSizeStr = results[1].str();
bold = results[1].str();
fontSizeStr = results[2].str();
fontName = results[3].str();
}
CGFloat fontSize = atof(fontSizeStr.c_str());
@@ -313,11 +382,43 @@ void CanvasRenderingContext2D::set_font(const std::string& font)
void CanvasRenderingContext2D::set_textAlign(const std::string& textAlign)
{
SE_LOGD("CanvasRenderingContext2D::set_textAlign: %s\n", textAlign.c_str());
if (textAlign == "left")
{
_impl.textAlign = CanvasTextAlign::LEFT;
}
else if (textAlign == "center")
{
_impl.textAlign = CanvasTextAlign::CENTER;
}
else if (textAlign == "right")
{
_impl.textAlign = CanvasTextAlign::RIGHT;
}
else
{
assert(false);
}
}
void CanvasRenderingContext2D::set_textBaseline(const std::string& textBaseline)
{
SE_LOGD("CanvasRenderingContext2D::set_textBaseline: %s\n", textBaseline.c_str());
if (textBaseline == "top")
{
_impl.textBaseLine = CanvasTextBaseline::TOP;
}
else if (textBaseline == "middle")
{
_impl.textBaseLine = CanvasTextBaseline::MIDDLE;
}
else if (textBaseline == "bottom")
{
_impl.textBaseLine = CanvasTextBaseline::BOTTOM;
}
else
{
assert(false);
}
}
void CanvasRenderingContext2D::set_fillStyle(const std::string& fillStyle)
@@ -540,14 +540,6 @@ float
{
},
/**
* @method beginPath
*/
beginPath : function (
)
{
},
/**
* @method lineTo
* @param {float} arg0
@@ -561,39 +553,39 @@ float
},
/**
* @method getImageData
* @param {float} arg0
* @param {float} arg1
* @param {float} arg2
* @param {float} arg3
* @return {cc.Data}
* @method stroke
*/
getImageData : function (
float,
float,
float,
float
stroke : function (
)
{
return cc.Data;
},
/**
* @method createLinearGradient
* @method measureText
* @param {String} arg0
* @return {size_object}
*/
measureText : function (
str
)
{
return cc.Size;
},
/**
* @method clearRect
* @param {float} arg0
* @param {float} arg1
* @param {float} arg2
* @param {float} arg3
* @return {cc.CanvasGradient}
*/
createLinearGradient : function (
clearRect : function (
float,
float,
float,
float
)
{
return cc.CanvasGradient;
},
/**
@@ -612,14 +604,6 @@ float
{
},
/**
* @method stroke
*/
stroke : function (
)
{
},
/**
* @method strokeText
* @param {String} arg0
@@ -636,26 +620,6 @@ float
{
},
/**
* @method measureText
* @param {String} arg0
* @return {size_object}
*/
measureText : function (
str
)
{
return cc.Size;
},
/**
* @method closePath
*/
closePath : function (
)
{
},
/**
* @method save
*/
@@ -665,18 +629,36 @@ save : function (
},
/**
* @method clearRect
* @method beginPath
*/
beginPath : function (
)
{
},
/**
* @method createLinearGradient
* @param {float} arg0
* @param {float} arg1
* @param {float} arg2
* @param {float} arg3
* @return {cc.CanvasGradient}
*/
clearRect : function (
createLinearGradient : function (
float,
float,
float,
float
)
{
return cc.CanvasGradient;
},
/**
* @method closePath
*/
closePath : function (
)
{
},
@@ -1057,21 +1057,6 @@ static bool js_cocos2dx_CanvasRenderingContext2D_moveTo(se::State& s)
}
SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_moveTo)
static bool js_cocos2dx_CanvasRenderingContext2D_beginPath(se::State& s)
{
cocos2d::CanvasRenderingContext2D* cobj = (cocos2d::CanvasRenderingContext2D*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_cocos2dx_CanvasRenderingContext2D_beginPath : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->beginPath();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_beginPath)
static bool js_cocos2dx_CanvasRenderingContext2D_lineTo(se::State& s)
{
cocos2d::CanvasRenderingContext2D* cobj = (cocos2d::CanvasRenderingContext2D*)s.nativeThisObject();
@@ -1093,37 +1078,46 @@ static bool js_cocos2dx_CanvasRenderingContext2D_lineTo(se::State& s)
}
SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_lineTo)
static bool js_cocos2dx_CanvasRenderingContext2D_getImageData(se::State& s)
static bool js_cocos2dx_CanvasRenderingContext2D_stroke(se::State& s)
{
cocos2d::CanvasRenderingContext2D* cobj = (cocos2d::CanvasRenderingContext2D*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_cocos2dx_CanvasRenderingContext2D_getImageData : Invalid Native Object");
SE_PRECONDITION2(cobj, false, "js_cocos2dx_CanvasRenderingContext2D_stroke : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 4) {
float arg0 = 0;
float arg1 = 0;
float arg2 = 0;
float arg3 = 0;
ok &= seval_to_float(args[0], &arg0);
ok &= seval_to_float(args[1], &arg1);
ok &= seval_to_float(args[2], &arg2);
ok &= seval_to_float(args[3], &arg3);
SE_PRECONDITION2(ok, false, "js_cocos2dx_CanvasRenderingContext2D_getImageData : Error processing arguments");
cocos2d::Data result = cobj->getImageData(arg0, arg1, arg2, arg3);
ok &= Data_to_seval(result, &s.rval());
SE_PRECONDITION2(ok, false, "js_cocos2dx_CanvasRenderingContext2D_getImageData : Error processing arguments");
if (argc == 0) {
cobj->stroke();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4);
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_getImageData)
SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_stroke)
static bool js_cocos2dx_CanvasRenderingContext2D_createLinearGradient(se::State& s)
static bool js_cocos2dx_CanvasRenderingContext2D_measureText(se::State& s)
{
cocos2d::CanvasRenderingContext2D* cobj = (cocos2d::CanvasRenderingContext2D*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_cocos2dx_CanvasRenderingContext2D_createLinearGradient : Invalid Native Object");
SE_PRECONDITION2(cobj, false, "js_cocos2dx_CanvasRenderingContext2D_measureText : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
std::string arg0;
ok &= seval_to_std_string(args[0], &arg0);
SE_PRECONDITION2(ok, false, "js_cocos2dx_CanvasRenderingContext2D_measureText : Error processing arguments");
cocos2d::Size result = cobj->measureText(arg0);
ok &= Size_to_seval(result, &s.rval());
SE_PRECONDITION2(ok, false, "js_cocos2dx_CanvasRenderingContext2D_measureText : Error processing arguments");
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_measureText)
static bool js_cocos2dx_CanvasRenderingContext2D_clearRect(se::State& s)
{
cocos2d::CanvasRenderingContext2D* cobj = (cocos2d::CanvasRenderingContext2D*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_cocos2dx_CanvasRenderingContext2D_clearRect : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
@@ -1136,16 +1130,14 @@ static bool js_cocos2dx_CanvasRenderingContext2D_createLinearGradient(se::State&
ok &= seval_to_float(args[1], &arg1);
ok &= seval_to_float(args[2], &arg2);
ok &= seval_to_float(args[3], &arg3);
SE_PRECONDITION2(ok, false, "js_cocos2dx_CanvasRenderingContext2D_createLinearGradient : Error processing arguments");
cocos2d::CanvasGradient* result = cobj->createLinearGradient(arg0, arg1, arg2, arg3);
ok &= native_ptr_to_seval<cocos2d::CanvasGradient>((cocos2d::CanvasGradient*)result, &s.rval());
SE_PRECONDITION2(ok, false, "js_cocos2dx_CanvasRenderingContext2D_createLinearGradient : Error processing arguments");
SE_PRECONDITION2(ok, false, "js_cocos2dx_CanvasRenderingContext2D_clearRect : Error processing arguments");
cobj->clearRect(arg0, arg1, arg2, arg3);
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4);
return false;
}
SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_createLinearGradient)
SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_clearRect)
static bool js_cocos2dx_CanvasRenderingContext2D_fillText(se::State& s)
{
@@ -1183,21 +1175,6 @@ static bool js_cocos2dx_CanvasRenderingContext2D_fillText(se::State& s)
}
SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_fillText)
static bool js_cocos2dx_CanvasRenderingContext2D_stroke(se::State& s)
{
cocos2d::CanvasRenderingContext2D* cobj = (cocos2d::CanvasRenderingContext2D*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_cocos2dx_CanvasRenderingContext2D_stroke : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->stroke();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_stroke)
static bool js_cocos2dx_CanvasRenderingContext2D_strokeText(se::State& s)
{
cocos2d::CanvasRenderingContext2D* cobj = (cocos2d::CanvasRenderingContext2D*)s.nativeThisObject();
@@ -1234,42 +1211,6 @@ static bool js_cocos2dx_CanvasRenderingContext2D_strokeText(se::State& s)
}
SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_strokeText)
static bool js_cocos2dx_CanvasRenderingContext2D_measureText(se::State& s)
{
cocos2d::CanvasRenderingContext2D* cobj = (cocos2d::CanvasRenderingContext2D*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_cocos2dx_CanvasRenderingContext2D_measureText : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
std::string arg0;
ok &= seval_to_std_string(args[0], &arg0);
SE_PRECONDITION2(ok, false, "js_cocos2dx_CanvasRenderingContext2D_measureText : Error processing arguments");
cocos2d::Size result = cobj->measureText(arg0);
ok &= Size_to_seval(result, &s.rval());
SE_PRECONDITION2(ok, false, "js_cocos2dx_CanvasRenderingContext2D_measureText : Error processing arguments");
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_measureText)
static bool js_cocos2dx_CanvasRenderingContext2D_closePath(se::State& s)
{
cocos2d::CanvasRenderingContext2D* cobj = (cocos2d::CanvasRenderingContext2D*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_cocos2dx_CanvasRenderingContext2D_closePath : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->closePath();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_closePath)
static bool js_cocos2dx_CanvasRenderingContext2D_save(se::State& s)
{
cocos2d::CanvasRenderingContext2D* cobj = (cocos2d::CanvasRenderingContext2D*)s.nativeThisObject();
@@ -1285,10 +1226,25 @@ static bool js_cocos2dx_CanvasRenderingContext2D_save(se::State& s)
}
SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_save)
static bool js_cocos2dx_CanvasRenderingContext2D_clearRect(se::State& s)
static bool js_cocos2dx_CanvasRenderingContext2D_beginPath(se::State& s)
{
cocos2d::CanvasRenderingContext2D* cobj = (cocos2d::CanvasRenderingContext2D*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_cocos2dx_CanvasRenderingContext2D_clearRect : Invalid Native Object");
SE_PRECONDITION2(cobj, false, "js_cocos2dx_CanvasRenderingContext2D_beginPath : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->beginPath();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_beginPath)
static bool js_cocos2dx_CanvasRenderingContext2D_createLinearGradient(se::State& s)
{
cocos2d::CanvasRenderingContext2D* cobj = (cocos2d::CanvasRenderingContext2D*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_cocos2dx_CanvasRenderingContext2D_createLinearGradient : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
@@ -1301,14 +1257,31 @@ static bool js_cocos2dx_CanvasRenderingContext2D_clearRect(se::State& s)
ok &= seval_to_float(args[1], &arg1);
ok &= seval_to_float(args[2], &arg2);
ok &= seval_to_float(args[3], &arg3);
SE_PRECONDITION2(ok, false, "js_cocos2dx_CanvasRenderingContext2D_clearRect : Error processing arguments");
cobj->clearRect(arg0, arg1, arg2, arg3);
SE_PRECONDITION2(ok, false, "js_cocos2dx_CanvasRenderingContext2D_createLinearGradient : Error processing arguments");
cocos2d::CanvasGradient* result = cobj->createLinearGradient(arg0, arg1, arg2, arg3);
ok &= native_ptr_to_seval<cocos2d::CanvasGradient>((cocos2d::CanvasGradient*)result, &s.rval());
SE_PRECONDITION2(ok, false, "js_cocos2dx_CanvasRenderingContext2D_createLinearGradient : Error processing arguments");
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4);
return false;
}
SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_clearRect)
SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_createLinearGradient)
static bool js_cocos2dx_CanvasRenderingContext2D_closePath(se::State& s)
{
cocos2d::CanvasRenderingContext2D* cobj = (cocos2d::CanvasRenderingContext2D*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_cocos2dx_CanvasRenderingContext2D_closePath : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cobj->closePath();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_closePath)
SE_DECLARE_FINALIZE_FUNC(js_cocos2d_CanvasRenderingContext2D_finalize)
@@ -1351,17 +1324,16 @@ bool js_register_cocos2dx_CanvasRenderingContext2D(se::Object* obj)
cls->defineFunction("restore", _SE(js_cocos2dx_CanvasRenderingContext2D_restore));
cls->defineFunction("moveTo", _SE(js_cocos2dx_CanvasRenderingContext2D_moveTo));
cls->defineFunction("beginPath", _SE(js_cocos2dx_CanvasRenderingContext2D_beginPath));
cls->defineFunction("lineTo", _SE(js_cocos2dx_CanvasRenderingContext2D_lineTo));
cls->defineFunction("_getImageData", _SE(js_cocos2dx_CanvasRenderingContext2D_getImageData));
cls->defineFunction("createLinearGradient", _SE(js_cocos2dx_CanvasRenderingContext2D_createLinearGradient));
cls->defineFunction("fillText", _SE(js_cocos2dx_CanvasRenderingContext2D_fillText));
cls->defineFunction("stroke", _SE(js_cocos2dx_CanvasRenderingContext2D_stroke));
cls->defineFunction("strokeText", _SE(js_cocos2dx_CanvasRenderingContext2D_strokeText));
cls->defineFunction("measureText", _SE(js_cocos2dx_CanvasRenderingContext2D_measureText));
cls->defineFunction("closePath", _SE(js_cocos2dx_CanvasRenderingContext2D_closePath));
cls->defineFunction("save", _SE(js_cocos2dx_CanvasRenderingContext2D_save));
cls->defineFunction("clearRect", _SE(js_cocos2dx_CanvasRenderingContext2D_clearRect));
cls->defineFunction("fillText", _SE(js_cocos2dx_CanvasRenderingContext2D_fillText));
cls->defineFunction("strokeText", _SE(js_cocos2dx_CanvasRenderingContext2D_strokeText));
cls->defineFunction("save", _SE(js_cocos2dx_CanvasRenderingContext2D_save));
cls->defineFunction("beginPath", _SE(js_cocos2dx_CanvasRenderingContext2D_beginPath));
cls->defineFunction("createLinearGradient", _SE(js_cocos2dx_CanvasRenderingContext2D_createLinearGradient));
cls->defineFunction("closePath", _SE(js_cocos2dx_CanvasRenderingContext2D_closePath));
cls->defineFinalizeFunction(_SE(js_cocos2d_CanvasRenderingContext2D_finalize));
cls->install();
JSBClassType::registerClass<cocos2d::CanvasRenderingContext2D>(cls);
@@ -70,16 +70,15 @@ bool js_register_cocos2d_CanvasRenderingContext2D(se::Object* obj);
bool register_all_cocos2dx(se::Object* obj);
SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_restore);
SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_moveTo);
SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_beginPath);
SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_lineTo);
SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_getImageData);
SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_createLinearGradient);
SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_fillText);
SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_stroke);
SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_strokeText);
SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_measureText);
SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_closePath);
SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_save);
SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_clearRect);
SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_fillText);
SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_strokeText);
SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_save);
SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_beginPath);
SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_createLinearGradient);
SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_closePath);
SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_CanvasRenderingContext2D);
@@ -357,6 +357,55 @@ BIND_PROP_WITH_TYPE__CONV_FUNC__RETURN(CanvasRenderingContext2D, globalComposite
#define _SE_DEFINE_PROP(cls, property) \
__jsb_cocos2d_##cls##_proto->defineProperty(#property, _SE(js_cocos2dx_##cls_get_##property), _SE(js_cocos2dx_##cls_set_##property));
//FIXME:cjh move to auto bindings.
static bool js_cocos2dx_CanvasRenderingContext2D_setCanvasBufferUpdatedCallback(se::State& s)
{
cocos2d::CanvasRenderingContext2D* cobj = (cocos2d::CanvasRenderingContext2D*)s.nativeThisObject();
SE_PRECONDITION2(cobj, false, "js_cocos2dx_CanvasRenderingContext2D_setCanvasBufferUpdatedCallback : Invalid Native Object");
const auto& args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
std::function<void (const cocos2d::Data &)> arg0;
do {
if (args[0].isObject() && args[0].toObject()->isFunction())
{
se::Value jsThis(s.thisObject());
se::Value jsFunc(args[0]);
jsThis.toObject()->attachObject(jsFunc.toObject());
auto lambda = [=](const cocos2d::Data & larg0) -> void {
se::ScriptEngine::getInstance()->clearException();
se::AutoHandleScope hs;
CC_UNUSED bool ok = true;
se::ValueArray args;
args.resize(1);
ok &= Data_to_seval(larg0, &args[0]);
se::Value rval;
se::Object* thisObj = jsThis.isObject() ? jsThis.toObject() : nullptr;
se::Object* funcObj = jsFunc.toObject();
bool succeed = funcObj->call(args, thisObj, &rval);
if (!succeed) {
se::ScriptEngine::getInstance()->clearException();
}
};
arg0 = lambda;
}
else
{
arg0 = nullptr;
}
} while(false)
;
SE_PRECONDITION2(ok, false, "js_cocos2dx_CanvasRenderingContext2D_setCanvasBufferUpdatedCallback : Error processing arguments");
cobj->setCanvasBufferUpdatedCallback(arg0);
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_setCanvasBufferUpdatedCallback)
static bool register_canvas_context2d(se::Object* obj)
{
_SE_DEFINE_PROP(CanvasRenderingContext2D, _width)
@@ -370,6 +419,8 @@ static bool register_canvas_context2d(se::Object* obj)
_SE_DEFINE_PROP(CanvasRenderingContext2D, strokeStyle)
_SE_DEFINE_PROP(CanvasRenderingContext2D, globalCompositeOperation)
__jsb_cocos2d_CanvasRenderingContext2D_proto->defineFunction("setCanvasBufferUpdatedCallback", _SE(js_cocos2dx_CanvasRenderingContext2D_setCanvasBufferUpdatedCallback));
se::ScriptEngine::getInstance()->clearException();
return true;
+2 -1
View File
@@ -44,7 +44,8 @@ field =
# functions from all classes.
skip = FileUtils::[getFileData setFilenameLookupDictionary destroyInstance getFullPathCache getContents],
SAXParser::[(?!(init))]
SAXParser::[(?!(init))],
CanvasRenderingContext2D::[setCanvasBufferUpdatedCallback set_.+]
rename_functions = FileUtils::[loadFilenameLookupDictionaryFromFile=loadFilenameLookup],
CanvasRenderingContext2D::[getImageData=_getImageData]