diff --git a/apps/calculation/app.cpp b/apps/calculation/app.cpp
index fd6a2ec45..faaf11a74 100644
--- a/apps/calculation/app.cpp
+++ b/apps/calculation/app.cpp
@@ -48,46 +48,24 @@ App::App(Container * container, Snapshot * snapshot) :
 }
 
 bool App::textFieldDidReceiveEvent(::TextField * textField, Ion::Events::Event event) {
-  if (event == Ion::Events::XNT && TextFieldDelegateApp::textFieldDidReceiveEvent(textField, event)) {
+  if (textField->isEditing() && textField->shouldFinishEditing(event) && textField->text()[0] == 0) {
     return true;
   }
-  if (textField->isEditing() && textField->shouldFinishEditing(event)) {
-    if (textField->text()[0] == 0) {
-      return true;
-    }
-    if (!textInputIsCorrect(textField->text())) {
-      displayWarning(I18n::Message::SyntaxError);
-      return true;
-    }
-  }
-  return false;
+  return Shared::ExpressionFieldDelegateApp::textFieldDidReceiveEvent(textField, event);
 }
 
 bool App::layoutFieldDidReceiveEvent(::LayoutField * layoutField, Ion::Events::Event event) {
-  if (event == Ion::Events::XNT && ExpressionFieldDelegateApp::layoutFieldDidReceiveEvent(layoutField, event)) {
+  if (layoutField->isEditing() && layoutField->shouldFinishEditing(event) && !layoutField->hasText()) {
     return true;
   }
-  if (layoutField->isEditing() && layoutField->shouldFinishEditing(event)) {
-    if (!layoutField->hasText()) {
-      return true;
-    }
-
-    char bufferForParsing[Calculation::k_printedExpressionSize];
-    layoutField->serialize(bufferForParsing, Calculation::k_printedExpressionSize);
-
-    if (!textInputIsCorrect(bufferForParsing)) {
-      displayWarning(I18n::Message::SyntaxError);
-      return true;
-    }
-  }
-  return false;
+  return Shared::ExpressionFieldDelegateApp::layoutFieldDidReceiveEvent(layoutField, event);
 }
 
-bool App::textInputIsCorrect(const char * text) {
+bool App::isAcceptableExpression(const Poincare::Expression expression, Responder * responder) {
   /* 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. */
-  Expression exp = Expression::parse(text);
+  Expression exp = expression;
   if (exp.isUninitialized()) {
     return false;
   }
diff --git a/apps/calculation/app.h b/apps/calculation/app.h
index fd64648f5..120b56585 100644
--- a/apps/calculation/app.h
+++ b/apps/calculation/app.h
@@ -28,8 +28,9 @@ public:
     CalculationStore m_calculationStore;
   };
   bool textFieldDidReceiveEvent(::TextField * textField, Ion::Events::Event event) override;
-  bool textInputIsCorrect(const char * text);
   bool layoutFieldDidReceiveEvent(::LayoutField * layoutField, Ion::Events::Event event) override;
+  // TextFieldDelegateApp
+  bool isAcceptableExpression(const Poincare::Expression expression, Responder * responder) override;
   char XNT() override;
 private:
   App(Container * container, Snapshot * snapshot);
diff --git a/apps/calculation/edit_expression_controller.cpp b/apps/calculation/edit_expression_controller.cpp
index 645bca6d8..e8db9d3f9 100644
--- a/apps/calculation/edit_expression_controller.cpp
+++ b/apps/calculation/edit_expression_controller.cpp
@@ -130,7 +130,7 @@ bool EditExpressionController::inputViewDidReceiveEvent(Ion::Events::Event event
     App * calculationApp = (App *)app();
     /* The input text store in m_cacheBuffer might have beed correct the first
      * time but then be too long when replacing ans in another context */
-    if (!calculationApp->textInputIsCorrect(m_cacheBuffer)) {
+    if (!calculationApp->isAcceptableText(m_cacheBuffer, calculationApp)) {
       return true;
     }
     m_calculationStore->push(m_cacheBuffer, calculationApp->localContext());
diff --git a/apps/shared/expression_field_delegate_app.cpp b/apps/shared/expression_field_delegate_app.cpp
index d9d952c2b..a9888b05e 100644
--- a/apps/shared/expression_field_delegate_app.cpp
+++ b/apps/shared/expression_field_delegate_app.cpp
@@ -33,6 +33,7 @@ bool ExpressionFieldDelegateApp::layoutFieldDidReceiveEvent(LayoutField * layout
       return true;
     }
     if (!isAcceptableText(buffer, layoutField)) {
+      displayWarning(I18n::Message::SyntaxError);
       return true;
     }
   }
diff --git a/apps/shared/text_field_delegate_app.cpp b/apps/shared/text_field_delegate_app.cpp
index 7a2ba0a74..f2391b453 100644
--- a/apps/shared/text_field_delegate_app.cpp
+++ b/apps/shared/text_field_delegate_app.cpp
@@ -7,12 +7,6 @@ using namespace Poincare;
 
 namespace Shared {
 
-TextFieldDelegateApp::TextFieldDelegateApp(Container * container, Snapshot * snapshot, ViewController * rootViewController) :
-  InputEventHandlerDelegateApp(container, snapshot, rootViewController),
-  TextFieldDelegate()
-{
-}
-
 Context * TextFieldDelegateApp::localContext() {
   return container()->globalContext();
 }
@@ -37,8 +31,20 @@ bool TextFieldDelegateApp::textFieldDidReceiveEvent(TextField * textField, Ion::
   return false;
 }
 
+
+bool TextFieldDelegateApp::isAcceptableText(const char * text, Responder * responder) {
+  Expression exp = Expression::parse(text);
+  return isAcceptableExpression(exp, responder);
+}
+
 /* Protected */
 
+TextFieldDelegateApp::TextFieldDelegateApp(Container * container, Snapshot * snapshot, ViewController * rootViewController) :
+  InputEventHandlerDelegateApp(container, snapshot, rootViewController),
+  TextFieldDelegate()
+{
+}
+
 bool TextFieldDelegateApp::fieldDidReceiveEvent(EditableField * field, Responder * responder, Ion::Events::Event event) {
   if (event == Ion::Events::XNT) {
     if (!field->isEditing()) {
@@ -54,19 +60,18 @@ bool TextFieldDelegateApp::isFinishingEvent(Ion::Events::Event event) {
   return event == Ion::Events::OK || event == Ion::Events::EXE;
 }
 
-bool TextFieldDelegateApp::isAcceptableText(const char * text, Responder * responder) {
-  Expression exp = Expression::parse(text);
-  return isAcceptableExpression(exp, responder);
-}
-
 bool TextFieldDelegateApp::isAcceptableExpression(const Expression exp, Responder * responder) {
   if (exp.isUninitialized()) {
-    responder->app()->displayWarning(I18n::Message::SyntaxError);
+    if (responder != nullptr) {
+      responder->app()->displayWarning(I18n::Message::SyntaxError);
+    }
     return false;
   }
   if (exp.type() == ExpressionNode::Type::Store) {
     // Most textfields do not allow Store "3->a" or "5->f(x)"
-    responder->app()->displayWarning(I18n::Message::StoreExpressionNotAllowed);
+    if (responder != nullptr) {
+      responder->app()->displayWarning(I18n::Message::StoreExpressionNotAllowed);
+    }
     return false;
   }
   return true;
diff --git a/apps/shared/text_field_delegate_app.h b/apps/shared/text_field_delegate_app.h
index a25f48fec..6910d8dca 100644
--- a/apps/shared/text_field_delegate_app.h
+++ b/apps/shared/text_field_delegate_app.h
@@ -17,11 +17,11 @@ public:
   virtual char XNT();
   bool textFieldShouldFinishEditing(TextField * textField, Ion::Events::Event event) override;
   virtual bool textFieldDidReceiveEvent(TextField * textField, Ion::Events::Event event) override;
+  bool isAcceptableText(const char * text, Responder * responder);
 protected:
   TextFieldDelegateApp(Container * container, Snapshot * snapshot, ViewController * rootViewController);
   bool fieldDidReceiveEvent(EditableField * field, Responder * responder, Ion::Events::Event event);
   bool isFinishingEvent(Ion::Events::Event event);
-  bool isAcceptableText(const char * text, Responder * responder);
   virtual bool isAcceptableExpression(const Poincare::Expression expression, Responder * responder);
 };