From 5dd043bf751f22ad491b064680a71c2978da2cc1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?L=C3=A9a=20Saviot?= Date: Fri, 10 Aug 2018 16:27:56 +0200 Subject: [PATCH] [poincare] Clean some layouts --- .../poincare/allocation_failure_layout_node.h | 21 +++++++++-- .../poincare/bracket_pair_layout_node.h | 1 - .../include/poincare/ceiling_layout_node.h | 2 + poincare/include/poincare/char_layout_node.h | 11 +++++- .../poincare/condensed_sum_layout_node.h | 2 + .../include/poincare/fraction_layout_node.h | 2 + poincare/include/poincare/grid_layout_node.h | 37 ++++++++++++++++--- .../include/poincare/matrix_layout_node.h | 24 ++++-------- poincare/src/bracket_pair_layout_node.cpp | 2 +- poincare/src/char_layout_node.cpp | 4 +- poincare/src/grid_layout_node.cpp | 35 ++++++++++++++---- poincare/src/matrix_layout_node.cpp | 16 ++------ 12 files changed, 103 insertions(+), 54 deletions(-) diff --git a/poincare/include/poincare/allocation_failure_layout_node.h b/poincare/include/poincare/allocation_failure_layout_node.h index 0ef3f98dc..69588acc8 100644 --- a/poincare/include/poincare/allocation_failure_layout_node.h +++ b/poincare/include/poincare/allocation_failure_layout_node.h @@ -20,18 +20,32 @@ public: return strlcpy(buffer, description(), bufferSize < descriptionLength ? bufferSize : descriptionLength); */ } + + // Rendering + void invalidAllSizesPositionsAndBaselines() override {} + + // Tree navigation void moveCursorLeft(LayoutCursor * cursor, bool * shouldRecomputeLayout) override {} void moveCursorRight(LayoutCursor * cursor, bool * shouldRecomputeLayout) override {} void moveCursorUp(LayoutCursor * cursor, bool * shouldRecomputeLayout, bool equivalentPositionVisited = false) override {} void moveCursorDown(LayoutCursor * cursor, bool * shouldRecomputeLayout, bool equivalentPositionVisited = false) override {} LayoutCursor equivalentCursor(LayoutCursor * cursor) override { return LayoutCursor(); } - void deleteBeforeCursor(LayoutCursor * cursor) override {} + + // Tree modification + + // Collapse bool shouldCollapseSiblingsOnLeft() const override { return false; } bool shouldCollapseSiblingsOnRight() const override { return false; } - int leftCollapsingAbsorbingChildIndex() const override { return 0; } - int rightCollapsingAbsorbingChildIndex() const override { return 0; } + int leftCollapsingAbsorbingChildIndex() const override { assert(false); return 0; } + int rightCollapsingAbsorbingChildIndex() const override { assert(false); return 0; } void didCollapseSiblings(LayoutCursor * cursor) override {} + + //User input + void deleteBeforeCursor(LayoutCursor * cursor) override {} + + // Other LayoutNode * layoutToPointWhenInserting() override { return this; } + bool hasText() const override { return false; } bool isCollapsable(int * numberOfOpenParenthesis, bool goingLeft) const override { return false; } bool canBeOmittedMultiplicationLeftFactor() const override { return false; } bool canBeOmittedMultiplicationRightFactor() const override { return false; } @@ -45,7 +59,6 @@ public: bool isEmpty() const override { return false; } bool isMatrix() const override { return false; } bool hasUpperLeftIndex() const override { return false; } - bool hasText() const override { return false; } bool willAddChildAtIndex(LayoutNode * l, int * index, int * currentNumberOfChildren, LayoutCursor * cursor) override { return false; } bool willAddSibling(LayoutCursor * cursor, LayoutNode * sibling, bool moveCursor) override { return false; } diff --git a/poincare/include/poincare/bracket_pair_layout_node.h b/poincare/include/poincare/bracket_pair_layout_node.h index 031252b34..450e05526 100644 --- a/poincare/include/poincare/bracket_pair_layout_node.h +++ b/poincare/include/poincare/bracket_pair_layout_node.h @@ -56,4 +56,3 @@ private: } #endif - diff --git a/poincare/include/poincare/ceiling_layout_node.h b/poincare/include/poincare/ceiling_layout_node.h index df7cb02b5..cc297f623 100644 --- a/poincare/include/poincare/ceiling_layout_node.h +++ b/poincare/include/poincare/ceiling_layout_node.h @@ -10,9 +10,11 @@ namespace Poincare { class CeilingLayoutNode : public BracketPairLayoutNode { public: using BracketPairLayoutNode::BracketPairLayoutNode; + int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return SerializationHelper::Prefix(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, "ceil"); } + // TreeNode static CeilingLayoutNode * FailedAllocationStaticNode(); CeilingLayoutNode * failedAllocationStaticNode() override { return FailedAllocationStaticNode(); } diff --git a/poincare/include/poincare/char_layout_node.h b/poincare/include/poincare/char_layout_node.h index 48bbeb7d0..cf4c7403e 100644 --- a/poincare/include/poincare/char_layout_node.h +++ b/poincare/include/poincare/char_layout_node.h @@ -1,22 +1,24 @@ #ifndef POINCARE_CHAR_LAYOUT_NODE_H #define POINCARE_CHAR_LAYOUT_NODE_H +#include #include #include #include +#include namespace Poincare { class CharLayoutNode : public LayoutNode { public: - CharLayoutNode(char c = 'a', KDText::FontSize fontSize = KDText::FontSize::Large) : + CharLayoutNode(char c = Ion::Charset::Empty, KDText::FontSize fontSize = KDText::FontSize::Large) : LayoutNode(), m_char(c), m_fontSize(fontSize) {} // CharLayout - void setChar(char c) { m_char = c; } + virtual void setChar(char c) { m_char = c; } KDText::FontSize fontSize() const { return m_fontSize; } void setFontSize(KDText::FontSize fontSize) { m_fontSize = fontSize; } @@ -57,6 +59,11 @@ private: KDText::FontSize m_fontSize; }; +class AllocationFailureCharLayoutNode : public AllocationFailureLayoutNode { +public: + void setChar(char c) override {} +}; + class CharLayoutRef : public LayoutReference { public: CharLayoutRef(char c, KDText::FontSize fontSize = KDText::FontSize::Large) : diff --git a/poincare/include/poincare/condensed_sum_layout_node.h b/poincare/include/poincare/condensed_sum_layout_node.h index 90827f5a1..043c86275 100644 --- a/poincare/include/poincare/condensed_sum_layout_node.h +++ b/poincare/include/poincare/condensed_sum_layout_node.h @@ -17,6 +17,8 @@ public: * a view with no cursor. */ void moveCursorLeft(LayoutCursor * cursor, bool * shouldRecomputeLayout) override { assert(false); } void moveCursorRight(LayoutCursor * cursor, bool * shouldRecomputeLayout) override { assert(false); } + void moveCursorUp(LayoutCursor * cursor, bool * shouldRecomputeLayout, bool equivalentPositionVisited = false) override { assert(false); } + void moveCursorDown(LayoutCursor * cursor, bool * shouldRecomputeLayout, bool equivalentPositionVisited = false) override { assert(false); } int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return SerializationHelper::Prefix(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, "sum"); } diff --git a/poincare/include/poincare/fraction_layout_node.h b/poincare/include/poincare/fraction_layout_node.h index ac6446b14..f1e016fc7 100644 --- a/poincare/include/poincare/fraction_layout_node.h +++ b/poincare/include/poincare/fraction_layout_node.h @@ -21,7 +21,9 @@ public: void moveCursorUp(LayoutCursor * cursor, bool * shouldRecomputeLayout, bool equivalentPositionVisited = false) override; void moveCursorDown(LayoutCursor * cursor, bool * shouldRecomputeLayout, bool equivalentPositionVisited = false) override; void deleteBeforeCursor(LayoutCursor * cursor) override; + int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; + bool shouldCollapseSiblingsOnLeft() const override { return true; } bool shouldCollapseSiblingsOnRight() const override { return true; } int leftCollapsingAbsorbingChildIndex() const override { return 0; } diff --git a/poincare/include/poincare/grid_layout_node.h b/poincare/include/poincare/grid_layout_node.h index 66e113f94..dd12126d0 100644 --- a/poincare/include/poincare/grid_layout_node.h +++ b/poincare/include/poincare/grid_layout_node.h @@ -40,22 +40,27 @@ public: } // TreeNode + static GridLayoutNode * FailedAllocationStaticNode(); + GridLayoutNode * failedAllocationStaticNode() override { return FailedAllocationStaticNode(); } size_t size() const override { return sizeof(GridLayoutNode); } + void didAddChildAtIndex(int newNumberOfChildren) override; int numberOfChildren() const override { return m_numberOfRows * m_numberOfColumns; } void eraseNumberOfChildren() override { m_numberOfRows = 0; m_numberOfColumns = 0; } -#if TREE_LOG - const char * description() const override { return "GridLayout"; } +#if POINCARE_TREE_LOG + virtual void logNodeName(std::ostream & stream) const override { + stream << "GridLayout"; + } #endif protected: // GridLayoutNode - void addEmptyRow(EmptyLayoutNode::Color color); - void addEmptyColumn(EmptyLayoutNode::Color color); - void deleteRowAtIndex(int index); - void deleteColumnAtIndex(int index); + virtual void addEmptyRow(EmptyLayoutNode::Color color); + virtual void addEmptyColumn(EmptyLayoutNode::Color color); + virtual void deleteRowAtIndex(int index); + virtual void deleteColumnAtIndex(int index); bool childIsRightOfGrid(int index) const; bool childIsLeftOfGrid(int index) const; bool childIsTopOfGrid(int index) const; @@ -82,6 +87,26 @@ private: void render(KDContext * ctx, KDPoint p, KDColor expressionColor, KDColor backgroundColor) override {} }; +class GridLayoutRef : public LayoutReference { +public: + GridLayoutRef(const GridLayoutNode * n) : LayoutReference(n) {} + GridLayoutRef() : LayoutReference(TreePool::sharedPool()->createTreeNode()) {} + void setDimensions(int rows, int columns); + void addChildAtIndex(LayoutReference l, int index, int currentNumberOfChildren, LayoutCursor * cursor) override { + LayoutReference::addChildAtIndex(l, index, currentNumberOfChildren, cursor); + } +private: + GridLayoutNode * node() const { return static_cast(LayoutReference::node()); } + void setNumberOfRows(int rows) { + assert(rows >= 0); + node()->setNumberOfRows(rows); + } + void setNumberOfColumns(int columns) { + assert(columns >= 0); + node()->setNumberOfColumns(columns); + } +}; + } #endif diff --git a/poincare/include/poincare/matrix_layout_node.h b/poincare/include/poincare/matrix_layout_node.h index 12228e000..9fa5b556c 100644 --- a/poincare/include/poincare/matrix_layout_node.h +++ b/poincare/include/poincare/matrix_layout_node.h @@ -33,7 +33,6 @@ public: static MatrixLayoutNode * FailedAllocationStaticNode(); MatrixLayoutNode * failedAllocationStaticNode() override { return FailedAllocationStaticNode(); } size_t size() const override { return sizeof(MatrixLayoutNode); } - void didAddChildAtIndex(int newNumberOfChildren) override; #if POINCARE_TREE_LOG virtual void logNodeName(std::ostream & stream) const override { stream << "MatrixLayout"; @@ -61,13 +60,18 @@ private: class AllocationFailureMatrixLayoutNode : public AllocationFailureLayoutNode { void setNumberOfRows(int numberOfRows) override {} void setNumberOfColumns(int numberOfColumns) override {} +protected: + void addEmptyRow(EmptyLayoutNode::Color color) override {} + void addEmptyColumn(EmptyLayoutNode::Color color) override {} + void deleteRowAtIndex(int index) override {} + void deleteColumnAtIndex(int index) override {} }; -class MatrixLayoutRef : public LayoutReference { +class MatrixLayoutRef : public GridLayoutRef { friend class MatrixLayoutNode; public: - MatrixLayoutRef(const MatrixLayoutNode * n) : LayoutReference(n) {} - MatrixLayoutRef() : LayoutReference(TreePool::sharedPool()->createTreeNode()) {} + MatrixLayoutRef(const MatrixLayoutNode * n) : GridLayoutRef(n) {} + MatrixLayoutRef() : GridLayoutRef(TreePool::sharedPool()->createTreeNode()) {} MatrixLayoutRef(LayoutRef l1, LayoutRef l2, LayoutRef l3, LayoutRef l4) : MatrixLayoutRef() { @@ -80,20 +84,8 @@ public: bool hasGreySquares() const { return node()->hasGreySquares(); } void addGreySquares() { node()->addGreySquares(); } void removeGreySquares() { node()->removeGreySquares(); } - void setDimensions(int rows, int columns); - void addChildAtIndex(LayoutReference l, int index, int currentNumberOfChildren, LayoutCursor * cursor) override { - LayoutReference::addChildAtIndex(l, index, currentNumberOfChildren, cursor); - } private: MatrixLayoutNode * node() const { return static_cast(LayoutReference::node()); } - void setNumberOfRows(int rows) { - assert(rows >= 0); - node()->setNumberOfRows(rows); - } - void setNumberOfColumns(int columns) { - assert(columns >= 0); - node()->setNumberOfColumns(columns); - } }; } diff --git a/poincare/src/bracket_pair_layout_node.cpp b/poincare/src/bracket_pair_layout_node.cpp index a70bff263..5f8cb9c53 100644 --- a/poincare/src/bracket_pair_layout_node.cpp +++ b/poincare/src/bracket_pair_layout_node.cpp @@ -75,7 +75,7 @@ void BracketPairLayoutNode::deleteBeforeCursor(LayoutCursor * cursor) { // Case: Left of the operand. Delete the layout, keep the operand. LayoutRef rootRef = LayoutRef(root()); LayoutRef thisRef = LayoutRef(this); - LayoutRef child = childLayout(); + LayoutRef child = LayoutRef(childLayout()); thisRef.replaceChildWithGhostInPlace(child); // WARNING: do not call "this" afterwards if (rootRef.isAllocationFailure()) { diff --git a/poincare/src/char_layout_node.cpp b/poincare/src/char_layout_node.cpp index 33d4f4009..76886909f 100644 --- a/poincare/src/char_layout_node.cpp +++ b/poincare/src/char_layout_node.cpp @@ -1,13 +1,11 @@ #include -#include #include #include -#include namespace Poincare { CharLayoutNode * CharLayoutNode::FailedAllocationStaticNode() { - static AllocationFailureLayoutNode failure; + static AllocationFailureCharLayoutNode failure; TreePool::sharedPool()->registerStaticNodeIfRequired(&failure); return &failure; } diff --git a/poincare/src/grid_layout_node.cpp b/poincare/src/grid_layout_node.cpp index 5574492b4..cb96b6f2a 100644 --- a/poincare/src/grid_layout_node.cpp +++ b/poincare/src/grid_layout_node.cpp @@ -1,4 +1,5 @@ #include +#include #include #include @@ -6,6 +7,12 @@ namespace Poincare { static inline KDCoordinate max(KDCoordinate x, KDCoordinate y) { return x > y ? x : y; } +GridLayoutNode * GridLayoutNode::FailedAllocationStaticNode() { + static AllocationFailureLayoutNode failure; + TreePool::sharedPool()->registerStaticNodeIfRequired(&failure); + return &failure; +} + // LayoutNode void GridLayoutNode::moveCursorLeft(LayoutCursor * cursor, bool * shouldRecomputeLayout) { @@ -90,11 +97,16 @@ void GridLayoutNode::moveCursorDown(LayoutCursor * cursor, bool * shouldRecomput LayoutNode::moveCursorDown(cursor, shouldRecomputeLayout, equivalentPositionVisited); } +void GridLayoutNode::didAddChildAtIndex(int newNumberOfChildren) { + GridLayoutRef(this).setDimensions(1, newNumberOfChildren); +} + // Protected void GridLayoutNode::addEmptyRow(EmptyLayoutNode::Color color) { - LayoutRef thisRef = LayoutRef(this); + GridLayoutRef thisRef = GridLayoutRef(this); int previousNumberOfChildren = numberOfChildren(); int columnsCount = m_numberOfColumns; + int previousRowCount = m_numberOfRows; for (int i = 0; i < columnsCount; i++) { thisRef.addChildAtIndex( EmptyLayoutRef(color), @@ -103,13 +115,11 @@ void GridLayoutNode::addEmptyRow(EmptyLayoutNode::Color color) { nullptr); // WARNING: Do not access "this" afterwards } - if (!thisRef.isAllocationFailure()) { - m_numberOfRows++; - } + thisRef.setDimensions(previousRowCount + 1, columnsCount); } void GridLayoutNode::addEmptyColumn(EmptyLayoutNode::Color color) { - LayoutRef thisRef = LayoutRef(this); + GridLayoutRef thisRef = GridLayoutRef(this); int previousNumberOfChildren = numberOfChildren(); int rowsCount = m_numberOfRows; int futureColumnsCount = m_numberOfColumns + 1; @@ -121,9 +131,7 @@ void GridLayoutNode::addEmptyColumn(EmptyLayoutNode::Color color) { nullptr); // WARNING: Do not access "this" afterwards } - if (!thisRef.isAllocationFailure()) { - m_numberOfColumns++; - } + thisRef.setDimensions(rowsCount, futureColumnsCount); } void GridLayoutNode::deleteRowAtIndex(int index) { @@ -259,4 +267,15 @@ KDCoordinate GridLayoutNode::width() const { return totalWidth; } +// Grid Layout Reference +void GridLayoutRef::setDimensions(int rows, int columns) { + if (!isAllocationFailure()) { + /* If the node is an allocation failure, setNumberOfRows and + * setNumberOfColumns will do nothing. */ + assert(rows * columns == numberOfChildren()); + } + setNumberOfRows(rows); + setNumberOfColumns(columns); +} + } diff --git a/poincare/src/matrix_layout_node.cpp b/poincare/src/matrix_layout_node.cpp index 4c844e2e8..45dd9d71e 100644 --- a/poincare/src/matrix_layout_node.cpp +++ b/poincare/src/matrix_layout_node.cpp @@ -15,11 +15,6 @@ MatrixLayoutNode * MatrixLayoutNode::FailedAllocationStaticNode() { // MatrixLayoutNode -void MatrixLayoutNode::didAddChildAtIndex(int newNumberOfChildren) { - setNumberOfRows(1); - setNumberOfColumns(newNumberOfChildren); -} - void MatrixLayoutNode::addGreySquares() { if (!hasGreySquares()) { LayoutRef thisRef(this); @@ -252,7 +247,9 @@ bool MatrixLayoutNode::isColumnEmpty(int index) const { } bool MatrixLayoutNode::hasGreySquares() const { - assert(m_numberOfRows*m_numberOfColumns - 1 >= 0); + if (numberOfChildren() == 0) { + return false; + } LayoutNode * lastChild = const_cast(this)->childAtIndex(m_numberOfRows * m_numberOfColumns - 1); if (lastChild->isEmpty() && !lastChild->isHorizontal() @@ -298,11 +295,4 @@ void MatrixLayoutNode::didReplaceChildAtIndex(int index, LayoutCursor * cursor, } } -// Matrix Layout Reference -void MatrixLayoutRef::setDimensions(int rows, int columns) { - assert(rows * columns == numberOfChildren()); - setNumberOfRows(rows); - setNumberOfColumns(columns); -} - }