[calculation] WIP: first version of ComplexListController

apps/calculation/Makefile

@@ -7,9 +7,10 @@ app_calculation_test_src += $(addprefix apps/calculation/,\
 )
 
 app_calculation_src = $(addprefix apps/calculation/,\
-  additional_outputs/complex_graph_controller.cpp \
-  additional_outputs/complex_graph_view.cpp \
+  additional_outputs/complex_graph_cell.cpp \
   additional_outputs/complex_model.cpp \
+  additional_outputs/complex_list_controller.cpp \
+  additional_outputs/illustrated_list_controller.cpp \
   additional_outputs/scrollable_input_exact_approximate_expressions_cell.cpp \
   app.cpp \
   edit_expression_controller.cpp \

apps/calculation/additional_outputs/complex_graph_cell.cpp

@@ -1,4 +1,4 @@
-#include "complex_graph_view.h"
+#include "complex_graph_cell.h"
 
 using namespace Shared;
 using namespace Poincare;

apps/calculation/additional_outputs/complex_graph_cell.h

@@ -0,0 +1,32 @@
+#ifndef CALCULATION_ADDITIONAL_OUTPUTS_COMPLEX_GRAPH_CELL_H
+#define CALCULATION_ADDITIONAL_OUTPUTS_COMPLEX_GRAPH_CELL_H
+
+#include "../../shared/curve_view.h"
+#include "complex_model.h"
+
+namespace Calculation {
+
+class ComplexGraphView : public Shared::CurveView {
+public:
+  ComplexGraphView(ComplexModel * complexModel);
+  void drawRect(KDContext * ctx, KDRect rect) const override;
+private:
+  char * label(Axis axis, int index) const override { return nullptr; }
+  ComplexModel * m_complex;
+};
+
+class ComplexGraphCell : public HighlightCell {
+public:
+  ComplexGraphCell(ComplexModel * complexModel) : m_view(complexModel) {}
+  void setHighlighted(bool highlight) override { return; }
+private:
+  int numberOfSubviews() const override { return 1; }
+  View * subviewAtIndex(int index) override { return &m_view; }
+  void layoutSubviews(bool force = false) override { m_view.setFrame(bounds(), force); }
+  ComplexGraphView m_view;
+};
+
+}
+
+#endif
+

apps/calculation/additional_outputs/complex_graph_controller.cpp

@@ -1,15 +0,0 @@
-#include "complex_graph_controller.h"
-
-using namespace Poincare;
-
-namespace Calculation {
-
-ComplexGraphController::ComplexGraphController() :
-  ViewController(nullptr),
-  m_complex(),
-  m_graphView(&m_complex)
-{
-}
-
-}
-

apps/calculation/additional_outputs/complex_graph_controller.h

@@ -1,25 +0,0 @@
-#ifndef CALCULATION_ADDITIONAL_OUTPUTS_COMPLEX_GRAPH_CONTROLLER_H
-#define CALCULATION_ADDITIONAL_OUTPUTS_COMPLEX_GRAPH_CONTROLLER_H
-
-#include "complex_graph_view.h"
-#include "complex_model.h"
-
-namespace Calculation {
-
-class ComplexGraphController : public ViewController {
-public:
-  ComplexGraphController();
-  const char * title() override { return "Emilie"; }
-  View * view() override {
-    return &m_graphView;
-  }
-  ComplexModel * complexModel() { return &m_complex; }
-private:
-  ComplexModel m_complex;
-  ComplexGraphView m_graphView;
-};
-
-}
-
-#endif
-

apps/calculation/additional_outputs/complex_graph_view.h

@@ -1,21 +0,0 @@
-#ifndef CALCULATION_ADDITIONAL_OUTPUTS_COMPLEX_GRAPH_VIEW_H
-#define CALCULATION_ADDITIONAL_OUTPUTS_COMPLEX_GRAPH_VIEW_H
-
-#include "../../shared/curve_view.h"
-#include "complex_model.h"
-
-namespace Calculation {
-
-class ComplexGraphView : public Shared::CurveView {
-public:
-  ComplexGraphView(ComplexModel * complexModel);
-  void drawRect(KDContext * ctx, KDRect rect) const override;
-private:
-  char * label(Axis axis, int index) const override { return nullptr; }
-  ComplexModel * m_complex;
-};
-
-}
-
-#endif
-

apps/calculation/additional_outputs/complex_list_controller.cpp

@@ -0,0 +1,11 @@
+#include "complex_list_controller.h"
+
+namespace Calculation {
+
+void ComplexListController::fillCalculationStoreFromExpression(Poincare::Expression e) {
+  //TODO
+  m_model.setComplex(std::complex<float>(1.2f,2.3f));
+  IllustratedListController::fillCalculationStoreFromExpression(e);
+}
+
+}

apps/calculation/additional_outputs/complex_list_controller.h

@@ -0,0 +1,25 @@
+#ifndef CALCULATION_ADDITIONAL_OUTPUTS_COMPLEX_LIST_CONTROLLER_H
+#define CALCULATION_ADDITIONAL_OUTPUTS_COMPLEX_LIST_CONTROLLER_H
+
+#include "complex_graph_cell.h"
+#include "complex_model.h"
+#include "illustrated_list_controller.h"
+
+namespace Calculation {
+
+class ComplexListController : public IllustratedListController {
+public:
+  ComplexListController() :
+    IllustratedListController(nullptr),
+    m_complexGraphCell(&m_model) {}
+  void fillCalculationStoreFromExpression(Poincare::Expression e) override;
+private:
+  HighlightCell * illustrationCell() override { return &m_complexGraphCell; }
+  ComplexGraphCell m_complexGraphCell;
+  ComplexModel m_model;
+};
+
+}
+
+#endif
+

apps/calculation/additional_outputs/illustrated_list_controller.cpp

@@ -0,0 +1,99 @@
+#include "illustrated_list_controller.h"
+#include "../app.h"
+
+using namespace Poincare;
+
+namespace Calculation {
+
+/* List Controller */
+
+IllustratedListController::ListController::ListController(IllustratedListController * dataSource) :
+  ViewController(dataSource),
+  m_selectableTableView(this, dataSource, dataSource)
+{
+  m_selectableTableView.setMargins(0);
+  m_selectableTableView.setDecoratorType(ScrollView::Decorator::Type::None);
+}
+
+void IllustratedListController::ListController::didBecomeFirstResponder() {
+  m_selectableTableView.reloadData();
+  m_selectableTableView.selectCellAtLocation(0, 1);
+  Container::activeApp()->setFirstResponder(&m_selectableTableView);
+}
+
+/* Illustrated list controller */
+
+IllustratedListController::IllustratedListController(Responder * parentResponder) :
+  StackViewController(parentResponder, &m_listController, KDColorWhite, Palette::PurpleBright, Palette::PurpleDark),
+  m_listController(this),
+  m_additionalCalculationCells{}
+{
+  for (int i = 0; i < k_maxNumberOfAdditionalCalculations; i++) {
+    m_additionalCalculationCells[i].setParentResponder(m_listController.selectableTableView());
+  }
+}
+
+bool IllustratedListController::handleEvent(Ion::Events::Event event) {
+  return false;
+}
+
+void IllustratedListController::didBecomeFirstResponder() {
+  Container::activeApp()->setFirstResponder(&m_listController);
+}
+
+int IllustratedListController::numberOfRows() const {
+  return k_maxNumberOfAdditionalCalculations + 1;
+}
+
+int IllustratedListController::reusableCellCount(int type) {
+  assert(type < 2);
+  if (type == 0) {
+    return 1;
+  }
+  return k_maxNumberOfAdditionalCalculations;
+}
+
+HighlightCell * IllustratedListController::reusableCell(int index, int type) {
+  assert(type < 2);
+  assert(index >= 0);
+  if (type == 0) {
+    return illustrationCell();
+  }
+  return &m_additionalCalculationCells[index];
+}
+
+KDCoordinate IllustratedListController::rowHeight(int j) {
+  if (j == 0) {
+    return k_illustrationHeight;
+  }
+  int calculationIndex = j-1;
+  if (calculationIndex >= m_calculationStore.numberOfCalculations()) {
+    return 0;
+  }
+  Shared::ExpiringPointer<Calculation> calculation = m_calculationStore.calculationAtIndex(calculationIndex);
+  return calculation->height(App::app()->localContext(), j == selectedRow()) + 4 * Metric::CommonSmallMargin;
+}
+
+int IllustratedListController::typeAtLocation(int i, int j) {
+  return j == 0 ? 0 : 1;
+}
+
+void IllustratedListController::willDisplayCellForIndex(HighlightCell * cell, int index) {
+  if (index == 0) {
+    // TODO ?
+    return;
+  }
+  ScrollableInputExactApproximateExpressionsCell * myCell = (ScrollableInputExactApproximateExpressionsCell *)cell;
+  myCell->setCalculation(m_calculationStore.calculationAtIndex(index-1).pointer());
+  //myCell->setHighlighted(myCell->isHighlighted()); //TODO??
+}
+
+void IllustratedListController::fillCalculationStoreFromExpression(Expression e) {
+  // TODO
+  Poincare::Context * context = App::app()->localContext();
+  m_calculationStore.push("1+root(2,3)", context);
+  m_calculationStore.push("2+root(2,3)", context);
+  m_calculationStore.push("3+root(2,3)", context);
+}
+
+}

apps/calculation/additional_outputs/illustrated_list_controller.h

@@ -0,0 +1,53 @@
+#ifndef CALCULATION_ADDITIONAL_OUTPUTS_ILLUSTRATED_LIST_CONTROLLER_H
+#define CALCULATION_ADDITIONAL_OUTPUTS_ILLUSTRATED_LIST_CONTROLLER_H
+
+#include <escher.h>
+#include "scrollable_input_exact_approximate_expressions_cell.h"
+#include "../calculation_store.h"
+#include <apps/i18n.h>
+
+namespace Calculation {
+
+class IllustratedListController : public StackViewController, public ListViewDataSource, public SelectableTableViewDataSource {
+public:
+  IllustratedListController(Responder * parentResponder);
+
+  // Responder
+  bool handleEvent(Ion::Events::Event event) override;
+  void didBecomeFirstResponder() override;
+
+  //ListViewDataSource
+  int numberOfRows() const override;
+  int reusableCellCount(int type) override;
+  HighlightCell * reusableCell(int index, int type) override;
+  KDCoordinate rowHeight(int j) override;
+  int typeAtLocation(int i, int j) override;
+  void willDisplayCellForIndex(HighlightCell * cell, int index) override;
+
+  // IllustratedListController
+  virtual void fillCalculationStoreFromExpression(Poincare::Expression e);
+
+private:
+  class ListController : public ViewController {
+  public:
+    ListController(IllustratedListController * dataSource);
+    const char * title() override { return I18n::translate(I18n::Message::AdditionalResults); }
+    View * view() override { return &m_selectableTableView; }
+    void didBecomeFirstResponder() override;
+    SelectableTableView * selectableTableView() { return &m_selectableTableView; }
+  private:
+    SelectableTableView m_selectableTableView;
+  };
+  constexpr static int k_maxNumberOfAdditionalCalculations = 3;
+  constexpr static KDCoordinate k_illustrationHeight = 50;
+  ListController m_listController;
+  // Cells
+  virtual HighlightCell * illustrationCell() = 0;
+  ScrollableInputExactApproximateExpressionsCell m_additionalCalculationCells[k_maxNumberOfAdditionalCalculations];
+  CalculationStore m_calculationStore;
+};
+
+}
+
+#endif
+

apps/calculation/additional_outputs/scrollable_input_exact_approximate_expressions_cell.h

@@ -9,11 +9,12 @@ namespace Calculation {
 
 class ScrollableInputExactApproximateExpressionsView : public Shared::AbstractScrollableExactApproximateExpressionsView {
 public:
-  ScrollableInputExactApproximateExpressionsView(Responder * parentResponder) : Shared::AbstractScrollableExactApproximateExpressionsView(parentResponder, &m_contentCell) {}
+  ScrollableInputExactApproximateExpressionsView(Responder * parentResponder) : Shared::AbstractScrollableExactApproximateExpressionsView(parentResponder, &m_contentCell), m_contentCell() {}
   void setCalculation(Calculation * calculation);
 private:
   class ContentCell : public Shared::AbstractScrollableExactApproximateExpressionsView::ContentCell {
   public:
+    ContentCell() : m_leftExpressionView() {}
     Poincare::Layout layout() const override;
     KDColor backgroundColor() const override { return KDColorWhite; }
     void setEven(bool even) override { return; }
@@ -31,6 +32,18 @@ private:
   ContentCell m_contentCell;
 };
 
+class ScrollableInputExactApproximateExpressionsCell : public HighlightCell {
+public:
+  ScrollableInputExactApproximateExpressionsCell() : m_view(nullptr) {}
+  void setParentResponder(Responder * r) { m_view.setParentResponder(r); }
+  void setCalculation(Calculation * calculation) { m_view.setCalculation(calculation); }
+private:
+  int numberOfSubviews() const override { return 1; }
+  View * subviewAtIndex(int index) override { return &m_view; }
+  void layoutSubviews(bool force = false) override { m_view.setFrame(bounds(), force); }
+  ScrollableInputExactApproximateExpressionsView m_view;
+};
+
 }
 
 #endif

apps/calculation/base.de.i18n

@@ -1,2 +1,3 @@
 CalculApp = "Berechnung"
 CalculAppCapital = "BERECHNUNG"
+AdditionalResults = "????"

apps/calculation/base.en.i18n

@@ -1,2 +1,3 @@
 CalculApp = "Calculation"
 CalculAppCapital = "CALCULATION"
+AdditionalResults = "Additional results"

apps/calculation/base.es.i18n

@@ -1,2 +1,3 @@
 CalculApp = "Cálculo"
 CalculAppCapital = "CÁLCULO"
+AdditionalResults = "????"

apps/calculation/base.fr.i18n

@@ -1,2 +1,3 @@
 CalculApp = "Calculs"
 CalculAppCapital = "CALCULS"
+AdditionalResults = "Résultats complémentaires"

apps/calculation/base.pt.i18n

@@ -1,2 +1,3 @@
 CalculApp = "Cálculo"
 CalculAppCapital = "CÁLCULO"
+AdditionalResults = "????"

apps/calculation/history_controller.cpp

@@ -74,7 +74,7 @@ bool HistoryController::handleEvent(Ion::Events::Event event) {
          * Controller * c = additionalInformationType ? graphController : listController?
          * m_controller->setType(additionalInformationType)*/
         if (additionalInfoType == Expression::AdditionalInformationType::Complex) {
-          m_complexController.complexModel()->setComplex(std::complex<float>(1.2f,2.0f));
+           m_complexController.fillCalculationStoreFromExpression(calculation->exactOutput());
           Container::activeApp()->displayModalViewController(&m_complexController, 0.f, 0.f, Metric::PopUpTopMargin, Metric::PopUpLeftMargin, Metric::PopUpTopMargin, Metric::PopUpRightMargin);
         }
       } else {

apps/calculation/history_controller.h

@@ -5,7 +5,7 @@
 #include "history_view_cell.h"
 #include "calculation_store.h"
 #include "selectable_table_view.h"
-#include "additional_outputs/complex_graph_controller.h"
+#include "additional_outputs/complex_list_controller.h"
 
 namespace Calculation {
 
@@ -37,7 +37,7 @@ private:
   CalculationSelectableTableView m_selectableTableView;
   HistoryViewCell m_calculationHistory[k_maxNumberOfDisplayedRows];
   CalculationStore * m_calculationStore;
-  ComplexGraphController m_complexController;
+  ComplexListController m_complexController;
 };
 
 }