Move and rename RenderFrame and RenderFrameSet.

Source/core/layout/LayoutFrameSet.cpp

 /**
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Simon Hausmann <hausmann@kde.org>
  *           (C) 2000 Stefan Schimanski (1Stein@gmx.de)
  * Copyright (C) 2004, 2005, 2006 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.
  *
  */
 
 #include "config.h"
-#include "core/rendering/RenderFrameSet.h"
+#include "core/layout/LayoutFrameSet.h"
 
 #include "core/dom/Document.h"
 #include "core/events/MouseEvent.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/HTMLDimension.h"
 #include "core/html/HTMLFrameSetElement.h"
+#include "core/layout/LayoutFrame.h"
 #include "core/layout/PaintInfo.h"
 #include "core/page/EventHandler.h"
 #include "core/paint/FrameSetPainter.h"
-#include "core/rendering/RenderFrame.h"
 #include "core/rendering/RenderView.h"
 #include "platform/Cursor.h"
 #include "platform/graphics/GraphicsContext.h"
 
 namespace blink {
 
-RenderFrameSet::RenderFrameSet(HTMLFrameSetElement* frameSet)
+LayoutFrameSet::LayoutFrameSet(HTMLFrameSetElement* frameSet)
     : RenderBox(frameSet)
     , m_isResizing(false)
     , m_isChildResizing(false)
 {
     setInline(false);
 }
 
-RenderFrameSet::~RenderFrameSet()
+LayoutFrameSet::~LayoutFrameSet()
 {
 }
 
-RenderFrameSet::GridAxis::GridAxis()
+LayoutFrameSet::GridAxis::GridAxis()
     : m_splitBeingResized(noSplit)
 {
 }
 
-HTMLFrameSetElement* RenderFrameSet::frameSet() const
+HTMLFrameSetElement* LayoutFrameSet::frameSet() const
 {
     return toHTMLFrameSetElement(node());
 }
 
-void RenderFrameSet::paint(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
+void LayoutFrameSet::paint(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     FrameSetPainter(*this).paint(paintInfo, paintOffset);
 }
 
-void RenderFrameSet::computePreferredLogicalWidths()
+void LayoutFrameSet::computePreferredLogicalWidths()
 {
     m_minPreferredLogicalWidth = 0;
     m_maxPreferredLogicalWidth = 0;
     clearPreferredLogicalWidthsDirty();
 }
 
-void RenderFrameSet::GridAxis::resize(int size)
+void LayoutFrameSet::GridAxis::resize(int size)
 {
     m_sizes.resize(size);
     m_deltas.resize(size);
     m_deltas.fill(0);
 
     // To track edges for resizability and borders, we need to be (size + 1). This is because a parent frameset
     // may ask us for information about our left/top/right/bottom edges in order to make its own decisions about
     // what to do. We are capable of tainting that parent frameset's borders, so we have to cache this info.
     m_preventResize.resize(size + 1);
     m_allowBorder.resize(size + 1);
 }
 
-void RenderFrameSet::layOutAxis(GridAxis& axis, const Vector<HTMLDimension>& grid, int availableLen)
+void LayoutFrameSet::layOutAxis(GridAxis& axis, const Vector<HTMLDimension>& grid, int availableLen)
 {
     availableLen = max(availableLen, 0);
 
     int* gridLayout = axis.m_sizes.data();
 
     if (grid.isEmpty()) {
         gridLayout[0] = availableLen;
         return;
     }
 
@@ skipping 40 matching lines @@
     // columns/rows we need to proportionally adjust their size.
     if (totalFixed > remainingLen) {
         int remainingFixed = remainingLen;
 
         for (int i = 0; i < gridLen; ++i) {
             if (grid[i].isAbsolute()) {
                 gridLayout[i] = (gridLayout[i] * remainingFixed) / totalFixed;
                 remainingLen -= gridLayout[i];
             }
         }
-    } else
+    } else {
         remainingLen -= totalFixed;
+    }
 
     // Percentage columns/rows are our second priority. Divide the remaining space proportionally
     // over all percentage columns/rows. IMPORTANT: the size of each column/row is not relative
     // to 100%, but to the total percentage. For example, if there are three columns, each of 75%,
     // and the available space is 300px, each column will become 100px in width.
     if (totalPercent > remainingLen) {
         int remainingPercent = remainingLen;
 
         for (int i = 0; i < gridLen; ++i) {
             if (grid[i].isPercentage()) {
                 gridLayout[i] = (gridLayout[i] * remainingPercent) / totalPercent;
                 remainingLen -= gridLayout[i];
             }
         }
-    } else
+    } else {
         remainingLen -= totalPercent;
+    }
 
     // Relative columns/rows are our last priority. Divide the remaining space proportionally
     // over all relative columns/rows. IMPORTANT: the relative value of 0* is treated as 1*.
     if (countRelative) {
         int lastRelative = 0;
         int remainingRelative = remainingLen;
 
         for (int i = 0; i < gridLen; ++i) {
             if (grid[i].isRelative()) {
                 gridLayout[i] = (max(grid[i].value(), 1.) * remainingRelative) / totalRelative;
@@ skipping 92 matching lines @@
         gridLayout[i] += gridDelta[i];
     }
     // if the deltas broke something, undo them
     if (!worked) {
         for (int i = 0; i < gridLen; ++i)
             gridLayout[i] -= gridDelta[i];
         axis.m_deltas.fill(0);
     }
 }
 
-void RenderFrameSet::notifyFrameEdgeInfoChanged()
+void LayoutFrameSet::notifyFrameEdgeInfoChanged()
 {
     if (needsLayout())
         return;
     // FIXME: We should only recompute the edge info with respect to the frame that changed
     // and its adjacent frame(s) instead of recomputing the edge info for the entire frameset.
     computeEdgeInfo();
 }
 
-void RenderFrameSet::fillFromEdgeInfo(const FrameEdgeInfo& edgeInfo, int r, int c)
+void LayoutFrameSet::fillFromEdgeInfo(const FrameEdgeInfo& edgeInfo, int r, int c)
 {
     if (edgeInfo.allowBorder(LeftFrameEdge))
         m_cols.m_allowBorder[c] = true;
     if (edgeInfo.allowBorder(RightFrameEdge))
         m_cols.m_allowBorder[c + 1] = true;
     if (edgeInfo.preventResize(LeftFrameEdge))
         m_cols.m_preventResize[c] = true;
     if (edgeInfo.preventResize(RightFrameEdge))
         m_cols.m_preventResize[c + 1] = true;
 
     if (edgeInfo.allowBorder(TopFrameEdge))
         m_rows.m_allowBorder[r] = true;
     if (edgeInfo.allowBorder(BottomFrameEdge))
         m_rows.m_allowBorder[r + 1] = true;
     if (edgeInfo.preventResize(TopFrameEdge))
         m_rows.m_preventResize[r] = true;
     if (edgeInfo.preventResize(BottomFrameEdge))
         m_rows.m_preventResize[r + 1] = true;
 }
 
-void RenderFrameSet::computeEdgeInfo()
+void LayoutFrameSet::computeEdgeInfo()
 {
     m_rows.m_preventResize.fill(frameSet()->noResize());
     m_rows.m_allowBorder.fill(false);
     m_cols.m_preventResize.fill(frameSet()->noResize());
     m_cols.m_allowBorder.fill(false);
 
     LayoutObject* child = firstChild();
     if (!child)
         return;
 
     size_t rows = m_rows.m_sizes.size();
     size_t cols = m_cols.m_sizes.size();
     for (size_t r = 0; r < rows; ++r) {
         for (size_t c = 0; c < cols; ++c) {
             FrameEdgeInfo edgeInfo;
             if (child->isFrameSet())
-                edgeInfo = toRenderFrameSet(child)->edgeInfo();
+                edgeInfo = toLayoutFrameSet(child)->edgeInfo();
             else
-                edgeInfo = toRenderFrame(child)->edgeInfo();
+                edgeInfo = toLayoutFrame(child)->edgeInfo();
             fillFromEdgeInfo(edgeInfo, r, c);
             child = child->nextSibling();
             if (!child)
                 return;
         }
     }
 }
 
-FrameEdgeInfo RenderFrameSet::edgeInfo() const
+FrameEdgeInfo LayoutFrameSet::edgeInfo() const
 {
     FrameEdgeInfo result(frameSet()->noResize(), true);
 
     int rows = frameSet()->totalRows();
     int cols = frameSet()->totalCols();
     if (rows && cols) {
         result.setPreventResize(LeftFrameEdge, m_cols.m_preventResize[0]);
         result.setAllowBorder(LeftFrameEdge, m_cols.m_allowBorder[0]);
         result.setPreventResize(RightFrameEdge, m_cols.m_preventResize[cols]);
         result.setAllowBorder(RightFrameEdge, m_cols.m_allowBorder[cols]);
         result.setPreventResize(TopFrameEdge, m_rows.m_preventResize[0]);
         result.setAllowBorder(TopFrameEdge, m_rows.m_allowBorder[0]);
         result.setPreventResize(BottomFrameEdge, m_rows.m_preventResize[rows]);
         result.setAllowBorder(BottomFrameEdge, m_rows.m_allowBorder[rows]);
     }
 
     return result;
 }
 
-void RenderFrameSet::layout()
+void LayoutFrameSet::layout()
 {
     ASSERT(needsLayout());
 
     if (!parent()->isFrameSet() && !document().printing()) {
         setWidth(view()->viewWidth());
         setHeight(view()->viewHeight());
     }
 
     unsigned cols = frameSet()->totalCols();
     unsigned rows = frameSet()->totalRows();
@@ skipping 21 matching lines @@
 static void clearNeedsLayoutOnHiddenFrames(RenderBox* frame)
 {
     for (; frame; frame = frame->nextSiblingBox()) {
         frame->setWidth(0);
         frame->setHeight(0);
         frame->clearNeedsLayout();
         clearNeedsLayoutOnHiddenFrames(frame->firstChildBox());
     }
 }
 
-void RenderFrameSet::positionFrames()
+void LayoutFrameSet::positionFrames()
 {
     RenderBox* child = firstChildBox();
     if (!child)
         return;
 
     int rows = frameSet()->totalRows();
     int cols = frameSet()->totalCols();
 
     int borderThickness = frameSet()->border();
     LayoutSize size;
@@ skipping 18 matching lines @@
             if (!child)
                 return;
         }
         position.setY(position.y() + size.height() + borderThickness);
     }
 
     // All the remaining frames are hidden to avoid ugly spurious unflowed frames.
     clearNeedsLayoutOnHiddenFrames(child);
 }
 
-void RenderFrameSet::startResizing(GridAxis& axis, int position)
+void LayoutFrameSet::startResizing(GridAxis& axis, int position)
 {
     int split = hitTestSplit(axis, position);
     if (split == noSplit || axis.m_preventResize[split]) {
         axis.m_splitBeingResized = noSplit;
         return;
     }
     axis.m_splitBeingResized = split;
     axis.m_splitResizeOffset = position - splitPosition(axis, split);
 }
 
-void RenderFrameSet::continueResizing(GridAxis& axis, int position)
+void LayoutFrameSet::continueResizing(GridAxis& axis, int position)
 {
     if (needsLayout())
         return;
     if (axis.m_splitBeingResized == noSplit)
         return;
     int currentSplitPosition = splitPosition(axis, axis.m_splitBeingResized);
     int delta = (position - currentSplitPosition) - axis.m_splitResizeOffset;
     if (!delta)
         return;
     axis.m_deltas[axis.m_splitBeingResized - 1] += delta;
     axis.m_deltas[axis.m_splitBeingResized] -= delta;
     setNeedsLayoutAndFullPaintInvalidation();
 }
 
-bool RenderFrameSet::userResize(MouseEvent* evt)
+bool LayoutFrameSet::userResize(MouseEvent* evt)
 {
     if (!m_isResizing) {
         if (needsLayout())
             return false;
         if (evt->type() == EventTypeNames::mousedown && evt->button() == LeftButton) {
             FloatPoint localPos = absoluteToLocal(FloatPoint(evt->absoluteLocation()), UseTransforms);
             startResizing(m_cols, localPos.x());
             startResizing(m_rows, localPos.y());
             if (m_cols.m_splitBeingResized != noSplit || m_rows.m_splitBeingResized != noSplit) {
                 setIsResizing(true);
                 return true;
             }
         }
     } else {
         if (evt->type() == EventTypeNames::mousemove || (evt->type() == EventTypeNames::mouseup && evt->button() == LeftButton)) {
             FloatPoint localPos = absoluteToLocal(FloatPoint(evt->absoluteLocation()), UseTransforms);
             continueResizing(m_cols, localPos.x());
             continueResizing(m_rows, localPos.y());
             if (evt->type() == EventTypeNames::mouseup && evt->button() == LeftButton) {
                 setIsResizing(false);
                 return true;
             }
         }
     }
 
     return false;
 }
 
-void RenderFrameSet::setIsResizing(bool isResizing)
+void LayoutFrameSet::setIsResizing(bool isResizing)
 {
     m_isResizing = isResizing;
     for (LayoutObject* ancestor = parent(); ancestor; ancestor = ancestor->parent()) {
         if (ancestor->isFrameSet())
-            toRenderFrameSet(ancestor)->m_isChildResizing = isResizing;
+            toLayoutFrameSet(ancestor)->m_isChildResizing = isResizing;
     }
     if (LocalFrame* frame = this->frame())
         frame->eventHandler().setResizingFrameSet(isResizing ? frameSet() : 0);
 }
 
-bool RenderFrameSet::canResizeRow(const IntPoint& p) const
+bool LayoutFrameSet::canResizeRow(const IntPoint& p) const
 {
     int r = hitTestSplit(m_rows, p.y());
     return r != noSplit && !m_rows.m_preventResize[r];
 }
 
-bool RenderFrameSet::canResizeColumn(const IntPoint& p) const
+bool LayoutFrameSet::canResizeColumn(const IntPoint& p) const
 {
     int c = hitTestSplit(m_cols, p.x());
     return c != noSplit && !m_cols.m_preventResize[c];
 }
 
-int RenderFrameSet::splitPosition(const GridAxis& axis, int split) const
+int LayoutFrameSet::splitPosition(const GridAxis& axis, int split) const
 {
     if (needsLayout())
         return 0;
 
     int borderThickness = frameSet()->border();
 
     int size = axis.m_sizes.size();
     if (!size)
         return 0;
 
     int position = 0;
     for (int i = 0; i < split && i < size; ++i)
         position += axis.m_sizes[i] + borderThickness;
     return position - borderThickness;
 }
 
-int RenderFrameSet::hitTestSplit(const GridAxis& axis, int position) const
+int LayoutFrameSet::hitTestSplit(const GridAxis& axis, int position) const
 {
     if (needsLayout())
         return noSplit;
 
     int borderThickness = frameSet()->border();
     if (borderThickness <= 0)
         return noSplit;
 
     size_t size = axis.m_sizes.size();
     if (!size)
         return noSplit;
 
     int splitPosition = axis.m_sizes[0];
     for (size_t i = 1; i < size; ++i) {
         if (position >= splitPosition && position < splitPosition + borderThickness)
             return i;
         splitPosition += borderThickness + axis.m_sizes[i];
     }
     return noSplit;
 }
 
-bool RenderFrameSet::isChildAllowed(LayoutObject* child, const LayoutStyle&) const
+bool LayoutFrameSet::isChildAllowed(LayoutObject* child, const LayoutStyle&) const
 {
     return child->isFrame() || child->isFrameSet();
 }
 
-CursorDirective RenderFrameSet::getCursor(const LayoutPoint& point, Cursor& cursor) const
+CursorDirective LayoutFrameSet::getCursor(const LayoutPoint& point, Cursor& cursor) const
 {
     IntPoint roundedPoint = roundedIntPoint(point);
     if (canResizeRow(roundedPoint)) {
         cursor = rowResizeCursor();
         return SetCursor;
     }
     if (canResizeColumn(roundedPoint)) {
         cursor = columnResizeCursor();
         return SetCursor;
     }
     return RenderBox::getCursor(point, cursor);
 }
 
 } // namespace blink