WebCore/platform/GlyphPageTreeNode.cpp - WebKit - Git at Google

 /*
  * Copyright (C) 2006, 2007 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
  *     documentation and/or other materials provided with the distribution.
  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
  *     its contributors may be used to endorse or promote products derived
  *     from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 #include "config.h"
 #include "GlyphPageTreeNode.h"

 #include "CharacterNames.h"
 #include "FontData.h"
 #include <wtf/unicode/Unicode.h>

 namespace WebCore {

 GlyphPageTreeNode* GlyphPageTreeNode::getRoot(unsigned pageNumber)
 {
     static HashMap<int, GlyphPageTreeNode*> roots;
     static GlyphPageTreeNode* pageZeroRoot;
     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;
 }

 void GlyphPageTreeNode::initializePage(const FontData* fontData, unsigned pageNumber)
 {
     ASSERT(!m_page);

     // This function must not be called for the root of the tree, because that
     // level does not contain any glyphs.
     ASSERT(m_level > 0 && m_parent);

     // The parent's page will be 0 if we are level one or the parent's font data
     // did not contain any glyphs for that page.
     GlyphPage* parentPage = m_parent->m_page;

     // NULL FontData means we're being asked for the system fallback font.
     if (fontData) {
         if (m_level == 1) {
             // Children of the root hold pure pages. These will cover only one
             // font data's glyphs, and will have glyph index 0 if the font data does not
             // contain the glyph.
             unsigned start = pageNumber * GlyphPage::size;
             UChar buffer[GlyphPage::size * 2 + 2];
             unsigned bufferLength;
             unsigned i;

             // Fill in a buffer with the entire "page" of characters that we want to look up glyphs for.
             if (start < 0x10000) {
                 bufferLength = GlyphPage::size;
                 for (i = 0; i < GlyphPage::size; i++)
                     buffer[i] = start + i;

                 if (start == 0) {
                     // Control characters must not render at all.
                     for (i = 0; i < 0x20; ++i)
                         buffer[i] = zeroWidthSpace;
                     for (i = 0x7F; i < 0xA0; i++)
                         buffer[i] = zeroWidthSpace;

                     // \n, \t, and nonbreaking space must render as a space.
                     buffer[(int)'\n'] = ' ';
                     buffer[(int)'\t'] = ' ';
                     buffer[noBreakSpace] = ' ';
                 } else if (start == (leftToRightMark & ~(GlyphPage::size - 1))) {
                     // LRM/RLM must not render at all.
                     buffer[leftToRightMark - start] = zeroWidthSpace;
                     buffer[rightToLeftMark - start] = zeroWidthSpace;
                 } else if (start == (objectReplacementCharacter & ~(GlyphPage::size - 1))) {
                     // Object replacement character must not render at all.
                     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 = new GlyphPage(this);

             // Now that we have a buffer full of characters, we want to get back an array
             // of glyph indices.  This part involves calling into the platform-specific
             // routine of our glyph map for actually filling in the page with the glyphs.
             // Success is not guaranteed. For example, Times fails to fill page 260, giving glyph data
             // for only 128 out of 256 characters.
             bool haveGlyphs = m_page->fill(buffer, bufferLength, fontData);

             if (!haveGlyphs) {
                 delete m_page;
                 m_page = 0;
             }
         } else if (parentPage && parentPage->owner() != m_parent) {
             // The page we're overriding may not be owned by our parent node.
             // This happens when our parent node provides no useful overrides
             // and just copies the pointer to an already-existing page (see
             // below).
             //
             // We want our override to be shared by all nodes that reference
             // that page to avoid duplication, and so standardize on having the
             // page's owner collect all the overrides.  Call getChild on the
             // page owner with the desired font data (this will populate
             // the page) and then reference it.
             m_page = parentPage->owner()->getChild(fontData, pageNumber)->page();
         } else {
             // Get the pure page for the fallback font (at level 1 with no
             // overrides). getRootChild will always create a page if one
             // doesn't exist, but the page doesn't necessarily have glyphs
             // (this pointer may be 0).
             GlyphPage* fallbackPage = getRootChild(fontData, pageNumber)->page();
             if (!parentPage) {
                 // When the parent has no glyphs for this page, we can easily
                 // override it just by supplying the glyphs from our font.
                 m_page = fallbackPage;
             } else if (!fallbackPage) {
                 // When our font has no glyphs for this page, we can just reference the
                 // parent page.
                 m_page = parentPage;
             } else {
                 // Combine the parent's glyphs and ours to form a new more complete page.
                 m_page = new GlyphPage(this);

                 // Overlay the parent page on the fallback page. Check if the fallback font
                 // has added anything.
                 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) {
                     // We didn't override anything, so our override is just the parent page.
                     delete m_page;
                     m_page = parentPage;
                 }
             }
         }
     } else {
         m_page = new GlyphPage(this);
         // System fallback. Initialized with the parent's page here, as individual
         // entries may use different fonts depending on character. If the Font
         // ever finds it needs a glyph out of the system fallback page, it will
         // ask the system for the best font to use and fill that glyph in for us.
         if (parentPage)
             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;
 #ifndef NDEBUG
         child->m_pageNumber = m_pageNumber;
 #endif
         if (fontData)
             m_children.set(fontData, child);
         else {
             m_systemFallbackChild = child;
             child->m_isSystemFallback = true;
         }
         child->initializePage(fontData, pageNumber);
     }
     return child;
 }

 }
	/*
	* Copyright (C) 2006, 2007 Apple Inc. All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	*
	* 1. Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	* 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of
	* its contributors may be used to endorse or promote products derived
	* from this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
	* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	* DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
	* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
	* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
	* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	#include "config.h"
	#include "GlyphPageTreeNode.h"

	#include "CharacterNames.h"
	#include "FontData.h"
	#include <wtf/unicode/Unicode.h>

	namespace WebCore {

	GlyphPageTreeNode* GlyphPageTreeNode::getRoot(unsigned pageNumber)
	{
	static HashMap<int, GlyphPageTreeNode*> roots;
	static GlyphPageTreeNode* pageZeroRoot;
	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;
	}

	void GlyphPageTreeNode::initializePage(const FontData* fontData, unsigned pageNumber)
	{
	ASSERT(!m_page);

	// This function must not be called for the root of the tree, because that
	// level does not contain any glyphs.
	ASSERT(m_level > 0 && m_parent);

	// The parent's page will be 0 if we are level one or the parent's font data
	// did not contain any glyphs for that page.
	GlyphPage* parentPage = m_parent->m_page;

	// NULL FontData means we're being asked for the system fallback font.
	if (fontData) {
	if (m_level == 1) {
	// Children of the root hold pure pages. These will cover only one
	// font data's glyphs, and will have glyph index 0 if the font data does not
	// contain the glyph.
	unsigned start = pageNumber * GlyphPage::size;
	UChar buffer[GlyphPage::size * 2 + 2];
	unsigned bufferLength;
	unsigned i;

	// Fill in a buffer with the entire "page" of characters that we want to look up glyphs for.
	if (start < 0x10000) {
	bufferLength = GlyphPage::size;
	for (i = 0; i < GlyphPage::size; i++)
	buffer[i] = start + i;

	if (start == 0) {
	// Control characters must not render at all.
	for (i = 0; i < 0x20; ++i)
	buffer[i] = zeroWidthSpace;
	for (i = 0x7F; i < 0xA0; i++)
	buffer[i] = zeroWidthSpace;

	// \n, \t, and nonbreaking space must render as a space.
	buffer[(int)'\n'] = ' ';
	buffer[(int)'\t'] = ' ';
	buffer[noBreakSpace] = ' ';
	} else if (start == (leftToRightMark & ~(GlyphPage::size - 1))) {
	// LRM/RLM must not render at all.
	buffer[leftToRightMark - start] = zeroWidthSpace;
	buffer[rightToLeftMark - start] = zeroWidthSpace;
	} else if (start == (objectReplacementCharacter & ~(GlyphPage::size - 1))) {
	// Object replacement character must not render at all.
	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 = new GlyphPage(this);

	// Now that we have a buffer full of characters, we want to get back an array
	// of glyph indices. This part involves calling into the platform-specific
	// routine of our glyph map for actually filling in the page with the glyphs.
	// Success is not guaranteed. For example, Times fails to fill page 260, giving glyph data
	// for only 128 out of 256 characters.
	bool haveGlyphs = m_page->fill(buffer, bufferLength, fontData);

	if (!haveGlyphs) {
	delete m_page;
	m_page = 0;
	}
	} else if (parentPage && parentPage->owner() != m_parent) {
	// The page we're overriding may not be owned by our parent node.
	// This happens when our parent node provides no useful overrides
	// and just copies the pointer to an already-existing page (see
	// below).
	//
	// We want our override to be shared by all nodes that reference
	// that page to avoid duplication, and so standardize on having the
	// page's owner collect all the overrides. Call getChild on the
	// page owner with the desired font data (this will populate
	// the page) and then reference it.
	m_page = parentPage->owner()->getChild(fontData, pageNumber)->page();
	} else {
	// Get the pure page for the fallback font (at level 1 with no
	// overrides). getRootChild will always create a page if one
	// doesn't exist, but the page doesn't necessarily have glyphs
	// (this pointer may be 0).
	GlyphPage* fallbackPage = getRootChild(fontData, pageNumber)->page();
	if (!parentPage) {
	// When the parent has no glyphs for this page, we can easily
	// override it just by supplying the glyphs from our font.
	m_page = fallbackPage;
	} else if (!fallbackPage) {
	// When our font has no glyphs for this page, we can just reference the
	// parent page.
	m_page = parentPage;
	} else {
	// Combine the parent's glyphs and ours to form a new more complete page.
	m_page = new GlyphPage(this);

	// Overlay the parent page on the fallback page. Check if the fallback font
	// has added anything.
	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) {
	// We didn't override anything, so our override is just the parent page.
	delete m_page;
	m_page = parentPage;
	}
	}
	}
	} else {
	m_page = new GlyphPage(this);
	// System fallback. Initialized with the parent's page here, as individual
	// entries may use different fonts depending on character. If the Font
	// ever finds it needs a glyph out of the system fallback page, it will
	// ask the system for the best font to use and fill that glyph in for us.
	if (parentPage)
	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;
	#ifndef NDEBUG
	child->m_pageNumber = m_pageNumber;
	#endif
	if (fontData)
	m_children.set(fontData, child);
	else {
	m_systemFallbackChild = child;
	child->m_isSystemFallback = true;
	}
	child->initializePage(fontData, pageNumber);
	}
	return child;
	}

	}