[apps/escher] Rename EditableExpressionView -> ExpressionField

Change-Id: Iadfb220ee94e68762305060215f1ead0cac951fb

apps/calculation/Makefile

@@ -6,7 +6,7 @@ app_objs += $(addprefix apps/calculation/,\
   calculation.o\
   calculation_store.o\
   edit_expression_controller.o\
-  editable_expression_view.o\
+  expression_field.o\
   history_view_cell.o\
   history_controller.o\
   output_expressions_view.o\

apps/calculation/app.cpp

@@ -43,7 +43,7 @@ void App::Snapshot::tidy() {
 }
 
 App::App(Container * container, Snapshot * snapshot) :
-  EditableExpressionViewDelegateApp(container, snapshot, &m_editExpressionController),
+  ExpressionFieldDelegateApp(container, snapshot, &m_editExpressionController),
   m_historyController(&m_editExpressionController, snapshot->calculationStore()),
   m_editExpressionController(&m_modalViewController, &m_historyController, snapshot->calculationStore())
 {
@@ -86,7 +86,7 @@ bool App::textInputIsCorrect(const char * text) {
 }
 
 bool App::expressionLayoutFieldDidReceiveEvent(::ExpressionLayoutField * expressionLayoutField, Ion::Events::Event event) {
-  if ((event == Ion::Events::Var ||  event == Ion::Events::XNT) && EditableExpressionViewDelegateApp::expressionLayoutFieldDidReceiveEvent(expressionLayoutField, event)) {
+  if ((event == Ion::Events::Var ||  event == Ion::Events::XNT) && ExpressionFieldDelegateApp::expressionLayoutFieldDidReceiveEvent(expressionLayoutField, event)) {
     return true;
   }
   /* Here, we check that the expression entered by the user can be printed with

apps/calculation/app.h

@@ -9,7 +9,7 @@
 
 namespace Calculation {
 
-class App : public Shared::EditableExpressionViewDelegateApp {
+class App : public Shared::ExpressionFieldDelegateApp {
 public:
   class Descriptor : public ::App::Descriptor {
   public:

apps/calculation/edit_expression_controller.cpp

@@ -12,7 +12,7 @@ namespace Calculation {
 EditExpressionController::ContentView::ContentView(Responder * parentResponder, TableView * subview, TextFieldDelegate * textFieldDelegate, ExpressionLayoutFieldDelegate * expressionLayoutFieldDelegate) :
   View(),
   m_mainView(subview),
-  m_editableExpressionView(parentResponder, textFieldDelegate, expressionLayoutFieldDelegate)
+  m_expressionField(parentResponder, textFieldDelegate, expressionLayoutFieldDelegate)
 {
 }
 
@@ -22,15 +22,15 @@ View * EditExpressionController::ContentView::subviewAtIndex(int index) {
     return m_mainView;
   }
   assert(index == 1);
-  return &m_editableExpressionView;
+  return &m_expressionField;
 }
 
 void EditExpressionController::ContentView::layoutSubviews() {
-  KDCoordinate inputViewFrameHeight = m_editableExpressionView.minimalSizeForOptimalDisplay().height();
+  KDCoordinate inputViewFrameHeight = m_expressionField.minimalSizeForOptimalDisplay().height();
   KDRect mainViewFrame(0, 0, bounds().width(), bounds().height() - inputViewFrameHeight);
   m_mainView->setFrame(mainViewFrame);
   KDRect inputViewFrame(0, bounds().height() - inputViewFrameHeight, bounds().width(), inputViewFrameHeight);
-  m_editableExpressionView.setFrame(inputViewFrame);
+  m_expressionField.setFrame(inputViewFrame);
 }
 
 void EditExpressionController::ContentView::reload() {
@@ -47,18 +47,18 @@ EditExpressionController::EditExpressionController(Responder * parentResponder,
 }
 
 const char * EditExpressionController::textBody() {
-  return ((ContentView *)view())->editableExpressionView()->text();
+  return ((ContentView *)view())->expressionField()->text();
 }
 
 void EditExpressionController::insertTextBody(const char * text) {
-  ((ContentView *)view())->editableExpressionView()->insertText(text);
+  ((ContentView *)view())->expressionField()->insertText(text);
 }
 
 bool EditExpressionController::handleEvent(Ion::Events::Event event) {
   if (event == Ion::Events::Up) {
     if (m_calculationStore->numberOfCalculations() > 0) {
       m_cacheBuffer[0] = 0;
-      ((ContentView *)view())->editableExpressionView()->setEditing(false, false);
+      ((ContentView *)view())->expressionField()->setEditing(false, false);
       app()->setFirstResponder(m_historyController);
     }
     return true;
@@ -69,12 +69,12 @@ bool EditExpressionController::handleEvent(Ion::Events::Event event) {
 void EditExpressionController::didBecomeFirstResponder() {
   int lastRow = m_calculationStore->numberOfCalculations() > 0 ? m_calculationStore->numberOfCalculations()-1 : 0;
   m_historyController->scrollToCell(0, lastRow);
-  ((ContentView *)view())->editableExpressionView()->setEditing(true, false);
-  app()->setFirstResponder(((ContentView *)view())->editableExpressionView());
+  ((ContentView *)view())->expressionField()->setEditing(true, false);
+  app()->setFirstResponder(((ContentView *)view())->expressionField());
 }
 
 bool EditExpressionController::textFieldDidReceiveEvent(::TextField * textField, Ion::Events::Event event) {
-  assert(textField == ((ContentView *)view())->editableExpressionView()->textField());
+  assert(textField == ((ContentView *)view())->expressionField()->textField());
   if (textField->isEditing() && textField->textFieldShouldFinishEditing(event) && textField->draftTextLength() == 0 && m_cacheBuffer[0] != 0) {
     return inputViewDidReceiveEvent(event);
   }
@@ -82,35 +82,35 @@ bool EditExpressionController::textFieldDidReceiveEvent(::TextField * textField,
 }
 
 bool EditExpressionController::textFieldDidFinishEditing(::TextField * textField, const char * text, Ion::Events::Event event) {
-  assert(textField == ((ContentView *)view())->editableExpressionView()->textField());
+  assert(textField == ((ContentView *)view())->expressionField()->textField());
   return inputViewDidFinishEditing(text, event);
 }
 
 bool EditExpressionController::textFieldDidAbortEditing(::TextField * textField) {
-  assert(textField == ((ContentView *)view())->editableExpressionView()->textField());
+  assert(textField == ((ContentView *)view())->expressionField()->textField());
   return inputViewDidAbortEditing(textField->text());
 }
 
 bool EditExpressionController::expressionLayoutFieldDidReceiveEvent(::ExpressionLayoutField * expressionLayoutField, Ion::Events::Event event) {
-  assert(expressionLayoutField == ((ContentView *)view())->editableExpressionView()->expressionLayoutField());
+  assert(expressionLayoutField == ((ContentView *)view())->expressionField()->expressionLayoutField());
   if (expressionLayoutField->isEditing() && expressionLayoutField->expressionLayoutFieldShouldFinishEditing(event) && !expressionLayout()->hasText() && m_calculationStore->numberOfCalculations() > 0) {
     return inputViewDidReceiveEvent(event);
   }
-  return editableExpressionViewDelegateApp()->expressionLayoutFieldDidReceiveEvent(expressionLayoutField, event);
+  return expressionFieldDelegateApp()->expressionLayoutFieldDidReceiveEvent(expressionLayoutField, event);
 }
 
 bool EditExpressionController::expressionLayoutFieldDidFinishEditing(::ExpressionLayoutField * expressionLayoutField, const char * text, Ion::Events::Event event) {
-  assert(expressionLayoutField == ((ContentView *)view())->editableExpressionView()->expressionLayoutField());
+  assert(expressionLayoutField == ((ContentView *)view())->expressionField()->expressionLayoutField());
   return inputViewDidFinishEditing(text, event);
 }
 
 bool EditExpressionController::expressionLayoutFieldDidAbortEditing(::ExpressionLayoutField * expressionLayoutField) {
-  assert(expressionLayoutField == ((ContentView *)view())->editableExpressionView()->expressionLayoutField());
+  assert(expressionLayoutField == ((ContentView *)view())->expressionField()->expressionLayoutField());
   return inputViewDidAbortEditing(nullptr);
 }
 
 void EditExpressionController::expressionLayoutFieldDidChangeSize(::ExpressionLayoutField * expressionLayoutField) {
-  assert(expressionLayoutField == ((ContentView *)view())->editableExpressionView()->expressionLayoutField());
+  assert(expressionLayoutField == ((ContentView *)view())->expressionField()->expressionLayoutField());
   reloadView();
 }
 
@@ -118,7 +118,7 @@ TextFieldDelegateApp * EditExpressionController::textFieldDelegateApp() {
   return (App *)app();
 }
 
-EditableExpressionViewDelegateApp * EditExpressionController::editableExpressionViewDelegateApp() {
+ExpressionFieldDelegateApp * EditExpressionController::expressionFieldDelegateApp() {
   return (App *)app();
 }
 
@@ -158,15 +158,15 @@ bool EditExpressionController::inputViewDidFinishEditing(const char * text, Ion:
   m_calculationStore->push(textBody(), calculationApp->localContext());
   m_historyController->reload();
   ((ContentView *)view())->mainView()->scrollToCell(0, m_historyController->numberOfRows()-1);
-  ((ContentView *)view())->editableExpressionView()->setEditing(true);
-  ((ContentView *)view())->editableExpressionView()->setText("");
+  ((ContentView *)view())->expressionField()->setEditing(true);
+  ((ContentView *)view())->expressionField()->setText("");
   return true;
 }
 
 bool EditExpressionController::inputViewDidAbortEditing(const char * text) {
   if (text != nullptr) {
-    ((ContentView *)view())->editableExpressionView()->setEditing(true, true);
-    ((ContentView *)view())->editableExpressionView()->setText(text);
+    ((ContentView *)view())->expressionField()->setEditing(true, true);
+    ((ContentView *)view())->expressionField()->setText(text);
   }
   return false;
 }
@@ -177,7 +177,7 @@ void EditExpressionController::viewDidDisappear() {
 }
 
 Poincare::ExpressionLayout * EditExpressionController::expressionLayout() {
-  return ((ContentView *)view())->editableExpressionView()->expressionLayoutField()->expressionViewWithCursor()->expressionView()->expressionLayout();
+  return ((ContentView *)view())->expressionField()->expressionLayoutField()->expressionViewWithCursor()->expressionView()->expressionLayout();
 }
 
 }

apps/calculation/edit_expression_controller.h

@@ -2,7 +2,7 @@
 #define CALCULATION_EDIT_EXPRESSION_CONTROLLER_H
 
 #include <escher.h>
-#include "editable_expression_view.h"
+#include "expression_field.h"
 #include "../shared/text_field_delegate.h"
 #include "../shared/expression_layout_field_delegate.h"
 #include "history_controller.h"
@@ -38,14 +38,14 @@ private:
     ContentView(Responder * parentResponder, TableView * subview, TextFieldDelegate * textFieldDelegate, ExpressionLayoutFieldDelegate * expressionLayoutFieldDelegate);
     void reload();
     TableView * mainView() { return m_mainView; }
-    EditableExpressionView * editableExpressionView() { return &m_editableExpressionView; }
+    ExpressionField * expressionField() { return &m_expressionField; }
     /* View */
     int numberOfSubviews() const override { return 2; }
     View * subviewAtIndex(int index) override;
     void layoutSubviews() override;
   private:
     TableView * m_mainView;
-    EditableExpressionView m_editableExpressionView;
+    ExpressionField m_expressionField;
   };
   View * loadView() override;
   void unloadView(View * view) override;
@@ -55,7 +55,7 @@ private:
   bool inputViewDidAbortEditing(const char * text);
   Shared::TextFieldDelegateApp * textFieldDelegateApp() override;
   char m_cacheBuffer[TextField::maxBufferSize()];
-  Shared::EditableExpressionViewDelegateApp * editableExpressionViewDelegateApp() override;
+  Shared::ExpressionFieldDelegateApp * expressionFieldDelegateApp() override;
   Poincare::ExpressionLayout * expressionLayout();
   HistoryController * m_historyController;
   CalculationStore * m_calculationStore;

apps/calculation/editable_expression_view.h

@@ -1,17 +0,0 @@
-#ifndef CALCULATION_EDITABLE_EXPRESSION_VIEW_H
-#define CALCULATION_EDITABLE_EXPRESSION_VIEW_H
-
-#include <escher.h>
-
-namespace Calculation {
-
-class EditableExpressionView : public ::EditableExpressionView {
-public:
-  EditableExpressionView(Responder * parentResponder, TextFieldDelegate * textFieldDelegate, ExpressionLayoutFieldDelegate * expressionLayoutFieldDelegate);
-protected:
-  bool handleEvent(Ion::Events::Event event) override;
-};
-
-}
-
-#endif

apps/calculation/expression_field.cpp

@@ -1,14 +1,14 @@
-#include "editable_expression_view.h"
+#include "expression_field.h"
 
 namespace Calculation {
 
-EditableExpressionView::EditableExpressionView(Responder * parentResponder, TextFieldDelegate * textFieldDelegate, ExpressionLayoutFieldDelegate * expressionLayoutFieldDelegate) :
-  ::EditableExpressionView(parentResponder, textFieldDelegate, expressionLayoutFieldDelegate)
+ExpressionField::ExpressionField(Responder * parentResponder, TextFieldDelegate * textFieldDelegate, ExpressionLayoutFieldDelegate * expressionLayoutFieldDelegate) :
+  ::ExpressionField(parentResponder, textFieldDelegate, expressionLayoutFieldDelegate)
 {
   setEditing(true);
 }
 
-bool EditableExpressionView::handleEvent(Ion::Events::Event event) {
+bool ExpressionField::handleEvent(Ion::Events::Event event) {
   if (event == Ion::Events::Back) {
     return false;
   }
@@ -25,7 +25,7 @@ bool EditableExpressionView::handleEvent(Ion::Events::Event event) {
        event == Ion::Events::Sto)) {
     insertText("ans");
   }
-  return(::EditableExpressionView::handleEvent(event));
+  return(::ExpressionField::handleEvent(event));
 }
 
 }

apps/calculation/expression_field.h

@@ -0,0 +1,17 @@
+#ifndef CALCULATION_EXPRESSION_FIELD_H
+#define CALCULATION_EXPRESSION_FIELD_H
+
+#include <escher.h>
+
+namespace Calculation {
+
+class ExpressionField : public ::ExpressionField {
+public:
+  ExpressionField(Responder * parentResponder, TextFieldDelegate * textFieldDelegate, ExpressionLayoutFieldDelegate * expressionLayoutFieldDelegate);
+protected:
+  bool handleEvent(Ion::Events::Event event) override;
+};
+
+}
+
+#endif

apps/sequence/list/list_controller.cpp

@@ -39,7 +39,7 @@ TextFieldDelegateApp * ListController::textFieldDelegateApp() {
   return (App *)app();
 }
 
-EditableExpressionViewDelegateApp * ListController::editableExpressionViewDelegateApp() {
+ExpressionFieldDelegateApp * ListController::expressionFieldDelegateApp() {
   return (App *)app();
 }
 

apps/sequence/list/list_controller.h

@@ -27,7 +27,7 @@ public:
   void selectPreviousNewSequenceCell();
 private:
   Shared::TextFieldDelegateApp * textFieldDelegateApp() override;
-  Shared::EditableExpressionViewDelegateApp * editableExpressionViewDelegateApp() override;
+  Shared::ExpressionFieldDelegateApp * expressionFieldDelegateApp() override;
   void editExpression(Sequence * sequence, int sequenceDefinitionIndex, Ion::Events::Event event);
   ListParameterController * parameterController() override;
   int maxNumberOfRows() override;

apps/shared/Makefile

@@ -6,7 +6,7 @@ app_objs += $(addprefix apps/shared/,\
   curve_view_cursor.o\
   curve_view_range.o\
   editable_cell_table_view_controller.o\
-  editable_expression_view_delegate_app.o\
+  expression_field_delegate_app.o\
   float_pair_store.o\
   float_parameter_controller.o\
   function.o\

apps/shared/expression_field_delegate_app.cpp

@@ -1,4 +1,4 @@
-#include "editable_expression_view_delegate_app.h"
+#include "expression_field_delegate_app.h"
 #include "../i18n.h"
 #include "../apps_container.h"
 
@@ -6,17 +6,17 @@ using namespace Poincare;
 
 namespace Shared {
 
-EditableExpressionViewDelegateApp::EditableExpressionViewDelegateApp(Container * container, Snapshot * snapshot, ViewController * rootViewController) :
+ExpressionFieldDelegateApp::ExpressionFieldDelegateApp(Container * container, Snapshot * snapshot, ViewController * rootViewController) :
   TextFieldDelegateApp(container, snapshot, rootViewController),
   ExpressionLayoutFieldDelegate()
 {
 }
 
-bool EditableExpressionViewDelegateApp::expressionLayoutFieldShouldFinishEditing(ExpressionLayoutField * expressionLayoutField, Ion::Events::Event event) {
+bool ExpressionFieldDelegateApp::expressionLayoutFieldShouldFinishEditing(ExpressionLayoutField * expressionLayoutField, Ion::Events::Event event) {
   return event == Ion::Events::OK || event == Ion::Events::EXE;
 }
 
-bool EditableExpressionViewDelegateApp::expressionLayoutFieldDidReceiveEvent(ExpressionLayoutField * expressionLayoutField, Ion::Events::Event event) {
+bool ExpressionFieldDelegateApp::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);
@@ -47,7 +47,7 @@ bool EditableExpressionViewDelegateApp::expressionLayoutFieldDidReceiveEvent(Exp
   return false;
 }
 
-Toolbox * EditableExpressionViewDelegateApp::toolboxForExpressionLayoutField(ExpressionLayoutField * expressionLayoutField) {
+Toolbox * ExpressionFieldDelegateApp::toolboxForExpressionLayoutField(ExpressionLayoutField * expressionLayoutField) {
   Toolbox * toolbox = container()->mathToolbox();
   static_cast<MathToolbox *>(toolbox)->setSenderAndAction(expressionLayoutField, MathToolbox::actionForExpressionLayoutField);
   return toolbox;

apps/shared/expression_field_delegate_app.h

@@ -1,19 +1,19 @@
-#ifndef SHARED_EDITABLE_EXPRESSION_VIEW_DELEGATE_APP_H
-#define SHARED_EDITABLE_EXPRESSION_VIEW_DELEGATE_APP_H
+#ifndef SHARED_EXPRESSION_FIELD_DELEGATE_APP_H
+#define SHARED_EXPRESSION_FIELD_DELEGATE_APP_H
 
 #include "text_field_delegate_app.h"
 #include <escher/expression_layout_field_delegate.h>
 
 namespace Shared {
 
-class EditableExpressionViewDelegateApp : public TextFieldDelegateApp, public ExpressionLayoutFieldDelegate {
+class ExpressionFieldDelegateApp : public TextFieldDelegateApp, public ExpressionLayoutFieldDelegate {
 public:
-  virtual ~EditableExpressionViewDelegateApp() = default;
+  virtual ~ExpressionFieldDelegateApp() = default;
   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);
+  ExpressionFieldDelegateApp(Container * container, Snapshot * snapshot, ViewController * rootViewController);
 };
 
 }

apps/shared/expression_layout_field_delegate.cpp

@@ -5,27 +5,27 @@ using namespace Poincare;
 namespace Shared {
 
 bool ExpressionLayoutFieldDelegate::expressionLayoutFieldShouldFinishEditing(ExpressionLayoutField * expressionLayoutField, Ion::Events::Event event) {
-  return editableExpressionViewDelegateApp()->expressionLayoutFieldShouldFinishEditing(expressionLayoutField, event);
+  return expressionFieldDelegateApp()->expressionLayoutFieldShouldFinishEditing(expressionLayoutField, event);
 }
 
 bool ExpressionLayoutFieldDelegate::expressionLayoutFieldDidReceiveEvent(ExpressionLayoutField * expressionLayoutField, Ion::Events::Event event) {
-  return editableExpressionViewDelegateApp()->expressionLayoutFieldDidReceiveEvent(expressionLayoutField, event);
+  return expressionFieldDelegateApp()->expressionLayoutFieldDidReceiveEvent(expressionLayoutField, event);
 }
 
 bool ExpressionLayoutFieldDelegate::expressionLayoutFieldDidFinishEditing(ExpressionLayoutField * expressionLayoutField, const char * text, Ion::Events::Event event) {
-  return editableExpressionViewDelegateApp()->expressionLayoutFieldDidFinishEditing(expressionLayoutField, text, event);
+  return expressionFieldDelegateApp()->expressionLayoutFieldDidFinishEditing(expressionLayoutField, text, event);
 }
 
 bool ExpressionLayoutFieldDelegate::expressionLayoutFieldDidAbortEditing(ExpressionLayoutField * expressionLayoutField) {
-  return editableExpressionViewDelegateApp()->expressionLayoutFieldDidAbortEditing(expressionLayoutField);
+  return expressionFieldDelegateApp()->expressionLayoutFieldDidAbortEditing(expressionLayoutField);
 }
 
 void ExpressionLayoutFieldDelegate::expressionLayoutFieldDidChangeSize(ExpressionLayoutField * expressionLayoutField) {
-  return editableExpressionViewDelegateApp()->expressionLayoutFieldDidChangeSize(expressionLayoutField);
+  return expressionFieldDelegateApp()->expressionLayoutFieldDidChangeSize(expressionLayoutField);
 }
 
 Toolbox * ExpressionLayoutFieldDelegate::toolboxForExpressionLayoutField(ExpressionLayoutField * expressionLayoutField) {
-  return editableExpressionViewDelegateApp()->toolboxForExpressionLayoutField(expressionLayoutField);
+  return expressionFieldDelegateApp()->toolboxForExpressionLayoutField(expressionLayoutField);
 }
 
 }

apps/shared/expression_layout_field_delegate.h

@@ -2,7 +2,7 @@
 #define SHARED_EXPRESSION_LAYOUT_FIELD_DELEGATE_H
 
 #include <escher/expression_layout_field_delegate.h>
-#include "editable_expression_view_delegate_app.h"
+#include "expression_field_delegate_app.h"
 
 namespace Shared {
 
@@ -15,7 +15,7 @@ public:
   void expressionLayoutFieldDidChangeSize(ExpressionLayoutField * expressionLayoutField) override;
   Toolbox * toolboxForExpressionLayoutField(ExpressionLayoutField * expressionLayoutField) override;
 private:
-  virtual EditableExpressionViewDelegateApp * editableExpressionViewDelegateApp() = 0;
+  virtual ExpressionFieldDelegateApp * expressionFieldDelegateApp() = 0;
 };
 
 }

apps/shared/function_app.cpp

@@ -53,7 +53,7 @@ void FunctionApp::Snapshot::reset() {
 }
 
 FunctionApp::FunctionApp(Container * container, Snapshot * snapshot, ViewController * rootViewController) :
-  EditableExpressionViewDelegateApp(container, snapshot, rootViewController)
+  ExpressionFieldDelegateApp(container, snapshot, rootViewController)
 {
 }
 

apps/shared/function_app.h

@@ -2,7 +2,7 @@
 #define SHARED_FUNCTION_APP_H
 
 #include <poincare.h>
-#include "editable_expression_view_delegate_app.h"
+#include "expression_field_delegate_app.h"
 #include "curve_view_cursor.h"
 #include "interval.h"
 
@@ -10,7 +10,7 @@ class AppsContainer;
 
 namespace Shared {
 
-class FunctionApp : public EditableExpressionViewDelegateApp {
+class FunctionApp : public ExpressionFieldDelegateApp {
 public:
   class Snapshot : public ::App::Snapshot, public TabViewDataSource {
   public:

escher/Makefile

@@ -12,7 +12,7 @@ objs += $(addprefix escher/src/,\
   dynamic_view_controller.o\
   editable_text_cell.o\
   ellipsis_view.o\
-  editable_expression_view.o\
+  expression_field.o\
   even_odd_cell.o\
   even_odd_cell_with_ellipsis.o\
   even_odd_buffer_text_cell.o\

escher/include/escher.h

@@ -11,7 +11,7 @@
 #include <escher/clipboard.h>
 #include <escher/container.h>
 #include <escher/dynamic_view_controller.h>
-#include <escher/editable_expression_view.h>
+#include <escher/expression_field.h>
 #include <escher/editable_text_cell.h>
 #include <escher/ellipsis_view.h>
 #include <escher/even_odd_cell.h>

escher/include/escher/expression_field.h

@@ -1,14 +1,14 @@
-#ifndef ESCHER_EDITABLE_EXPRESSION_VIEW_H
-#define ESCHER_EDITABLE_EXPRESSION_VIEW_H
+#ifndef ESCHER_EXPRESSION_FIELD_H
+#define ESCHER_EXPRESSION_FIELD_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 {
+class ExpressionField :  public Responder, public View {
 public:
-  EditableExpressionView(Responder * parentResponder, TextFieldDelegate * textFieldDelegate, ExpressionLayoutFieldDelegate * expressionLayoutFieldDelegate);
+  ExpressionField(Responder * parentResponder, TextFieldDelegate * textFieldDelegate, ExpressionLayoutFieldDelegate * expressionLayoutFieldDelegate);
 
   void setEditing(bool isEditing, bool reinitDraftBuffer = true);
   bool isEditing() const;

escher/include/escher/input_view_controller.h

@@ -1,7 +1,7 @@
 #ifndef ESCHER_INPUT_VIEW_CONTROLLER_H
 #define ESCHER_INPUT_VIEW_CONTROLLER_H
 
-#include <escher/editable_expression_view.h>
+#include <escher/expression_field.h>
 #include <escher/expression_layout_field_delegate.h>
 #include <escher/modal_view_controller.h>
 #include <escher/invocation.h>
@@ -34,18 +34,18 @@ public:
   Toolbox * toolboxForExpressionLayoutField(ExpressionLayoutField * expressionLayoutField) override;
 
 private:
-  class EditableExpressionViewController : public ViewController {
+  class ExpressionFieldController : public ViewController {
   public:
-    EditableExpressionViewController(Responder * parentResponder, TextFieldDelegate * textFieldDelegate, ExpressionLayoutFieldDelegate * expressionLayoutFieldDelegate);
+    ExpressionFieldController(Responder * parentResponder, TextFieldDelegate * textFieldDelegate, ExpressionLayoutFieldDelegate * expressionLayoutFieldDelegate);
     void didBecomeFirstResponder() override;
-    View * view() override { return &m_editableExpressionView; }
-    EditableExpressionView * editableExpressionView() { return &m_editableExpressionView; }
+    View * view() override { return &m_expressionField; }
+    ExpressionField * expressionField() { return &m_expressionField; }
   private:
-    EditableExpressionView m_editableExpressionView;
+    ExpressionField m_expressionField;
   };
   bool inputViewDidFinishEditing();
   bool inputViewDidAbortEditing();
-  EditableExpressionViewController m_editableExpressionViewController;
+  ExpressionFieldController m_expressionFieldController;
   Invocation m_successAction;
   Invocation m_failureAction;
   TextFieldDelegate * m_textFieldDelegate;

escher/src/expression_field.cpp

@@ -1,8 +1,8 @@
-#include <escher/editable_expression_view.h>
+#include <escher/expression_field.h>
 #include <poincare/preferences.h>
 #include <assert.h>
 
-EditableExpressionView::EditableExpressionView(Responder * parentResponder, TextFieldDelegate * textFieldDelegate, ExpressionLayoutFieldDelegate * expressionLayoutFieldDelegate) :
+ExpressionField::ExpressionField(Responder * parentResponder, TextFieldDelegate * textFieldDelegate, ExpressionLayoutFieldDelegate * expressionLayoutFieldDelegate) :
   Responder(parentResponder),
   View(),
   m_textField(parentResponder, m_textBody, m_textBody, k_bufferLength, textFieldDelegate, false),
@@ -11,7 +11,7 @@ EditableExpressionView::EditableExpressionView(Responder * parentResponder, Text
   m_textBody[0] = 0;
 }
 
-void EditableExpressionView::setEditing(bool isEditing, bool reinitDraftBuffer) {
+void ExpressionField::setEditing(bool isEditing, bool reinitDraftBuffer) {
   if (editionIsInTextField()) {
     m_textField.setEditing(isEditing, reinitDraftBuffer);
   } else {
@@ -22,18 +22,18 @@ void EditableExpressionView::setEditing(bool isEditing, bool reinitDraftBuffer)
   }
 }
 
-bool EditableExpressionView::isEditing() const {
+bool ExpressionField::isEditing() const {
   return editionIsInTextField() ? m_textField.isEditing() : m_expressionLayoutField.isEditing();
 }
 
-const char * EditableExpressionView::text() {
+const char * ExpressionField::text() {
   if (!editionIsInTextField()) {
     m_expressionLayoutField.expressionViewWithCursor()->expressionView()->expressionLayout()->writeTextInBuffer(m_textBody, k_bufferLength);
   }
   return m_textBody;
 }
 
-void EditableExpressionView::setText(const char * text) {
+void ExpressionField::setText(const char * text) {
   if (editionIsInTextField()) {
     m_textField.setText(text);
     return;
@@ -44,7 +44,7 @@ void EditableExpressionView::setText(const char * text) {
   }
 }
 
-void EditableExpressionView::insertText(const char * text) {
+void ExpressionField::insertText(const char * text) {
   if (editionIsInTextField()) {
     m_textField.handleEventWithText(text);
   } else {
@@ -53,7 +53,7 @@ void EditableExpressionView::insertText(const char * text) {
   }
 }
 
-View * EditableExpressionView::subviewAtIndex(int index) {
+View * ExpressionField::subviewAtIndex(int index) {
   assert(index == 0);
   if (editionIsInTextField()) {
     return &m_textField;
@@ -61,7 +61,7 @@ View * EditableExpressionView::subviewAtIndex(int index) {
   return &m_expressionLayoutField;
 }
 
-void EditableExpressionView::layoutSubviews() {
+void ExpressionField::layoutSubviews() {
   KDRect inputViewFrame(k_leftMargin, k_separatorThickness, bounds().width() - k_leftMargin, bounds().height() - k_separatorThickness);
   if (editionIsInTextField()) {
     m_textField.setFrame(inputViewFrame);
@@ -72,12 +72,12 @@ void EditableExpressionView::layoutSubviews() {
   m_textField.setFrame(KDRectZero);
 }
 
-void EditableExpressionView::reload() {
+void ExpressionField::reload() {
   layoutSubviews();
   markRectAsDirty(bounds());
 }
 
-void EditableExpressionView::drawRect(KDContext * ctx, KDRect rect) const {
+void ExpressionField::drawRect(KDContext * ctx, KDRect rect) const {
   // Draw the separator
   ctx->fillRect(KDRect(0, 0, bounds().width(), k_separatorThickness), Palette::GreyMiddle);
   // Color the left margin
@@ -88,19 +88,19 @@ void EditableExpressionView::drawRect(KDContext * ctx, KDRect rect) const {
   }
 }
 
-bool EditableExpressionView::handleEvent(Ion::Events::Event event) {
+bool ExpressionField::handleEvent(Ion::Events::Event event) {
   return editionIsInTextField() ? m_textField.handleEvent(event) : m_expressionLayoutField.handleEvent(event);
 }
 
-KDSize EditableExpressionView::minimalSizeForOptimalDisplay() const {
+KDSize ExpressionField::minimalSizeForOptimalDisplay() const {
   return KDSize(0, inputViewHeight());
 }
 
-bool EditableExpressionView::editionIsInTextField() const {
+bool ExpressionField::editionIsInTextField() const {
   return Poincare::Preferences::sharedPreferences()->editionMode() == Poincare::Preferences::EditionMode::Edition1D;
 }
 
-bool EditableExpressionView::isEmpty() const {
+bool ExpressionField::isEmpty() const {
   if (editionIsInTextField()) {
     return m_textField.draftTextLength() == 0;
   }
@@ -108,11 +108,11 @@ bool EditableExpressionView::isEmpty() const {
   return !layout->hasText();
 }
 
-bool EditableExpressionView::heightIsMaximal() const {
+bool ExpressionField::heightIsMaximal() const {
   return inputViewHeight() == k_separatorThickness + k_verticalExpressionViewMargin + maximalHeight();
 }
 
-KDCoordinate EditableExpressionView::inputViewHeight() const {
+KDCoordinate ExpressionField::inputViewHeight() const {
   if (editionIsInTextField()) {
     return k_separatorThickness + k_textFieldHeight;
   }
@@ -124,6 +124,6 @@ KDCoordinate EditableExpressionView::inputViewHeight() const {
           + k_verticalExpressionViewMargin));
 }
 
-KDCoordinate EditableExpressionView::maximalHeight() const {
+KDCoordinate ExpressionField::maximalHeight() const {
   return 0.6*Ion::Display::Height;
 }

escher/src/input_view_controller.cpp

@@ -4,19 +4,19 @@
 #include <poincare/src/layout/horizontal_layout.h>
 #include <assert.h>
 
-InputViewController::EditableExpressionViewController::EditableExpressionViewController(Responder * parentResponder, TextFieldDelegate * textFieldDelegate, ExpressionLayoutFieldDelegate * expressionLayoutFieldDelegate) :
+InputViewController::ExpressionFieldController::ExpressionFieldController(Responder * parentResponder, TextFieldDelegate * textFieldDelegate, ExpressionLayoutFieldDelegate * expressionLayoutFieldDelegate) :
   ViewController(parentResponder),
-  m_editableExpressionView(this, textFieldDelegate, expressionLayoutFieldDelegate)
+  m_expressionField(this, textFieldDelegate, expressionLayoutFieldDelegate)
 {
 }
 
-void InputViewController::EditableExpressionViewController::didBecomeFirstResponder() {
-  app()->setFirstResponder(&m_editableExpressionView);
+void InputViewController::ExpressionFieldController::didBecomeFirstResponder() {
+  app()->setFirstResponder(&m_expressionField);
 }
 
 InputViewController::InputViewController(Responder * parentResponder, ViewController * child, TextFieldDelegate * textFieldDelegate, ExpressionLayoutFieldDelegate * expressionLayoutFieldDelegate) :
   ModalViewController(parentResponder, child),
-  m_editableExpressionViewController(this, this, this),
+  m_expressionFieldController(this, this, this),
   m_successAction(Invocation(nullptr, nullptr)),
   m_failureAction(Invocation(nullptr, nullptr)),
   m_textFieldDelegate(textFieldDelegate),
@@ -26,21 +26,21 @@ InputViewController::InputViewController(Responder * parentResponder, ViewContro
 }
 
 const char * InputViewController::textBody() {
-  return m_editableExpressionViewController.editableExpressionView()->text();
+  return m_expressionFieldController.expressionField()->text();
 }
 
 void InputViewController::edit(Responder * caller, Ion::Events::Event event, void * context, const char * initialText, Invocation::Action successAction, Invocation::Action failureAction) {
   m_successAction = Invocation(successAction, context);
   m_failureAction = Invocation(failureAction, context);
-  displayModalViewController(&m_editableExpressionViewController, 1.0f, 1.0f);
+  displayModalViewController(&m_expressionFieldController, 1.0f, 1.0f);
   if (initialText != nullptr) {
-    m_editableExpressionViewController.editableExpressionView()->setText(initialText);
+    m_expressionFieldController.expressionField()->setText(initialText);
   }
-  m_editableExpressionViewController.editableExpressionView()->handleEvent(event);
+  m_expressionFieldController.expressionField()->handleEvent(event);
 }
 
 void InputViewController::abortEditionAndDismiss() {
-  m_editableExpressionViewController.editableExpressionView()->setEditing(false);
+  m_expressionFieldController.expressionField()->setEditing(false);
   dismissModalViewController();
 }
 
@@ -81,9 +81,9 @@ bool InputViewController::expressionLayoutFieldDidAbortEditing(ExpressionLayoutF
 }
 
 void InputViewController::expressionLayoutFieldDidChangeSize(ExpressionLayoutField * expressionLayoutField) {
-  // Reload the view only if the EditableExpressionView height actually changes,
+  // Reload the view only if the ExpressionField height actually changes,
   // i.e. not if the height is already maximal and stays maximal.
-  bool newInputViewHeightIsMaximal = m_editableExpressionViewController.editableExpressionView()->heightIsMaximal();
+  bool newInputViewHeightIsMaximal = m_expressionFieldController.expressionField()->heightIsMaximal();
   if (!m_inputViewHeightIsMaximal || !newInputViewHeightIsMaximal) {
     m_inputViewHeightIsMaximal = newInputViewHeightIsMaximal;
     reloadView();