diff --git a/apps/calculation/history_controller.cpp b/apps/calculation/history_controller.cpp index acbab958f..c2f6ed508 100644 --- a/apps/calculation/history_controller.cpp +++ b/apps/calculation/history_controller.cpp @@ -64,7 +64,7 @@ bool HistoryController::handleEvent(Ion::Events::Event event) { editController->insertTextBody(calculation->inputText()); } else { ScrollableExactApproximateExpressionsView::SubviewPosition outputSubviewPosition = selectedCell->outputView()->selectedSubviewPosition(); - if (outputSubviewPosition == ScrollableExactApproximateExpressionsView::SubviewPosition::Burger) { + if (outputSubviewPosition == ScrollableExactApproximateExpressionsView::SubviewPosition::Left) { Expression::AdditionalInformationType additionalInfoType = selectedCell->additionalInformationType(); /* TODO * Controller * c = additionalInformationType ? graphController : listController? diff --git a/apps/calculation/history_view_cell.cpp b/apps/calculation/history_view_cell.cpp index d4f8ced2a..f1ae14195 100644 --- a/apps/calculation/history_view_cell.cpp +++ b/apps/calculation/history_view_cell.cpp @@ -84,7 +84,7 @@ void HistoryViewCell::reloadOutputSelection() { /* Select the right output according to the calculation display output. This * will reload the scroll to display the selected output. */ if (m_calculationDisplayOutput == Calculation::DisplayOutput::ExactAndApproximate) { - m_scrollableOutputView.setSelectedSubviewPosition(Shared::ScrollableExactApproximateExpressionsView::SubviewPosition::Left); + m_scrollableOutputView.setSelectedSubviewPosition(Shared::ScrollableExactApproximateExpressionsView::SubviewPosition::Center); } else { assert((m_calculationDisplayOutput == Calculation::DisplayOutput::ApproximateOnly) || (m_calculationDisplayOutput == Calculation::DisplayOutput::ExactAndApproximateToggle) @@ -103,8 +103,8 @@ void HistoryViewCell::cellDidSelectSubview(HistoryViewCellDataSource::SubviewTyp /* The selected subview has changed. The displayed outputs might have changed. * For example, for the calculation 1.2+2 --> 3.2, selecting the output would * display 1.2+2 --> 16/5 = 3.2. */ - m_scrollableOutputView.setDisplayLeftLayout(m_calculationDisplayOutput == Calculation::DisplayOutput::ExactAndApproximate || (m_calculationDisplayOutput == Calculation::DisplayOutput::ExactAndApproximateToggle && outputSelected)); - m_scrollableOutputView.setDisplayBurger(outputSelected && m_calculationAdditionInformation != Poincare::Expression::AdditionalInformationType::None); + m_scrollableOutputView.setDisplayCenter(m_calculationDisplayOutput == Calculation::DisplayOutput::ExactAndApproximate || (m_calculationDisplayOutput == Calculation::DisplayOutput::ExactAndApproximateToggle && outputSelected)); + m_scrollableOutputView.setDisplayLeft(outputSelected && m_calculationAdditionInformation != Poincare::Expression::AdditionalInformationType::None); /* The displayed outputs have changed. We need to re-layout the cell * and re-initialize the scroll. */ diff --git a/apps/shared/scrollable_exact_approximate_expressions_cell.cpp b/apps/shared/scrollable_exact_approximate_expressions_cell.cpp index da4bb9881..879f4d476 100644 --- a/apps/shared/scrollable_exact_approximate_expressions_cell.cpp +++ b/apps/shared/scrollable_exact_approximate_expressions_cell.cpp @@ -12,7 +12,7 @@ ScrollableExactApproximateExpressionsCell::ScrollableExactApproximateExpressions void ScrollableExactApproximateExpressionsCell::setLayouts(Poincare::Layout approximateLayout, Poincare::Layout exactLayout) { m_view.setLayouts(approximateLayout, exactLayout); - m_view.setSelectedSubviewPosition(ScrollableExactApproximateExpressionsView::SubviewPosition::Left); + m_view.setSelectedSubviewPosition(ScrollableExactApproximateExpressionsView::SubviewPosition::Center); } void ScrollableExactApproximateExpressionsCell::setHighlighted(bool highlight) { @@ -31,7 +31,7 @@ void ScrollableExactApproximateExpressionsCell::reloadScroll() { } void ScrollableExactApproximateExpressionsCell::didBecomeFirstResponder() { - m_view.setSelectedSubviewPosition(ScrollableExactApproximateExpressionsView::SubviewPosition::Left); + m_view.setSelectedSubviewPosition(ScrollableExactApproximateExpressionsView::SubviewPosition::Center); Container::activeApp()->setFirstResponder(&m_view); } diff --git a/apps/shared/scrollable_exact_approximate_expressions_view.cpp b/apps/shared/scrollable_exact_approximate_expressions_view.cpp index 6a045212f..ad2d620d2 100644 --- a/apps/shared/scrollable_exact_approximate_expressions_view.cpp +++ b/apps/shared/scrollable_exact_approximate_expressions_view.cpp @@ -7,142 +7,145 @@ namespace Shared { static inline KDCoordinate maxCoordinate(KDCoordinate x, KDCoordinate y) { return x > y ? x : y; } -ScrollableExactApproximateExpressionsView::ContentCell::ContentCell() : +AbstractScrollableExactApproximateExpressionsView::ContentCell::ContentCell() : m_rightExpressionView(), m_approximateSign(KDFont::LargeFont, I18n::Message::AlmostEqual, 0.5f, 0.5f, Palette::GreyVeryDark), - m_leftExpressionView(), - m_selectedSubviewPosition(SubviewPosition::Left), - m_displayLeftExpression(true), - m_displayBurger(false) + m_centeredExpressionView(), + m_selectedSubviewPosition(SubviewPosition::Center), + m_displayCenter(true), + m_displayLeft(false) { } -KDColor ScrollableExactApproximateExpressionsView::ContentCell::backgroundColor() const { +KDColor AbstractScrollableExactApproximateExpressionsView::ContentCell::backgroundColor() const { KDColor background = m_even ? KDColorWhite : Palette::WallScreen; return background; } -void ScrollableExactApproximateExpressionsView::ContentCell::setHighlighted(bool highlight) { +void AbstractScrollableExactApproximateExpressionsView::ContentCell::setHighlighted(bool highlight) { // Do not call HighlightCell::setHighlighted to avoid marking all cell as dirty m_highlighted = highlight; - m_leftExpressionView.setBackgroundColor(backgroundColor()); + m_centeredExpressionView.setBackgroundColor(backgroundColor()); m_rightExpressionView.setBackgroundColor(backgroundColor()); m_approximateSign.setBackgroundColor(backgroundColor()); - if (m_displayBurger) { - burgerMenuView()->setBackgroundColor(backgroundColor()); + if (m_displayLeft) { + setLeftViewBackgroundColor(backgroundColor()); } if (highlight) { - if (m_selectedSubviewPosition == SubviewPosition::Left) { - m_leftExpressionView.setBackgroundColor(Palette::Select); + if (m_selectedSubviewPosition == SubviewPosition::Center) { + m_centeredExpressionView.setBackgroundColor(Palette::Select); } else if (m_selectedSubviewPosition == SubviewPosition::Right) { m_rightExpressionView.setBackgroundColor(Palette::Select); } else { - burgerMenuView()->setBackgroundColor(Palette::Select); + setLeftViewBackgroundColor(Palette::Select); } } } -void ScrollableExactApproximateExpressionsView::ContentCell::setEven(bool even) { +void AbstractScrollableExactApproximateExpressionsView::ContentCell::setEven(bool even) { EvenOddCell::setEven(even); - m_leftExpressionView.setBackgroundColor(backgroundColor()); + m_centeredExpressionView.setBackgroundColor(backgroundColor()); m_rightExpressionView.setBackgroundColor(backgroundColor()); m_approximateSign.setBackgroundColor(backgroundColor()); - if (m_displayBurger) { - burgerMenuView()->setBackgroundColor(backgroundColor()); + if (m_displayLeft) { + setLeftViewBackgroundColor(backgroundColor()); } } -void ScrollableExactApproximateExpressionsView::ContentCell::reloadTextColor() { - if (numberOfSubviews() == 1+m_displayBurger) { +void AbstractScrollableExactApproximateExpressionsView::ContentCell::reloadTextColor() { + if (numberOfSubviews() == 1+m_displayLeft) { m_rightExpressionView.setTextColor(KDColorBlack); } else { m_rightExpressionView.setTextColor(Palette::GreyVeryDark); } } -KDSize ScrollableExactApproximateExpressionsView::ContentCell::minimalSizeForOptimalDisplay() const { - KDSize burgerSize = KDSizeZero; +KDSize AbstractScrollableExactApproximateExpressionsView::ContentCell::minimalSizeForOptimalDisplay() const { + KDSize leftSize = KDSizeZero; + KDCoordinate leftViewBaseline = 0; KDCoordinate width = 0; - if (m_displayBurger) { - burgerSize = burgerMenuView()->minimalSizeForOptimalDisplay(); - width += burgerSize.width() + Metric::CommonLargeMargin; + if (m_displayLeft) { + leftSize = leftView()->minimalSizeForOptimalDisplay(); + leftViewBaseline = leftBaseline(); + width += leftSize.width() + Metric::CommonLargeMargin; } KDSize rightExpressionSize = m_rightExpressionView.minimalSizeForOptimalDisplay(); width += rightExpressionSize.width(); KDCoordinate rightBaseline = m_rightExpressionView.layout().isUninitialized() ? 0 : m_rightExpressionView.layout().baseline(); - KDSize leftExpressionSize = KDSizeZero; - KDCoordinate leftBaseline = 0; - if (m_displayLeftExpression && !m_leftExpressionView.layout().isUninitialized()) { - leftBaseline = m_leftExpressionView.layout().baseline(); - leftExpressionSize = m_leftExpressionView.minimalSizeForOptimalDisplay(); - width += leftExpressionSize.width() + 2*Metric::CommonLargeMargin + m_approximateSign.minimalSizeForOptimalDisplay().width(); + KDSize centeredExpressionSize = KDSizeZero; + KDCoordinate centeredBaseline = 0; + if (m_displayCenter && !m_centeredExpressionView.layout().isUninitialized()) { + centeredBaseline = m_centeredExpressionView.layout().baseline(); + centeredExpressionSize = m_centeredExpressionView.minimalSizeForOptimalDisplay(); + width += centeredExpressionSize.width() + 2*Metric::CommonLargeMargin + m_approximateSign.minimalSizeForOptimalDisplay().width(); } - KDCoordinate height = maxCoordinate(maxCoordinate(leftBaseline, rightBaseline), burgerSize.height()/2) + maxCoordinate(maxCoordinate(leftExpressionSize.height()-leftBaseline, rightExpressionSize.height()-rightBaseline), burgerSize.height()/2); + KDCoordinate height = maxCoordinate(maxCoordinate(centeredBaseline, rightBaseline), leftViewBaseline) + maxCoordinate(maxCoordinate(centeredExpressionSize.height()-centeredBaseline, rightExpressionSize.height()-rightBaseline), leftSize.height()-leftViewBaseline); return KDSize(width, height); } -void ScrollableExactApproximateExpressionsView::ContentCell::setSelectedSubviewPosition(ScrollableExactApproximateExpressionsView::SubviewPosition subviewPosition) { +void AbstractScrollableExactApproximateExpressionsView::ContentCell::setSelectedSubviewPosition(AbstractScrollableExactApproximateExpressionsView::SubviewPosition subviewPosition) { m_selectedSubviewPosition = subviewPosition; setHighlighted(isHighlighted()); } -void ScrollableExactApproximateExpressionsView::ContentCell::setDisplayLeftExpression(bool display) { - m_displayLeftExpression = display; +void AbstractScrollableExactApproximateExpressionsView::ContentCell::setDisplayCenter(bool display) { + m_displayCenter = display; reloadTextColor(); } -Poincare::Layout ScrollableExactApproximateExpressionsView::ContentCell::layout() const { - if (m_selectedSubviewPosition == SubviewPosition::Left) { - return m_leftExpressionView.layout(); +Poincare::Layout AbstractScrollableExactApproximateExpressionsView::ContentCell::layout() const { + if (m_selectedSubviewPosition == SubviewPosition::Center) { + return m_centeredExpressionView.layout(); } else { assert(m_selectedSubviewPosition == SubviewPosition::Right); return m_rightExpressionView.layout(); } } -int ScrollableExactApproximateExpressionsView::ContentCell::numberOfSubviews() const { +int AbstractScrollableExactApproximateExpressionsView::ContentCell::numberOfSubviews() const { int nbOfSubviews = 1; - if (m_displayLeftExpression && !m_leftExpressionView.layout().isUninitialized()) { + if (m_displayCenter && !m_centeredExpressionView.layout().isUninitialized()) { nbOfSubviews += 2; } - if (m_displayBurger) { + if (m_displayLeft) { nbOfSubviews += 1; } return nbOfSubviews; } -View * ScrollableExactApproximateExpressionsView::ContentCell::subviewAtIndex(int index) { - if (m_displayBurger && index == 0) { - return burgerMenuView(); +View * AbstractScrollableExactApproximateExpressionsView::ContentCell::subviewAtIndex(int index) { + if (m_displayLeft && index == 0) { + return leftView(); } - View * views[3] = {&m_rightExpressionView, &m_approximateSign, &m_leftExpressionView}; - return views[index - m_displayBurger]; + View * views[3] = {&m_rightExpressionView, &m_approximateSign, &m_centeredExpressionView}; + return views[index - m_displayLeft]; } -void ScrollableExactApproximateExpressionsView::ContentCell::layoutSubviews(bool force) { +void AbstractScrollableExactApproximateExpressionsView::ContentCell::layoutSubviews(bool force) { // Subviews sizes - KDSize burgerSize = m_displayBurger ? burgerMenuView()->minimalSizeForOptimalDisplay() : KDSizeZero; - KDSize leftExpressionSize = KDSizeZero; - KDCoordinate leftBaseline = 0; - if (m_displayLeftExpression && !m_leftExpressionView.layout().isUninitialized()) { - leftBaseline = m_leftExpressionView.layout().baseline(); - leftExpressionSize = m_leftExpressionView.minimalSizeForOptimalDisplay(); + KDSize leftSize = m_displayLeft ? leftView()->minimalSizeForOptimalDisplay() : KDSizeZero; + KDCoordinate leftViewBaseline = m_displayLeft ? leftBaseline() : 0; + KDSize centeredExpressionSize = KDSizeZero; + KDCoordinate centeredBaseline = 0; + if (m_displayCenter && !m_centeredExpressionView.layout().isUninitialized()) { + centeredBaseline = m_centeredExpressionView.layout().baseline(); + centeredExpressionSize = m_centeredExpressionView.minimalSizeForOptimalDisplay(); } KDSize rightExpressionSize = m_rightExpressionView.minimalSizeForOptimalDisplay(); KDCoordinate rightBaseline = m_rightExpressionView.layout().isUninitialized() ? 0 : m_rightExpressionView.layout().baseline(); // Compute baseline - KDCoordinate baseline = maxCoordinate(maxCoordinate(leftBaseline, rightBaseline), burgerSize.height()/2); - // Layout burger + KDCoordinate baseline = maxCoordinate(maxCoordinate(leftViewBaseline, rightBaseline), centeredBaseline); + // Layout left view KDCoordinate currentWidth = 0; - if (m_displayBurger) { - burgerMenuView()->setFrame(KDRect(currentWidth, baseline-burgerSize.height()/2, burgerSize), force); - currentWidth += burgerSize.width() + Metric::CommonLargeMargin; + if (m_displayLeft) { + leftView()->setFrame(KDRect(currentWidth, baseline-leftBaseline(), leftSize), force); + currentWidth += leftSize.width() + Metric::CommonLargeMargin; } - // Layout left expression - if (m_displayLeftExpression && !m_leftExpressionView.layout().isUninitialized()) { + // Layout centerd expression + if (m_displayCenter && !m_centeredExpressionView.layout().isUninitialized()) { KDSize approximateSignSize = m_approximateSign.minimalSizeForOptimalDisplay(); - m_leftExpressionView.setFrame(KDRect(currentWidth, baseline-leftBaseline, leftExpressionSize), force); - currentWidth += Metric::CommonLargeMargin+leftExpressionSize.width(); + m_centeredExpressionView.setFrame(KDRect(currentWidth, baseline-centeredBaseline, centeredExpressionSize), force); + currentWidth += Metric::CommonLargeMargin+centeredExpressionSize.width(); m_approximateSign.setFrame(KDRect(currentWidth, baseline-approximateSignSize.height()/2, approximateSignSize), force); currentWidth += Metric::CommonLargeMargin + approximateSignSize.width(); } @@ -150,14 +153,8 @@ void ScrollableExactApproximateExpressionsView::ContentCell::layoutSubviews(bool m_rightExpressionView.setFrame(KDRect(currentWidth, baseline-rightBaseline, rightExpressionSize), force); } -BurgerMenuView * ScrollableExactApproximateExpressionsView::ContentCell::burgerMenuView() { - static BurgerMenuView burger; - return &burger; -} - -ScrollableExactApproximateExpressionsView::ScrollableExactApproximateExpressionsView(Responder * parentResponder) : - ScrollableView(parentResponder, &m_contentCell, this), - m_contentCell() +AbstractScrollableExactApproximateExpressionsView::AbstractScrollableExactApproximateExpressionsView(Responder * parentResponder, View * contentCell) : + ScrollableView(parentResponder, contentCell, this) { setDecoratorType(ScrollView::Decorator::Type::Arrows); setMargins( @@ -168,69 +165,74 @@ ScrollableExactApproximateExpressionsView::ScrollableExactApproximateExpressions ); } -void ScrollableExactApproximateExpressionsView::setLayouts(Poincare::Layout rightLayout, Poincare::Layout leftLayout) { - m_contentCell.rightExpressionView()->setLayout(rightLayout); - m_contentCell.leftExpressionView()->setLayout(leftLayout); +void AbstractScrollableExactApproximateExpressionsView::setLayouts(Poincare::Layout rightLayout, Poincare::Layout leftLayout) { + contentCell()->rightExpressionView()->setLayout(rightLayout); + contentCell()->centeredExpressionView()->setLayout(leftLayout); } -void ScrollableExactApproximateExpressionsView::setEqualMessage(I18n::Message equalSignMessage) { - m_contentCell.approximateSign()->setMessage(equalSignMessage); +void AbstractScrollableExactApproximateExpressionsView::setEqualMessage(I18n::Message equalSignMessage) { + contentCell()->approximateSign()->setMessage(equalSignMessage); } -void ScrollableExactApproximateExpressionsView::reloadScroll() { - if (selectedSubviewPosition() == SubviewPosition::Left) { +void AbstractScrollableExactApproximateExpressionsView::reloadScroll() { + if (selectedSubviewPosition() == SubviewPosition::Center) { // Scroll to the left extremity ScrollableView::reloadScroll(); } else { // Scroll to the right extremity - scrollToContentPoint(KDPoint(m_contentCell.bounds().width(), 0), true); + scrollToContentPoint(KDPoint(contentCell()->bounds().width(), 0), true); } } -void ScrollableExactApproximateExpressionsView::didBecomeFirstResponder() { - if (m_contentCell.leftExpressionView()->layout().isUninitialized()) { +void AbstractScrollableExactApproximateExpressionsView::didBecomeFirstResponder() { + if (contentCell()->centeredExpressionView()->layout().isUninitialized()) { setSelectedSubviewPosition(SubviewPosition::Right); } - if (m_contentCell.rightExpressionView()->layout().isUninitialized()) { - setSelectedSubviewPosition(SubviewPosition::Left); + if (contentCell()->rightExpressionView()->layout().isUninitialized()) { + setSelectedSubviewPosition(SubviewPosition::Center); } } -bool ScrollableExactApproximateExpressionsView::handleEvent(Ion::Events::Event event) { - bool burgerIsVisible = false; - KDCoordinate burgerWidth = 0; - if (m_contentCell.displayBurger()) { - burgerWidth = ContentCell::burgerMenuView()->minimalSizeForOptimalDisplay().width(); - burgerIsVisible = burgerWidth - contentOffset().x() > 0; +bool AbstractScrollableExactApproximateExpressionsView::handleEvent(Ion::Events::Event event) { + bool leftIsVisible = false; + KDCoordinate leftWidth = 0; + if (contentCell()->displayLeft()) { + leftWidth = contentCell()->leftView()->minimalSizeForOptimalDisplay().width(); + leftIsVisible = leftWidth - contentOffset().x() > 0; } - KDCoordinate rightExpressionWidth = m_contentCell.rightExpressionView()->minimalSizeForOptimalDisplay().width(); + KDCoordinate rightExpressionWidth = contentCell()->rightExpressionView()->minimalSizeForOptimalDisplay().width(); bool rightExpressionIsVisible = minimalSizeForOptimalDisplay().width() - rightExpressionWidth - contentOffset().x() < bounds().width(); - bool leftExpressionIsVisibleOnTheLeft = false; - bool leftExpressionIsVisibleOnTheRight = false; - if (m_contentCell.displayLeftExpression()) { - KDCoordinate leftExpressionWidth = m_contentCell.leftExpressionView()->minimalSizeForOptimalDisplay().width(); - KDCoordinate signWidth = m_contentCell.approximateSign()->minimalSizeForOptimalDisplay().width(); - leftExpressionIsVisibleOnTheLeft = burgerWidth + Metric::CommonLargeMargin + leftExpressionWidth - contentOffset().x() > 0; - leftExpressionIsVisibleOnTheRight = minimalSizeForOptimalDisplay().width() - rightExpressionWidth - signWidth - leftExpressionWidth - 2*Metric::CommonLargeMargin - contentOffset().x() < bounds().width(); + bool centeredExpressionIsVisibleOnTheLeft = false; + bool centeredExpressionIsVisibleOnTheRight = false; + if (contentCell()->displayCenter()) { + KDCoordinate centerExpressionWidth = contentCell()->centeredExpressionView()->minimalSizeForOptimalDisplay().width(); + KDCoordinate signWidth = contentCell()->approximateSign()->minimalSizeForOptimalDisplay().width(); + centeredExpressionIsVisibleOnTheLeft = leftWidth + Metric::CommonLargeMargin + centerExpressionWidth - contentOffset().x() > 0; + centeredExpressionIsVisibleOnTheRight = minimalSizeForOptimalDisplay().width() - rightExpressionWidth - signWidth - centerExpressionWidth - 2*Metric::CommonLargeMargin - contentOffset().x() < bounds().width(); } // Select left - if ((event == Ion::Events::Left && selectedSubviewPosition() == SubviewPosition::Right && leftExpressionIsVisibleOnTheLeft) || - (event == Ion::Events::Right && selectedSubviewPosition() == SubviewPosition::Burger && leftExpressionIsVisibleOnTheRight)) { - setSelectedSubviewPosition(SubviewPosition::Left); + if ((event == Ion::Events::Left && selectedSubviewPosition() == SubviewPosition::Right && centeredExpressionIsVisibleOnTheLeft) || + (event == Ion::Events::Right && selectedSubviewPosition() == SubviewPosition::Left && centeredExpressionIsVisibleOnTheRight)) { + setSelectedSubviewPosition(SubviewPosition::Center); return true; } // Select burger - if ((event == Ion::Events::Left && selectedSubviewPosition() == SubviewPosition::Right && burgerIsVisible) || - (event == Ion::Events::Left && selectedSubviewPosition() == SubviewPosition::Left && burgerIsVisible)) { - setSelectedSubviewPosition(SubviewPosition::Burger); + if ((event == Ion::Events::Left && selectedSubviewPosition() == SubviewPosition::Right && leftIsVisible) || + (event == Ion::Events::Left && selectedSubviewPosition() == SubviewPosition::Center && leftIsVisible)) { + setSelectedSubviewPosition(SubviewPosition::Left); return true; } - if ((event == Ion::Events::Right && selectedSubviewPosition() == SubviewPosition::Left && rightExpressionIsVisible) || - (event == Ion::Events::Right && selectedSubviewPosition() == SubviewPosition::Burger && rightExpressionIsVisible)) { + if ((event == Ion::Events::Right && selectedSubviewPosition() == SubviewPosition::Center && rightExpressionIsVisible) || + (event == Ion::Events::Right && selectedSubviewPosition() == SubviewPosition::Left && rightExpressionIsVisible)) { setSelectedSubviewPosition(SubviewPosition::Right); return true; } return ScrollableView::handleEvent(event); } +BurgerMenuView * ScrollableExactApproximateExpressionsView::ContentCell::burgerMenuView() { + static BurgerMenuView burger; + return &burger; +} + } diff --git a/apps/shared/scrollable_exact_approximate_expressions_view.h b/apps/shared/scrollable_exact_approximate_expressions_view.h index aaefe335c..3eb6dbd79 100644 --- a/apps/shared/scrollable_exact_approximate_expressions_view.h +++ b/apps/shared/scrollable_exact_approximate_expressions_view.h @@ -5,34 +5,34 @@ namespace Shared { -class ScrollableExactApproximateExpressionsView : public ScrollableView, public ScrollViewDataSource { +class AbstractScrollableExactApproximateExpressionsView : public ScrollableView, public ScrollViewDataSource { public: enum class SubviewPosition : uint8_t { - Burger = 0, - Left = 1, + Left = 0, + Center = 1, Right = 2 }; - ScrollableExactApproximateExpressionsView(Responder * parentResponder); + AbstractScrollableExactApproximateExpressionsView(Responder * parentResponder, View * contentCell); ::EvenOddCell * evenOddCell() { - return &m_contentCell; + return contentCell(); } void setLayouts(Poincare::Layout rightlayout, Poincare::Layout leftLayout); void setEqualMessage(I18n::Message equalSignMessage); SubviewPosition selectedSubviewPosition() { - return m_contentCell.selectedSubviewPosition(); + return contentCell()->selectedSubviewPosition(); } void setSelectedSubviewPosition(SubviewPosition subviewPosition) { - m_contentCell.setSelectedSubviewPosition(subviewPosition); + contentCell()->setSelectedSubviewPosition(subviewPosition); } - void setDisplayLeftLayout(bool display) { m_contentCell.setDisplayLeftExpression(display); } - void setDisplayBurger(bool display) { m_contentCell.setDisplayBurger(display); } + void setDisplayCenter(bool display) { contentCell()->setDisplayCenter(display); } + void setDisplayLeft(bool display) { contentCell()->setDisplayLeft(display); } void reloadScroll(); void didBecomeFirstResponder() override; bool handleEvent(Ion::Events::Event event) override; Poincare::Layout layout() const { - return m_contentCell.layout(); + return constContentCell()->layout(); } -private: +protected: class ContentCell : public ::EvenOddCell { public: ContentCell(); @@ -44,8 +44,8 @@ private: ExpressionView * rightExpressionView() { return &m_rightExpressionView; } - ExpressionView * leftExpressionView() { - return &m_leftExpressionView; + ExpressionView * centeredExpressionView() { + return &m_centeredExpressionView; } MessageTextView * approximateSign() { return &m_approximateSign; @@ -54,27 +54,50 @@ private: return m_selectedSubviewPosition; } void setSelectedSubviewPosition(SubviewPosition subviewPosition); - bool displayLeftExpression() const { return m_displayLeftExpression; } - void setDisplayLeftExpression(bool display); - bool displayBurger() const { return m_displayBurger; } - void setDisplayBurger(bool display) { m_displayBurger = display; } + bool displayCenter() const { return m_displayCenter; } + void setDisplayCenter(bool display); + bool displayLeft() const { return m_displayLeft; } + void setDisplayLeft(bool display) { m_displayLeft = display; } void layoutSubviews(bool force = false) override; int numberOfSubviews() const override; Poincare::Layout layout() const override; + virtual View * leftView() const = 0; + private: + virtual void setLeftViewBackgroundColor(KDColor color) = 0; + virtual KDCoordinate leftBaseline() const = 0; + + View * subviewAtIndex(int index) override; + ExpressionView m_rightExpressionView; + MessageTextView m_approximateSign; + ExpressionView m_centeredExpressionView; + SubviewPosition m_selectedSubviewPosition; + bool m_displayCenter; + bool m_displayLeft; + }; + virtual ContentCell * contentCell() = 0; + virtual const ContentCell * constContentCell() const = 0; +}; + + +class ScrollableExactApproximateExpressionsView : public AbstractScrollableExactApproximateExpressionsView { +public: + ScrollableExactApproximateExpressionsView(Responder * parentResponder) : AbstractScrollableExactApproximateExpressionsView(parentResponder, &m_contentCell) {} + +private: + class ContentCell : public AbstractScrollableExactApproximateExpressionsView::ContentCell { + public: + View * leftView() const override { return ContentCell::burgerMenuView(); } + private: /* We keep only one instance of BurgerMenuView to avoid wasting space when * we know that only one ScrollableExactApproximateExpressionsView display * the burger view at a time. */ static BurgerMenuView * burgerMenuView(); - private: - View * subviewAtIndex(int index) override; - ExpressionView m_rightExpressionView; - MessageTextView m_approximateSign; - ExpressionView m_leftExpressionView; - SubviewPosition m_selectedSubviewPosition; - bool m_displayLeftExpression; - bool m_displayBurger; + void setLeftViewBackgroundColor(KDColor color) override { burgerMenuView()->setBackgroundColor(color); } + KDCoordinate leftBaseline() const override { return burgerMenuView()->minimalSizeForOptimalDisplay().height()/2; } }; + ContentCell * contentCell() override { return &m_contentCell; }; + const ContentCell * constContentCell() const override { return &m_contentCell; }; ContentCell m_contentCell; };