[apps/shared] ScrollableExactApproximateExpressionsView: split

ScrollableExactApproximateExpressionsView into
AbstractScrollableExactApproximateExpressionsView and
ScrollableExactApproximateExpressionsView to factorize code with future
ScrollableInputExactApproximateExpressionsView

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?

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. */

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);
 }
 

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;
+}
+
 }

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;
 };