2013-03-02 01:09:58 +08:00
|
|
|
/****************************************************************************
|
|
|
|
Copyright (c) 2013 The Chromium Authors
|
|
|
|
|
|
|
|
http://www.cocos2d-x.org
|
|
|
|
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
|
|
in the Software without restriction, including without limitation the rights
|
|
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
|
|
all copies or substantial portions of the Software.
|
|
|
|
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
THE SOFTWARE.
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
#include <vector>
|
|
|
|
#include <string>
|
|
|
|
#include <sstream>
|
|
|
|
#include <algorithm>
|
|
|
|
|
|
|
|
#include "platform/CCFileUtils.h"
|
|
|
|
#include "platform/CCPlatformMacros.h"
|
|
|
|
#define __CC_PLATFORM_IMAGE_CPP__
|
|
|
|
#include "platform/CCImageCommon_cpp.h"
|
|
|
|
#include "platform/CCImage.h"
|
|
|
|
#include "platform/linux/CCApplication.h"
|
|
|
|
|
|
|
|
#include "ft2build.h"
|
|
|
|
#include "CCStdC.h"
|
|
|
|
|
|
|
|
#include FT_FREETYPE_H
|
|
|
|
|
|
|
|
#define szFont_kenning 2
|
|
|
|
|
|
|
|
#define SHIFT6(num) (num>>6)
|
|
|
|
|
|
|
|
using namespace std;
|
|
|
|
|
|
|
|
struct TextLine {
|
|
|
|
int iLineWidth;
|
|
|
|
wchar_t* text;
|
|
|
|
};
|
|
|
|
|
|
|
|
NS_CC_BEGIN
|
|
|
|
|
|
|
|
class BitmapDC
|
|
|
|
{
|
|
|
|
public:
|
2013-04-19 02:19:12 +08:00
|
|
|
BitmapDC() : _data(NULL), _cachedFont(NULL)
|
2013-03-02 01:09:58 +08:00
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
libError = FT_Init_FreeType(&_library);
|
2013-03-02 01:09:58 +08:00
|
|
|
iInterval = szFont_kenning;
|
|
|
|
reset();
|
|
|
|
}
|
|
|
|
|
|
|
|
~BitmapDC()
|
|
|
|
{
|
2013-06-15 14:03:30 +08:00
|
|
|
if (_cachedFont)
|
|
|
|
FT_Done_Face(_cachedFont);
|
|
|
|
FT_Done_FreeType(_library);
|
2013-03-02 01:09:58 +08:00
|
|
|
reset();
|
|
|
|
}
|
|
|
|
|
|
|
|
void reset()
|
|
|
|
{
|
|
|
|
iMaxLineWidth = 0;
|
|
|
|
iMaxLineHeight = 0;
|
|
|
|
//Free all text lines
|
|
|
|
size_t size = vLines.size();
|
2013-03-05 02:21:45 +08:00
|
|
|
for (size_t i=0; i<size; ++i)
|
|
|
|
{
|
2013-03-02 01:09:58 +08:00
|
|
|
TextLine line = vLines[i];
|
|
|
|
free(line.text);
|
|
|
|
}
|
|
|
|
vLines.clear();
|
|
|
|
}
|
|
|
|
|
|
|
|
int utf8(char **p)
|
|
|
|
{
|
|
|
|
if ((**p & 0x80) == 0x00)
|
|
|
|
{
|
|
|
|
int a = *((*p)++);
|
|
|
|
|
|
|
|
return a;
|
|
|
|
}
|
|
|
|
if ((**p & 0xE0) == 0xC0)
|
|
|
|
{
|
|
|
|
int a = *((*p)++) & 0x1F;
|
|
|
|
int b = *((*p)++) & 0x3F;
|
|
|
|
|
|
|
|
return (a << 6) | b;
|
|
|
|
}
|
|
|
|
if ((**p & 0xF0) == 0xE0)
|
|
|
|
{
|
|
|
|
int a = *((*p)++) & 0x0F;
|
|
|
|
int b = *((*p)++) & 0x3F;
|
|
|
|
int c = *((*p)++) & 0x3F;
|
|
|
|
|
|
|
|
return (a << 12) | (b << 6) | c;
|
|
|
|
}
|
|
|
|
if ((**p & 0xF8) == 0xF0)
|
|
|
|
{
|
|
|
|
int a = *((*p)++) & 0x07;
|
|
|
|
int b = *((*p)++) & 0x3F;
|
|
|
|
int c = *((*p)++) & 0x3F;
|
|
|
|
int d = *((*p)++) & 0x3F;
|
|
|
|
|
|
|
|
return (a << 18) | (b << 12) | (c << 8) | d;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void buildLine(wchar_t* buf, size_t buf_len, FT_Face face, int iCurXCursor, FT_UInt cLastChar)
|
|
|
|
{
|
|
|
|
TextLine oTempLine;
|
|
|
|
wchar_t* text = (wchar_t*)malloc(sizeof(wchar_t) * (buf_len+1));
|
|
|
|
memcpy(text, buf, sizeof(wchar_t) * buf_len);
|
|
|
|
text[buf_len] = '\0';
|
|
|
|
oTempLine.text = text;
|
|
|
|
|
|
|
|
//get last glyph
|
|
|
|
FT_Load_Char(face, cLastChar, FT_LOAD_DEFAULT);
|
|
|
|
|
|
|
|
oTempLine.iLineWidth = iCurXCursor;// - SHIFT6((face->glyph->metrics.horiAdvance + face->glyph->metrics.horiBearingX - face->glyph->metrics.width))/*-iInterval*/;//TODO interval
|
|
|
|
iMaxLineWidth = MAX(iMaxLineWidth, oTempLine.iLineWidth);
|
|
|
|
|
|
|
|
vLines.push_back(oTempLine);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool divideString(FT_Face face, const char* sText, int iMaxWidth, int iMaxHeight)
|
|
|
|
{
|
|
|
|
int iError = 0;
|
|
|
|
const char* pText = sText;
|
|
|
|
|
|
|
|
FT_UInt unicode = utf8((char**)&pText);
|
|
|
|
iError = FT_Load_Char(face, unicode, FT_LOAD_DEFAULT);
|
|
|
|
if (iError)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
int iCurXCursor = -SHIFT6(face->glyph->metrics.horiBearingX);
|
|
|
|
|
|
|
|
FT_UInt cLastCh = 0;
|
|
|
|
|
|
|
|
pText = sText;
|
|
|
|
size_t text_len = 0;
|
|
|
|
wchar_t* text_buf = (wchar_t*) malloc(sizeof(wchar_t) * strlen(sText));
|
|
|
|
while ((unicode=utf8((char**)&pText)))
|
|
|
|
{
|
|
|
|
if (unicode == '\n')
|
|
|
|
{
|
|
|
|
buildLine(text_buf, text_len, face, iCurXCursor, cLastCh);
|
|
|
|
text_len = 0;
|
|
|
|
|
|
|
|
iError = FT_Load_Char(face, unicode, FT_LOAD_DEFAULT);
|
|
|
|
if (iError) {
|
|
|
|
free(text_buf);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
iCurXCursor = -SHIFT6(face->glyph->metrics.horiBearingX);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
iError = FT_Load_Char(face, unicode, FT_LOAD_DEFAULT);
|
|
|
|
|
|
|
|
if (iError) {
|
|
|
|
free(text_buf);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
//check its width
|
|
|
|
//divide it when exceeding
|
|
|
|
if ((iMaxWidth > 0
|
|
|
|
&& iCurXCursor + SHIFT6(face->glyph->metrics.width)
|
|
|
|
> iMaxWidth)) {
|
|
|
|
buildLine(text_buf, text_len, face , iCurXCursor, cLastCh);
|
|
|
|
text_len = 0;
|
|
|
|
|
|
|
|
iCurXCursor = -SHIFT6(face->glyph->metrics.horiBearingX);
|
|
|
|
}
|
|
|
|
|
|
|
|
cLastCh = unicode;
|
|
|
|
text_buf[text_len] = unicode;
|
|
|
|
++text_len;
|
|
|
|
iCurXCursor += SHIFT6(face->glyph->metrics.horiAdvance) + iInterval;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (iError)
|
|
|
|
{
|
|
|
|
free(text_buf);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
buildLine(text_buf, text_len, face, iCurXCursor, cLastCh);
|
|
|
|
free(text_buf);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* compute the start pos of every line
|
|
|
|
*
|
|
|
|
* return >0 represent the start x pos of the line
|
|
|
|
* while -1 means fail
|
|
|
|
*
|
|
|
|
*/
|
2013-06-20 14:13:12 +08:00
|
|
|
int computeLineStart(FT_Face face, Image::ETextAlign eAlignMask, FT_UInt unicode,
|
2013-03-02 01:09:58 +08:00
|
|
|
int iLineIndex)
|
|
|
|
{
|
|
|
|
int iRet;
|
|
|
|
int iError = FT_Load_Char(face, unicode, FT_LOAD_DEFAULT);
|
|
|
|
if (iError) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-06-20 14:13:12 +08:00
|
|
|
if (eAlignMask == Image::kAlignCenter) {
|
2013-03-02 01:09:58 +08:00
|
|
|
iRet = (iMaxLineWidth - vLines[iLineIndex].iLineWidth) / 2
|
|
|
|
- SHIFT6(face->glyph->metrics.horiBearingX );
|
|
|
|
|
2013-06-20 14:13:12 +08:00
|
|
|
} else if (eAlignMask == Image::kAlignRight) {
|
2013-03-02 01:09:58 +08:00
|
|
|
iRet = (iMaxLineWidth - vLines[iLineIndex].iLineWidth)
|
|
|
|
- SHIFT6(face->glyph->metrics.horiBearingX );
|
|
|
|
} else {
|
|
|
|
// left or other situation
|
|
|
|
iRet = -SHIFT6(face->glyph->metrics.horiBearingX );
|
|
|
|
}
|
|
|
|
return iRet;
|
|
|
|
}
|
|
|
|
|
2013-06-20 14:13:12 +08:00
|
|
|
int computeLineStartY(FT_Face face, Image::ETextAlign eAlignMask, int txtHeight, int borderHeight)
|
2013-03-02 01:09:58 +08:00
|
|
|
{
|
|
|
|
int iRet = 0;
|
2013-06-20 14:13:12 +08:00
|
|
|
if (eAlignMask == Image::kAlignCenter || eAlignMask == Image::kAlignLeft ||
|
|
|
|
eAlignMask == Image::kAlignRight ) {
|
2013-03-02 01:09:58 +08:00
|
|
|
//vertical center
|
|
|
|
iRet = (borderHeight - txtHeight)/2;
|
|
|
|
|
2013-06-20 14:13:12 +08:00
|
|
|
} else if (eAlignMask == Image::kAlignBottomRight ||
|
|
|
|
eAlignMask == Image::kAlignBottom ||
|
|
|
|
eAlignMask == Image::kAlignBottomLeft ) {
|
2013-03-02 01:09:58 +08:00
|
|
|
//vertical bottom
|
|
|
|
iRet = borderHeight - txtHeight;
|
|
|
|
}
|
|
|
|
iRet += SHIFT6(face->size->metrics.ascender);
|
|
|
|
return iRet;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool renderLine(FT_Face face, const wchar_t* text_ptr, int* iCurXCursor, int iCurYCursor)
|
|
|
|
{
|
|
|
|
assert(iCurYCursor > 0);
|
|
|
|
size_t text_len = wcslen(text_ptr);
|
|
|
|
for (size_t i=0; i<text_len; ++i)
|
|
|
|
{
|
|
|
|
int iError = FT_Load_Char(face, text_ptr[i], FT_LOAD_RENDER);
|
|
|
|
if (iError)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// convert glyph to bitmap with 256 gray
|
|
|
|
// and get the bitmap
|
|
|
|
FT_Bitmap& bitmap = face->glyph->bitmap;
|
|
|
|
|
|
|
|
int yoffset = iCurYCursor - SHIFT6(face->glyph->metrics.horiBearingY);
|
|
|
|
int xoffset = *iCurXCursor + SHIFT6(face->glyph->metrics.horiBearingX);
|
|
|
|
for (int i = 0; i < bitmap.rows; ++i)
|
|
|
|
{
|
|
|
|
for (int j = 0; j < bitmap.width; ++j)
|
|
|
|
{
|
|
|
|
unsigned char cTemp = bitmap.buffer[i * bitmap.width + j];
|
|
|
|
if (cTemp == 0) continue;
|
|
|
|
|
|
|
|
// if it has gray>0 we set show it as 1, o otherwise
|
|
|
|
int iY = yoffset + i;
|
|
|
|
int iX = xoffset + j;
|
|
|
|
|
|
|
|
if (iY < 0)
|
|
|
|
{
|
|
|
|
//truncate if drawing below first line
|
|
|
|
assert(iY >= -1);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (iY >= iMaxLineHeight)
|
|
|
|
{
|
|
|
|
//exceed the height truncate
|
|
|
|
assert(iY <= iMaxLineHeight + 1);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
int iTemp = cTemp << 24 | cTemp << 16 | cTemp << 8 | cTemp;
|
|
|
|
int data_offset = iY * iMaxLineWidth + iX;
|
|
|
|
assert(data_offset >= 0);
|
2013-06-15 14:03:30 +08:00
|
|
|
assert(data_offset < _dataSize);
|
|
|
|
_data[data_offset] = iTemp;
|
2013-03-02 01:09:58 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//step to next glyph
|
|
|
|
*iCurXCursor += SHIFT6(face->glyph->metrics.horiAdvance) + iInterval;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2013-06-20 14:13:12 +08:00
|
|
|
bool renderLines(FT_Face face, Image::ETextAlign eAlignMask, int iCurYCursor)
|
2013-03-02 01:09:58 +08:00
|
|
|
{
|
|
|
|
size_t lines = vLines.size();
|
|
|
|
for (size_t i = 0; i < lines; i++)
|
|
|
|
{
|
|
|
|
const wchar_t* text_ptr = vLines[i].text;
|
|
|
|
|
|
|
|
// initialize the origin cursor
|
|
|
|
int iCurXCursor = computeLineStart(face, eAlignMask, text_ptr[0], i);
|
|
|
|
if (!renderLine(face, text_ptr, &iCurXCursor, iCurYCursor))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
iCurYCursor += SHIFT6(face->size->metrics.ascender) -
|
|
|
|
SHIFT6(face->size->metrics.descender);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2013-06-20 14:13:12 +08:00
|
|
|
bool getBitmap(const char *text, int nWidth, int nHeight, Image::ETextAlign eAlignMask, const char * pFontName, float fontSize)
|
2013-03-02 01:09:58 +08:00
|
|
|
{
|
|
|
|
FT_Error iError;
|
|
|
|
if (libError)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
std::string fontfile = pFontName;
|
|
|
|
std::string fontfileOrig = std::string(fontfile);
|
|
|
|
|
|
|
|
std::string ext = fileNameExtension(fontfile);
|
|
|
|
if (ext.empty() || (ext != "ttf" && ext != "TTF"))
|
|
|
|
{
|
|
|
|
fontfile += ".ttf" ;
|
|
|
|
}
|
|
|
|
|
2013-04-19 02:19:12 +08:00
|
|
|
iError = openFont(fontfile, fontfileOrig);
|
2013-03-02 01:09:58 +08:00
|
|
|
// try with fonts prefixed
|
|
|
|
if (iError && !startsWith(fontfile,"fonts/") )
|
|
|
|
{
|
|
|
|
fontfile = std::string("fonts/") + fontfile;
|
2013-04-19 02:19:12 +08:00
|
|
|
iError = openFont(fontfile, fontfileOrig);
|
2013-03-02 01:09:58 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (iError)
|
|
|
|
{
|
|
|
|
// try lowercase version
|
|
|
|
std::transform(fontfile.begin(), fontfile.end(), fontfile.begin(), ::tolower);
|
2013-04-19 02:19:12 +08:00
|
|
|
iError = openFont(fontfile, fontfileOrig);
|
2013-03-02 01:09:58 +08:00
|
|
|
if (iError)
|
|
|
|
{
|
|
|
|
// try default font
|
|
|
|
CCLOG("font missing (%s) falling back to default font", fontfileOrig.c_str());
|
2013-04-19 02:19:12 +08:00
|
|
|
iError = openFont("fonts/Marker Felt.ttf", fontfileOrig);
|
2013-03-02 01:09:58 +08:00
|
|
|
if (iError)
|
|
|
|
CCLOG("default font missing (fonts/Marker Felt.ttf)");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (iError)
|
|
|
|
return false;
|
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
FT_Face face = _cachedFont;
|
2013-03-02 01:09:58 +08:00
|
|
|
|
|
|
|
//select utf8 charmap
|
|
|
|
iError = FT_Select_Charmap(face,FT_ENCODING_UNICODE);
|
|
|
|
if (iError)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
iError = FT_Set_Pixel_Sizes(face, fontSize, fontSize);
|
|
|
|
if (iError)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!divideString(face, text, nWidth, nHeight))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
//compute the final line width
|
|
|
|
iMaxLineWidth = MAX(iMaxLineWidth, nWidth);
|
|
|
|
|
|
|
|
iMaxLineHeight = SHIFT6(face->size->metrics.ascender) - SHIFT6(face->size->metrics.descender);
|
|
|
|
iMaxLineHeight *= vLines.size();
|
|
|
|
|
|
|
|
int txtHeight = iMaxLineHeight;
|
|
|
|
|
|
|
|
//compute the final line height
|
|
|
|
iMaxLineHeight = MAX(iMaxLineHeight, nHeight);
|
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
// create _data as render target
|
|
|
|
_dataSize = iMaxLineWidth * iMaxLineHeight;
|
|
|
|
_data = new int[_dataSize];
|
|
|
|
memset(_data, 0, _dataSize*sizeof(*_data));
|
2013-03-02 01:09:58 +08:00
|
|
|
|
|
|
|
//iCurYCursor = SHIFT6(face->size->metrics.ascender);
|
|
|
|
int iCurYCursor = computeLineStartY(face, eAlignMask, txtHeight, iMaxLineHeight);
|
|
|
|
if (!renderLines(face, eAlignMask, iCurYCursor))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// success;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
public:
|
2013-06-15 14:03:30 +08:00
|
|
|
FT_Library _library;
|
2013-03-02 01:09:58 +08:00
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
int *_data;
|
|
|
|
// size of _data in words
|
|
|
|
int _dataSize;
|
2013-03-02 01:09:58 +08:00
|
|
|
int libError;
|
|
|
|
vector<TextLine> vLines;
|
|
|
|
int iInterval;
|
|
|
|
int iMaxLineWidth;
|
|
|
|
int iMaxLineHeight;
|
|
|
|
private:
|
|
|
|
bool startsWith(const std::string& str, const std::string& what);
|
|
|
|
/**
|
|
|
|
* Attempt to open font file, and cache it if successful.
|
|
|
|
*/
|
2013-04-19 02:19:12 +08:00
|
|
|
int openFont(const std::string& fontName, const std::string& fontNameOrig);
|
2013-03-02 01:09:58 +08:00
|
|
|
std::string fileNameExtension(const std::string& pathName);
|
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
FT_Face _cachedFont;
|
|
|
|
std::string _cachedFontname;
|
|
|
|
std::string _cachedFontnameOrig;
|
2013-03-02 01:09:58 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
static BitmapDC& sharedBitmapDC()
|
|
|
|
{
|
|
|
|
static BitmapDC s_BmpDC;
|
|
|
|
return s_BmpDC;
|
|
|
|
}
|
|
|
|
|
2013-06-20 14:13:12 +08:00
|
|
|
bool Image::initWithString(
|
2013-03-02 01:09:58 +08:00
|
|
|
const char * pText,
|
|
|
|
int nWidth/* = 0*/,
|
|
|
|
int nHeight/* = 0*/,
|
|
|
|
ETextAlign eAlignMask/* = kAlignCenter*/,
|
|
|
|
const char * pFontName/* = nil*/,
|
|
|
|
int nSize/* = 0*/)
|
|
|
|
{
|
|
|
|
bool bRet = false;
|
|
|
|
do
|
|
|
|
{
|
|
|
|
CC_BREAK_IF(! pText);
|
|
|
|
|
|
|
|
BitmapDC &dc = sharedBitmapDC();
|
|
|
|
|
2013-07-12 12:03:39 +08:00
|
|
|
//const char* pFullFontName = FileUtils::getInstance()->fullPathFromRelativePath(pFontName);
|
2013-03-02 01:09:58 +08:00
|
|
|
|
|
|
|
CC_BREAK_IF(! dc.getBitmap(pText, nWidth, nHeight, eAlignMask, pFontName, nSize));
|
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
// assign the dc._data to _data in order to save time
|
|
|
|
_data = (unsigned char*)dc._data;
|
|
|
|
CC_BREAK_IF(! _data);
|
2013-03-02 01:09:58 +08:00
|
|
|
|
2013-06-15 14:03:30 +08:00
|
|
|
_width = (short)dc.iMaxLineWidth;
|
|
|
|
_height = (short)dc.iMaxLineHeight;
|
|
|
|
_preMulti = true;
|
2013-07-26 17:34:44 +08:00
|
|
|
_renderFormat = kTexture2DPixelFormat_RGBA8888;
|
2013-03-02 01:09:58 +08:00
|
|
|
|
|
|
|
bRet = true;
|
|
|
|
|
|
|
|
dc.reset();
|
|
|
|
} while (0);
|
|
|
|
|
|
|
|
if (!bRet)
|
|
|
|
CCLOG("CCImage::initWithString failed");
|
|
|
|
|
|
|
|
//do nothing
|
|
|
|
return bRet;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string BitmapDC::fileNameExtension(const std::string& pathName)
|
|
|
|
{
|
|
|
|
std::string ext ;
|
|
|
|
std::string::size_type pos = pathName.find_last_of(".") ;
|
|
|
|
if (pos != std::string::npos && pos != pathName.size()-1 )
|
|
|
|
{
|
|
|
|
ext = pathName.substr(pos+1) ;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ext ;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool BitmapDC::startsWith(const std::string& str, const std::string& what)
|
|
|
|
{
|
|
|
|
bool result = false ;
|
|
|
|
if (what.size() <= str.size())
|
|
|
|
{
|
|
|
|
result = (str.substr(0, what.size()) == what);
|
|
|
|
}
|
|
|
|
return result ;
|
|
|
|
}
|
|
|
|
|
2013-04-19 02:19:12 +08:00
|
|
|
int BitmapDC::openFont(const std::string& fontName, const std::string& fontNameOrig)
|
2013-03-02 01:09:58 +08:00
|
|
|
{
|
|
|
|
// try to satisfy request based on currently cached font.
|
2013-04-19 02:19:12 +08:00
|
|
|
if (fontNameOrig == _cachedFontnameOrig)
|
|
|
|
return 0;
|
2013-03-02 01:09:58 +08:00
|
|
|
|
2013-04-19 02:19:12 +08:00
|
|
|
if (fontName == _cachedFontname)
|
|
|
|
return 0;
|
2013-03-02 01:09:58 +08:00
|
|
|
|
|
|
|
FT_Face face;
|
2013-06-15 14:03:30 +08:00
|
|
|
int iError = FT_New_Face(_library, fontName.c_str(), 0, &face);
|
2013-03-02 01:09:58 +08:00
|
|
|
if (iError)
|
|
|
|
return iError;
|
|
|
|
|
|
|
|
// free existing cached font
|
2013-06-15 14:03:30 +08:00
|
|
|
if (_cachedFont)
|
|
|
|
FT_Done_Face(_cachedFont);
|
2013-03-02 01:09:58 +08:00
|
|
|
|
|
|
|
// cache newly loaded font
|
2013-06-15 14:03:30 +08:00
|
|
|
_cachedFontnameOrig = fontNameOrig;
|
|
|
|
_cachedFontname = fontName;
|
|
|
|
_cachedFont = face;
|
2013-03-02 01:09:58 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_CC_END
|