[apps/escher] ScrollableEVWithCursor renamed ExpressionLayoutField

Change-Id: Id0e4610fb677d8ad36721eef1a85f1c424d1743e

apps/calculation/app.cpp

@@ -85,23 +85,23 @@ bool App::textInputIsCorrect(const char * text) {
   return true;
 }
 
-bool App::scrollableExpressionViewWithCursorDidReceiveEvent(::ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor, Ion::Events::Event event) {
-  if ((event == Ion::Events::Var ||  event == Ion::Events::XNT) && EditableExpressionViewDelegateApp::scrollableExpressionViewWithCursorDidReceiveEvent(scrollableExpressionViewWithCursor, event)) {
+bool App::expressionLayoutFieldDidReceiveEvent(::ExpressionLayoutField * expressionLayoutField, Ion::Events::Event event) {
+  if ((event == Ion::Events::Var ||  event == Ion::Events::XNT) && EditableExpressionViewDelegateApp::expressionLayoutFieldDidReceiveEvent(expressionLayoutField, event)) {
     return true;
   }
   /* Here, we check that the expression entered by the user can be printed with
    * less than k_printedExpressionLength characters. Otherwise, we prevent the
    * user from adding this expression to the calculation store. */
-  if (!(scrollableExpressionViewWithCursor->isEditing() && scrollableExpressionViewWithCursor->scrollableExpressionViewWithCursorShouldFinishEditing(event))) {
+  if (!(expressionLayoutField->isEditing() && expressionLayoutField->expressionLayoutFieldShouldFinishEditing(event))) {
     return false;
   }
   int bufferLength = TextField::maxBufferSize();
   char bufferForParsing[bufferLength];
-  Poincare::ExpressionLayout * expressionLayout = scrollableExpressionViewWithCursor->expressionViewWithCursor()->expressionView()->expressionLayout();
+  Poincare::ExpressionLayout * expressionLayout = expressionLayoutField->expressionViewWithCursor()->expressionView()->expressionLayout();
   expressionLayout->writeTextInBuffer(bufferForParsing, bufferLength);
   Expression * exp = Expression::parse(bufferForParsing);
   if (exp == nullptr) {
-    scrollableExpressionViewWithCursor->app()->displayWarning(I18n::Message::SyntaxError);
+    expressionLayoutField->app()->displayWarning(I18n::Message::SyntaxError);
     return true;
   }
   char buffer[Calculation::k_printedExpressionSize];

apps/calculation/app.h

@@ -29,7 +29,7 @@ public:
   };
   bool textFieldDidReceiveEvent(::TextField * textField, Ion::Events::Event event) override;
   bool textInputIsCorrect(const char * text);
-  bool scrollableExpressionViewWithCursorDidReceiveEvent(::ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor, Ion::Events::Event event) override;
+  bool expressionLayoutFieldDidReceiveEvent(::ExpressionLayoutField * expressionLayoutField, Ion::Events::Event event) override;
   const char * XNT() override;
 private:
   App(Container * container, Snapshot * snapshot);

apps/calculation/edit_expression_controller.cpp

@@ -9,10 +9,10 @@ using namespace Shared;
 
 namespace Calculation {
 
-EditExpressionController::ContentView::ContentView(Responder * parentResponder, TableView * subview, TextFieldDelegate * textFieldDelegate, ScrollableExpressionViewWithCursorDelegate * scrollableExpressionViewWithCursorDelegate) :
+EditExpressionController::ContentView::ContentView(Responder * parentResponder, TableView * subview, TextFieldDelegate * textFieldDelegate, ExpressionLayoutFieldDelegate * expressionLayoutFieldDelegate) :
   View(),
   m_mainView(subview),
-  m_editableExpressionView(parentResponder, textFieldDelegate, scrollableExpressionViewWithCursorDelegate)
+  m_editableExpressionView(parentResponder, textFieldDelegate, expressionLayoutFieldDelegate)
 {
 }
 
@@ -91,26 +91,26 @@ bool EditExpressionController::textFieldDidAbortEditing(::TextField * textField)
   return inputViewDidAbortEditing(textField->text());
 }
 
-bool EditExpressionController::scrollableExpressionViewWithCursorDidReceiveEvent(::ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor, Ion::Events::Event event) {
-  assert(scrollableExpressionViewWithCursor == ((ContentView *)view())->editableExpressionView()->scrollableExpressionViewWithCursor());
-  if (scrollableExpressionViewWithCursor->isEditing() && scrollableExpressionViewWithCursor->scrollableExpressionViewWithCursorShouldFinishEditing(event) && !expressionLayout()->hasText() && m_calculationStore->numberOfCalculations() > 0) {
+bool EditExpressionController::expressionLayoutFieldDidReceiveEvent(::ExpressionLayoutField * expressionLayoutField, Ion::Events::Event event) {
+  assert(expressionLayoutField == ((ContentView *)view())->editableExpressionView()->expressionLayoutField());
+  if (expressionLayoutField->isEditing() && expressionLayoutField->expressionLayoutFieldShouldFinishEditing(event) && !expressionLayout()->hasText() && m_calculationStore->numberOfCalculations() > 0) {
     return inputViewDidReceiveEvent(event);
   }
-  return editableExpressionViewDelegateApp()->scrollableExpressionViewWithCursorDidReceiveEvent(scrollableExpressionViewWithCursor, event);
+  return editableExpressionViewDelegateApp()->expressionLayoutFieldDidReceiveEvent(expressionLayoutField, event);
 }
 
-bool EditExpressionController::scrollableExpressionViewWithCursorDidFinishEditing(::ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor, const char * text, Ion::Events::Event event) {
-  assert(scrollableExpressionViewWithCursor == ((ContentView *)view())->editableExpressionView()->scrollableExpressionViewWithCursor());
+bool EditExpressionController::expressionLayoutFieldDidFinishEditing(::ExpressionLayoutField * expressionLayoutField, const char * text, Ion::Events::Event event) {
+  assert(expressionLayoutField == ((ContentView *)view())->editableExpressionView()->expressionLayoutField());
   return inputViewDidFinishEditing(text, event);
 }
 
-bool EditExpressionController::scrollableExpressionViewWithCursorDidAbortEditing(::ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor) {
-  assert(scrollableExpressionViewWithCursor == ((ContentView *)view())->editableExpressionView()->scrollableExpressionViewWithCursor());
+bool EditExpressionController::expressionLayoutFieldDidAbortEditing(::ExpressionLayoutField * expressionLayoutField) {
+  assert(expressionLayoutField == ((ContentView *)view())->editableExpressionView()->expressionLayoutField());
   return inputViewDidAbortEditing(nullptr);
 }
 
-void EditExpressionController::scrollableExpressionViewWithCursorDidChangeSize(::ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor) {
-  assert(scrollableExpressionViewWithCursor == ((ContentView *)view())->editableExpressionView()->scrollableExpressionViewWithCursor());
+void EditExpressionController::expressionLayoutFieldDidChangeSize(::ExpressionLayoutField * expressionLayoutField) {
+  assert(expressionLayoutField == ((ContentView *)view())->editableExpressionView()->expressionLayoutField());
   reloadView();
 }
 
@@ -177,7 +177,7 @@ void EditExpressionController::viewDidDisappear() {
 }
 
 Poincare::ExpressionLayout * EditExpressionController::expressionLayout() {
-  return ((ContentView *)view())->editableExpressionView()->scrollableExpressionViewWithCursor()->expressionViewWithCursor()->expressionView()->expressionLayout();
+  return ((ContentView *)view())->editableExpressionView()->expressionLayoutField()->expressionViewWithCursor()->expressionView()->expressionLayout();
 }
 
 }

apps/calculation/edit_expression_controller.h

@@ -4,7 +4,7 @@
 #include <escher.h>
 #include "editable_expression_view.h"
 #include "../shared/text_field_delegate.h"
-#include "../shared/scrollable_expression_view_with_cursor_delegate.h"
+#include "../shared/expression_layout_field_delegate.h"
 #include "history_controller.h"
 #include "calculation_store.h"
 
@@ -12,7 +12,7 @@ namespace Calculation {
 class HistoryController;
 
 /* TODO: implement a split view */
-class EditExpressionController : public DynamicViewController, public Shared::TextFieldDelegate, public Shared::ScrollableExpressionViewWithCursorDelegate {
+class EditExpressionController : public DynamicViewController, public Shared::TextFieldDelegate, public Shared::ExpressionLayoutFieldDelegate {
 public:
   EditExpressionController(Responder * parentResponder, HistoryController * historyController, CalculationStore * calculationStore);
   void didBecomeFirstResponder() override;
@@ -26,16 +26,16 @@ public:
   bool textFieldDidFinishEditing(::TextField * textField, const char * text, Ion::Events::Event event) override;
   bool textFieldDidAbortEditing(::TextField * textField) override;
 
-  /* ScrollableExpressionViewWithCursorDelegate */
-  bool scrollableExpressionViewWithCursorDidReceiveEvent(::ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor, Ion::Events::Event event) override;
-  bool scrollableExpressionViewWithCursorDidFinishEditing(::ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor, const char * text, Ion::Events::Event event) override;
-  bool scrollableExpressionViewWithCursorDidAbortEditing(::ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor) override;
-  void scrollableExpressionViewWithCursorDidChangeSize(::ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor) override;
+  /* ExpressionLayoutFieldDelegate */
+  bool expressionLayoutFieldDidReceiveEvent(::ExpressionLayoutField * expressionLayoutField, Ion::Events::Event event) override;
+  bool expressionLayoutFieldDidFinishEditing(::ExpressionLayoutField * expressionLayoutField, const char * text, Ion::Events::Event event) override;
+  bool expressionLayoutFieldDidAbortEditing(::ExpressionLayoutField * expressionLayoutField) override;
+  void expressionLayoutFieldDidChangeSize(::ExpressionLayoutField * expressionLayoutField) override;
 
 private:
   class ContentView : public View {
   public:
-    ContentView(Responder * parentResponder, TableView * subview, TextFieldDelegate * textFieldDelegate, ScrollableExpressionViewWithCursorDelegate * scrollableExpressionViewWithCursorDelegate);
+    ContentView(Responder * parentResponder, TableView * subview, TextFieldDelegate * textFieldDelegate, ExpressionLayoutFieldDelegate * expressionLayoutFieldDelegate);
     void reload();
     TableView * mainView() { return m_mainView; }
     EditableExpressionView * editableExpressionView() { return &m_editableExpressionView; }

apps/calculation/editable_expression_view.cpp

@@ -2,8 +2,8 @@
 
 namespace Calculation {
 
-EditableExpressionView::EditableExpressionView(Responder * parentResponder, TextFieldDelegate * textFieldDelegate, ScrollableExpressionViewWithCursorDelegate * scrollableExpressionViewWithCursorDelegate) :
-  ::EditableExpressionView(parentResponder, textFieldDelegate, scrollableExpressionViewWithCursorDelegate)
+EditableExpressionView::EditableExpressionView(Responder * parentResponder, TextFieldDelegate * textFieldDelegate, ExpressionLayoutFieldDelegate * expressionLayoutFieldDelegate) :
+  ::EditableExpressionView(parentResponder, textFieldDelegate, expressionLayoutFieldDelegate)
 {
   setEditing(true);
 }

apps/calculation/editable_expression_view.h

@@ -7,7 +7,7 @@ namespace Calculation {
 
 class EditableExpressionView : public ::EditableExpressionView {
 public:
-  EditableExpressionView(Responder * parentResponder, TextFieldDelegate * textFieldDelegate, ScrollableExpressionViewWithCursorDelegate * scrollableExpressionViewWithCursorDelegate);
+  EditableExpressionView(Responder * parentResponder, TextFieldDelegate * textFieldDelegate, ExpressionLayoutFieldDelegate * expressionLayoutFieldDelegate);
 protected:
   bool handleEvent(Ion::Events::Event event) override;
 };

apps/math_toolbox.cpp

@@ -118,8 +118,8 @@ void MathToolbox::setSenderAndAction(Responder * sender, Action action) {
   m_action = action;
 }
 
-void MathToolbox::actionForScrollableExpressionViewWithCursor(void * sender, const char * text, bool removeArguments) {
-  ScrollableExpressionViewWithCursor * expressionLayoutEditorSender = static_cast<ScrollableExpressionViewWithCursor *>(sender);
+void MathToolbox::actionForExpressionLayoutField(void * sender, const char * text, bool removeArguments) {
+  ExpressionLayoutField * expressionLayoutEditorSender = static_cast<ExpressionLayoutField *>(sender);
   Expression * resultExpression = nullptr;
   if (removeArguments) {
     // Replace the arguments with Empty chars.

apps/math_toolbox.h

@@ -10,7 +10,7 @@ public:
   typedef void (*Action)(void * sender, const char * text, bool removeArguments);
   MathToolbox();
   void setSenderAndAction(Responder * sender, Action action);
-  static void actionForScrollableExpressionViewWithCursor(void * sender, const char * text, bool removeArguments = true);
+  static void actionForExpressionLayoutField(void * sender, const char * text, bool removeArguments = true);
   static void actionForTextInput(void * sender, const char * text, bool removeArguments = true);
 protected:
   bool selectLeaf(ToolboxMessageTree * selectedMessageTree) override;

apps/sequence/list/list_controller.cpp

@@ -29,9 +29,9 @@ Toolbox * ListController::toolboxForTextInput(TextInput * textInput) {
   return &m_sequenceToolbox;
 }
 
-Toolbox * ListController::toolboxForScrollableExpressionViewWithCursor(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor) {
+Toolbox * ListController::toolboxForExpressionLayoutField(ExpressionLayoutField * expressionLayoutField) {
   setToolboxExtraCells();
-  m_sequenceToolbox.setSenderAndAction(scrollableExpressionViewWithCursor, MathToolbox::actionForScrollableExpressionViewWithCursor);
+  m_sequenceToolbox.setSenderAndAction(expressionLayoutField, MathToolbox::actionForExpressionLayoutField);
   return &m_sequenceToolbox;
 }
 

apps/sequence/list/list_controller.h

@@ -7,7 +7,7 @@
 #include "../../shared/function_expression_cell.h"
 #include "../../shared/list_controller.h"
 #include "../../shared/new_function_cell.h"
-#include "../../shared/scrollable_expression_view_with_cursor_delegate.h"
+#include "../../shared/expression_layout_field_delegate.h"
 #include "../../shared/text_field_delegate.h"
 #include "list_parameter_controller.h"
 #include "sequence_toolbox.h"
@@ -15,7 +15,7 @@
 
 namespace Sequence {
 
-class ListController : public Shared::ListController, public Shared::TextFieldDelegate, public Shared::ScrollableExpressionViewWithCursorDelegate {
+class ListController : public Shared::ListController, public Shared::TextFieldDelegate, public Shared::ExpressionLayoutFieldDelegate {
 public:
   ListController(Responder * parentResponder, SequenceStore * sequenceStore, ButtonRowController * header, ButtonRowController * footer);
   const char * title() override;
@@ -23,7 +23,7 @@ public:
   virtual KDCoordinate rowHeight(int j) override;
   void willDisplayCellAtLocation(HighlightCell * cell, int i, int j) override;
   Toolbox * toolboxForTextInput(TextInput * textInput) override;
-  Toolbox * toolboxForScrollableExpressionViewWithCursor(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor) override;
+  Toolbox * toolboxForExpressionLayoutField(ExpressionLayoutField * expressionLayoutField) override;
   void selectPreviousNewSequenceCell();
 private:
   Shared::TextFieldDelegateApp * textFieldDelegateApp() override;

apps/shared/Makefile

@@ -38,7 +38,7 @@ app_objs += $(addprefix apps/shared/,\
   regular_table_view_data_source.o\
   round_cursor_view.o\
   simple_interactive_curve_view_controller.o\
-  scrollable_expression_view_with_cursor_delegate.o\
+  expression_layout_field_delegate.o\
   store_controller.o\
   store_parameter_controller.o\
   sum_graph_controller.o\

apps/shared/editable_expression_view_delegate_app.cpp

@@ -8,48 +8,48 @@ namespace Shared {
 
 EditableExpressionViewDelegateApp::EditableExpressionViewDelegateApp(Container * container, Snapshot * snapshot, ViewController * rootViewController) :
   TextFieldDelegateApp(container, snapshot, rootViewController),
-  ScrollableExpressionViewWithCursorDelegate()
+  ExpressionLayoutFieldDelegate()
 {
 }
 
-bool EditableExpressionViewDelegateApp::scrollableExpressionViewWithCursorShouldFinishEditing(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor, Ion::Events::Event event) {
+bool EditableExpressionViewDelegateApp::expressionLayoutFieldShouldFinishEditing(ExpressionLayoutField * expressionLayoutField, Ion::Events::Event event) {
   return event == Ion::Events::OK || event == Ion::Events::EXE;
 }
 
-bool EditableExpressionViewDelegateApp::scrollableExpressionViewWithCursorDidReceiveEvent(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor, Ion::Events::Event event) {
-  if (scrollableExpressionViewWithCursor->isEditing() && scrollableExpressionViewWithCursor->scrollableExpressionViewWithCursorShouldFinishEditing(event)) {
-    if (!scrollableExpressionViewWithCursor->expressionViewWithCursor()->expressionView()->expressionLayout()->hasText()) {
-      scrollableExpressionViewWithCursor->app()->displayWarning(I18n::Message::SyntaxError);
+bool EditableExpressionViewDelegateApp::expressionLayoutFieldDidReceiveEvent(ExpressionLayoutField * expressionLayoutField, Ion::Events::Event event) {
+  if (expressionLayoutField->isEditing() && expressionLayoutField->expressionLayoutFieldShouldFinishEditing(event)) {
+    if (!expressionLayoutField->expressionViewWithCursor()->expressionView()->expressionLayout()->hasText()) {
+      expressionLayoutField->app()->displayWarning(I18n::Message::SyntaxError);
       return true;
     }
     int bufferSize = 256;
     char buffer[bufferSize];
-    scrollableExpressionViewWithCursor->expressionViewWithCursor()->expressionView()->expressionLayout()->writeTextInBuffer(buffer, bufferSize);
+    expressionLayoutField->expressionViewWithCursor()->expressionView()->expressionLayout()->writeTextInBuffer(buffer, bufferSize);
     Expression * exp = Expression::parse(buffer);
     if (exp != nullptr) {
       delete exp;
     }
     if (exp == nullptr) {
-      scrollableExpressionViewWithCursor->app()->displayWarning(I18n::Message::SyntaxError);
+      expressionLayoutField->app()->displayWarning(I18n::Message::SyntaxError);
       return true;
     }
   }
   if (event == Ion::Events::Var) {
-    if (!scrollableExpressionViewWithCursor->isEditing()) {
-      scrollableExpressionViewWithCursor->setEditing(true);
+    if (!expressionLayoutField->isEditing()) {
+      expressionLayoutField->setEditing(true);
     }
-    AppsContainer * appsContainer = (AppsContainer *)scrollableExpressionViewWithCursor->app()->container();
+    AppsContainer * appsContainer = (AppsContainer *)expressionLayoutField->app()->container();
     VariableBoxController * variableBoxController = appsContainer->variableBoxController();
-    variableBoxController->setScrollableExpressionViewWithCursorSender(scrollableExpressionViewWithCursor);
-    scrollableExpressionViewWithCursor->app()->displayModalViewController(variableBoxController, 0.f, 0.f, Metric::PopUpTopMargin, Metric::PopUpLeftMargin, 0, Metric::PopUpRightMargin);
+    variableBoxController->setExpressionLayoutFieldSender(expressionLayoutField);
+    expressionLayoutField->app()->displayModalViewController(variableBoxController, 0.f, 0.f, Metric::PopUpTopMargin, Metric::PopUpLeftMargin, 0, Metric::PopUpRightMargin);
     return true;
   }
   return false;
 }
 
-Toolbox * EditableExpressionViewDelegateApp::toolboxForScrollableExpressionViewWithCursor(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor) {
+Toolbox * EditableExpressionViewDelegateApp::toolboxForExpressionLayoutField(ExpressionLayoutField * expressionLayoutField) {
   Toolbox * toolbox = container()->mathToolbox();
-  static_cast<MathToolbox *>(toolbox)->setSenderAndAction(scrollableExpressionViewWithCursor, MathToolbox::actionForScrollableExpressionViewWithCursor);
+  static_cast<MathToolbox *>(toolbox)->setSenderAndAction(expressionLayoutField, MathToolbox::actionForExpressionLayoutField);
   return toolbox;
 }
 

apps/shared/editable_expression_view_delegate_app.h

@@ -2,16 +2,16 @@
 #define SHARED_EDITABLE_EXPRESSION_VIEW_DELEGATE_APP_H
 
 #include "text_field_delegate_app.h"
-#include <escher/scrollable_expression_view_with_cursor_delegate.h>
+#include <escher/expression_layout_field_delegate.h>
 
 namespace Shared {
 
-class EditableExpressionViewDelegateApp : public TextFieldDelegateApp, public ScrollableExpressionViewWithCursorDelegate {
+class EditableExpressionViewDelegateApp : public TextFieldDelegateApp, public ExpressionLayoutFieldDelegate {
 public:
   virtual ~EditableExpressionViewDelegateApp() = default;
-  bool scrollableExpressionViewWithCursorShouldFinishEditing(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor, Ion::Events::Event event) override;
-  virtual bool scrollableExpressionViewWithCursorDidReceiveEvent(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor, Ion::Events::Event event) override;
-  Toolbox * toolboxForScrollableExpressionViewWithCursor(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor) override;
+  bool expressionLayoutFieldShouldFinishEditing(ExpressionLayoutField * expressionLayoutField, Ion::Events::Event event) override;
+  virtual bool expressionLayoutFieldDidReceiveEvent(ExpressionLayoutField * expressionLayoutField, Ion::Events::Event event) override;
+  Toolbox * toolboxForExpressionLayoutField(ExpressionLayoutField * expressionLayoutField) override;
 protected:
   EditableExpressionViewDelegateApp(Container * container, Snapshot * snapshot, ViewController * rootViewController);
 };

apps/shared/expression_layout_field_delegate.cpp

@@ -0,0 +1,31 @@
+#include "expression_layout_field_delegate.h"
+
+using namespace Poincare;
+
+namespace Shared {
+
+bool ExpressionLayoutFieldDelegate::expressionLayoutFieldShouldFinishEditing(ExpressionLayoutField * expressionLayoutField, Ion::Events::Event event) {
+  return editableExpressionViewDelegateApp()->expressionLayoutFieldShouldFinishEditing(expressionLayoutField, event);
+}
+
+bool ExpressionLayoutFieldDelegate::expressionLayoutFieldDidReceiveEvent(ExpressionLayoutField * expressionLayoutField, Ion::Events::Event event) {
+  return editableExpressionViewDelegateApp()->expressionLayoutFieldDidReceiveEvent(expressionLayoutField, event);
+}
+
+bool ExpressionLayoutFieldDelegate::expressionLayoutFieldDidFinishEditing(ExpressionLayoutField * expressionLayoutField, const char * text, Ion::Events::Event event) {
+  return editableExpressionViewDelegateApp()->expressionLayoutFieldDidFinishEditing(expressionLayoutField, text, event);
+}
+
+bool ExpressionLayoutFieldDelegate::expressionLayoutFieldDidAbortEditing(ExpressionLayoutField * expressionLayoutField) {
+  return editableExpressionViewDelegateApp()->expressionLayoutFieldDidAbortEditing(expressionLayoutField);
+}
+
+void ExpressionLayoutFieldDelegate::expressionLayoutFieldDidChangeSize(ExpressionLayoutField * expressionLayoutField) {
+  return editableExpressionViewDelegateApp()->expressionLayoutFieldDidChangeSize(expressionLayoutField);
+}
+
+Toolbox * ExpressionLayoutFieldDelegate::toolboxForExpressionLayoutField(ExpressionLayoutField * expressionLayoutField) {
+  return editableExpressionViewDelegateApp()->toolboxForExpressionLayoutField(expressionLayoutField);
+}
+
+}

apps/shared/expression_layout_field_delegate.h

@@ -0,0 +1,23 @@
+#ifndef SHARED_EXPRESSION_LAYOUT_FIELD_DELEGATE_H
+#define SHARED_EXPRESSION_LAYOUT_FIELD_DELEGATE_H
+
+#include <escher/expression_layout_field_delegate.h>
+#include "editable_expression_view_delegate_app.h"
+
+namespace Shared {
+
+class ExpressionLayoutFieldDelegate : public ::ExpressionLayoutFieldDelegate {
+public:
+  bool expressionLayoutFieldShouldFinishEditing(ExpressionLayoutField * expressionLayoutField, Ion::Events::Event event) override;
+  bool expressionLayoutFieldDidReceiveEvent(ExpressionLayoutField * expressionLayoutField, Ion::Events::Event event) override;
+  bool expressionLayoutFieldDidFinishEditing(ExpressionLayoutField * expressionLayoutField, const char * text, Ion::Events::Event event) override;
+  bool expressionLayoutFieldDidAbortEditing(ExpressionLayoutField * expressionLayoutField) override;
+  void expressionLayoutFieldDidChangeSize(ExpressionLayoutField * expressionLayoutField) override;
+  Toolbox * toolboxForExpressionLayoutField(ExpressionLayoutField * expressionLayoutField) override;
+private:
+  virtual EditableExpressionViewDelegateApp * editableExpressionViewDelegateApp() = 0;
+};
+
+}
+
+#endif

apps/shared/scrollable_expression_view_with_cursor_delegate.cpp

@@ -1,31 +0,0 @@
-#include "scrollable_expression_view_with_cursor_delegate.h"
-
-using namespace Poincare;
-
-namespace Shared {
-
-bool ScrollableExpressionViewWithCursorDelegate::scrollableExpressionViewWithCursorShouldFinishEditing(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor, Ion::Events::Event event) {
-  return editableExpressionViewDelegateApp()->scrollableExpressionViewWithCursorShouldFinishEditing(scrollableExpressionViewWithCursor, event);
-}
-
-bool ScrollableExpressionViewWithCursorDelegate::scrollableExpressionViewWithCursorDidReceiveEvent(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor, Ion::Events::Event event) {
-  return editableExpressionViewDelegateApp()->scrollableExpressionViewWithCursorDidReceiveEvent(scrollableExpressionViewWithCursor, event);
-}
-
-bool ScrollableExpressionViewWithCursorDelegate::scrollableExpressionViewWithCursorDidFinishEditing(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor, const char * text, Ion::Events::Event event) {
-  return editableExpressionViewDelegateApp()->scrollableExpressionViewWithCursorDidFinishEditing(scrollableExpressionViewWithCursor, text, event);
-}
-
-bool ScrollableExpressionViewWithCursorDelegate::scrollableExpressionViewWithCursorDidAbortEditing(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor) {
-  return editableExpressionViewDelegateApp()->scrollableExpressionViewWithCursorDidAbortEditing(scrollableExpressionViewWithCursor);
-}
-
-void ScrollableExpressionViewWithCursorDelegate::scrollableExpressionViewWithCursorDidChangeSize(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor) {
-  return editableExpressionViewDelegateApp()->scrollableExpressionViewWithCursorDidChangeSize(scrollableExpressionViewWithCursor);
-}
-
-Toolbox * ScrollableExpressionViewWithCursorDelegate::toolboxForScrollableExpressionViewWithCursor(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor) {
-  return editableExpressionViewDelegateApp()->toolboxForScrollableExpressionViewWithCursor(scrollableExpressionViewWithCursor);
-}
-
-}

apps/shared/scrollable_expression_view_with_cursor_delegate.h

@@ -1,23 +0,0 @@
-#ifndef SHARED_SCROLLABLE_EXPRESSION_VIEW_WITH_CURSOR_DELEGATE_H
-#define SHARED_SCROLLABLE_EXPRESSION_VIEW_WITH_CURSOR_DELEGATE_H
-
-#include <escher/scrollable_expression_view_with_cursor_delegate.h>
-#include "editable_expression_view_delegate_app.h"
-
-namespace Shared {
-
-class ScrollableExpressionViewWithCursorDelegate : public ::ScrollableExpressionViewWithCursorDelegate {
-public:
-  bool scrollableExpressionViewWithCursorShouldFinishEditing(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor, Ion::Events::Event event) override;
-  bool scrollableExpressionViewWithCursorDidReceiveEvent(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor, Ion::Events::Event event) override;
-  bool scrollableExpressionViewWithCursorDidFinishEditing(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor, const char * text, Ion::Events::Event event) override;
-  bool scrollableExpressionViewWithCursorDidAbortEditing(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor) override;
-  void scrollableExpressionViewWithCursorDidChangeSize(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor) override;
-  Toolbox * toolboxForScrollableExpressionViewWithCursor(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor) override;
-private:
-  virtual EditableExpressionViewDelegateApp * editableExpressionViewDelegateApp() = 0;
-};
-
-}
-
-#endif

apps/variable_box_controller.cpp

@@ -200,9 +200,9 @@ void VariableBoxController::ContentViewController::setTextFieldSender(TextField
   m_insertTextAction = &insertTextInTextInput;
 }
 
-void VariableBoxController::ContentViewController::setScrollableExpressionViewWithCursorSender(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor) {
-  m_sender = scrollableExpressionViewWithCursor;
-  m_insertTextAction = &insertTextInScrollableExpressionViewWithCursor;
+void VariableBoxController::ContentViewController::setExpressionLayoutFieldSender(ExpressionLayoutField * expressionLayoutField) {
+  m_sender = expressionLayoutField;
+  m_insertTextAction = &insertTextInExpressionLayoutField;
 }
 
 void VariableBoxController::ContentViewController::reloadData() {
@@ -295,12 +295,12 @@ void VariableBoxController::ContentViewController::insertTextInTextInput(void *
   textInput->handleEventWithText(textToInsert);
 }
 
-void VariableBoxController::ContentViewController::insertTextInScrollableExpressionViewWithCursor(void * sender, const char * textToInsert) {
-  ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor = static_cast<ScrollableExpressionViewWithCursor *>(sender);
-  if (!scrollableExpressionViewWithCursor->isEditing()) {
-    scrollableExpressionViewWithCursor->setEditing(true);
+void VariableBoxController::ContentViewController::insertTextInExpressionLayoutField(void * sender, const char * textToInsert) {
+  ExpressionLayoutField * expressionLayoutField = static_cast<ExpressionLayoutField *>(sender);
+  if (!expressionLayoutField->isEditing()) {
+    expressionLayoutField->setEditing(true);
   }
-  scrollableExpressionViewWithCursor->insertLayoutFromTextAtCursor(textToInsert);
+  expressionLayoutField->insertLayoutFromTextAtCursor(textToInsert);
 }
 
 VariableBoxController::VariableBoxController(GlobalContext * context) :
@@ -317,8 +317,8 @@ void VariableBoxController::setTextFieldSender(TextField * textField) {
   m_contentViewController.setTextFieldSender(textField);
 }
 
-void VariableBoxController::setScrollableExpressionViewWithCursorSender(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor) {
-  m_contentViewController.setScrollableExpressionViewWithCursorSender(scrollableExpressionViewWithCursor);
+void VariableBoxController::setExpressionLayoutFieldSender(ExpressionLayoutField * expressionLayoutField) {
+  m_contentViewController.setExpressionLayoutFieldSender(expressionLayoutField);
 }
 
 void VariableBoxController::viewWillAppear() {

apps/variable_box_controller.h

@@ -14,7 +14,7 @@ public:
   VariableBoxController(Poincare::GlobalContext * context);
   void didBecomeFirstResponder() override;
   void setTextFieldSender(TextField * textField);
-  void setScrollableExpressionViewWithCursorSender(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor);
+  void setExpressionLayoutFieldSender(ExpressionLayoutField * expressionLayoutField);
   void viewWillAppear() override;
   void viewDidDisappear() override;
 private:
@@ -34,7 +34,7 @@ private:
     int indexFromCumulatedHeight(KDCoordinate offsetY) override;
     int typeAtLocation(int i, int j) override;
     void setTextFieldSender(TextField * textField);
-    void setScrollableExpressionViewWithCursorSender(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor);
+    void setExpressionLayoutFieldSender(ExpressionLayoutField * expressionLayoutField);
     void reloadData();
     void resetPage();
     void viewDidDisappear() override;
@@ -60,7 +60,7 @@ private:
     const Poincare::Expression * expressionForIndex(int index);
     Poincare::ExpressionLayout * expressionLayoutForIndex(int index);
     static void insertTextInTextInput(void * sender, const char * textToInsert);
-    static void insertTextInScrollableExpressionViewWithCursor(void * sender, const char * textToInsert);
+    static void insertTextInExpressionLayoutField(void * sender, const char * textToInsert);
     Poincare::GlobalContext * m_context;
     Responder * m_sender;
     Action m_insertTextAction;

escher/Makefile

@@ -50,7 +50,7 @@ objs += $(addprefix escher/src/,\
   scroll_view_data_source.o\
   scroll_view_indicator.o\
   scrollable_view.o\
-  scrollable_expression_view_with_cursor.o\
+  expression_layout_field.o\
   selectable_table_view.o\
   selectable_table_view_data_source.o\
   selectable_table_view_delegate.o\

escher/include/escher.h

@@ -53,8 +53,8 @@
 #include <escher/scroll_view_data_source.h>
 #include <escher/scroll_view_indicator.h>
 #include <escher/scrollable_view.h>
-#include <escher/scrollable_expression_view_with_cursor.h>
-#include <escher/scrollable_expression_view_with_cursor_delegate.h>
+#include <escher/expression_layout_field.h>
+#include <escher/expression_layout_field_delegate.h>
 #include <escher/selectable_table_view.h>
 #include <escher/selectable_table_view_data_source.h>
 #include <escher/selectable_table_view_delegate.h>

escher/include/escher/editable_expression_view.h

@@ -1,14 +1,14 @@
 #ifndef ESCHER_EDITABLE_EXPRESSION_VIEW_H
 #define ESCHER_EDITABLE_EXPRESSION_VIEW_H
 
-#include <escher/scrollable_expression_view_with_cursor.h>
-#include <escher/scrollable_expression_view_with_cursor_delegate.h>
+#include <escher/expression_layout_field.h>
+#include <escher/expression_layout_field_delegate.h>
 #include <escher/text_field.h>
 #include <escher/text_field_delegate.h>
 
 class EditableExpressionView :  public Responder, public View {
 public:
-  EditableExpressionView(Responder * parentResponder, TextFieldDelegate * textFieldDelegate, ScrollableExpressionViewWithCursorDelegate * scrollableExpressionViewWithCursorDelegate);
+  EditableExpressionView(Responder * parentResponder, TextFieldDelegate * textFieldDelegate, ExpressionLayoutFieldDelegate * expressionLayoutFieldDelegate);
 
   void setEditing(bool isEditing, bool reinitDraftBuffer = true);
   bool isEditing() const;
@@ -17,7 +17,7 @@ public:
   void insertText(const char * text);
   void reload();
   TextField * textField() { return &m_textField; }
-  ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor() { return &m_scrollableExpressionViewWithCursor; }
+  ExpressionLayoutField * expressionLayoutField() { return &m_expressionLayoutField; }
   bool editionIsInTextField() const;
   bool isEmpty() const;
   bool heightIsMaximal() const;
@@ -41,7 +41,7 @@ private:
   KDCoordinate inputViewHeight() const;
   KDCoordinate maximalHeight() const;
   TextField m_textField;
-  ScrollableExpressionViewWithCursor m_scrollableExpressionViewWithCursor;
+  ExpressionLayoutField m_expressionLayoutField;
   char m_textBody[k_bufferLength];
 };
 

escher/include/escher/expression_layout_field.h

@@ -1,15 +1,15 @@
-#ifndef ESCHER_SCROLLABLE_EXPRESSION_VIEW_WITH_CURSOR_H
-#define ESCHER_SCROLLABLE_EXPRESSION_VIEW_WITH_CURSOR_H
+#ifndef ESCHER_EXPRESSION_LAYOUT_FIELD_H
+#define ESCHER_EXPRESSION_LAYOUT_FIELD_H
 
 #include <escher/scrollable_view.h>
 #include <escher/expression_view_with_cursor.h>
-#include <escher/scrollable_expression_view_with_cursor_delegate.h>
+#include <escher/expression_layout_field_delegate.h>
 #include <poincare/expression_layout_cursor.h>
 
-class ScrollableExpressionViewWithCursor : public ScrollableView, public ScrollViewDataSource {
+class ExpressionLayoutField : public ScrollableView, public ScrollViewDataSource {
 public:
-  ScrollableExpressionViewWithCursor(Responder * parentResponder, Poincare::ExpressionLayout * expressionLayout, ScrollableExpressionViewWithCursorDelegate * delegate = nullptr);
-  void setDelegate(ScrollableExpressionViewWithCursorDelegate * delegate) { m_delegate = delegate; }
+  ExpressionLayoutField(Responder * parentResponder, Poincare::ExpressionLayout * expressionLayout, ExpressionLayoutFieldDelegate * delegate = nullptr);
+  void setDelegate(ExpressionLayoutFieldDelegate * delegate) { m_delegate = delegate; }
   ExpressionViewWithCursor * expressionViewWithCursor() { return &m_expressionViewWithCursor; }
   bool isEditing() const;
   void setEditing(bool isEditing);
@@ -21,7 +21,7 @@ public:
   Toolbox * toolbox() override;
   bool handleEvent(Ion::Events::Event event) override;
 
-  bool scrollableExpressionViewWithCursorShouldFinishEditing(Ion::Events::Event event);
+  bool expressionLayoutFieldShouldFinishEditing(Ion::Events::Event event);
 
   void insertLayoutAtCursor(Poincare::ExpressionLayout * layout, Poincare::ExpressionLayout * pointedLayout);
   void insertLayoutFromTextAtCursor(const char * text);
@@ -34,7 +34,7 @@ protected:
   bool privateHandleMoveEvent(Ion::Events::Event event, bool * shouldRecomputeLayout);
   ExpressionViewWithCursor m_expressionViewWithCursor;
 private:
-  ScrollableExpressionViewWithCursorDelegate * m_delegate;
+  ExpressionLayoutFieldDelegate * m_delegate;
 };
 
 #endif

escher/include/escher/expression_layout_field_delegate.h

@@ -0,0 +1,19 @@
+#ifndef ESCHER_EXPRESSION_LAYOUT_FIELD_DELEGATE_H
+#define ESCHER_EXPRESSION_LAYOUT_FIELD_DELEGATE_H
+
+#include <escher/toolbox.h>
+#include <ion/events.h>
+
+class ExpressionLayoutField;
+
+class ExpressionLayoutFieldDelegate {
+public:
+  virtual bool expressionLayoutFieldShouldFinishEditing(ExpressionLayoutField * expressionLayoutField, Ion::Events::Event event) = 0;
+  virtual bool expressionLayoutFieldDidReceiveEvent(ExpressionLayoutField * expressionLayoutField, Ion::Events::Event event) = 0;
+  virtual bool expressionLayoutFieldDidFinishEditing(ExpressionLayoutField * expressionLayoutField, const char * text, Ion::Events::Event event) { return false; }
+  virtual bool expressionLayoutFieldDidAbortEditing(ExpressionLayoutField * expressionLayoutField) { return false; }
+  virtual void expressionLayoutFieldDidChangeSize(ExpressionLayoutField * expressionLayoutField) {}
+  virtual Toolbox * toolboxForExpressionLayoutField(ExpressionLayoutField * expressionLayoutField) = 0;
+};
+
+#endif

escher/include/escher/input_view_controller.h

@@ -2,7 +2,7 @@
 #define ESCHER_INPUT_VIEW_CONTROLLER_H
 
 #include <escher/editable_expression_view.h>
-#include <escher/scrollable_expression_view_with_cursor_delegate.h>
+#include <escher/expression_layout_field_delegate.h>
 #include <escher/modal_view_controller.h>
 #include <escher/invocation.h>
 #include <escher/text_field.h>
@@ -11,9 +11,9 @@
 /* TODO Implement a split view. Because we use a modal view, the main view is
  * redrawn underneath the modal view, which is visible and ugly. */
 
-class InputViewController : public ModalViewController, TextFieldDelegate, ScrollableExpressionViewWithCursorDelegate {
+class InputViewController : public ModalViewController, TextFieldDelegate, ExpressionLayoutFieldDelegate {
 public:
-  InputViewController(Responder * parentResponder, ViewController * child, TextFieldDelegate * textFieldDelegate, ScrollableExpressionViewWithCursorDelegate * scrollableExpressionViewWithCursorDelegate);
+  InputViewController(Responder * parentResponder, ViewController * child, TextFieldDelegate * textFieldDelegate, ExpressionLayoutFieldDelegate * expressionLayoutFieldDelegate);
   void edit(Responder * caller, Ion::Events::Event event, void * context, const char * initialText, Invocation::Action successAction, Invocation::Action failureAction);
   const char * textBody();
   void abortEditionAndDismiss();
@@ -25,18 +25,18 @@ public:
   bool textFieldDidAbortEditing(TextField * textField) override;
   Toolbox * toolboxForTextInput(TextInput * textInput) override;
 
-  /* ScrollableExpressionViewWithCursorDelegate */
-  bool scrollableExpressionViewWithCursorShouldFinishEditing(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor, Ion::Events::Event event) override;
-  bool scrollableExpressionViewWithCursorDidReceiveEvent(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor, Ion::Events::Event event) override;
-  bool scrollableExpressionViewWithCursorDidFinishEditing(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor, const char * text, Ion::Events::Event event) override;
-  bool scrollableExpressionViewWithCursorDidAbortEditing(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor) override;
-  void scrollableExpressionViewWithCursorDidChangeSize(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor) override;
-  Toolbox * toolboxForScrollableExpressionViewWithCursor(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor) override;
+  /* ExpressionLayoutFieldDelegate */
+  bool expressionLayoutFieldShouldFinishEditing(ExpressionLayoutField * expressionLayoutField, Ion::Events::Event event) override;
+  bool expressionLayoutFieldDidReceiveEvent(ExpressionLayoutField * expressionLayoutField, Ion::Events::Event event) override;
+  bool expressionLayoutFieldDidFinishEditing(ExpressionLayoutField * expressionLayoutField, const char * text, Ion::Events::Event event) override;
+  bool expressionLayoutFieldDidAbortEditing(ExpressionLayoutField * expressionLayoutField) override;
+  void expressionLayoutFieldDidChangeSize(ExpressionLayoutField * expressionLayoutField) override;
+  Toolbox * toolboxForExpressionLayoutField(ExpressionLayoutField * expressionLayoutField) override;
 
 private:
   class EditableExpressionViewController : public ViewController {
   public:
-    EditableExpressionViewController(Responder * parentResponder, TextFieldDelegate * textFieldDelegate, ScrollableExpressionViewWithCursorDelegate * scrollableExpressionViewWithCursorDelegate);
+    EditableExpressionViewController(Responder * parentResponder, TextFieldDelegate * textFieldDelegate, ExpressionLayoutFieldDelegate * expressionLayoutFieldDelegate);
     void didBecomeFirstResponder() override;
     View * view() override { return &m_editableExpressionView; }
     EditableExpressionView * editableExpressionView() { return &m_editableExpressionView; }
@@ -49,7 +49,7 @@ private:
   Invocation m_successAction;
   Invocation m_failureAction;
   TextFieldDelegate * m_textFieldDelegate;
-  ScrollableExpressionViewWithCursorDelegate * m_scrollableExpressionViewWithCursorDelegate;
+  ExpressionLayoutFieldDelegate * m_expressionLayoutFieldDelegate;
   bool m_inputViewHeightIsMaximal;
 };
 

escher/include/escher/scrollable_expression_view_with_cursor_delegate.h

@@ -1,19 +0,0 @@
-#ifndef ESCHER_SCROLLABLE_EXPRESSION_VIEW_WITH_CURSOR_DELEGATE_H
-#define ESCHER_SCROLLABLE_EXPRESSION_VIEW_WITH_CURSOR_DELEGATE_H
-
-#include <escher/toolbox.h>
-#include <ion/events.h>
-
-class ScrollableExpressionViewWithCursor;
-
-class ScrollableExpressionViewWithCursorDelegate {
-public:
-  virtual bool scrollableExpressionViewWithCursorShouldFinishEditing(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor, Ion::Events::Event event) = 0;
-  virtual bool scrollableExpressionViewWithCursorDidReceiveEvent(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor, Ion::Events::Event event) = 0;
-  virtual bool scrollableExpressionViewWithCursorDidFinishEditing(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor, const char * text, Ion::Events::Event event) { return false; }
-  virtual bool scrollableExpressionViewWithCursorDidAbortEditing(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor) { return false; }
-  virtual void scrollableExpressionViewWithCursorDidChangeSize(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor) {}
-  virtual Toolbox * toolboxForScrollableExpressionViewWithCursor(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor) = 0;
-};
-
-#endif

escher/src/editable_expression_view.cpp

@@ -2,11 +2,11 @@
 #include <poincare/preferences.h>
 #include <assert.h>
 
-EditableExpressionView::EditableExpressionView(Responder * parentResponder, TextFieldDelegate * textFieldDelegate, ScrollableExpressionViewWithCursorDelegate * scrollableExpressionViewWithCursorDelegate) :
+EditableExpressionView::EditableExpressionView(Responder * parentResponder, TextFieldDelegate * textFieldDelegate, ExpressionLayoutFieldDelegate * expressionLayoutFieldDelegate) :
   Responder(parentResponder),
   View(),
   m_textField(parentResponder, m_textBody, m_textBody, k_bufferLength, textFieldDelegate, false),
-  m_scrollableExpressionViewWithCursor(parentResponder, new Poincare::HorizontalLayout(), scrollableExpressionViewWithCursorDelegate)
+  m_expressionLayoutField(parentResponder, new Poincare::HorizontalLayout(), expressionLayoutFieldDelegate)
 {
   m_textBody[0] = 0;
 }
@@ -16,19 +16,19 @@ void EditableExpressionView::setEditing(bool isEditing, bool reinitDraftBuffer)
     m_textField.setEditing(isEditing, reinitDraftBuffer);
   } else {
     if (reinitDraftBuffer) {
-      m_scrollableExpressionViewWithCursor.clearLayout();
+      m_expressionLayoutField.clearLayout();
     }
-    m_scrollableExpressionViewWithCursor.setEditing(isEditing);
+    m_expressionLayoutField.setEditing(isEditing);
   }
 }
 
 bool EditableExpressionView::isEditing() const {
-  return editionIsInTextField() ? m_textField.isEditing() : m_scrollableExpressionViewWithCursor.isEditing();
+  return editionIsInTextField() ? m_textField.isEditing() : m_expressionLayoutField.isEditing();
 }
 
 const char * EditableExpressionView::text() {
   if (!editionIsInTextField()) {
-    m_scrollableExpressionViewWithCursor.expressionViewWithCursor()->expressionView()->expressionLayout()->writeTextInBuffer(m_textBody, k_bufferLength);
+    m_expressionLayoutField.expressionViewWithCursor()->expressionView()->expressionLayout()->writeTextInBuffer(m_textBody, k_bufferLength);
   }
   return m_textBody;
 }
@@ -38,9 +38,9 @@ void EditableExpressionView::setText(const char * text) {
     m_textField.setText(text);
     return;
   }
-  m_scrollableExpressionViewWithCursor.clearLayout();
+  m_expressionLayoutField.clearLayout();
   if (strlen(text) > 0) {
-    m_scrollableExpressionViewWithCursor.insertLayoutFromTextAtCursor(text);
+    m_expressionLayoutField.insertLayoutFromTextAtCursor(text);
   }
 }
 
@@ -48,8 +48,8 @@ void EditableExpressionView::insertText(const char * text) {
   if (editionIsInTextField()) {
     m_textField.handleEventWithText(text);
   } else {
-    m_scrollableExpressionViewWithCursor.setEditing(true);
-    m_scrollableExpressionViewWithCursor.insertLayoutFromTextAtCursor(text);
+    m_expressionLayoutField.setEditing(true);
+    m_expressionLayoutField.insertLayoutFromTextAtCursor(text);
   }
 }
 
@@ -58,17 +58,17 @@ View * EditableExpressionView::subviewAtIndex(int index) {
   if (editionIsInTextField()) {
     return &m_textField;
   }
-  return &m_scrollableExpressionViewWithCursor;
+  return &m_expressionLayoutField;
 }
 
 void EditableExpressionView::layoutSubviews() {
   KDRect inputViewFrame(k_leftMargin, k_separatorThickness, bounds().width() - k_leftMargin, bounds().height() - k_separatorThickness);
   if (editionIsInTextField()) {
     m_textField.setFrame(inputViewFrame);
-    m_scrollableExpressionViewWithCursor.setFrame(KDRectZero);
+    m_expressionLayoutField.setFrame(KDRectZero);
     return;
   }
-  m_scrollableExpressionViewWithCursor.setFrame(inputViewFrame);
+  m_expressionLayoutField.setFrame(inputViewFrame);
   m_textField.setFrame(KDRectZero);
 }
 
@@ -89,7 +89,7 @@ void EditableExpressionView::drawRect(KDContext * ctx, KDRect rect) const {
 }
 
 bool EditableExpressionView::handleEvent(Ion::Events::Event event) {
-  return editionIsInTextField() ? m_textField.handleEvent(event) : m_scrollableExpressionViewWithCursor.handleEvent(event);
+  return editionIsInTextField() ? m_textField.handleEvent(event) : m_expressionLayoutField.handleEvent(event);
 }
 
 KDSize EditableExpressionView::minimalSizeForOptimalDisplay() const {
@@ -104,7 +104,7 @@ bool EditableExpressionView::isEmpty() const {
   if (editionIsInTextField()) {
     return m_textField.draftTextLength() == 0;
   }
-  Poincare::ExpressionLayout * layout =  const_cast<ScrollableExpressionViewWithCursor *>(&m_scrollableExpressionViewWithCursor)->expressionViewWithCursor()->expressionView()->expressionLayout();
+  Poincare::ExpressionLayout * layout =  const_cast<ExpressionLayoutField *>(&m_expressionLayoutField)->expressionViewWithCursor()->expressionView()->expressionLayout();
   return !layout->hasText();
 }
 
@@ -120,7 +120,7 @@ KDCoordinate EditableExpressionView::inputViewHeight() const {
     + k_verticalExpressionViewMargin
     + min(maximalHeight(),
         max(k_textFieldHeight,
-          m_scrollableExpressionViewWithCursor.minimalSizeForOptimalDisplay().height()
+          m_expressionLayoutField.minimalSizeForOptimalDisplay().height()
           + k_verticalExpressionViewMargin));
 }
 

escher/src/expression_layout_field.cpp

@@ -1,44 +1,44 @@
-#include <escher/scrollable_expression_view_with_cursor.h>
+#include <escher/expression_layout_field.h>
 #include <escher/clipboard.h>
 #include <escher/text_field.h>
 #include <poincare/src/layout/matrix_layout.h>
 #include <poincare/expression_layout_cursor.h>
 #include <assert.h>
 
-ScrollableExpressionViewWithCursor::ScrollableExpressionViewWithCursor(Responder * parentResponder, Poincare::ExpressionLayout * expressionLayout, ScrollableExpressionViewWithCursorDelegate * delegate) :
+ExpressionLayoutField::ExpressionLayoutField(Responder * parentResponder, Poincare::ExpressionLayout * expressionLayout, ExpressionLayoutFieldDelegate * delegate) :
   ScrollableView(parentResponder, &m_expressionViewWithCursor, this),
   m_expressionViewWithCursor(expressionLayout),
   m_delegate(delegate)
 {
 }
 
-bool ScrollableExpressionViewWithCursor::isEditing() const {
+bool ExpressionLayoutField::isEditing() const {
   return m_expressionViewWithCursor.isEditing();
 }
 
-void ScrollableExpressionViewWithCursor::setEditing(bool isEditing) {
+void ExpressionLayoutField::setEditing(bool isEditing) {
   m_expressionViewWithCursor.setEditing(isEditing);
 }
 
-void ScrollableExpressionViewWithCursor::clearLayout() {
+void ExpressionLayoutField::clearLayout() {
   delete m_expressionViewWithCursor.expressionView()->expressionLayout();
   Poincare::ExpressionLayout * newLayout = new Poincare::HorizontalLayout();
   m_expressionViewWithCursor.expressionView()->setExpressionLayout(newLayout);
   m_expressionViewWithCursor.cursor()->setPointedExpressionLayout(newLayout);
 }
 
-void ScrollableExpressionViewWithCursor::scrollToCursor() {
+void ExpressionLayoutField::scrollToCursor() {
   scrollToContentRect(m_expressionViewWithCursor.cursorRect(), true);
 }
 
-Toolbox * ScrollableExpressionViewWithCursor::toolbox() {
+Toolbox * ExpressionLayoutField::toolbox() {
   if (m_delegate) {
-    return m_delegate->toolboxForScrollableExpressionViewWithCursor(this);
+    return m_delegate->toolboxForExpressionLayoutField(this);
   }
   return nullptr;
 }
 
-bool ScrollableExpressionViewWithCursor::handleEvent(Ion::Events::Event event) {
+bool ExpressionLayoutField::handleEvent(Ion::Events::Event event) {
   KDSize previousSize = minimalSizeForOptimalDisplay();
   bool didHandleEvent = false;
   bool shouldRecomputeLayout = m_expressionViewWithCursor.cursor()->showEmptyLayoutIfNeeded();
@@ -63,7 +63,7 @@ bool ScrollableExpressionViewWithCursor::handleEvent(Ion::Events::Event event) {
     reload();
     KDSize newSize = minimalSizeForOptimalDisplay();
     if (m_delegate && previousSize.height() != newSize.height()) {
-      m_delegate->scrollableExpressionViewWithCursorDidChangeSize(this);
+      m_delegate->expressionLayoutFieldDidChangeSize(this);
       reload();
     }
     return true;
@@ -71,15 +71,15 @@ bool ScrollableExpressionViewWithCursor::handleEvent(Ion::Events::Event event) {
   return false;
 }
 
-bool ScrollableExpressionViewWithCursor::scrollableExpressionViewWithCursorShouldFinishEditing(Ion::Events::Event event) {
-  return m_delegate->scrollableExpressionViewWithCursorShouldFinishEditing(this, event);
+bool ExpressionLayoutField::expressionLayoutFieldShouldFinishEditing(Ion::Events::Event event) {
+  return m_delegate->expressionLayoutFieldShouldFinishEditing(this, event);
 }
 
-KDSize ScrollableExpressionViewWithCursor::minimalSizeForOptimalDisplay() const {
+KDSize ExpressionLayoutField::minimalSizeForOptimalDisplay() const {
   return m_expressionViewWithCursor.minimalSizeForOptimalDisplay();
 }
 
-bool ScrollableExpressionViewWithCursor::privateHandleMoveEvent(Ion::Events::Event event, bool * shouldRecomputeLayout) {
+bool ExpressionLayoutField::privateHandleMoveEvent(Ion::Events::Event event, bool * shouldRecomputeLayout) {
   Poincare::ExpressionLayoutCursor result;
   if (event == Ion::Events::Left) {
     result = m_expressionViewWithCursor.cursor()->cursorOnLeft(shouldRecomputeLayout);
@@ -103,24 +103,24 @@ bool ScrollableExpressionViewWithCursor::privateHandleMoveEvent(Ion::Events::Eve
   return false;
 }
 
-bool ScrollableExpressionViewWithCursor::privateHandleEvent(Ion::Events::Event event) {
-  if (m_delegate && m_delegate->scrollableExpressionViewWithCursorDidReceiveEvent(this, event)) {
+bool ExpressionLayoutField::privateHandleEvent(Ion::Events::Event event) {
+  if (m_delegate && m_delegate->expressionLayoutFieldDidReceiveEvent(this, event)) {
     return true;
   }
   if (Responder::handleEvent(event)) {
     /* The only event Responder handles is 'Toolbox' displaying. In that case,
-     * the ScrollableExpressionViewWithCursor is forced into editing mode. */
+     * the ExpressionLayoutField is forced into editing mode. */
     if (!isEditing()) {
       setEditing(true);
     }
     return true;
   }
-  if (isEditing() && scrollableExpressionViewWithCursorShouldFinishEditing(event)) {
+  if (isEditing() && expressionLayoutFieldShouldFinishEditing(event)) {
     setEditing(false);
     int bufferSize = TextField::maxBufferSize();
     char buffer[bufferSize];
     m_expressionViewWithCursor.expressionView()->expressionLayout()->writeTextInBuffer(buffer, bufferSize);
-    if (m_delegate->scrollableExpressionViewWithCursorDidFinishEditing(this, buffer, event)) {
+    if (m_delegate->expressionLayoutFieldDidFinishEditing(this, buffer, event)) {
       delete m_expressionViewWithCursor.expressionView()->expressionLayout();
       Poincare::ExpressionLayout * newLayout = new Poincare::HorizontalLayout();
       m_expressionViewWithCursor.expressionView()->setExpressionLayout(newLayout);
@@ -136,7 +136,7 @@ bool ScrollableExpressionViewWithCursor::privateHandleEvent(Ion::Events::Event e
   }
   if (event == Ion::Events::Back && isEditing()) {
     setEditing(false);
-    m_delegate->scrollableExpressionViewWithCursorDidAbortEditing(this);
+    m_delegate->expressionLayoutFieldDidAbortEditing(this);
     return true;
   }
   if (event == Ion::Events::Division) {
@@ -197,7 +197,7 @@ bool ScrollableExpressionViewWithCursor::privateHandleEvent(Ion::Events::Event e
   return false;
 }
 
-void ScrollableExpressionViewWithCursor::insertLayoutAtCursor(Poincare::ExpressionLayout * layout, Poincare::ExpressionLayout * pointedLayout) {
+void ExpressionLayoutField::insertLayoutAtCursor(Poincare::ExpressionLayout * layout, Poincare::ExpressionLayout * pointedLayout) {
   if (layout == nullptr) {
     return;
   }
@@ -219,11 +219,11 @@ void ScrollableExpressionViewWithCursor::insertLayoutAtCursor(Poincare::Expressi
   reload();
   KDSize newSize = minimalSizeForOptimalDisplay();
   if (m_delegate && previousSize.height() != newSize.height()) {
-    m_delegate->scrollableExpressionViewWithCursorDidChangeSize(this);
+    m_delegate->expressionLayoutFieldDidChangeSize(this);
   }
 }
 
-void ScrollableExpressionViewWithCursor::insertLayoutFromTextAtCursor(const char * text) {
+void ExpressionLayoutField::insertLayoutFromTextAtCursor(const char * text) {
   Poincare::Expression * expression = Poincare::Expression::parse(text);
   if (expression != nullptr) {
     Poincare::ExpressionLayout * layout = expression->createLayout();
@@ -240,10 +240,10 @@ void ScrollableExpressionViewWithCursor::insertLayoutFromTextAtCursor(const char
   reload();
 }
 
-void ScrollableExpressionViewWithCursor::reload() {
+void ExpressionLayoutField::reload() {
   m_expressionViewWithCursor.expressionView()->expressionLayout()->invalidAllSizesPositionsAndBaselines();
   layoutSubviews();
-  m_delegate->scrollableExpressionViewWithCursorDidChangeSize(this);
+  m_delegate->expressionLayoutFieldDidChangeSize(this);
   scrollToCursor();
   m_expressionViewWithCursor.cursorPositionChanged();
   markRectAsDirty(bounds());

escher/src/input_view_controller.cpp

@@ -4,9 +4,9 @@
 #include <poincare/src/layout/horizontal_layout.h>
 #include <assert.h>
 
-InputViewController::EditableExpressionViewController::EditableExpressionViewController(Responder * parentResponder, TextFieldDelegate * textFieldDelegate, ScrollableExpressionViewWithCursorDelegate * scrollableExpressionViewWithCursorDelegate) :
+InputViewController::EditableExpressionViewController::EditableExpressionViewController(Responder * parentResponder, TextFieldDelegate * textFieldDelegate, ExpressionLayoutFieldDelegate * expressionLayoutFieldDelegate) :
   ViewController(parentResponder),
-  m_editableExpressionView(this, textFieldDelegate, scrollableExpressionViewWithCursorDelegate)
+  m_editableExpressionView(this, textFieldDelegate, expressionLayoutFieldDelegate)
 {
 }
 
@@ -14,13 +14,13 @@ void InputViewController::EditableExpressionViewController::didBecomeFirstRespon
   app()->setFirstResponder(&m_editableExpressionView);
 }
 
-InputViewController::InputViewController(Responder * parentResponder, ViewController * child, TextFieldDelegate * textFieldDelegate, ScrollableExpressionViewWithCursorDelegate * scrollableExpressionViewWithCursorDelegate) :
+InputViewController::InputViewController(Responder * parentResponder, ViewController * child, TextFieldDelegate * textFieldDelegate, ExpressionLayoutFieldDelegate * expressionLayoutFieldDelegate) :
   ModalViewController(parentResponder, child),
   m_editableExpressionViewController(this, this, this),
   m_successAction(Invocation(nullptr, nullptr)),
   m_failureAction(Invocation(nullptr, nullptr)),
   m_textFieldDelegate(textFieldDelegate),
-  m_scrollableExpressionViewWithCursorDelegate(scrollableExpressionViewWithCursorDelegate),
+  m_expressionLayoutFieldDelegate(expressionLayoutFieldDelegate),
   m_inputViewHeightIsMaximal(false)
 {
 }
@@ -64,23 +64,23 @@ Toolbox * InputViewController::toolboxForTextInput(TextInput * input) {
   return m_textFieldDelegate->toolboxForTextInput(input);
 }
 
-bool InputViewController::scrollableExpressionViewWithCursorShouldFinishEditing(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor, Ion::Events::Event event) {
+bool InputViewController::expressionLayoutFieldShouldFinishEditing(ExpressionLayoutField * expressionLayoutField, Ion::Events::Event event) {
   return event == Ion::Events::OK || event == Ion::Events::EXE;
 }
 
-bool InputViewController::scrollableExpressionViewWithCursorDidReceiveEvent(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor, Ion::Events::Event event) {
-  return m_scrollableExpressionViewWithCursorDelegate->scrollableExpressionViewWithCursorDidReceiveEvent(scrollableExpressionViewWithCursor, event);
+bool InputViewController::expressionLayoutFieldDidReceiveEvent(ExpressionLayoutField * expressionLayoutField, Ion::Events::Event event) {
+  return m_expressionLayoutFieldDelegate->expressionLayoutFieldDidReceiveEvent(expressionLayoutField, event);
 }
 
-bool InputViewController::scrollableExpressionViewWithCursorDidFinishEditing(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor, const char * text, Ion::Events::Event event) {
+bool InputViewController::expressionLayoutFieldDidFinishEditing(ExpressionLayoutField * expressionLayoutField, const char * text, Ion::Events::Event event) {
   return inputViewDidFinishEditing();
 }
 
-bool InputViewController::scrollableExpressionViewWithCursorDidAbortEditing(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor) {
+bool InputViewController::expressionLayoutFieldDidAbortEditing(ExpressionLayoutField * expressionLayoutField) {
   return inputViewDidAbortEditing();
 }
 
-void InputViewController::scrollableExpressionViewWithCursorDidChangeSize(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor) {
+void InputViewController::expressionLayoutFieldDidChangeSize(ExpressionLayoutField * expressionLayoutField) {
   // Reload the view only if the EditableExpressionView height actually changes,
   // i.e. not if the height is already maximal and stays maximal.
   bool newInputViewHeightIsMaximal = m_editableExpressionViewController.editableExpressionView()->heightIsMaximal();
@@ -90,8 +90,8 @@ void InputViewController::scrollableExpressionViewWithCursorDidChangeSize(Scroll
   }
 }
 
-Toolbox * InputViewController::toolboxForScrollableExpressionViewWithCursor(ScrollableExpressionViewWithCursor * scrollableExpressionViewWithCursor) {
-  return m_scrollableExpressionViewWithCursorDelegate->toolboxForScrollableExpressionViewWithCursor(scrollableExpressionViewWithCursor);
+Toolbox * InputViewController::toolboxForExpressionLayoutField(ExpressionLayoutField * expressionLayoutField) {
+  return m_expressionLayoutFieldDelegate->toolboxForExpressionLayoutField(expressionLayoutField);
 }
 
 bool InputViewController::inputViewDidFinishEditing() {