/*

 * 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;

}

}