/*
 * Copyright (C) 2007 Nikolas Zimmermann <zimmermann@kde.org>
 * Copyright (C) Research In Motion Limited 2010. All rights reserved.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this library; see the file COPYING.LIB.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 *
 */

#ifndef SVGTextChunkLayoutInfo_h
#define SVGTextChunkLayoutInfo_h

#if ENABLE(SVG)
#include "AffineTransform.h"
#include "SVGCharacterData.h"
#include "SVGRenderStyle.h"
#include "SVGTextContentElement.h"

#include <wtf/Assertions.h>
#include <wtf/Vector.h>

namespace WebCore {

class InlineBox;
class InlineFlowBox;
class SVGInlineTextBox;

// A SVGTextChunk directly corresponds to the definition of a "text chunk" per SVG 1.1 specification
// For example, each absolute positioned character starts a text chunk (much more to respect, see spec).
// Each SVGTextChunk contains a Vector of SVGInlineBoxCharacterRange, describing how many boxes are spanned
// by this chunk. Following two examples should clarify the code a bit:
//
// 1. <text x="10 20 30">ABC</text> - one InlineTextBox is created, three SVGTextChunks each with one SVGInlineBoxCharaterRange
// [SVGTextChunk 1]
//    [SVGInlineBoxCharacterRange 1, startOffset=0, endOffset=1, box=0x1]
// [SVGTextChunk 2]
//    [SVGInlineBoxCharacterRange 1, startOffset=1, endOffset=2, box=0x1]
// [SVGTextChunk 3]
//    [SVGInlineBoxCharacterRange 1, startOffset=2, endOffset=3, box=0x1]
//
// 2. <text x="10">A<tspan>B</tspan>C</text> - three InlineTextBoxs are created, one SVGTextChunk, with three SVGInlineBoxCharacterRanges
// [SVGTextChunk 1]
//    [SVGInlineBoxCharacterRange 1, startOffset=0, endOffset=1, box=0x1]
//    [SVGInlineBoxCharacterRange 2, startOffset=0, endOffset=1, box=0x2]
//    [SVGInlineBoxCharacterRange 3, startOffset=0, endOffset=1, box=0x3]
//
// High level overview of the SVG text layout code:
// Step #1) - Build Vector of SVGChar objects starting from root <text> diving into children
// Step #2) - Build Vector of SVGTextChunk objects, containing offsets into the InlineTextBoxes and SVGChar vectors
// Step #3) - Apply chunk post processing (text-anchor / textLength support, which operate on text chunks!)
// Step #4) - Propagate information, how many chunk "parts" are associated with each SVGInlineTextBox (see below)
// Step #5) - Layout all InlineBoxes, only by measuring their context rect (x/y/width/height defined through SVGChars and transformations)
// Step #6) - Layout SVGRootInlineBox, it's parent RenderSVGText block and fixup child positions, to be relative to the root box
//
// When painting a range of characters, we have to determine how many can be drawn in a row. Each absolute postioned
// character is drawn individually. After step #2) we know all text chunks, and how they span across the SVGInlineTextBoxes.
// In step #4) we build a list of text chunk "parts" and store it in each SVGInlineTextBox. A chunk "part" is a part of a
// text chunk that lives in a SVGInlineTextBox (consists of a length, width, height and a monotonic offset from the chunk begin)
// The SVGTextChunkPart object describes this information.
// When painting we can follow the regular InlineBox flow, we start painting the SVGRootInlineBox, which just asks its children
// to paint. They can paint on their own because all position information are known. Previously we used to draw _all_ characters
// from the SVGRootInlineBox, which violates the whole concept of the multiple InlineBoxes, and made text selection very hard to
// implement.

struct SVGTextChunkPart {
    SVGTextChunkPart()
        : offset(-1)
        , length(-1)
        , width(0)
        , height(0)
    {
    }

    bool isValid() const
    {
        return offset != -1
            && length != -1
            && width
            && height;
    }

    // First character of this text chunk part, defining the origin to be drawn
    Vector<SVGChar>::const_iterator firstCharacter;

    // Start offset in textRenderer()->characters() buffer.
    int offset;

    // length/width/height of chunk part
    int length;
    float width;
    float height;
};

struct SVGInlineBoxCharacterRange {
    SVGInlineBoxCharacterRange()
        : startOffset(INT_MIN)
        , endOffset(INT_MIN)
        , box(0)
    {
    }

    bool isOpen() const { return (startOffset == endOffset) && (endOffset == INT_MIN); }
    bool isClosed() const { return startOffset != INT_MIN && endOffset != INT_MIN; }

    int startOffset;
    int endOffset;

    InlineBox* box;
};

struct SVGChar;

// Convenience typedef
typedef SVGTextContentElement::SVGLengthAdjustType ELengthAdjust;

struct SVGTextChunk {
    SVGTextChunk(Vector<SVGChar>::iterator it)
        : anchor(TA_START)
        , textLength(0.0f)
        , lengthAdjust(SVGTextContentElement::LENGTHADJUST_SPACING)
        , isVerticalText(false)
        , isTextPath(false)
        , start(it)
        , end(it)
    {
    }

    // text-anchor support
    ETextAnchor anchor;

    // textLength & lengthAdjust support
    float textLength;
    ELengthAdjust lengthAdjust;
    AffineTransform ctm;

    // status flags
    bool isVerticalText : 1;
    bool isTextPath : 1;

    // main chunk data
    Vector<SVGChar>::iterator start;
    Vector<SVGChar>::iterator end;

    Vector<SVGInlineBoxCharacterRange> boxes;
};

struct SVGTextChunkLayoutInfo {
    SVGTextChunkLayoutInfo()
        : m_assignChunkProperties(true)
        , m_handlingTextPath(false)
        , m_charsIt(0)
        , m_charsBegin(0)
        , m_charsEnd(0)
        , m_chunk(0)
    {
    }

    const Vector<SVGTextChunk>& textChunks() const { return m_svgTextChunks; }

    void buildTextChunks(Vector<SVGChar>::iterator charsBegin, Vector<SVGChar>::iterator charsEnd, InlineFlowBox* start);
    void layoutTextChunks();

private:
    void startTextChunk();
    void closeTextChunk();
    void recursiveBuildTextChunks(InlineFlowBox* start);

    bool m_assignChunkProperties : 1;
    bool m_handlingTextPath : 1;

    Vector<SVGChar>::iterator m_charsIt;
    Vector<SVGChar>::iterator m_charsBegin;
    Vector<SVGChar>::iterator m_charsEnd;

    Vector<SVGTextChunk> m_svgTextChunks;
    SVGTextChunk m_chunk;
};

// Helper functions
float calculateTextAnchorShiftForTextChunk(SVGTextChunk&, ETextAnchor);
float calculateTextLengthCorrectionForTextChunk(SVGTextChunk&, ELengthAdjust, float& computedLength);

} // namespace WebCore

#endif // ENABLE(SVG)
#endif // SVGTextChunkLayoutInfo_h