GlyphPageTreeNode.cpp [plain text]
#include "config.h"
#include "GlyphPageTreeNode.h"
#include "CharacterNames.h"
#include "SegmentedFontData.h"
#include "SimpleFontData.h"
#include <wtf/unicode/Unicode.h>
namespace WebCore {
using std::max;
using std::min;
HashMap<int, GlyphPageTreeNode*>* GlyphPageTreeNode::roots = 0;
GlyphPageTreeNode* GlyphPageTreeNode::pageZeroRoot = 0;
GlyphPageTreeNode* GlyphPageTreeNode::getRoot(unsigned pageNumber)
{
static bool initialized;
if (!initialized) {
initialized = true;
roots = new HashMap<int, GlyphPageTreeNode*>;
pageZeroRoot = new GlyphPageTreeNode;
}
GlyphPageTreeNode* node = pageNumber ? roots->get(pageNumber) : pageZeroRoot;
if (!node) {
node = new GlyphPageTreeNode;
#ifndef NDEBUG
node->m_pageNumber = pageNumber;
#endif
if (pageNumber)
roots->set(pageNumber, node);
else
pageZeroRoot = node;
}
return node;
}
size_t GlyphPageTreeNode::treeGlyphPageCount()
{
size_t count = 0;
if (roots) {
HashMap<int, GlyphPageTreeNode*>::iterator end = roots->end();
for (HashMap<int, GlyphPageTreeNode*>::iterator it = roots->begin(); it != end; ++it)
count += it->second->pageCount();
}
if (pageZeroRoot)
count += pageZeroRoot->pageCount();
return count;
}
size_t GlyphPageTreeNode::pageCount() const
{
size_t count = m_page && m_page->owner() == this ? 1 : 0;
HashMap<const FontData*, GlyphPageTreeNode*>::const_iterator end = m_children.end();
for (HashMap<const FontData*, GlyphPageTreeNode*>::const_iterator it = m_children.begin(); it != end; ++it)
count += it->second->pageCount();
return count;
}
void GlyphPageTreeNode::pruneTreeCustomFontData(const FontData* fontData)
{
if (roots) {
HashMap<int, GlyphPageTreeNode*>::iterator end = roots->end();
for (HashMap<int, GlyphPageTreeNode*>::iterator it = roots->begin(); it != end; ++it)
it->second->pruneCustomFontData(fontData);
}
if (pageZeroRoot)
pageZeroRoot->pruneCustomFontData(fontData);
}
void GlyphPageTreeNode::pruneTreeFontData(const SimpleFontData* fontData)
{
if (roots) {
HashMap<int, GlyphPageTreeNode*>::iterator end = roots->end();
for (HashMap<int, GlyphPageTreeNode*>::iterator it = roots->begin(); it != end; ++it)
it->second->pruneFontData(fontData);
}
if (pageZeroRoot)
pageZeroRoot->pruneFontData(fontData);
}
GlyphPageTreeNode::~GlyphPageTreeNode()
{
deleteAllValues(m_children);
delete m_systemFallbackChild;
}
void GlyphPageTreeNode::initializePage(const FontData* fontData, unsigned pageNumber)
{
ASSERT(!m_page);
ASSERT(m_level > 0 && m_parent);
GlyphPage* parentPage = m_parent->page();
if (fontData) {
if (m_level == 1) {
unsigned start = pageNumber * GlyphPage::size;
UChar buffer[GlyphPage::size * 2 + 2];
unsigned bufferLength;
unsigned i;
if (start < 0x10000) {
bufferLength = GlyphPage::size;
for (i = 0; i < GlyphPage::size; i++)
buffer[i] = start + i;
if (start == 0) {
for (i = 0; i < 0x20; ++i)
buffer[i] = zeroWidthSpace;
for (i = 0x7F; i < 0xA0; i++)
buffer[i] = zeroWidthSpace;
buffer[(int)'\n'] = ' ';
buffer[(int)'\t'] = ' ';
buffer[noBreakSpace] = ' ';
} else if (start == (leftToRightMark & ~(GlyphPage::size - 1))) {
buffer[leftToRightMark - start] = zeroWidthSpace;
buffer[rightToLeftMark - start] = zeroWidthSpace;
buffer[leftToRightEmbed - start] = zeroWidthSpace;
buffer[rightToLeftEmbed - start] = zeroWidthSpace;
buffer[leftToRightOverride - start] = zeroWidthSpace;
buffer[rightToLeftOverride - start] = zeroWidthSpace;
buffer[popDirectionalFormatting - start] = zeroWidthSpace;
} else if (start == (objectReplacementCharacter & ~(GlyphPage::size - 1))) {
buffer[objectReplacementCharacter - start] = zeroWidthSpace;
}
} else {
bufferLength = GlyphPage::size * 2;
for (i = 0; i < GlyphPage::size; i++) {
int c = i + start;
buffer[i * 2] = U16_LEAD(c);
buffer[i * 2 + 1] = U16_TRAIL(c);
}
}
m_page = GlyphPage::create(this);
bool haveGlyphs;
if (fontData->isSegmented()) {
haveGlyphs = false;
const SegmentedFontData* segmentedFontData = static_cast<const SegmentedFontData*>(fontData);
unsigned numRanges = segmentedFontData->numRanges();
bool zeroFilled = false;
RefPtr<GlyphPage> scratchPage;
GlyphPage* pageToFill = m_page.get();
for (unsigned i = 0; i < numRanges; i++) {
const FontDataRange& range = segmentedFontData->rangeAt(i);
int from = max(0, range.from() - static_cast<int>(start));
int to = 1 + min(range.to() - static_cast<int>(start), static_cast<int>(GlyphPage::size) - 1);
if (from < static_cast<int>(GlyphPage::size) && to > 0) {
if (haveGlyphs && !scratchPage) {
scratchPage = GlyphPage::create(this);
pageToFill = scratchPage.get();
}
if (!zeroFilled) {
if (from > 0 || to < static_cast<int>(GlyphPage::size)) {
for (unsigned i = 0; i < GlyphPage::size; i++)
pageToFill->setGlyphDataForIndex(i, 0, 0);
}
zeroFilled = true;
}
haveGlyphs |= pageToFill->fill(from, to - from, buffer + from * (start < 0x10000 ? 1 : 2), (to - from) * (start < 0x10000 ? 1 : 2), range.fontData());
if (scratchPage) {
for (int j = from; j < to; j++) {
if (!m_page->m_glyphs[j].glyph && pageToFill->m_glyphs[j].glyph)
m_page->m_glyphs[j] = pageToFill->m_glyphs[j];
}
}
}
}
} else
haveGlyphs = m_page->fill(0, GlyphPage::size, buffer, bufferLength, static_cast<const SimpleFontData*>(fontData));
if (!haveGlyphs)
m_page = 0;
} else if (parentPage && parentPage->owner() != m_parent) {
m_page = parentPage->owner()->getChild(fontData, pageNumber)->page();
} else {
GlyphPage* fallbackPage = getRootChild(fontData, pageNumber)->page();
if (!parentPage) {
m_page = fallbackPage;
} else if (!fallbackPage) {
m_page = parentPage;
} else {
m_page = GlyphPage::create(this);
bool newGlyphs = false;
for (unsigned i = 0; i < GlyphPage::size; i++) {
if (parentPage->m_glyphs[i].glyph)
m_page->m_glyphs[i] = parentPage->m_glyphs[i];
else if (fallbackPage->m_glyphs[i].glyph) {
m_page->m_glyphs[i] = fallbackPage->m_glyphs[i];
newGlyphs = true;
} else {
const GlyphData data = { 0, 0 };
m_page->m_glyphs[i] = data;
}
}
if (!newGlyphs)
m_page = parentPage;
}
}
} else {
m_page = GlyphPage::create(this);
if (parentPage && pageNumber != 6) memcpy(m_page->m_glyphs, parentPage->m_glyphs, GlyphPage::size * sizeof(m_page->m_glyphs[0]));
else {
const GlyphData data = { 0, 0 };
for (unsigned i = 0; i < GlyphPage::size; i++)
m_page->m_glyphs[i] = data;
}
}
}
GlyphPageTreeNode* GlyphPageTreeNode::getChild(const FontData* fontData, unsigned pageNumber)
{
ASSERT(fontData || !m_isSystemFallback);
ASSERT(pageNumber == m_pageNumber);
GlyphPageTreeNode* child = fontData ? m_children.get(fontData) : m_systemFallbackChild;
if (!child) {
child = new GlyphPageTreeNode;
child->m_parent = this;
child->m_level = m_level + 1;
if (fontData && fontData->isCustomFont()) {
for (GlyphPageTreeNode* curr = this; curr; curr = curr->m_parent)
curr->m_customFontCount++;
}
#ifndef NDEBUG
child->m_pageNumber = m_pageNumber;
#endif
if (fontData) {
m_children.set(fontData, child);
fontData->setMaxGlyphPageTreeLevel(max(fontData->maxGlyphPageTreeLevel(), child->m_level));
} else {
m_systemFallbackChild = child;
child->m_isSystemFallback = true;
}
child->initializePage(fontData, pageNumber);
}
return child;
}
void GlyphPageTreeNode::pruneCustomFontData(const FontData* fontData)
{
if (!fontData || !m_customFontCount)
return;
GlyphPageTreeNode* node = m_children.get(fontData);
if (node) {
m_children.remove(fontData);
unsigned fontCount = node->m_customFontCount + 1;
delete node;
for (GlyphPageTreeNode* curr = this; curr; curr = curr->m_parent)
curr->m_customFontCount -= fontCount;
}
if (!m_customFontCount)
return;
HashMap<const FontData*, GlyphPageTreeNode*>::iterator end = m_children.end();
for (HashMap<const FontData*, GlyphPageTreeNode*>::iterator it = m_children.begin(); it != end; ++it)
it->second->pruneCustomFontData(fontData);
}
void GlyphPageTreeNode::pruneFontData(const SimpleFontData* fontData, unsigned level)
{
ASSERT(fontData);
if (!fontData)
return;
HashMap<const FontData*, GlyphPageTreeNode*>::iterator child = m_children.find(fontData);
if (child == m_children.end()) {
if (!level)
return;
} else {
GlyphPageTreeNode* node = child->second;
m_children.remove(fontData);
unsigned customFontCount = node->m_customFontCount;
delete node;
if (customFontCount) {
for (GlyphPageTreeNode* curr = this; curr; curr = curr->m_parent)
curr->m_customFontCount -= customFontCount;
}
}
level++;
if (level > fontData->maxGlyphPageTreeLevel())
return;
HashMap<const FontData*, GlyphPageTreeNode*>::iterator end = m_children.end();
for (HashMap<const FontData*, GlyphPageTreeNode*>::iterator it = m_children.begin(); it != end; ++it)
it->second->pruneFontData(fontData, level);
}
}