[New Multicolumn] Make positionForPoint() work.

Source/core/layout/MultiColumnFragmentainerGroup.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 
 #include "core/layout/MultiColumnFragmentainerGroup.h"
 
 #include "core/layout/LayoutMultiColumnSet.h"
 
@@ skipping 128 matching lines @@
     m_columnSet.flipForWritingMode(columnRect);
     return columnRect.location() - portionRect.location();
 }
 
 LayoutUnit MultiColumnFragmentainerGroup::columnLogicalTopForOffset(LayoutUnit offsetInFlowThread) const
 {
     unsigned columnIndex = columnIndexAtOffset(offsetInFlowThread, AssumeNewColumns);
     return m_logicalTopInFlowThread + columnIndex * m_columnHeight;
 }
 
+LayoutPoint MultiColumnFragmentainerGroup::visualPointToFlowThreadPoint(const LayoutPoint& visualPoint) const
+{
+    unsigned columnIndex = columnIndexAtVisualPoint(visualPoint);
+    LayoutRect columnRect = columnRectAt(columnIndex);
+    LayoutPoint localPoint(visualPoint);
+    localPoint.moveBy(-columnRect.location());
+    // Before converting to a flow thread position, if the block direction coordinate is outside the
+    // column, snap to the bounds of the column, and reset the inline direction coordinate to the
+    // start position in the column. The effect of this is that if the block position is before the
+    // column rectangle, we'll get to the beginning of this column, while if the block position is
+    // after the column rectangle, we'll get to the beginning of the next column.
+    if (!m_columnSet.isHorizontalWritingMode()) {
+        LayoutUnit columnStart = m_columnSet.style()->isLeftToRightDirection() ? LayoutUnit() : columnRect.height();
+        if (localPoint.x() < 0)
+            localPoint = LayoutPoint(LayoutUnit(), columnStart);
+        else if (localPoint.x() > logicalHeight())
+            localPoint = LayoutPoint(logicalHeight(), columnStart);
+        return LayoutPoint(localPoint.x() + logicalTopInFlowThreadAt(columnIndex), localPoint.y());
+    }
+    LayoutUnit columnStart = m_columnSet.style()->isLeftToRightDirection() ? LayoutUnit() : columnRect.width();
+    if (localPoint.y() < 0)
+        localPoint = LayoutPoint(columnStart, LayoutUnit());
+    else if (localPoint.y() > logicalHeight())
+        localPoint = LayoutPoint(columnStart, logicalHeight());
+    return LayoutPoint(localPoint.x(), localPoint.y() + logicalTopInFlowThreadAt(columnIndex));
+}
+
 void MultiColumnFragmentainerGroup::collectLayerFragments(LayerFragments& fragments, const LayoutRect& layerBoundingBox, const LayoutRect& dirtyRect) const
 {
     // |layerBoundingBox| is in the flow thread coordinate space, relative to the top/left edge of
     // the flow thread, but note that it has been converted with respect to writing mode (so that
     // it's visual/physical in that sense).
     //
     // |dirtyRect| is visual, relative to the multicol container.
     //
     // Then there's the output from this method - the stuff we put into the list of fragments. The
     // fragment.paginationOffset point is the actual visual translation required to get from a
@@ skipping 324 matching lines @@
     if (mode == ClampToExistingColumns) {
         if (offsetInFlowThread >= m_logicalBottomInFlowThread)
             return actualColumnCount() - 1;
     }
 
     if (m_columnHeight)
         return (offsetInFlowThread - m_logicalTopInFlowThread).toFloat() / m_columnHeight.toFloat();
     return 0;
 }
 
+unsigned MultiColumnFragmentainerGroup::columnIndexAtVisualPoint(const LayoutPoint& visualPoint) const
+{
+    bool isColumnProgressionInline = m_columnSet.multiColumnFlowThread()->progressionIsInline();

[Julien - ping for review, 2015/03/09 15:49:03]

progressionIsInline() is only set for paged overflow. However I don't see any
new or newly enabled test covering this. Is this tested at all?

[mstensho (USE GERRIT), 2015/03/12 11:43:27]

Done.

Added a paged-y test.

+    bool isHorizontalWritingMode = m_columnSet.isHorizontalWritingMode();
+    LayoutUnit columnLengthInColumnProgressionDirection = isColumnProgressionInline ? m_columnSet.pageLogicalWidth() : m_columnSet.pageLogicalHeight();
+    LayoutUnit offsetInColumnProgressionDirection = isHorizontalWritingMode == isColumnProgressionInline ? visualPoint.x() : visualPoint.y();
+    if (!m_columnSet.style()->isLeftToRightDirection() && isColumnProgressionInline)
+        offsetInColumnProgressionDirection = m_columnSet.logicalWidth() - offsetInColumnProgressionDirection;
+    LayoutUnit columnGap = m_columnSet.columnGap();
+    if (columnLengthInColumnProgressionDirection + columnGap <= 0)
+        return 0;
+    // Column boundaries are in the middle of the column gap.
+    int index = (offsetInColumnProgressionDirection + columnGap / 2) / (columnLengthInColumnProgressionDirection + columnGap);
+    if (index < 0)
+        return 0;
+    return std::min(unsigned(index), actualColumnCount() - 1);
+}
+
 MultiColumnFragmentainerGroupList::MultiColumnFragmentainerGroupList(LayoutMultiColumnSet& columnSet)
     : m_columnSet(columnSet)
 {
     append(MultiColumnFragmentainerGroup(m_columnSet));
 }
 
 MultiColumnFragmentainerGroup& MultiColumnFragmentainerGroupList::addExtraGroup()
 {
     append(MultiColumnFragmentainerGroup(m_columnSet));
     return last();
 }
 
 void MultiColumnFragmentainerGroupList::deleteExtraGroups()
 {
     shrink(1);
 }
 
 } // namespace blink