File indexing completed on 2024-04-21 14:58:00

 /*
  * This file is part of the line box implementation for KDE.
  *
  * Copyright (C) 2003 Apple Computer, Inc.
  *
  * 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 RENDER_LINE_H
 #define RENDER_LINE_H
 
 #include "render_object.h"
 
 namespace khtml
 {
 
 class EllipsisBox;
 class InlineFlowBox;
 class RootInlineBox;
 class RenderArena;
 struct BidiStatus;
 class BidiContext;
 
 // InlineBox represents a rectangle that occurs on a line.  It corresponds to
 // some RenderObject (i.e., it represents a portion of that RenderObject).
 class InlineBox
 {
 public:
     InlineBox(RenderObject *obj)
         : m_object(obj), m_x(0), m_width(0), m_y(0), m_height(0), m_baseline(0),
           m_firstLine(false), m_constructed(false), m_dirty(false), m_extracted(false), m_endsWithBreak(false)
     {
         m_next = nullptr;
         m_prev = nullptr;
         m_parent = nullptr;
     }
 
     virtual ~InlineBox() {}
 
     virtual void detach(RenderArena *renderArena, bool noRemove = false);
 
     virtual void paint(RenderObject::PaintInfo &i, int _tx, int _ty);
     virtual bool nodeAtPoint(RenderObject::NodeInfo &i, int x, int y, int tx, int ty);
 
     // Overloaded new operator.
     void *operator new(size_t sz, RenderArena *renderArena) throw();
 
     // Overridden to prevent the normal delete from being called.
     void operator delete(void *ptr, size_t sz);
 
 #ifdef ENABLE_DUMP
     QString information() const;
     void printTree(int indent = 0) const;
 #endif
 
 private:
     // The normal operator new is disallowed.
     void *operator new(size_t sz) throw();
 
 public:
     virtual bool isPlaceHolderBox() const
     {
         return false;
     }
     virtual bool isInlineFlowBox() const
     {
         return false;
     }
     virtual bool isContainer() const
     {
         return false;
     }
     virtual bool isInlineTextBox() const
     {
         return false;
     }
     virtual bool isRootInlineBox() const
     {
         return false;
     }
     // SVG
     virtual bool isSVGRootInlineBox() const
     {
         return false;
     }
 
     bool isConstructed() const
     {
         return m_constructed;
     }
     virtual void setConstructed()
     {
         m_constructed = true;
         if (m_next) {
             m_next->setConstructed();
         }
     }
 
     void setFirstLineStyleBit(bool f)
     {
         m_firstLine = f;
     }
 
     InlineBox *nextOnLine() const
     {
         return m_next;
     }
     InlineBox *prevOnLine() const
     {
         return m_prev;
     }
     void setNextOnLine(InlineBox *next)
     {
         m_next = next;
     }
     void setPrevOnLine(InlineBox *prev)
     {
         m_prev = prev;
     }
     bool nextOnLineExists() const;
     bool prevOnLineExists() const;
 
     virtual InlineBox *firstLeafChild();
     virtual InlineBox *lastLeafChild();
     InlineBox *closestLeafChildForXPos(int _x, int _tx);
 
     RenderObject *object() const
     {
         return m_object;
     }
 
     InlineFlowBox *parent() const
     {
         return m_parent;
     }
     void setParent(InlineFlowBox *par)
     {
         m_parent = par;
     }
 
     RootInlineBox *root();
 
     void setWidth(short w)
     {
         m_width = w;
     }
     short width() const
     {
         return m_width;
     }
 
     void setXPos(short x)
     {
         m_x = x;
     }
     short xPos() const
     {
         return m_x;
     }
 
     void setYPos(int y)
     {
         m_y = y;
     }
     int yPos() const
     {
         return m_y;
     }
 
     void setHeight(int h)
     {
         m_height = h;
     }
     int height() const
     {
         return m_height;
     }
 
     void setBaseline(int b)
     {
         m_baseline = b;
     }
     int baseline() const
     {
         return m_baseline;
     }
 
     virtual bool hasTextChildren() const
     {
         return true;
     }
     virtual bool hasTextDescendant() const
     {
         return true;
     }
 
     virtual int topOverflow() const
     {
         return yPos();
     }
     virtual int bottomOverflow() const
     {
         return yPos() + height();
     }
 
     virtual long caretMinOffset() const;
     virtual long caretMaxOffset() const;
     virtual unsigned long caretMaxRenderedOffset() const;
 
     bool isDirty() const
     {
         return m_dirty;
     }
     void markDirty(bool dirty = true)
     {
         m_dirty = dirty;
     }
 
     void setExtracted(bool b = true)
     {
         m_extracted = b;
     }
     void remove();
 
     void dirtyInlineBoxes();
     virtual void deleteLine(RenderArena *arena);
     virtual void extractLine();
     virtual void attachLine();
     void adjustPosition(int dx, int dy);
 
     virtual void clearTruncation() {}
 
     virtual bool canAccommodateEllipsisBox(bool ltr, int blockEdge, int ellipsisWidth);
     virtual int placeEllipsisBox(bool ltr, int blockEdge, int ellipsisWidth, bool &);
 
 public: // FIXME: Would like to make this protected, but methods are accessing these
     // members over in the part.
     RenderObject *m_object;
 
     short m_x;
     short m_width;
     int m_y;
     int m_height;
     int m_baseline;
 
     bool m_firstLine : 1;
     bool m_constructed : 1;
     bool m_dirty : 1;
     bool m_extracted : 1;
     bool m_endsWithBreak : 1;
 
     InlineBox *m_next; // The next element on the same line as us.
     InlineBox *m_prev; // The previous element on the same line as us.
 
     InlineFlowBox *m_parent; // The box that contains us.
 };
 
 class PlaceHolderBox: public InlineBox
 {
 public:
     PlaceHolderBox(RenderObject *obj): InlineBox(obj) {}
     bool isPlaceHolderBox() const override
     {
         return true;
     }
 };
 
 class InlineRunBox : public InlineBox
 {
 public:
     InlineRunBox(RenderObject *obj)
         : InlineBox(obj)
     {
         m_prevLine = nullptr;
         m_nextLine = nullptr;
     }
 
     InlineRunBox *prevLineBox() const
     {
         return m_prevLine;
     }
     InlineRunBox *nextLineBox() const
     {
         return m_nextLine;
     }
     void setNextLineBox(InlineRunBox *n)
     {
         m_nextLine = n;
     }
     void setPreviousLineBox(InlineRunBox *p)
     {
         m_prevLine = p;
     }
 
     virtual void paintBackgroundAndBorder(RenderObject::PaintInfo &, int /*_tx*/, int /*_ty*/) {}
     virtual void paintDecorations(RenderObject::PaintInfo &, int /*_tx*/, int /*_ty*/, bool /*paintedChildren*/ = false) {}
 
 protected:
     InlineRunBox *m_prevLine;  // The previous box that also uses our RenderObject
     InlineRunBox *m_nextLine;  // The next box that also uses our RenderObject
 };
 
 class InlineFlowBox : public InlineRunBox
 {
 public:
     InlineFlowBox(RenderObject *obj)
         : InlineRunBox(obj)
     {
         m_firstChild = nullptr;
         m_lastChild = nullptr;
         m_includeLeftEdge = m_includeRightEdge = false;
         m_hasTextChildren = false;
         m_hasTextDescendant = false;
         m_afterPageBreak = false;
     }
 
     ~InlineFlowBox();
 
     bool isInlineFlowBox() const override
     {
         return true;
     }
 
     InlineFlowBox *prevFlowBox() const
     {
         return static_cast<InlineFlowBox *>(m_prevLine);
     }
     InlineFlowBox *nextFlowBox() const
     {
         return static_cast<InlineFlowBox *>(m_nextLine);
     }
 
     InlineBox *firstChild() const
     {
         return m_firstChild;
     }
     InlineBox *lastChild() const
     {
         return m_lastChild;
     }
 
     InlineBox *firstLeafChild() override;
     InlineBox *lastLeafChild() override;
     InlineBox *closestChildForXPos(int _x, int _tx);
 
     void setConstructed() override
     {
         InlineBox::setConstructed();
         if (m_firstChild) {
             m_firstChild->setConstructed();
         }
     }
     void addToLine(InlineBox *child)
     {
         if (!m_firstChild) {
             m_firstChild = m_lastChild = child;
         } else {
             m_lastChild->m_next = child;
             child->m_prev = m_lastChild;
             m_lastChild = child;
         }
         child->setFirstLineStyleBit(m_firstLine);
         child->setParent(this);
         if (!m_hasTextChildren && child->isInlineTextBox()) {
             m_hasTextDescendant = m_hasTextChildren = true;
             for (InlineFlowBox *p = m_parent; p && !p->hasTextDescendant(); p = p->parent()) {
                 p->m_hasTextDescendant = true;
             }
         }
     }
 
     void clearTruncation() override;
 
     void removeFromLine(InlineBox *child);
     void paintBackgroundAndBorder(RenderObject::PaintInfo &, int _tx, int _ty) override;
     void paintAllBackgrounds(QPainter *p, const QColor &c, const BackgroundLayer *bgLayer,
                              QRect clipr, int _tx, int _ty, int w, int h);
     void paintOneBackground(QPainter *p, const QColor &c, const BackgroundLayer *bgLayer,
                             QRect clipr, int _tx, int _ty, int w, int h);
     void paint(RenderObject::PaintInfo &i, int _tx, int _ty) override;
     void paintDecorations(RenderObject::PaintInfo &, int _tx, int _ty, bool paintedChildren = false) override;
     bool nodeAtPoint(RenderObject::NodeInfo &i, int x, int y, int tx, int ty) override;
 
     int marginBorderPaddingLeft() const;
     int marginBorderPaddingRight() const;
     int marginLeft() const;
     int marginRight()const;
     int borderLeft() const
     {
         if (includeLeftEdge()) {
             return object()->borderLeft();
         } return 0;
     }
     int borderRight() const
     {
         if (includeRightEdge()) {
             return object()->borderRight();
         } return 0;
     }
     int paddingLeft() const
     {
         if (includeLeftEdge()) {
             return object()->paddingLeft();
         } return 0;
     }
     int paddingRight() const
     {
         if (includeRightEdge()) {
             return object()->paddingRight();
         } return 0;
     }
 
     bool includeLeftEdge() const
     {
         return m_includeLeftEdge;
     }
     bool includeRightEdge() const
     {
         return m_includeRightEdge;
     }
     void setEdges(bool includeLeft, bool includeRight)
     {
         m_includeLeftEdge = includeLeft;
         m_includeRightEdge = includeRight;
     }
     bool hasTextChildren() const override
     {
         return m_hasTextChildren;
     }
     bool hasTextDescendant() const override
     {
         return m_hasTextDescendant;
     }
 
     // Helper functions used during line construction and placement.
     void determineSpacingForFlowBoxes(bool lastLine, RenderObject *endObject);
     int getFlowSpacingWidth() const;
     bool nextOnLineExists();
     bool prevOnLineExists();
     bool onEndChain(RenderObject *endObject);
     int placeBoxesHorizontally(int x);
     void verticallyAlignBoxes(int &heightOfBlock);
     void computeLogicalBoxHeights(int &maxPositionTop, int &maxPositionBottom,
                                   int &maxAscent, int &maxDescent, bool strictMode);
     void adjustMaxAscentAndDescent(int &maxAscent, int &maxDescent,
                                    int maxPositionTop, int maxPositionBottom);
     void placeBoxesVertically(int y, int maxHeight, int maxAscent, bool strictMode,
                               int &topPosition, int &bottomPosition);
     void shrinkBoxesWithNoTextChildren(int topPosition, int bottomPosition);
 
     virtual void setOverflowPositions(int /*top*/, int /*bottom*/) {}
 
     void setAfterPageBreak(bool b = true)
     {
         m_afterPageBreak = b;
     }
     bool afterPageBreak() const
     {
         return m_afterPageBreak;
     }
 
     bool canAccommodateEllipsisBox(bool ltr, int blockEdge, int ellipsisWidth) override;
     int placeEllipsisBox(bool ltr, int blockEdge, int ellipsisWidth, bool &) override;
 
     void deleteLine(RenderArena *arena) override;
     void extractLine() override;
     void attachLine() override;
 
 protected:
     InlineBox *m_firstChild;
     InlineBox *m_lastChild;
     bool m_includeLeftEdge : 1;
     bool m_includeRightEdge : 1;
     bool m_hasTextChildren : 1;
     bool m_hasTextDescendant : 1;
     bool m_afterPageBreak : 1;
 };
 
 class RootInlineBox : public InlineFlowBox
 {
 public:
     RootInlineBox(RenderObject *obj) : InlineFlowBox(obj), m_lineBreakObj(nullptr), m_lineBreakPos(0),
         m_lineBreakContext(nullptr), m_blockHeight(0), m_ellipsisBox(nullptr)
     {
         m_topOverflow = m_bottomOverflow = 0;
     }
 
     void detach(RenderArena *renderArena, bool noRemove = false) override;
     void detachEllipsisBox(RenderArena *renderArena);
 
     RootInlineBox *nextRootBox() const
     {
         return static_cast<RootInlineBox *>(m_nextLine);
     }
     RootInlineBox *prevRootBox() const
     {
         return static_cast<RootInlineBox *>(m_prevLine);
     }
 
     bool isRootInlineBox() const override
     {
         return true;
     }
     int topOverflow() const override
     {
         return m_topOverflow;
     }
     int bottomOverflow() const override
     {
         return m_bottomOverflow;
     }
     void setOverflowPositions(int top, int bottom) override
     {
         m_topOverflow = top;
         m_bottomOverflow = bottom;
     }
 
     bool canAccommodateEllipsis(bool ltr, int blockEdge, int lineBoxEdge, int ellipsisWidth);
     void placeEllipsis(const DOM::DOMString &ellipsisStr, bool ltr, int blockEdge, int ellipsisWidth, InlineBox *markupBox = nullptr);
     int placeEllipsisBox(bool ltr, int blockEdge, int ellipsisWidth, bool &) override;
 
     EllipsisBox *ellipsisBox() const
     {
         return m_ellipsisBox;
     }
     void paintEllipsisBox(RenderObject::PaintInfo &i, int _tx, int _ty) const;
     bool hitTestEllipsisBox(RenderObject::NodeInfo &info, int _x, int _y, int _tx, int _ty);
 
     void clearTruncation() override;
 
     void paint(RenderObject::PaintInfo &i, int _tx, int _ty) override;
     bool nodeAtPoint(RenderObject::NodeInfo &i, int x, int y, int tx, int ty) override;
 
     RenderObject *lineBreakObj() const
     {
         return m_lineBreakObj;
     }
     BidiStatus lineBreakBidiStatus() const;
     void setLineBreakInfo(RenderObject *, unsigned breakPos, const BidiStatus &, BidiContext *context);
 
     BidiContext *lineBreakBidiContext() const
     {
         return m_lineBreakContext;
     }
 
     unsigned lineBreakPos() const
     {
         return m_lineBreakPos;
     }
     void setLineBreakPos(unsigned p)
     {
         m_lineBreakPos = p;
     }
 
     int blockHeight() const
     {
         return m_blockHeight;
     }
     void setBlockHeight(int h)
     {
         m_blockHeight = h;
     }
 
     bool endsWithBreak() const
     {
         return m_endsWithBreak;
     }
     void setEndsWithBreak(bool b)
     {
         m_endsWithBreak = b;
     }
 
     void childRemoved(InlineBox *box);
 
 protected:
     int m_topOverflow;
     int m_bottomOverflow;
 
     // Where this line ended.  The exact object and the position within that object are stored so that
     // we can create a BidiIterator beginning just after the end of this line.
     RenderObject *m_lineBreakObj;
     unsigned m_lineBreakPos;
     BidiContext *m_lineBreakContext;
 
     // The height of the block at the end of this line.  This is where the next line starts.
     int m_blockHeight;
 
     KDE_BF_ENUM(QChar::Direction) m_lineBreakBidiStatusEor : 5;
     KDE_BF_ENUM(QChar::Direction) m_lineBreakBidiStatusLastStrong : 5;
     KDE_BF_ENUM(QChar::Direction) m_lineBreakBidiStatusLast : 5;
 
     // An inline text box that represents our text truncation string.
     EllipsisBox *m_ellipsisBox;
 };
 
 } //namespace
 
 #endif