[Apps/Shared] Fixed interval and curve view exit

apps/shared/interactive_curve_view_controller.cpp

@@ -15,8 +15,10 @@ InteractiveCurveViewController::InteractiveCurveViewController(Responder * paren
   m_rangeVersion(rangeVersion),
   m_rangeParameterController(this, inputEventHandlerDelegate, interactiveRange),
   m_zoomParameterController(this, interactiveRange, curveView),
+  m_interactiveRange(interactiveRange),
   m_rangeButton(this, I18n::Message::Axis, Invocation([](void * context, void * sender) {
     InteractiveCurveViewController * graphController = (InteractiveCurveViewController *) context;
+    graphController->rangeParameterController()->setRange(graphController->interactiveRange());
     StackViewController * stack = graphController->stackController();
     stack->push(graphController->rangeParameterController());
     return true;
@@ -113,7 +115,7 @@ void InteractiveCurveViewController::didBecomeFirstResponder() {
   }
 }
 
-ViewController * InteractiveCurveViewController::rangeParameterController() {
+RangeParameterController * InteractiveCurveViewController::rangeParameterController() {
   return &m_rangeParameterController;
 }
 

apps/shared/interactive_curve_view_controller.h

@@ -19,7 +19,7 @@ public:
   void didBecomeFirstResponder() override;
   TELEMETRY_ID("Graph");
 
-  ViewController * rangeParameterController();
+  RangeParameterController * rangeParameterController();
   ViewController * zoomParameterController();
   virtual ViewController * initialisationParameterController() = 0;
 
@@ -35,6 +35,7 @@ public:
   void willExitResponderChain(Responder * nextFirstResponder) override;
   bool textFieldDidFinishEditing(TextField * textField, const char * text, Ion::Events::Event event) override;
   bool textFieldDidReceiveEvent(TextField * textField, Ion::Events::Event event) override;
+
 protected:
   Responder * tabController() const;
   virtual StackViewController * stackController() const;
@@ -57,6 +58,8 @@ protected:
   float cursorBottomMarginRatio() override;
 
   OkView m_okView;
+
+  InteractiveCurveViewRange * interactiveRange(){return m_interactiveRange;}
 private:
   /* The value 21 is the actual height of the ButtonRow, that is
    * ButtonRowController::ContentView::k_plainStyleHeight + 1.
@@ -75,6 +78,7 @@ private:
   uint32_t * m_rangeVersion;
   RangeParameterController m_rangeParameterController;
   ZoomParameterController m_zoomParameterController;
+  InteractiveCurveViewRange * m_interactiveRange;
   Button m_rangeButton;
   Button m_zoomButton;
   Button m_defaultInitialisationButton;

apps/shared/interval.cpp

@@ -29,21 +29,6 @@ double Interval::element(int i) {
   return m_intervalBuffer[i];
 }
 
-void Interval::setStart(double f) {
-  m_start = f;
-  m_needCompute = true;
-}
-
-void Interval::setEnd(double f) {
-  m_end = f;
-  m_needCompute = true;
-}
-
-void Interval::setStep(double f) {
-  m_step = f;
-  m_needCompute = true;
-}
-
 void Interval::setElement(int i, double f) {
   assert(i <= numberOfElements() && i < k_maxNumberOfElements);
   computeElements();
@@ -54,16 +39,16 @@ void Interval::setElement(int i, double f) {
 }
 
 void Interval::reset() {
-  m_start = 0.0;
-  m_end = 10.0;
-  m_step = 1.0;
+  m_parameters.setStart(0.0);
+  m_parameters.setEnd(10.0);
+  m_parameters.setStep(1.0);
   m_needCompute = true;
 }
 
 void Interval::clear() {
-  m_start = 1.0;
-  m_end = 0.0;
-  m_step = 1.0;
+  m_parameters.setStart(1.0);
+  m_parameters.setEnd(10.0);
+  m_parameters.setStep(1.0);
   m_needCompute = true;
 }
 
@@ -71,14 +56,14 @@ void Interval::computeElements() {
   if (!m_needCompute) {
     return;
   }
-  if (m_start > m_end) {
+  if (m_parameters.start() > m_parameters.end()) {
     m_numberOfElements = 0;
   } else {
-    m_numberOfElements = m_step > 0 ? 1 + (m_end - m_start)/m_step : k_maxNumberOfElements;
+    m_numberOfElements = m_parameters.step() > 0 ? 1 + (m_parameters.end() - m_parameters.start())/m_parameters.step() : k_maxNumberOfElements;
     m_numberOfElements = m_numberOfElements > k_maxNumberOfElements || m_numberOfElements < 0 ? k_maxNumberOfElements : m_numberOfElements;
   }
   for (int i = 0; i < m_numberOfElements; i += 1) {
-    m_intervalBuffer[i] = m_start + i * m_step;
+    m_intervalBuffer[i] = m_parameters.start() + i * m_parameters.step();
   }
   m_needCompute = false;
 }

apps/shared/interval.h

@@ -10,13 +10,22 @@ public:
   Interval(const Interval&) = delete;
   int numberOfElements();
   void deleteElementAtIndex(int index);
+  class intervalParameters {
+    public:
+      void setStart(double f) { m_start = f; }
+      void setEnd(double f) { m_end = f; }
+      void setStep(double f) {m_step = f; }
+      double start() const { return m_start; }
+      double end() const { return m_end; }
+      double step() const { return m_step; }
+    private:
+      double m_start;
+      double m_end;
+      double m_step;
+  };
   double element(int i);
-  double start() const { return m_start; }
-  double end() const { return m_end; }
-  double step() const { return m_step; }
-  void setStart(double f);
-  void setEnd(double f);
-  void setStep(double f);
+  intervalParameters * parameters() { return &m_parameters; }
+  void setParameters(intervalParameters parameters) { m_parameters = parameters; }
   void setElement(int i, double f);
   void forceRecompute(){ m_needCompute = true;}
   void reset();
@@ -27,14 +36,12 @@ private:
   void computeElements();
   int m_numberOfElements;
   double m_intervalBuffer[k_maxNumberOfElements];
-  double m_start;
-  double m_end;
-  double m_step;
   bool m_needCompute;
+  intervalParameters m_parameters;
 };
 
-typedef void (Interval::*SetterPointer)(double);
-typedef double (Interval::*GetterPointer)() const;
+typedef void (Interval::intervalParameters::*SetterPointer)(double);
+typedef double (Interval::intervalParameters::*GetterPointer)() const;
 
 }
 

apps/shared/interval_parameter_controller.cpp

@@ -2,6 +2,8 @@
 
 namespace Shared {
 
+static Interval::intervalParameters s_tempIntevalParameters;
+
 IntervalParameterController::IntervalParameterController(Responder * parentResponder, InputEventHandlerDelegate * inputEventHandlerDelegate) :
   FloatParameterController<double>(parentResponder),
   m_interval(nullptr),
@@ -16,6 +18,11 @@ IntervalParameterController::IntervalParameterController(Responder * parentRespo
   }
 }
 
+void IntervalParameterController::setInterval(Interval * interval) { 
+  m_interval = interval;
+  s_tempIntevalParameters = *(*interval).parameters();
+}
+
 const char * IntervalParameterController::title() {
   return I18n::translate(m_title);
 }
@@ -42,8 +49,8 @@ void IntervalParameterController::willDisplayCellForIndex(HighlightCell * cell,
 }
 
 double IntervalParameterController::parameterAtIndex(int index) {
-  GetterPointer getters[k_totalNumberOfCell] = {&Interval::start, &Interval::end, &Interval::step};
-  return (m_interval->*getters[index])();
+  GetterPointer getters[k_totalNumberOfCell] = {&Shared::Interval::intervalParameters::start, &Shared::Interval::intervalParameters::end, &Shared::Interval::intervalParameters::step};
+  return (s_tempIntevalParameters.*getters[index])();
 }
 
 bool IntervalParameterController::setParameterAtIndex(int parameterIndex, double f) {
@@ -51,18 +58,18 @@ bool IntervalParameterController::setParameterAtIndex(int parameterIndex, double
     Container::activeApp()->displayWarning(I18n::Message::ForbiddenValue);
     return false;
   }
-  double start = parameterIndex == 0 ? f : m_interval->start();
-  double end = parameterIndex == 1 ? f : m_interval->end();
+  double start = parameterIndex == 0 ? f : s_tempIntevalParameters.start();
+  double end = parameterIndex == 1 ? f : s_tempIntevalParameters.end();
   if (start > end) {
     if (parameterIndex == 1) {
       Container::activeApp()->displayWarning(I18n::Message::ForbiddenValue);
       return false;
     }
     double g = f+1.0;
-    m_interval->setEnd(g);
+    s_tempIntevalParameters.setEnd(g);
   }
-  SetterPointer setters[k_totalNumberOfCell] = {&Interval::setStart, &Interval::setEnd, &Interval::setStep};
-  (m_interval->*setters[parameterIndex])(f);
+  SetterPointer setters[k_totalNumberOfCell] = {&Shared::Interval::intervalParameters::setStart, &Shared::Interval::intervalParameters::setEnd, &Shared::Interval::intervalParameters::setStep};
+  (s_tempIntevalParameters.*setters[parameterIndex])(f);
   return true;
 }
 
@@ -85,6 +92,7 @@ int IntervalParameterController::reusableParameterCellCount(int type) {
 }
 
 void IntervalParameterController::buttonAction() {
+  m_interval->setParameters(s_tempIntevalParameters);
   m_interval->forceRecompute();
   StackViewController * stack = stackController();
   stack->pop();

apps/shared/interval_parameter_controller.h

@@ -12,7 +12,7 @@ class IntervalParameterController : public Shared::FloatParameterController<doub
 public:
   IntervalParameterController(Responder * parentResponder, InputEventHandlerDelegate * inputEventHandlerDelegate);
   Interval * interval() { assert(m_interval); return m_interval; }
-  void setInterval(Interval * interval) { m_interval = interval; }
+  void setInterval(Interval * interval);
   const char * title() override;
   void setTitle(I18n::Message title) { m_title = title; }
   void willDisplayCellForIndex(HighlightCell * cell, int index) override;

apps/shared/range_parameter_controller.cpp

@@ -8,6 +8,7 @@ namespace Shared {
 RangeParameterController::RangeParameterController(Responder * parentResponder, InputEventHandlerDelegate * inputEventHandlerDelegate, InteractiveCurveViewRange * interactiveRange) :
   FloatParameterController<float>(parentResponder),
   m_interactiveRange(interactiveRange),
+  m_tempInteractiveRange(*interactiveRange),
   m_xRangeCells{},
   m_yRangeCells{},
   m_yAutoCell(I18n::Message::YAuto)
@@ -18,7 +19,7 @@ RangeParameterController::RangeParameterController(Responder * parentResponder,
   }
   for (int i = 0; i < k_numberOfConvertibleTextCell; i++) {
     m_yRangeCells[i].setParentResponder(&m_selectableTableView);
-    m_yRangeCells[i].setInteractiveCurveViewRange(m_interactiveRange);
+    m_yRangeCells[i].setInteractiveCurveViewRange(&m_tempInteractiveRange);
     m_yRangeCells[i].textField()->setDelegates(inputEventHandlerDelegate, this);
   }
 }
@@ -50,13 +51,13 @@ void RangeParameterController::willDisplayCellForIndex(HighlightCell * cell, int
   }
   if (index == 2) {
     SwitchView * switchView = (SwitchView *)m_yAutoCell.accessoryView();
-    switchView->setState(m_interactiveRange->yAuto());
+    switchView->setState(m_tempInteractiveRange.yAuto());
     return;
   }
   MessageTableCellWithEditableText * myCell = (MessageTableCellWithEditableText *)cell;
   I18n::Message labels[k_numberOfTextCell+1] = {I18n::Message::XMin, I18n::Message::XMax, I18n::Message::Default, I18n::Message::YMin, I18n::Message::YMax};
   myCell->setMessage(labels[index]);
-  KDColor yColor = m_interactiveRange->yAuto() ? Palette::GreyDark : KDColorBlack;
+  KDColor yColor = m_tempInteractiveRange.yAuto() ? Palette::GreyDark : KDColorBlack;
   KDColor colors[k_numberOfTextCell+1] = {KDColorBlack, KDColorBlack, KDColorBlack, yColor, yColor};
   myCell->setTextColor(colors[index]);
   FloatParameterController::willDisplayCellForIndex(cell, index);
@@ -70,9 +71,14 @@ bool RangeParameterController::textFieldDidFinishEditing(TextField * textField,
   return false;
 }
 
+void RangeParameterController::setRange(InteractiveCurveViewRange * range){
+  m_interactiveRange = range;
+  m_tempInteractiveRange = *range;
+}
+
 bool RangeParameterController::handleEvent(Ion::Events::Event event) {
   if (activeCell() == 2 && (event == Ion::Events::OK || event == Ion::Events::EXE)) {
-    m_interactiveRange->setYAuto(!m_interactiveRange->yAuto());
+    m_tempInteractiveRange.setYAuto(!m_tempInteractiveRange.yAuto());
     m_selectableTableView.reloadData();
     return true;
   }
@@ -83,14 +89,14 @@ float RangeParameterController::parameterAtIndex(int parameterIndex) {
   ParameterGetterPointer getters[k_numberOfTextCell] = {&InteractiveCurveViewRange::xMin,
     &InteractiveCurveViewRange::xMax, &InteractiveCurveViewRange::yMin, &InteractiveCurveViewRange::yMax};
   int index = parameterIndex > 2 ? parameterIndex - 1 : parameterIndex;
-  return (m_interactiveRange->*getters[index])();
+  return (m_tempInteractiveRange.*getters[index])();
 }
 
 bool RangeParameterController::setParameterAtIndex(int parameterIndex, float f) {
   ParameterSetterPointer setters[k_numberOfTextCell] = {&InteractiveCurveViewRange::setXMin,
     &InteractiveCurveViewRange::setXMax, &InteractiveCurveViewRange::setYMin, &InteractiveCurveViewRange::setYMax};
   int index = parameterIndex > 2 ? parameterIndex - 1 : parameterIndex;
-  (m_interactiveRange->*setters[index])(f);
+  (m_tempInteractiveRange.*setters[index])(f);
   return true;
 }
 
@@ -119,4 +125,11 @@ int RangeParameterController::reusableParameterCellCount(int type) {
   return k_numberOfConvertibleTextCell;
 }
 
+void RangeParameterController::buttonAction() {
+  *m_interactiveRange = m_tempInteractiveRange;
+  StackViewController * stack = stackController();
+  stack->pop();
+}
+
+
 }

apps/shared/range_parameter_controller.h

@@ -16,6 +16,7 @@ public:
   void willDisplayCellForIndex(HighlightCell * cell, int index) override;
   bool textFieldDidFinishEditing(TextField * textField, const char * text, Ion::Events::Event event) override;
   bool handleEvent(Ion::Events::Event event) override;
+  void setRange(InteractiveCurveViewRange * range);
   TELEMETRY_ID("Range");
 private:
   class MessageTableCellWithConvertibleEditableText : public MessageTableCellWithEditableText {
@@ -39,9 +40,11 @@ private:
   constexpr static int k_numberOfConvertibleTextCell = 2;
   constexpr static int k_numberOfTextCell = k_numberOfEditableTextCell+k_numberOfConvertibleTextCell;
   InteractiveCurveViewRange * m_interactiveRange;
+  InteractiveCurveViewRange m_tempInteractiveRange;
   MessageTableCellWithEditableText m_xRangeCells[k_numberOfEditableTextCell];
   MessageTableCellWithConvertibleEditableText m_yRangeCells[k_numberOfConvertibleTextCell];
   MessageTableCellWithSwitch m_yAutoCell;
+  void buttonAction() override;
 };
 
 }