File indexing completed on 2025-01-12 12:27:55

 /*
  * This file is part of the render object implementation for KHTML.
  *
  * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org)
  *           (C) 1999-2003 Antti Koivisto (koivisto@kde.org)
  *           (C) 2002-2003 Dirk Mueller (mueller@kde.org)
  *           (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_BLOCK_H
 #define RENDER_BLOCK_H
 
 #include <QList>
 
 #include "render_flow.h"
 
 namespace DOM
 {
 class Position;
 }
 
 namespace khtml
 {
 
 class RenderBlock : public RenderFlow
 {
 public:
     RenderBlock(DOM::NodeImpl *node);
     virtual ~RenderBlock();
 
     const char *renderName() const override;
 
     bool isRenderBlock() const override
     {
         return true;
     }
     bool isBlockFlow() const override
     {
         return (!isInline() || isReplaced()) && !isTable();
     }
     bool isInlineFlow() const override
     {
         return isInline() && !isReplaced();
     }
     bool isInlineBlockOrInlineTable() const override
     {
         return isInline() && isReplaced();
     }
 
     bool childrenInline() const override
     {
         return m_childrenInline;
     }
     virtual void setChildrenInline(bool b)
     {
         m_childrenInline = b;
     }
     short baselinePosition(bool firstLine) const override;
 
     int getBaselineOfLastLineBox() const;
     void makeChildrenNonInline(RenderObject *insertionPoint = nullptr);
 
     void makePageBreakAvoidBlocks();
 
     // The height (and width) of a block when you include overflow spillage out of the bottom
     // of the block (e.g., a <div style="height:25px"> that has a 100px tall image inside
     // it would have an overflow height of borderTop() + paddingTop() + 100px.
     int overflowHeight() const override
     {
         return m_overflowHeight;
     }
     int overflowWidth() const override
     {
         return m_overflowWidth;
     }
     int overflowLeft() const override
     {
         return m_overflowLeft;
     }
     int overflowTop() const override
     {
         return m_overflowTop;
     }
     virtual void setOverflowHeight(int h)
     {
         m_overflowHeight = h;
     }
     virtual void setOverflowWidth(int w)
     {
         m_overflowWidth = w;
     }
     virtual void setOverflowLeft(int l)
     {
         m_overflowLeft = l;
     }
     virtual void setOverflowTop(int t)
     {
         m_overflowTop = t;
     }
 
     bool isSelfCollapsingBlock() const override;
     bool isTopMarginQuirk() const override
     {
         return m_topMarginQuirk;
     }
     bool isBottomMarginQuirk() const override
     {
         return m_bottomMarginQuirk;
     }
 
     short maxTopMargin(bool positive) const override
     {
         if (positive) {
             return m_maxTopPosMargin;
         } else {
             return m_maxTopNegMargin;
         }
     }
     short maxBottomMargin(bool positive) const override
     {
         if (positive) {
             return m_maxBottomPosMargin;
         } else {
             return m_maxBottomNegMargin;
         }
     }
 
     void initMaxMarginValues()
     {
         if (m_marginTop >= 0) {
             m_maxTopPosMargin = m_marginTop;
         } else {
             m_maxTopNegMargin = -m_marginTop;
         }
         if (m_marginBottom >= 0) {
             m_maxBottomPosMargin = m_marginBottom;
         } else {
             m_maxBottomNegMargin = -m_marginBottom;
         }
     }
 
     void addChildToFlow(RenderObject *newChild, RenderObject *beforeChild) override;
     void removeChild(RenderObject *oldChild) override;
 
     void setStyle(RenderStyle *_style) override;
     void attach() override;
     void updateFirstLetter();
 
     void layout() override;
     void layoutBlock(bool relayoutChildren);
     void layoutBlockChildren(bool relayoutChildren);
     void layoutInlineChildren(bool relayoutChildren, int breakBeforeLine = 0);
 
     void layoutPositionedObjects(bool relayoutChildren);
     void insertPositionedObject(RenderObject *o);
     void removePositionedObject(RenderObject *o);
 
     QRegion visibleFloatingRegion(int x, int y) const;
     // Called to lay out the legend for a fieldset.
     virtual RenderObject *layoutLegend(bool /*relayoutChildren*/)
     {
         return nullptr;
     }
 
     // the implementation of the following functions is in bidi.cpp
     void bidiReorderLine(const BidiIterator &start, const BidiIterator &end, BidiState &bidi);
     void fitBelowFloats(int widthToFit, int &availableWidth);
     BidiIterator findNextLineBreak(BidiIterator &start, BidiState &info);
     RootInlineBox *constructLine(const BidiIterator &start, const BidiIterator &end);
     InlineFlowBox *createLineBoxes(RenderObject *obj);
     bool inlineChildNeedsLineBox(RenderObject *obj);
     void computeHorizontalPositionsForLine(InlineFlowBox *lineBox, BidiState &bidi);
     void computeVerticalPositionsForLine(RootInlineBox *lineBox);
     bool clearLineOfPageBreaks(InlineFlowBox *lineBox);
     void checkLinesForOverflow();
     void deleteEllipsisLineBoxes();
     void checkLinesForTextOverflow();
     RootInlineBox *determineStartPosition(bool fullLayout, BidiIterator &start, BidiState &bidi);
     RootInlineBox *determineEndPosition(RootInlineBox *startLine, BidiIterator &cleanLineStart, BidiStatus &cleanLineBidiStatus, BidiContext *cleanLineBidiContext, int &yPos);
     bool matchedEndLine(const BidiIterator &start, const BidiStatus &status, BidiContext *context,
                         const BidiIterator &endLineStart, const BidiStatus &endLineStatus, BidiContext *endLineContext,
                         RootInlineBox *&endLine, int &endYPos);
     // end bidi.cpp functions
 
     void paint(PaintInfo &i, int tx, int ty) override;
     void paintObject(PaintInfo &i, int tx, int ty, bool paintOutline = true);
     void paintFloats(PaintInfo &i, int _tx, int _ty, bool paintSelection = false);
 
     void insertFloatingObject(RenderObject *o);
     void removeFloatingObject(RenderObject *o);
 
     // called from lineWidth, to position the floats added in the last line.
     void positionNewFloats();
     void clearFloats();
     int getClearDelta(RenderObject *child, int yPos);
     void markAllDescendantsWithFloatsForLayout(RenderObject *floatToRemove = nullptr) override;
 
     // FIXME: containsFloats() should not return true if the floating objects list
     // is empty. However, layoutInlineChildren() relies on the current behavior.
     // http://bugzilla.opendarwin.org/show_bug.cgi?id=7395#c3
     bool hasFloats() const override
     {
         return m_floatingObjects != nullptr;
     }
     bool containsFloat(RenderObject *o) const override;
 
     bool hasOverhangingFloats() const override
     {
         return floatBottom() > m_height;
     }
     void addOverHangingFloats(RenderBlock *block, int xoffset, int yoffset, bool child);
 
     int nearestFloatBottom(int height) const;
     int floatBottom() const;
     inline int leftBottom();
     inline int rightBottom();
 
     virtual unsigned short lineWidth(int y, bool *canClearLine = nullptr) const;
     int lowestPosition(bool includeOverflowInterior = true, bool includeSelf = true) const override;
     int rightmostPosition(bool includeOverflowInterior = true, bool includeSelf = true) const override;
     int leftmostPosition(bool includeOverflowInterior = true, bool includeSelf = true) const override;
     int highestPosition(bool includeOverflowInterior, bool includeSelf) const override;
     int lowestAbsolutePosition() const;
     int leftmostAbsolutePosition() const;
     int rightmostAbsolutePosition() const;
     int highestAbsolutePosition() const;
 
     int rightOffset() const;
     int rightRelOffset(int y, int fixedOffset, bool applyTextIndent = true, int *heightRemaining = nullptr, bool *canClearLine = nullptr) const;
     int rightOffset(int y, bool *canClearLine = nullptr) const
     {
         return rightRelOffset(y, rightOffset(), true, nullptr, canClearLine);
     }
 
     int leftOffset() const;
     int leftRelOffset(int y, int fixedOffset, bool applyTextIndent = true, int *heightRemaining = nullptr, bool *canClearLine = nullptr) const;
     int leftOffset(int y, bool *canClearLine = nullptr) const
     {
         return leftRelOffset(y, leftOffset(), true, nullptr, canClearLine);
     }
 
     bool nodeAtPoint(NodeInfo &info, int x, int y, int _tx, int _ty, HitTestAction hitTestAction = HitTestAll, bool inside = false) override;
 
     bool isPointInScrollbar(int x, int y, int tx, int ty);
 
     RenderPosition positionForCoordinates(int x, int y) override;
 
     void calcMinMaxWidth() override;
     void calcInlineMinMaxWidth();
     void calcBlockMinMaxWidth();
 
     void close() override;
 
     int getBaselineOfFirstLineBox() override;
 
     RootInlineBox *firstRootBox() const
     {
         return static_cast<RootInlineBox *>(m_firstLineBox);
     }
     RootInlineBox *lastRootBox() const
     {
         return static_cast<RootInlineBox *>(m_lastLineBox);
     }
 
     InlineFlowBox *getFirstLineBox() override;
 
     bool inRootBlockContext() const;
     void deleteLineBoxTree();
 
 #ifdef ENABLE_DUMP
     void printTree(int indent = 0) const override;
     void dump(QTextStream &stream, const QString &ind) const override;
 #endif
 
 protected:
     void newLine();
 
 private:
     RenderPosition positionForBox(InlineBox *box, bool start = true) const;
     RenderPosition positionForRenderer(RenderObject *renderer, bool start = true) const;
 
 protected:
     struct FloatingObject {
         enum Type {
             FloatLeft,
             FloatRight
         };
 
         FloatingObject(Type _type)
         {
             node = nullptr;
             startY = 0;
             endY = 0;
             type = _type;
             left = 0;
             width = 0;
             noPaint = false;
             crossedLayer = false;
 
         }
         RenderObject *node;
         int startY;
         int endY;
         short left;
         short width;
         KDE_BF_ENUM(Type) type : 1; // left or right aligned
         bool noPaint : 1;
         bool crossedLayer : 1; // lock noPaint flag
     };
 
     // The following helper functions and structs are used by layoutBlockChildren.
     class CompactInfo
     {
         // A compact child that needs to be collapsed into the margin of the following block.
         RenderObject *m_compact;
 
         // The block with the open margin that the compact child is going to place itself within.
         RenderObject *m_block;
         bool m_treatAsBlock : 1;
 
     public:
         RenderObject *compact() const
         {
             return m_compact;
         }
         RenderObject *block() const
         {
             return m_block;
         }
         void setTreatAsBlock(bool b)
         {
             m_treatAsBlock = b;
         }
         bool treatAsBlock() const
         {
             return m_treatAsBlock;
         }
         bool matches(RenderObject *child) const
         {
             return m_compact && m_block == child;
         }
 
         void clear()
         {
             set(nullptr, nullptr);
         }
         void set(RenderObject *c, RenderObject *b)
         {
             m_compact = c;
             m_block = b;
         }
 
         CompactInfo()
         {
             clear();
         }
     };
 
     class MarginInfo
     {
         // Collapsing flags for whether we can collapse our margins with our children's margins.
         bool m_canCollapseWithChildren : 1;
         bool m_canCollapseTopWithChildren : 1;
         bool m_canCollapseBottomWithChildren : 1;
 
         // Whether or not we are a quirky container, i.e., do we collapse away top and bottom
         // margins in our container.  Table cells and the body are the common examples. We
         // also have a custom style property for Safari RSS to deal with TypePad blog articles.
         bool m_quirkContainer : 1;
 
         // This flag tracks whether we are still looking at child margins that can all collapse together at the beginning of a block.
         // They may or may not collapse with the top margin of the block (|m_canCollapseTopWithChildren| tells us that), but they will
         // always be collapsing with one another.  This variable can remain set to true through multiple iterations
         // as long as we keep encountering self-collapsing blocks.
         bool m_atTopOfBlock : 1;
 
         // This flag is set when we know we're examining bottom margins and we know we're at the bottom of the block.
         bool m_atBottomOfBlock : 1;
 
         // If our last normal flow child was a self-collapsing block that cleared a float,
         // we track it in this variable.
         bool m_selfCollapsingBlockClearedFloat : 1;
 
         // These variables are used to detect quirky margins that we need to collapse away (in table cells
         // and in the body element).
         bool m_topQuirk : 1;
         bool m_bottomQuirk : 1;
         bool m_determinedTopQuirk : 1;
 
         // These flags track the previous maximal positive and negative margins.
         int m_posMargin;
         int m_negMargin;
 
     public:
         MarginInfo(RenderBlock *b, int top, int bottom);
 
         void setAtTopOfBlock(bool b)
         {
             m_atTopOfBlock = b;
         }
         void setAtBottomOfBlock(bool b)
         {
             m_atBottomOfBlock = b;
         }
         void clearMargin()
         {
             m_posMargin = m_negMargin = 0;
         }
         void setSelfCollapsingBlockClearedFloat(bool b)
         {
             m_selfCollapsingBlockClearedFloat = b;
         }
         void setTopQuirk(bool b)
         {
             m_topQuirk = b;
         }
         void setBottomQuirk(bool b)
         {
             m_bottomQuirk = b;
         }
         void setDeterminedTopQuirk(bool b)
         {
             m_determinedTopQuirk = b;
         }
         void setPosMargin(int p)
         {
             m_posMargin = p;
         }
         void setNegMargin(int n)
         {
             m_negMargin = n;
         }
         void setPosMarginIfLarger(int p)
         {
             if (p > m_posMargin) {
                 m_posMargin = p;
             }
         }
         void setNegMarginIfLarger(int n)
         {
             if (n > m_negMargin) {
                 m_negMargin = n;
             }
         }
 
         void setMargin(int p, int n)
         {
             m_posMargin = p;
             m_negMargin = n;
         }
 
         bool atTopOfBlock() const
         {
             return m_atTopOfBlock;
         }
         bool canCollapseWithTop() const
         {
             return m_atTopOfBlock && m_canCollapseTopWithChildren;
         }
         bool canCollapseWithBottom() const
         {
             return m_atBottomOfBlock && m_canCollapseBottomWithChildren;
         }
         bool canCollapseTopWithChildren() const
         {
             return m_canCollapseTopWithChildren;
         }
         bool canCollapseBottomWithChildren() const
         {
             return m_canCollapseBottomWithChildren;
         }
         bool selfCollapsingBlockClearedFloat() const
         {
             return m_selfCollapsingBlockClearedFloat;
         }
         bool quirkContainer() const
         {
             return m_quirkContainer;
         }
         bool determinedTopQuirk() const
         {
             return m_determinedTopQuirk;
         }
         bool topQuirk() const
         {
             return m_topQuirk;
         }
         bool bottomQuirk() const
         {
             return m_bottomQuirk;
         }
         int posMargin() const
         {
             return m_posMargin;
         }
         int negMargin() const
         {
             return m_negMargin;
         }
         int margin() const
         {
             return m_posMargin - m_negMargin;
         }
     };
 
     class PageBreakInfo
     {
         int m_pageBottom; // Next calculated page-break
         bool m_forcePageBreak : 1; // Must break before next block
         // ### to do better "page-break-after/before: avoid" this struct
         // should keep a pagebreakAvoid block and gather children in it
     public:
         PageBreakInfo(int pageBottom) : m_pageBottom(pageBottom), m_forcePageBreak(false) {}
         bool forcePageBreak()
         {
             return m_forcePageBreak;
         }
         void setForcePageBreak(bool b)
         {
             m_forcePageBreak = b;
         }
         int pageBottom()
         {
             return m_pageBottom;
         }
         void setPageBottom(int bottom)
         {
             m_pageBottom = bottom;
         }
     };
 
     bool canClear(RenderObject *child, PageBreakLevel level) override;
     void clearPageBreak(RenderObject *child, int pageBottom);
 
     void adjustPositionedBlock(RenderObject *child, const MarginInfo &marginInfo);
     void adjustFloatingBlock(const MarginInfo &marginInfo);
     RenderObject *handleSpecialChild(RenderObject *child, const MarginInfo &marginInfo, CompactInfo &compactInfo, bool &handled);
     RenderObject *handleFloatingChild(RenderObject *child, const MarginInfo &marginInfo, bool &handled);
     RenderObject *handlePositionedChild(RenderObject *child, const MarginInfo &marginInfo, bool &handled);
     RenderObject *handleCompactChild(RenderObject *child, CompactInfo &compactInfo, const MarginInfo &marginInfo, bool &handled);
     RenderObject *handleRunInChild(RenderObject *child, bool &handled);
     int collapseMargins(RenderObject *child, MarginInfo &marginInfo, int yPos);
     int clearFloatsIfNeeded(RenderObject *child, MarginInfo &marginInfo, int oldTopPosMargin, int oldTopNegMargin, int yPos);
     void adjustSizeForCompactIfNeeded(RenderObject *child, CompactInfo &compactInfo);
     void insertCompactIfNeeded(RenderObject *child, CompactInfo &compactInfo);
     int estimateVerticalPosition(RenderObject *child, const MarginInfo &info);
     void determineHorizontalPosition(RenderObject *child);
     void handleBottomOfBlock(int top, int bottom, MarginInfo &marginInfo);
     void setCollapsedBottomMargin(const MarginInfo &marginInfo);
     void clearChildOfPageBreaks(RenderObject *child, PageBreakInfo &pageBreakInfo, MarginInfo &marginInfo);
     // End helper functions and structs used by layoutBlockChildren.
 
 protected:
     // How much content overflows out of our block vertically or horizontally (all we support
     // for now is spillage out of the bottom and the right, which are the common cases).
     int m_overflowHeight;
     int m_overflowWidth;
 
     // Left and top overflow.
     int m_overflowTop;
     int m_overflowLeft;
 
     QList<FloatingObject *> *m_floatingObjects;
     QList<RenderObject *>   *m_positionedObjects;
 
 private:
     bool m_childrenInline : 1;
     bool m_firstLine      : 1; // used in inline layouting
     KDE_BF_ENUM(EClear) m_clearStatus  : 2; // used during layuting of paragraphs
     bool m_avoidPageBreak : 1; // anonymous avoid page-break block
     bool m_topMarginQuirk : 1;
     bool m_bottomMarginQuirk : 1;
 
     short m_maxTopPosMargin;
     short m_maxTopNegMargin;
     short m_maxBottomPosMargin;
     short m_maxBottomNegMargin;
 
 };
 
 } // namespace
 
 #endif // RENDER_BLOCK_H