diff --git a/apps/probability/parameters_controller.cpp b/apps/probability/parameters_controller.cpp index 8c624cf20..90d0d30c1 100644 --- a/apps/probability/parameters_controller.cpp +++ b/apps/probability/parameters_controller.cpp @@ -8,15 +8,6 @@ namespace Probability { ParametersController::ContentView::ContentView(Responder * parentResponder, SelectableTableView * selectableTableView) : m_numberOfParameters(1), - m_nextButton(Button(parentResponder, "Suivant", Invocation([](void * context, void * sender) { - ParametersController * parameterController = (ParametersController *) context; - CalculationController * calculationController = parameterController->calculationController(); - calculationController->setCalculationAccordingToIndex(0); - calculationController->selectSubview(1); - calculationController->reload(); - StackViewController * stack = parameterController->stackController(); - stack->push(calculationController, KDColorWhite, Palette::SubTab, Palette::SubTab); - }, parentResponder), KDText::FontSize::Large)), m_titleView(PointerTextView(KDText::FontSize::Small, "Choisir les parametres", 0.5f, 0.5f, Palette::GreyDark, Palette::WallScreen)), m_firstParameterDefinition(PointerTextView(KDText::FontSize::Small, nullptr, 0.5f, 0.5f, KDColorBlack, Palette::WallScreen)), m_secondParameterDefinition(PointerTextView(KDText::FontSize::Small, nullptr, 0.5f, 0.5f, KDColorBlack, Palette::WallScreen)), @@ -24,8 +15,9 @@ ParametersController::ContentView::ContentView(Responder * parentResponder, Sele { } -Button * ParametersController::ContentView::button() { - return &m_nextButton; +void ParametersController::ContentView::drawRect(KDContext * ctx, KDRect rect) const { + int tableHeight = m_selectableTableView->size().height()+ Metric::CommonTopMargin + Metric::CommonBottomMargin; + ctx->fillRect(KDRect(0, tableHeight, bounds().width(), bounds().height() - tableHeight), Palette::WallScreen); } PointerTextView * ParametersController::ContentView::parameterDefinitionAtIndex(int index) { @@ -36,17 +28,12 @@ PointerTextView * ParametersController::ContentView::parameterDefinitionAtIndex( return &m_secondParameterDefinition; } -void ParametersController::ContentView::drawRect(KDContext * ctx, KDRect rect) const { - int tableHeight = m_selectableTableView->size().height()+ Metric::CommonTopMargin + Metric::CommonBottomMargin; - ctx->fillRect(KDRect(0, tableHeight, bounds().width(), bounds().height() - tableHeight), Palette::WallScreen); -} - void ParametersController::ContentView::setNumberOfParameters(int numberOfParameters) { m_numberOfParameters = numberOfParameters; } int ParametersController::ContentView::numberOfSubviews() const { - return m_numberOfParameters+3; + return m_numberOfParameters+2; } View * ParametersController::ContentView::subviewAtIndex(int index) { @@ -58,9 +45,6 @@ View * ParametersController::ContentView::subviewAtIndex(int index) { return m_selectableTableView; } if (index == 2) { - return &m_nextButton; - } - if (index == 3) { return &m_firstParameterDefinition; } return &m_secondParameterDefinition; @@ -71,12 +55,11 @@ void ParametersController::ContentView::layoutSubviews() { m_titleView.setFrame(KDRect(0, 0, bounds().width(), titleHeight)); KDCoordinate tableHeight = m_selectableTableView->size().height() + Metric::CommonTopMargin + Metric::CommonBottomMargin; m_selectableTableView->setFrame(KDRect(0, titleHeight, bounds().width(), tableHeight)); - m_nextButton.setFrame(KDRect(Metric::CommonLeftMargin, titleHeight+tableHeight, bounds().width() - Metric::CommonRightMargin - Metric::CommonLeftMargin, k_buttonHeight)); KDCoordinate textHeight = KDText::stringSize("", KDText::FontSize::Small).height(); - KDCoordinate defOrigin = (titleHeight+tableHeight+k_buttonHeight)/2+(bounds().height()-textHeight)/2; + KDCoordinate defOrigin = (titleHeight+tableHeight)/2+(bounds().height()-textHeight)/2; m_secondParameterDefinition.setFrame(KDRectZero); if (m_numberOfParameters == 2) { - defOrigin = (titleHeight+tableHeight+k_buttonHeight)/2+(bounds().height()-2*textHeight-k_textMargin)/2; + defOrigin = (titleHeight+tableHeight)/2+(bounds().height()-2*textHeight-k_textMargin)/2; m_secondParameterDefinition.setFrame(KDRect(0, defOrigin+textHeight+k_textMargin, bounds().width(), textHeight)); } m_firstParameterDefinition.setFrame(KDRect(0, defOrigin, bounds().width(), textHeight)); @@ -85,12 +68,11 @@ void ParametersController::ContentView::layoutSubviews() { /* Parameters Controller */ ParametersController::ParametersController(Responder * parentResponder) : - FloatParameterController(parentResponder), + FloatParameterController(parentResponder, "Suivant"), m_menuListCell{PointerTableCellWithEditableText(&m_selectableTableView, this, m_draftTextBuffer), PointerTableCellWithEditableText(&m_selectableTableView, this, m_draftTextBuffer)}, m_contentView(ContentView(this, &m_selectableTableView)), m_law(nullptr), - m_buttonSelected(false), m_calculationController(CalculationController(nullptr)) { } @@ -114,62 +96,44 @@ void ParametersController::setLaw(Law * law) { m_calculationController.setLaw(law); } -bool ParametersController::handleEvent(Ion::Events::Event event) { - if (event == Ion::Events::Down && !m_buttonSelected) { - m_buttonSelected = true; - m_contentView.button()->setHighlighted(true); - m_selectableTableView.deselectTable(); - app()->setFirstResponder(m_contentView.button()); - return true; - } - if (event == Ion::Events::Up && m_buttonSelected) { - m_buttonSelected = false; - m_contentView.button()->setHighlighted(false); - m_selectableTableView.selectCellAtLocation(0, numberOfRows()-1); - app()->setFirstResponder(&m_selectableTableView); - return true; - } - return FloatParameterController::handleEvent(event); -} - -void ParametersController::didBecomeFirstResponder() { - for (int i = 0; i < numberOfRows(); i++) { +void ParametersController::viewWillAppear() { + for (int i = 0; i < m_law->numberOfParameter(); i++) { + m_previousParameters[i] = parameterAtIndex(i); m_contentView.parameterDefinitionAtIndex(i)->setText(m_law->parameterDefinitionAtIndex(i)); } m_contentView.layoutSubviews(); - m_buttonSelected = false; - m_contentView.button()->setHighlighted(false); - FloatParameterController::didBecomeFirstResponder(); -} - -StackViewController * ParametersController::stackController() { - return (StackViewController * )parentResponder(); -} - -CalculationController * ParametersController::calculationController() { - return &m_calculationController; + FloatParameterController::viewWillAppear(); } int ParametersController::numberOfRows() { - return m_law->numberOfParameter(); -}; + return 1+m_law->numberOfParameter(); +} void ParametersController::willDisplayCellForIndex(HighlightCell * cell, int index) { + if (index == numberOfRows()-1) { + return; + } PointerTableCellWithEditableText * myCell = (PointerTableCellWithEditableText *) cell; myCell->setText(m_law->parameterNameAtIndex(index)); FloatParameterController::willDisplayCellForIndex(cell, index); } -HighlightCell * ParametersController::reusableCell(int index) { +HighlightCell * ParametersController::reusableParameterCell(int index, int type) { assert(index >= 0); assert(index < 2); return &m_menuListCell[index]; } -int ParametersController::reusableCellCount() { +int ParametersController::reusableParameterCellCount(int type) { return m_law->numberOfParameter(); } +float ParametersController::previousParameterAtIndex(int index) { + assert(index >= 0); + assert(index < 2); + return m_previousParameters[index]; +} + float ParametersController::parameterAtIndex(int index) { return m_law->parameterValueAtIndex(index); } @@ -182,5 +146,13 @@ void ParametersController::setParameterAtIndex(int parameterIndex, float f) { m_law->setParameterAtIndex(f, parameterIndex); } +void ParametersController::buttonAction() { + m_calculationController.setCalculationAccordingToIndex(0); + m_calculationController.selectSubview(1); + m_calculationController.reload(); + StackViewController * stack = stackController(); + stack->push(&m_calculationController, KDColorWhite, Palette::SubTab, Palette::SubTab); +} + } diff --git a/apps/probability/parameters_controller.h b/apps/probability/parameters_controller.h index 933d3e3f2..f2a337787 100644 --- a/apps/probability/parameters_controller.h +++ b/apps/probability/parameters_controller.h @@ -14,33 +14,29 @@ public: View * view() override; const char * title() const override; void setLaw(Law * law); - bool handleEvent(Ion::Events::Event event) override; - void didBecomeFirstResponder() override; - StackViewController * stackController(); - CalculationController * calculationController(); + void viewWillAppear() override; int numberOfRows() override; void willDisplayCellForIndex(HighlightCell * cell, int index) override; - HighlightCell * reusableCell(int index) override; - int reusableCellCount() override; private: + HighlightCell * reusableParameterCell(int index, int type) override; + int reusableParameterCellCount(int type) override; + void buttonAction() override; + float previousParameterAtIndex(int index) override; float parameterAtIndex(int index) override; void setParameterAtIndex(int parameterIndex, float f) override; class ContentView : public View { public: ContentView(Responder * parentResponder, SelectableTableView * selectableTableView); - Button * button(); - PointerTextView * parameterDefinitionAtIndex(int index); void drawRect(KDContext * ctx, KDRect rect) const override; + PointerTextView * parameterDefinitionAtIndex(int index); void layoutSubviews() override; void setNumberOfParameters(int numberOfParameters); private: - constexpr static KDCoordinate k_buttonHeight = 40; constexpr static KDCoordinate k_textMargin = 5; constexpr static KDCoordinate k_titleMargin = 5; int numberOfSubviews() const override; View * subviewAtIndex(int index) override; int m_numberOfParameters; - Button m_nextButton; PointerTextView m_titleView; PointerTextView m_firstParameterDefinition; PointerTextView m_secondParameterDefinition; @@ -49,9 +45,9 @@ private: constexpr static int k_maxNumberOfCells = 2; char m_draftTextBuffer[PointerTableCellWithEditableText::k_bufferLength]; PointerTableCellWithEditableText m_menuListCell[k_maxNumberOfCells]; + float m_previousParameters[k_maxNumberOfCells]; ContentView m_contentView; Law * m_law; - bool m_buttonSelected; CalculationController m_calculationController; }; diff --git a/apps/regression/go_to_parameter_controller.cpp b/apps/regression/go_to_parameter_controller.cpp index ae434babc..8e9083175 100644 --- a/apps/regression/go_to_parameter_controller.cpp +++ b/apps/regression/go_to_parameter_controller.cpp @@ -8,7 +8,7 @@ using namespace Poincare; namespace Regression { GoToParameterController::GoToParameterController(Responder * parentResponder, Store * store, CurveViewCursor * cursor) : - FloatParameterController(parentResponder), + FloatParameterController(parentResponder, "Valider"), m_abscisseCell(PointerTableCellWithEditableText(&m_selectableTableView, this, m_draftTextBuffer)), m_store(store), m_cursor(cursor), @@ -27,6 +27,15 @@ const char * GoToParameterController::title() const { return "Prediction sachant y"; } +int GoToParameterController::numberOfRows() { + return 2; +} + +float GoToParameterController::previousParameterAtIndex(int index) { + assert(index == 0); + return m_previousParameter; +} + float GoToParameterController::parameterAtIndex(int index) { assert(index == 0); if (m_xPrediction) { @@ -53,20 +62,19 @@ void GoToParameterController::setParameterAtIndex(int parameterIndex, float f) { } } -int GoToParameterController::numberOfRows() { - return 1; -}; - -HighlightCell * GoToParameterController::reusableCell(int index) { +HighlightCell * GoToParameterController::reusableParameterCell(int index, int type) { assert(index == 0); return &m_abscisseCell; } -int GoToParameterController::reusableCellCount() { +int GoToParameterController::reusableParameterCellCount(int type) { return 1; } void GoToParameterController::willDisplayCellForIndex(HighlightCell * cell, int index) { + if (index == numberOfRows()-1) { + return; + } PointerTableCellWithEditableText * myCell = (PointerTableCellWithEditableText *) cell; if (m_xPrediction) { myCell->setText("x"); @@ -88,15 +96,18 @@ bool GoToParameterController::textFieldDidFinishEditing(TextField * textField, c app()->displayWarning("Valeur non atteinte par la regression"); return false; } - FloatParameterController::textFieldDidFinishEditing(textField, text); - StackViewController * stack = (StackViewController *)parentResponder(); - stack->pop(); - stack->pop(); - return true; + return FloatParameterController::textFieldDidFinishEditing(textField, text); } void GoToParameterController::viewWillAppear() { + m_previousParameter = parameterAtIndex(0); m_selectableTableView.reloadData(); } +void GoToParameterController::buttonAction() { + StackViewController * stack = (StackViewController *)parentResponder(); + stack->pop(); + stack->pop(); +} + } diff --git a/apps/regression/go_to_parameter_controller.h b/apps/regression/go_to_parameter_controller.h index 45f5d5dbd..d02672692 100644 --- a/apps/regression/go_to_parameter_controller.h +++ b/apps/regression/go_to_parameter_controller.h @@ -14,16 +14,19 @@ public: void setXPrediction(bool xPrediction); const char * title() const override; int numberOfRows() override; - HighlightCell * reusableCell(int index) override; - int reusableCellCount() override; void willDisplayCellForIndex(HighlightCell * cell, int index) override; bool textFieldDidFinishEditing(TextField * textField, const char * text) override; void viewWillAppear() override; private: + HighlightCell * reusableParameterCell(int index, int type) override; + int reusableParameterCellCount(int type) override; + float previousParameterAtIndex(int index) override; float parameterAtIndex(int index) override; void setParameterAtIndex(int parameterIndex, float f) override; + void buttonAction() override; char m_draftTextBuffer[PointerTableCellWithEditableText::k_bufferLength]; PointerTableCellWithEditableText m_abscisseCell; + float m_previousParameter; Store * m_store; Shared::CurveViewCursor * m_cursor; bool m_xPrediction; @@ -31,4 +34,4 @@ private: } -#endif \ No newline at end of file +#endif diff --git a/apps/shared/float_parameter_controller.cpp b/apps/shared/float_parameter_controller.cpp index 43150e631..68bcec3ac 100644 --- a/apps/shared/float_parameter_controller.cpp +++ b/apps/shared/float_parameter_controller.cpp @@ -8,10 +8,14 @@ using namespace Poincare; namespace Shared { -FloatParameterController::FloatParameterController(Responder * parentResponder) : +FloatParameterController::FloatParameterController(Responder * parentResponder, const char * okButtonText) : ViewController(parentResponder), m_selectableTableView(SelectableTableView(this, this, Metric::CommonTopMargin, Metric::CommonRightMargin, - Metric::CommonBottomMargin, Metric::CommonLeftMargin, this)) + Metric::CommonBottomMargin, Metric::CommonLeftMargin, this)), + m_okButton(Button(&m_selectableTableView, okButtonText, Invocation([](void * context, void * sender) { + FloatParameterController * parameterController = (FloatParameterController *) context; + parameterController->buttonAction(); + }, this), KDText::FontSize::Large)) { } @@ -28,11 +32,60 @@ void FloatParameterController::viewWillAppear() { m_selectableTableView.reloadData(); } -int FloatParameterController::activeCell() { - return m_selectableTableView.selectedRow(); +bool FloatParameterController::handleEvent(Ion::Events::Event event) { + if (event == Ion::Events::Back) { + for (int i = 0; i < numberOfRows()-1; i++) { + setParameterAtIndex(i, previousParameterAtIndex(i)); + } + stackController()->pop(); + return true; + } + return false; +} + +int FloatParameterController::typeAtLocation(int i, int j) { + if (j == numberOfRows()-1) { + return 0; + } + return 1; +} + +int FloatParameterController::reusableCellCount(int type) { + if (type == 0) { + return 1; + } + return reusableParameterCellCount(type); +} + +HighlightCell * FloatParameterController::reusableCell(int index, int type) { + if (type == 0) { + return &m_okButton; + } + return reusableParameterCell(index, type); +} + +KDCoordinate FloatParameterController::rowHeight(int j) { + if (j == numberOfRows()-1) { + return Metric::ParameterCellHeight+k_buttonMargin; + } + return Metric::ParameterCellHeight; +} + +KDCoordinate FloatParameterController::cumulatedHeightFromIndex(int j) { + return Metric::ParameterCellHeight*j; +} + +int FloatParameterController::indexFromCumulatedHeight(KDCoordinate offsetY) { + if (offsetY > numberOfRows()*Metric::ParameterCellHeight + k_buttonMargin) { + return numberOfRows(); + } + return (offsetY - 1) / Metric::ParameterCellHeight; } void FloatParameterController::willDisplayCellForIndex(HighlightCell * cell, int index) { + if (index == numberOfRows()-1) { + return; + } PointerTableCellWithEditableText * myCell = (PointerTableCellWithEditableText *) cell; char buffer[Complex::bufferSizeForFloatsWithPrecision(Constant::LargeNumberOfSignificantDigits)]; Complex::convertFloatToText(parameterAtIndex(index), buffer, Complex::bufferSizeForFloatsWithPrecision(Constant::LargeNumberOfSignificantDigits), Constant::LargeNumberOfSignificantDigits, Expression::FloatDisplayMode::Decimal); @@ -43,21 +96,27 @@ bool FloatParameterController::textFieldDidFinishEditing(TextField * textField, AppsContainer * appsContainer = ((TextFieldDelegateApp *)app())->container(); Context * globalContext = appsContainer->globalContext(); float floatBody = Expression::parse(text)->approximate(*globalContext); - if (isnan(floatBody)) { + if (isnan(floatBody) || isinf(floatBody)) { app()->displayWarning("Valeur non defini"); return false; } setParameterAtIndex(m_selectableTableView.selectedRow(), floatBody); willDisplayCellForIndex(m_selectableTableView.cellAtLocation(m_selectableTableView.selectedColumn(), m_selectableTableView.selectedRow()), activeCell()); + m_selectableTableView.selectCellAtLocation(m_selectableTableView.selectedColumn(), m_selectableTableView.selectedRow()+1); return true; } void FloatParameterController::tableViewDidChangeSelection(SelectableTableView * t, int previousSelectedCellX, int previousSelectedCellY) { - if (previousSelectedCellY >= 0) { + if (previousSelectedCellY >= 0 && previousSelectedCellX < numberOfRows()-1) { PointerTableCellWithEditableText * myCell = (PointerTableCellWithEditableText *)t->cellAtLocation(previousSelectedCellX, previousSelectedCellY); myCell->setEditing(false); } + if (t->selectedRow() == numberOfRows()-1) { + Button * myNewCell = (Button *)t->cellAtLocation(t->selectedColumn(), t->selectedRow()); + app()->setFirstResponder(myNewCell); + return; + } if (t->selectedRow() >= 0) { PointerTableCellWithEditableText * myNewCell = (PointerTableCellWithEditableText *)t->cellAtLocation(t->selectedColumn(), t->selectedRow()); app()->setFirstResponder(myNewCell); @@ -68,8 +127,17 @@ TextFieldDelegateApp * FloatParameterController::textFieldDelegateApp() { return (TextFieldDelegateApp *)app(); } -KDCoordinate FloatParameterController::cellHeight() { - return Metric::ParameterCellHeight; +int FloatParameterController::activeCell() { + return m_selectableTableView.selectedRow(); +} + +StackViewController * FloatParameterController::stackController() { + return (StackViewController *)parentResponder(); +} + +void FloatParameterController::buttonAction() { + StackViewController * stack = stackController(); + stack->pop(); } } diff --git a/apps/shared/float_parameter_controller.h b/apps/shared/float_parameter_controller.h index 3a73804a0..81dceaee0 100644 --- a/apps/shared/float_parameter_controller.h +++ b/apps/shared/float_parameter_controller.h @@ -9,23 +9,38 @@ namespace Shared { /* This controller edits float parameter of any model (given through * parameterAtIndex and setParameterAtIndex). */ -class FloatParameterController : public ViewController, public SimpleListViewDataSource, public SelectableTableViewDelegate, public TextFieldDelegate { +class FloatParameterController : public ViewController, public ListViewDataSource, public SelectableTableViewDelegate, public TextFieldDelegate { public: - FloatParameterController(Responder * parentResponder); + FloatParameterController(Responder * parentResponder, const char * okButtonText = "Valider"); View * view() override; void viewWillAppear() override; void didBecomeFirstResponder() override; - KDCoordinate cellHeight() override; + bool handleEvent(Ion::Events::Event event) override; + + int typeAtLocation(int i, int j) override; + int reusableCellCount(int type) override; + HighlightCell * reusableCell(int index, int type) override; + KDCoordinate rowHeight(int j) override; + KDCoordinate cumulatedHeightFromIndex(int j) override; + int indexFromCumulatedHeight(KDCoordinate offsetY) override; void willDisplayCellForIndex(HighlightCell * cell, int index) override; + bool textFieldDidFinishEditing(TextField * textField, const char * text) override; void tableViewDidChangeSelection(SelectableTableView * t, int previousSelectedCellX, int previousSelectedCellY) override; protected: int activeCell(); + StackViewController * stackController(); SelectableTableView m_selectableTableView; private: + constexpr static int k_buttonMargin = 5; + virtual void buttonAction(); + virtual int reusableParameterCellCount(int type) = 0; + virtual HighlightCell * reusableParameterCell(int index, int type) = 0; TextFieldDelegateApp * textFieldDelegateApp() override; + virtual float previousParameterAtIndex(int index) = 0; virtual float parameterAtIndex(int index) = 0; virtual void setParameterAtIndex(int parameterIndex, float f) = 0; + Button m_okButton; }; } diff --git a/apps/shared/go_to_parameter_controller.cpp b/apps/shared/go_to_parameter_controller.cpp index 02dcf7586..28792c1dd 100644 --- a/apps/shared/go_to_parameter_controller.cpp +++ b/apps/shared/go_to_parameter_controller.cpp @@ -5,7 +5,7 @@ namespace Shared { GoToParameterController::GoToParameterController(Responder * parentResponder, InteractiveCurveViewRange * graphRange, CurveViewCursor * cursor, const char * symbol) : - FloatParameterController(parentResponder), + FloatParameterController(parentResponder, "Valider"), m_abscisseCell(PointerTableCellWithEditableText(&m_selectableTableView, this, m_draftTextBuffer, (char*)symbol)), m_graphRange(graphRange), m_cursor(cursor), @@ -17,6 +17,20 @@ const char * GoToParameterController::title() const { return "Aller a"; } +void GoToParameterController::viewWillAppear() { + m_previousParameter = parameterAtIndex(0); + FloatParameterController::viewWillAppear(); +} + +int GoToParameterController::numberOfRows() { + return 2; +} + +float GoToParameterController::previousParameterAtIndex(int index) { + assert(index == 0); + return m_previousParameter; +} + float GoToParameterController::parameterAtIndex(int index) { assert(index == 0); return m_cursor->x(); @@ -31,16 +45,12 @@ void GoToParameterController::setParameterAtIndex(int parameterIndex, float f) { m_cursor->moveTo(f, y); } -int GoToParameterController::numberOfRows() { - return 1; -}; - -HighlightCell * GoToParameterController::reusableCell(int index) { +HighlightCell * GoToParameterController::reusableParameterCell(int index, int type) { assert(index == 0); return &m_abscisseCell; } -int GoToParameterController::reusableCellCount() { +int GoToParameterController::reusableParameterCellCount(int type) { return 1; } @@ -48,12 +58,10 @@ void GoToParameterController::setFunction(Function * function) { m_function = function; } -bool GoToParameterController::textFieldDidFinishEditing(TextField * textField, const char * text) { - FloatParameterController::textFieldDidFinishEditing(textField, text); +void GoToParameterController::buttonAction() { StackViewController * stack = (StackViewController *)parentResponder(); stack->pop(); stack->pop(); - return true; } } diff --git a/apps/shared/go_to_parameter_controller.h b/apps/shared/go_to_parameter_controller.h index ae88aebfc..ff2329b13 100644 --- a/apps/shared/go_to_parameter_controller.h +++ b/apps/shared/go_to_parameter_controller.h @@ -13,16 +13,19 @@ class GoToParameterController : public FloatParameterController { public: GoToParameterController(Responder * parentResponder, InteractiveCurveViewRange * graphRange, CurveViewCursor * cursor, const char * symbol); const char * title() const override; - int numberOfRows() override; - HighlightCell * reusableCell(int index) override; - int reusableCellCount() override; + void viewWillAppear() override; void setFunction(Function * function); - bool textFieldDidFinishEditing(TextField * textField, const char * text) override; + int numberOfRows() override; private: + void buttonAction() override; + HighlightCell * reusableParameterCell(int index, int type) override; + int reusableParameterCellCount(int type) override; + float previousParameterAtIndex(int index) override; float parameterAtIndex(int index) override; void setParameterAtIndex(int parameterIndex, float f) override; char m_draftTextBuffer[PointerTableCellWithEditableText::k_bufferLength]; PointerTableCellWithEditableText m_abscisseCell; + float m_previousParameter; InteractiveCurveViewRange * m_graphRange; CurveViewCursor * m_cursor; Function * m_function; diff --git a/apps/shared/interval_parameter_controller.cpp b/apps/shared/interval_parameter_controller.cpp index edeec377e..b4baccc9f 100644 --- a/apps/shared/interval_parameter_controller.cpp +++ b/apps/shared/interval_parameter_controller.cpp @@ -4,11 +4,9 @@ namespace Shared { IntervalParameterController::IntervalParameterController(Responder * parentResponder, Interval * interval) : - FloatParameterController(parentResponder), + FloatParameterController(parentResponder, "Valider"), m_interval(interval), - m_intervalStartCell(PointerTableCellWithEditableText(&m_selectableTableView, this, m_draftTextBuffer, (char*)"X Debut")), - m_intervalEndCell(PointerTableCellWithEditableText(&m_selectableTableView, this, m_draftTextBuffer, (char*)"X Fin")), - m_intervalStepCell(PointerTableCellWithEditableText(&m_selectableTableView, this, m_draftTextBuffer, (char*)"Pas")) + m_intervalCells{PointerTableCellWithEditableText(&m_selectableTableView, this, m_draftTextBuffer, nullptr), PointerTableCellWithEditableText(&m_selectableTableView, this, m_draftTextBuffer, nullptr), PointerTableCellWithEditableText(&m_selectableTableView, this, m_draftTextBuffer, nullptr)} { } @@ -16,10 +14,36 @@ const char * IntervalParameterController::title() const { return "Regler l'intervalle"; } +void IntervalParameterController::viewWillAppear() { + for (int i = 0; i < k_totalNumberOfCell; i++) { + m_previousParameters[i] = parameterAtIndex(i); + } + FloatParameterController::viewWillAppear(); +} + +int IntervalParameterController::numberOfRows() { + return k_totalNumberOfCell+1; +} + +void IntervalParameterController::willDisplayCellForIndex(HighlightCell * cell, int index) { + if (index == numberOfRows()-1) { + return; + } + PointerTableCellWithEditableText * myCell = (PointerTableCellWithEditableText *)cell; + const char * labels[k_totalNumberOfCell] = {"x Debut", "x Fin", "x Pas"}; + myCell->setText(labels[index]); + FloatParameterController::willDisplayCellForIndex(cell, index); +} + Interval * IntervalParameterController::interval() { return m_interval; } +float IntervalParameterController::previousParameterAtIndex(int index) { + assert(index >= 0 && index < k_totalNumberOfCell); + return m_previousParameters[index]; +} + float IntervalParameterController::parameterAtIndex(int index) { GetterPointer getters[k_totalNumberOfCell] = {&Interval::start, &Interval::end, &Interval::step}; return (m_interval->*getters[index])(); @@ -30,18 +54,13 @@ void IntervalParameterController::setParameterAtIndex(int parameterIndex, float (m_interval->*setters[parameterIndex])(f); } -int IntervalParameterController::numberOfRows() { - return k_totalNumberOfCell; -}; - -HighlightCell * IntervalParameterController::reusableCell(int index) { +HighlightCell * IntervalParameterController::reusableParameterCell(int index, int type) { assert(index >= 0); assert(index < k_totalNumberOfCell); - HighlightCell * cells[] = {&m_intervalStartCell, &m_intervalEndCell, &m_intervalStepCell}; - return cells[index]; + return &m_intervalCells[index]; } -int IntervalParameterController::reusableCellCount() { +int IntervalParameterController::reusableParameterCellCount(int type) { return k_totalNumberOfCell; } diff --git a/apps/shared/interval_parameter_controller.h b/apps/shared/interval_parameter_controller.h index ef7db598a..a3a2da227 100644 --- a/apps/shared/interval_parameter_controller.h +++ b/apps/shared/interval_parameter_controller.h @@ -12,18 +12,20 @@ public: IntervalParameterController(Responder * parentResponder, Interval * interval); Interval * interval(); const char * title() const override; + void viewWillAppear() override; + void willDisplayCellForIndex(HighlightCell * cell, int index) override; int numberOfRows() override; - HighlightCell * reusableCell(int index) override; - int reusableCellCount() override; private: + HighlightCell * reusableParameterCell(int index, int type) override; + int reusableParameterCellCount(int type) override; + float previousParameterAtIndex(int index) override; float parameterAtIndex(int index) override; void setParameterAtIndex(int parameterIndex, float f) override; constexpr static int k_totalNumberOfCell = 3; Interval * m_interval; char m_draftTextBuffer[PointerTableCellWithEditableText::k_bufferLength]; - PointerTableCellWithEditableText m_intervalStartCell; - PointerTableCellWithEditableText m_intervalEndCell; - PointerTableCellWithEditableText m_intervalStepCell; + PointerTableCellWithEditableText m_intervalCells[k_totalNumberOfCell]; + float m_previousParameters[k_totalNumberOfCell]; }; } diff --git a/apps/shared/range_parameter_controller.cpp b/apps/shared/range_parameter_controller.cpp index e6dc80da6..a19c7d856 100644 --- a/apps/shared/range_parameter_controller.cpp +++ b/apps/shared/range_parameter_controller.cpp @@ -8,10 +8,10 @@ using namespace Poincare; namespace Shared { RangeParameterController::RangeParameterController(Responder * parentResponder, InteractiveCurveViewRange * interactiveRange) : - FloatParameterController(parentResponder), + FloatParameterController(parentResponder, "Valider"), m_interactiveRange(interactiveRange), - m_rangeCells{PointerTableCellWithEditableText(&m_selectableTableView, this, m_draftTextBuffer, (char *)"Xmin"), PointerTableCellWithEditableText(&m_selectableTableView, this, m_draftTextBuffer, (char *)"Xmax"), - PointerTableCellWithEditableText(&m_selectableTableView, this, m_draftTextBuffer, (char *)"Ymin"), PointerTableCellWithEditableText(&m_selectableTableView, this, m_draftTextBuffer, (char *)"Ymax")}, + m_rangeCells{PointerTableCellWithEditableText(&m_selectableTableView, this, m_draftTextBuffer, nullptr), PointerTableCellWithEditableText(&m_selectableTableView, this, m_draftTextBuffer, nullptr), + PointerTableCellWithEditableText(&m_selectableTableView, this, m_draftTextBuffer, nullptr), PointerTableCellWithEditableText(&m_selectableTableView, this, m_draftTextBuffer, nullptr)}, m_yAutoCell(PointerTableCellWithSwitch((char*)"Y auto")) { } @@ -20,40 +20,65 @@ const char * RangeParameterController::title() const { return "Axes"; } +void RangeParameterController::viewWillAppear() { + for (int i = 0; i < k_numberOfTextCell; i++) { + int index = i > 2 ? i + 1 : i; + m_previousParameters[i] = parameterAtIndex(index); + } + m_previousSwitchState = m_interactiveRange->yAuto(); + FloatParameterController::viewWillAppear(); +} + +int RangeParameterController::numberOfRows() { + return k_numberOfTextCell+2; +} + +int RangeParameterController::typeAtLocation(int i, int j) { + if (j == numberOfRows()-1) { + return 0; + } + if (j == 2) { + return 2; + } + return 1; +} + void RangeParameterController::willDisplayCellForIndex(HighlightCell * cell, int index) { + if (index == numberOfRows()-1) { + return; + } if (index == 2) { SwitchView * switchView = (SwitchView *)m_yAutoCell.accessoryView(); switchView->setState(m_interactiveRange->yAuto()); return; } - if (index == 3 || index == 4) { - if (m_interactiveRange->yAuto()) { - m_rangeCells[index-1].setTextColor(Palette::GreyDark); - } else { - m_rangeCells[index-1].setTextColor(KDColorBlack); - } - } + PointerTableCellWithEditableText * myCell = (PointerTableCellWithEditableText *)cell; + const char * labels[k_numberOfTextCell+1] = {"Xmin", "Xmax", "", "Ymin", "Ymax"}; + myCell->setText(labels[index]); + KDColor yColor = m_interactiveRange->yAuto() ? Palette::GreyDark : KDColorBlack; + KDColor colors[k_numberOfTextCell+1] = {KDColorBlack, KDColorBlack, KDColorBlack, yColor, yColor}; + myCell->setTextColor(colors[index]); FloatParameterController::willDisplayCellForIndex(cell, index); } bool RangeParameterController::textFieldDidFinishEditing(TextField * textField, const char * text) { - AppsContainer * appsContainer = ((TextFieldDelegateApp *)app())->container(); - Context * globalContext = appsContainer->globalContext(); - float floatBody = Expression::parse(text)->approximate(*globalContext); - setParameterAtIndex(m_selectableTableView.selectedRow(), floatBody); - willDisplayCellForIndex(m_selectableTableView.cellAtLocation(m_selectableTableView.selectedColumn(), - m_selectableTableView.selectedRow()), activeCell()); + FloatParameterController::textFieldDidFinishEditing(textField, text); m_selectableTableView.reloadData(); return true; } void RangeParameterController::tableViewDidChangeSelection(SelectableTableView * t, int previousSelectedCellX, int previousSelectedCellY) { - if (previousSelectedCellX == 0 && previousSelectedCellY >= 0 && previousSelectedCellY !=2) { + if (previousSelectedCellX < numberOfRows()-1 && previousSelectedCellY >= 0 && previousSelectedCellY !=2) { PointerTableCellWithEditableText * myCell = (PointerTableCellWithEditableText *)t->cellAtLocation(previousSelectedCellX, previousSelectedCellY); myCell->setEditing(false); app()->setFirstResponder(t); } - if (t->selectedColumn() == 0 && t->selectedRow() >= 0 && t->selectedRow() !=2) { + if (t->selectedRow() == numberOfRows()-1) { + Button * myNewCell = (Button *)t->cellAtLocation(t->selectedColumn(), t->selectedRow()); + app()->setFirstResponder(myNewCell); + return; + } + if (t->selectedRow() >= 0 && t->selectedRow() !=2) { PointerTableCellWithEditableText * myNewCell = (PointerTableCellWithEditableText *)t->cellAtLocation(t->selectedColumn(), t->selectedRow()); if ((t->selectedRow() == 0 || t->selectedRow() == 1) || !m_interactiveRange->yAuto()) { app()->setFirstResponder(myNewCell); @@ -73,7 +98,15 @@ bool RangeParameterController::handleEvent(Ion::Events::Event event) { if (m_interactiveRange->yAuto() && (activeCell() == 3 || activeCell() == 4)) { return false; } - return false; + if (event == Ion::Events::Back) { + m_interactiveRange->setYAuto(m_previousSwitchState); + } + return FloatParameterController::handleEvent(event); +} + +float RangeParameterController::previousParameterAtIndex(int parameterIndex) { + int index = parameterIndex > 2 ? parameterIndex - 1 : parameterIndex; + return m_previousParameters[index]; } float RangeParameterController::parameterAtIndex(int parameterIndex) { @@ -90,22 +123,20 @@ void RangeParameterController::setParameterAtIndex(int parameterIndex, float f) (m_interactiveRange->*setters[index])(f); } -int RangeParameterController::numberOfRows() { - return k_numberOfTextCell+1; -}; - -HighlightCell * RangeParameterController::reusableCell(int index) { - if (index == 2) { +HighlightCell * RangeParameterController::reusableParameterCell(int index, int type) { + if (type == 2) { return &m_yAutoCell; } - int cellIndex = index > 2 ? index - 1 : index; - assert(cellIndex >= 0); - assert(cellIndex < k_numberOfTextCell); - return &m_rangeCells[cellIndex]; + assert(index >= 0); + assert(index < k_numberOfTextCell); + return &m_rangeCells[index]; } -int RangeParameterController::reusableCellCount() { - return k_numberOfTextCell+1; +int RangeParameterController::reusableParameterCellCount(int type) { + if (type == 2) { + return 1; + } + return k_numberOfTextCell; } } diff --git a/apps/shared/range_parameter_controller.h b/apps/shared/range_parameter_controller.h index 3e8c83833..706e72749 100644 --- a/apps/shared/range_parameter_controller.h +++ b/apps/shared/range_parameter_controller.h @@ -11,14 +11,17 @@ class RangeParameterController : public FloatParameterController { public: RangeParameterController(Responder * parentResponder, InteractiveCurveViewRange * interactiveCurveViewRange); const char * title() const override; + void viewWillAppear() override; int numberOfRows() override; - HighlightCell * reusableCell(int index) override; - int reusableCellCount() override; + int typeAtLocation(int i, int j) override; void willDisplayCellForIndex(HighlightCell * cell, int index) override; bool textFieldDidFinishEditing(TextField * textField, const char * text) override; void tableViewDidChangeSelection(SelectableTableView * t, int previousSelectedCellX, int previousSelectedCellY) override; bool handleEvent(Ion::Events::Event event) override; private: + HighlightCell * reusableParameterCell(int index, int type) override; + int reusableParameterCellCount(int type) override; + float previousParameterAtIndex(int index) override; float parameterAtIndex(int index) override; void setParameterAtIndex(int parameterIndex, float f) override; constexpr static int k_numberOfTextCell = 4; @@ -26,6 +29,8 @@ private: char m_draftTextBuffer[PointerTableCellWithEditableText::k_bufferLength]; PointerTableCellWithEditableText m_rangeCells[k_numberOfTextCell]; PointerTableCellWithSwitch m_yAutoCell; + float m_previousParameters[k_numberOfTextCell]; + bool m_previousSwitchState; }; } diff --git a/apps/statistics/histogram_parameter_controller.cpp b/apps/statistics/histogram_parameter_controller.cpp index 79b62871a..feb6d46da 100644 --- a/apps/statistics/histogram_parameter_controller.cpp +++ b/apps/statistics/histogram_parameter_controller.cpp @@ -7,9 +7,8 @@ using namespace Shared; namespace Statistics { HistogramParameterController::HistogramParameterController(Responder * parentResponder, Store * store) : - FloatParameterController(parentResponder), - m_binWidthCell(PointerTableCellWithEditableText(&m_selectableTableView, this, m_draftTextBuffer, (char*)"Largeur des rectangles : ")), - m_minValueCell(PointerTableCellWithEditableText(&m_selectableTableView, this, m_draftTextBuffer, (char*)"Debut de la serie : ")), + FloatParameterController(parentResponder, "Valider"), + m_cells{PointerTableCellWithEditableText(&m_selectableTableView, this, m_draftTextBuffer, nullptr), PointerTableCellWithEditableText(&m_selectableTableView, this, m_draftTextBuffer, nullptr)}, m_store(store) { } @@ -18,6 +17,27 @@ const char * HistogramParameterController::title() const { return "Parametres de l'histogramme"; } +void HistogramParameterController::viewWillAppear() { + for (int i = 0; i < 2; i++) { + m_previousParameters[i] = parameterAtIndex(i); + } + FloatParameterController::viewWillAppear(); +} + +int HistogramParameterController::numberOfRows() { + return 1+2; +} + +void HistogramParameterController::willDisplayCellForIndex(HighlightCell * cell, int index) { + if (index == numberOfRows()-1) { + return; + } + PointerTableCellWithEditableText * myCell = (PointerTableCellWithEditableText *)cell; + const char * labels[2] = {"Largeur des rectangles : ", "Debut de la serie : "}; + myCell->setText(labels[index]); + FloatParameterController::willDisplayCellForIndex(cell, index); +} + float HistogramParameterController::parameterAtIndex(int index) { assert(index >= 0 && index < 2); if (index == 0) { @@ -26,10 +46,14 @@ float HistogramParameterController::parameterAtIndex(int index) { return m_store->firstDrawnBarAbscissa(); } +float HistogramParameterController::previousParameterAtIndex(int index) { + return m_previousParameters[index]; +} + void HistogramParameterController::setParameterAtIndex(int parameterIndex, float f) { assert(parameterIndex >= 0 && parameterIndex < 2); if (parameterIndex == 0) { - if (f <= 0.0f || isnan(f) || isinf(f)) { + if (f <= 0.0f) { app()->displayWarning("Valeur interdite"); return; } @@ -39,19 +63,12 @@ void HistogramParameterController::setParameterAtIndex(int parameterIndex, float } } -int HistogramParameterController::numberOfRows() { - return 2; -}; - -HighlightCell * HistogramParameterController::reusableCell(int index) { +HighlightCell * HistogramParameterController::reusableParameterCell(int index, int type) { assert(index >= 0 && index < 2); - if (index == 0) { - return &m_binWidthCell; - } - return &m_minValueCell; + return &m_cells[index]; } -int HistogramParameterController::reusableCellCount() { +int HistogramParameterController::reusableParameterCellCount(int type) { return 2; } diff --git a/apps/statistics/histogram_parameter_controller.h b/apps/statistics/histogram_parameter_controller.h index a7e0713ab..c0f770ddb 100644 --- a/apps/statistics/histogram_parameter_controller.h +++ b/apps/statistics/histogram_parameter_controller.h @@ -11,15 +11,18 @@ class HistogramParameterController : public Shared::FloatParameterController { public: HistogramParameterController(Responder * parentResponder, Store * store); const char * title() const override; + void viewWillAppear() override; int numberOfRows() override; - HighlightCell * reusableCell(int index) override; - int reusableCellCount() override; + void willDisplayCellForIndex(HighlightCell * cell, int index) override; private: + HighlightCell * reusableParameterCell(int index, int type) override; + int reusableParameterCellCount(int type) override; float parameterAtIndex(int index) override; + float previousParameterAtIndex(int index) override; void setParameterAtIndex(int parameterIndex, float f) override; char m_draftTextBuffer[PointerTableCellWithEditableText::k_bufferLength]; - PointerTableCellWithEditableText m_binWidthCell; - PointerTableCellWithEditableText m_minValueCell; + PointerTableCellWithEditableText m_cells[2]; + float m_previousParameters[2]; Store * m_store; };