Merge overrightarrow

[apps/reader] Refactoring the LaTeX parser

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,6 +1,6 @@
 ---
 name: Bug report
-about: Upsilon is not working like it should? Let us know!
+about: Omega is not working like it should? Let us know!
 title: ''
 labels: 'Status: Triage, Type: Bug'
 assignees: ''
@@ -24,4 +24,4 @@ A clear and concise description of what you expected to happen.
 If applicable, add screenshots to help explain your problem.
 
 **Desktop (please complete the following information):**
- - Upsilon Version: [go to settings > about > Upsilon Version and type the version here]
+ - Omega Version: [go to settings > about > Omega Version and type the version here]

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,6 +1,6 @@
 ---
 name: Feature request
-about: Suggest an idea for Upsilon
+about: Suggest an idea for Omega
 title: ''
 labels: 'Status: Triage, Type: Feature'
 assignees: ''

.github/ISSUE_TEMPLATE/omega-beta-only---bug-report.md

@@ -0,0 +1,28 @@
+---
+name: OMEGA BETA ONLY - Bug report
+about: Omega 1.21 is not working like it should? Let us know!
+title: "[BETA-1.21] …"
+labels: 'Status: Triage, Type: Bug'
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Desktop (please complete the following information):**
+ - Omega Version: [go to settings > about > Omega Version and type the version here]
+ - Discord username: ..........#....

.github/ISSUE_TEMPLATE/problems-during-installation.md

@@ -1,6 +1,6 @@
 ---
 name: Problems during installation
-about: Need help to install Upsilon?
+about: Need help to install Omega?
 title: ''
 labels: 'Status: Triage, Type: Installation issue'
 assignees: ''
@@ -16,4 +16,4 @@ Copy/paste the logs here (If you have some)
 ```
 
 **Environment**
- - Upsilon Version: {go to settings > about > Upsilon Version and type the version here}
+ - Omega Version: {go to settings > about > Omega Version and type the version here}

.github/workflows/ci-workflow.yml

@@ -140,7 +140,7 @@ jobs:
     steps:
       - uses: numworks/setup-emscripten@v1
         with:
-          sdk: 1.40.1-fastcomp
+          sdk: latest-upstream
       - uses: actions/checkout@v2
         with:
           submodules: 'recursive'

.gitmodules

@@ -1,6 +1,6 @@
 [submodule "apps/rpn"]
 	path = apps/rpn
-	url = https://github.com/Lauryy06/Upsilon-RPN.git
+	url = https://github.com/Omega-Numworks/Omega-RPN.git
 [submodule "apps/atomic"]
 	path = apps/atomic
 	url = https://github.com/Lauryy06/atomic

README.fr.md

@@ -126,7 +126,7 @@ Vous aurez besoin de devkitPro et de devkitARM disponible dans votre `$PATH` (in
 ```bash
 git clone --recursive https://github.com/Lauryy06/Upsilon.git
 cd Upsilon
-git checkout --recursive upsilon-dev
+git checkout --recursive omega-dev
 make PLATFORM=simulator TARGET=3ds -j
 ```
 

README.md

@@ -240,7 +240,7 @@ You need devkitPro and devkitARM installed and in your path (instructions [here]
 ```bash
 git clone --recursive https://github.com/Lauryy06/Upsilon.git
 cd Upsilon
-git checkout --recursive upsilon-dev
+git checkout --recursive omega-dev
 make PLATFORM=simulator TARGET=3ds -j
 ```
 You can then put epsilon.3dsx on a SD card to run it from the HBC or use 3dslink to launch it over the network:

apps/apps_container.h

@@ -66,8 +66,8 @@ private:
   bool updateAlphaLock();
 
   static I18n::Message k_promptMessages[];
-  static KDColor const * k_promptFGColors[];
-  static KDColor const * k_promptBGColors[];
+  static KDColor k_promptFGColors[];
+  static KDColor k_promptBGColors[];
   static int k_promptNumberOfMessages;
   AppsWindow m_window;
   EmptyBatteryWindow m_emptyBatteryWindow;

apps/apps_container_prompt_beta.cpp

@@ -11,14 +11,14 @@ I18n::Message AppsContainer::k_promptMessages[] = {
   I18n::Message::BetaVersionMessage6};
 
 KDColor AppsContainer::k_promptFGColors[] = {
-  &KDColorBlack,
-  &KDColorBlack,
-  &KDColorBlack,
-  &KDColorBlack,
-  &KDColorWhite,
-  &KDColorBlack,
-  &KDColorBlack,
-  *Palette::AccentText};
+  KDColorBlack,
+  KDColorBlack,
+  KDColorBlack,
+  KDColorBlack,
+  KDColorWhite,
+  KDColorBlack,
+  KDColorBlack,
+  Palette::AccentText};
 
 KDColor AppsContainer::k_promptBGColors[] = {
     KDColorWhite,

apps/apps_container_prompt_none.cpp

@@ -2,8 +2,8 @@
 
 I18n::Message AppsContainer::k_promptMessages[] = {};
 
-KDColor const * AppsContainer::k_promptFGColors[] = {};
-KDColor const * AppsContainer::k_promptBGColors[] = {};
+KDColor AppsContainer::k_promptFGColors[] = {};
+KDColor AppsContainer::k_promptBGColors[] = {};
 
 int AppsContainer::k_promptNumberOfMessages = 0;
 

apps/apps_container_prompt_update.cpp

@@ -8,15 +8,15 @@ I18n::Message AppsContainer::k_promptMessages[] = {
   I18n::Message::UpdateMessage3,
   I18n::Message::UpdateMessage4};
 
-KDColor const * AppsContainer::k_promptFGColors[] = {
-  &KDColorBlack,
-  &KDColorBlack,
-  &KDColorBlack,
-  &KDColorWhite,
-  &KDColorBlack,
-  *Palette::AccentText};
+KDColor AppsContainer::k_promptFGColors[] = {
+  KDColorBlack,
+  KDColorBlack,
+  KDColorBlack,
+  KDColorWhite,
+  KDColorBlack,
+  Palette::AccentText};
 
-KDColor const * AppsContainer::k_promptBGColors[] = {
+KDColor AppsContainer::k_promptBGColors[] = {
     KDColorWhite,
     KDColorWhite,
     KDColorWhite,

apps/battery_view.cpp

@@ -60,43 +60,43 @@ void BatteryView::drawRect(KDContext * ctx, KDRect rect) const {
    *'content' depends on the charge */
 
   // Draw the left part
-  ctx->fillRect(KDRect(0, 0, k_elementWidth, k_batteryHeight), *Palette::Battery);
+  ctx->fillRect(KDRect(0, 0, k_elementWidth, k_batteryHeight), Palette::Battery);
 
   // Draw the middle part
   constexpr KDCoordinate batteryInsideX = k_elementWidth+k_separatorThickness;
   constexpr KDCoordinate batteryInsideWidth = k_batteryWidth-3*k_elementWidth-2*k_separatorThickness;
   if (m_isCharging) {
     // Charging: Yellow background with flash
-    ctx->fillRect(KDRect(batteryInsideX, 0, batteryInsideWidth, k_batteryHeight), *Palette::BatteryInCharge);
+    ctx->fillRect(KDRect(batteryInsideX, 0, batteryInsideWidth, k_batteryHeight), Palette::BatteryInCharge);
     KDRect frame((k_batteryWidth-k_flashWidth)/2, 0, k_flashWidth, k_flashHeight);
     KDColor flashWorkingBuffer[BatteryView::k_flashHeight*BatteryView::k_flashWidth];
-    ctx->blendRectWithMask(frame, *Palette::Battery, (const uint8_t *)flashMask, flashWorkingBuffer);
+    ctx->blendRectWithMask(frame, Palette::Battery, (const uint8_t *)flashMask, flashWorkingBuffer);
   } else if (m_chargeState == Ion::Battery::Charge::LOW) {
     assert(!m_isPlugged);
     // Low: Quite empty battery
-    ctx->fillRect(KDRect(batteryInsideX, 0, 2*k_elementWidth, k_batteryHeight), *Palette::BatteryLow);
-    ctx->fillRect(KDRect(3*k_elementWidth+k_separatorThickness, 0, k_batteryWidth-5*k_elementWidth-2*k_separatorThickness, k_batteryHeight), KDColor::blend(*Palette::Toolbar, *Palette::Battery, 128));
+    ctx->fillRect(KDRect(batteryInsideX, 0, 2*k_elementWidth, k_batteryHeight), Palette::BatteryLow);
+    ctx->fillRect(KDRect(3*k_elementWidth+k_separatorThickness, 0, k_batteryWidth-5*k_elementWidth-2*k_separatorThickness, k_batteryHeight), Palette::BatteryInCharge);
   } else if (m_chargeState == Ion::Battery::Charge::SOMEWHERE_INBETWEEN) {
     assert(!m_isPlugged);
     // Middle: Half full battery
     constexpr KDCoordinate middleChargeWidth = batteryInsideWidth/2;
-    ctx->fillRect(KDRect(batteryInsideX, 0, middleChargeWidth, k_batteryHeight), *Palette::Battery);
-    ctx->fillRect(KDRect(batteryInsideX+middleChargeWidth, 0, middleChargeWidth, k_batteryHeight), KDColor::blend(*Palette::Toolbar, *Palette::Battery, 128));
+    ctx->fillRect(KDRect(batteryInsideX, 0, middleChargeWidth, k_batteryHeight), Palette::Battery);
+    ctx->fillRect(KDRect(batteryInsideX+middleChargeWidth, 0, middleChargeWidth, k_batteryHeight), Palette::BatteryInCharge);
   } else {
     assert(m_chargeState == Ion::Battery::Charge::FULL);
     // Full but not plugged: Full battery
-    ctx->fillRect(KDRect(batteryInsideX, 0, batteryInsideWidth, k_batteryHeight), *Palette::Battery);
+    ctx->fillRect(KDRect(batteryInsideX, 0, batteryInsideWidth, k_batteryHeight), Palette::Battery);
     if (m_isPlugged) {
       // Plugged and full: Full battery with tick
       KDRect frame((k_batteryWidth-k_tickWidth)/2, (k_batteryHeight-k_tickHeight)/2, k_tickWidth, k_tickHeight);
       KDColor tickWorkingBuffer[BatteryView::k_tickHeight*BatteryView::k_tickWidth];
-      ctx->blendRectWithMask(frame, *Palette::Toolbar, (const uint8_t *)tickMask, tickWorkingBuffer);
+      ctx->blendRectWithMask(frame, Palette::Toolbar, (const uint8_t *)tickMask, tickWorkingBuffer);
     }
   }
 
   // Draw the right part
-  ctx->fillRect(KDRect(k_batteryWidth-2*k_elementWidth, 0, k_elementWidth, k_batteryHeight), *Palette::Battery);
-  ctx->fillRect(KDRect(k_batteryWidth-k_elementWidth, (k_batteryHeight-k_capHeight)/2, k_elementWidth, k_capHeight), *Palette::Battery);
+  ctx->fillRect(KDRect(k_batteryWidth-2*k_elementWidth, 0, k_elementWidth, k_batteryHeight), Palette::Battery);
+  ctx->fillRect(KDRect(k_batteryWidth-k_elementWidth, (k_batteryHeight-k_capHeight)/2, k_elementWidth, k_capHeight), Palette::Battery);
 }
 
 KDSize BatteryView::minimalSizeForOptimalDisplay() const {

apps/calculation/additional_outputs/complex_graph_cell.cpp

@@ -13,7 +13,7 @@ ComplexGraphView::ComplexGraphView(ComplexModel * complexModel) :
 }
 
 void ComplexGraphView::drawRect(KDContext * ctx, KDRect rect) const {
-  ctx->fillRect(rect, *Palette::BackgroundApps);
+  ctx->fillRect(rect, Palette::BackgroundApps);
 
   // Draw grid, axes and graduations
   drawGrid(ctx, rect);
@@ -26,7 +26,7 @@ void ComplexGraphView::drawRect(KDContext * ctx, KDRect rect) const {
 
   assert(!std::isnan(real) && !std::isnan(imag) && !std::isinf(real) && !std::isinf(imag));
   // Draw the segment from the origin to the dot (real, imag)
-  drawSegment(ctx, rect, 0.0f, 0.0f, m_complex->real(), m_complex->imag(), *Palette::SecondaryText, false);
+  drawSegment(ctx, rect, 0.0f, 0.0f, m_complex->real(), m_complex->imag(), Palette::SecondaryText, false);
 
   /* Draw the partial ellipse indicating the angle θ
    * - the ellipse parameters are a = |real|/5 and b = |imag|/5,
@@ -59,27 +59,27 @@ void ComplexGraphView::drawRect(KDContext * ctx, KDRect rect) const {
         float a = parameters.real();
         float b = parameters.imag();
         return Poincare::Coordinate2D<float>(a*std::cos(t*th), b*std::sin(t*th));
-    }, &parameters, &th, false, *Palette::SecondaryText, false);
+    }, &parameters, &th, false, Palette::SecondaryText, false);
 
   // Draw dashed segment to indicate real and imaginary
-  drawHorizontalOrVerticalSegment(ctx, rect, Axis::Vertical, real, 0.0f, imag, *Palette::CalculationTrigoAndComplexForeground, 1, 3);
-  drawHorizontalOrVerticalSegment(ctx, rect, Axis::Horizontal, imag, 0.0f, real, *Palette::CalculationTrigoAndComplexForeground, 1, 3);
+  drawHorizontalOrVerticalSegment(ctx, rect, Axis::Vertical, real, 0.0f, imag, Palette::CalculationTrigoAndComplexForeground, 1, 3);
+  drawHorizontalOrVerticalSegment(ctx, rect, Axis::Horizontal, imag, 0.0f, real, Palette::CalculationTrigoAndComplexForeground, 1, 3);
 
   // Draw complex position on the plan
-  drawDot(ctx, rect, real, imag, *Palette::CalculationTrigoAndComplexForeground, Size::Large);
+  drawDot(ctx, rect, real, imag, Palette::CalculationTrigoAndComplexForeground, Size::Large);
 
   // Draw labels
   // 're(z)' label
-  drawLabel(ctx, rect, real, 0.0f, "re(z)", *Palette::CalculationTrigoAndComplexForeground, CurveView::RelativePosition::None, imag >= 0.0f ? CurveView::RelativePosition::Before : CurveView::RelativePosition::After);
+  drawLabel(ctx, rect, real, 0.0f, "re(z)", Palette::CalculationTrigoAndComplexForeground, CurveView::RelativePosition::None, imag >= 0.0f ? CurveView::RelativePosition::Before : CurveView::RelativePosition::After);
   // 'im(z)' label
-  drawLabel(ctx, rect, 0.0f, imag, "im(z)", *Palette::CalculationTrigoAndComplexForeground, real >= 0.0f ? CurveView::RelativePosition::Before : CurveView::RelativePosition::After, CurveView::RelativePosition::None);
+  drawLabel(ctx, rect, 0.0f, imag, "im(z)", Palette::CalculationTrigoAndComplexForeground, real >= 0.0f ? CurveView::RelativePosition::Before : CurveView::RelativePosition::After, CurveView::RelativePosition::None);
   // '|z|' label, the relative horizontal position of this label depends on the quadrant
   CurveView::RelativePosition verticalPosition = real*imag < 0.0f ? CurveView::RelativePosition::Before : CurveView::RelativePosition::After;
   if (real == 0.0f) {
     // Edge case: pure imaginary
     verticalPosition = CurveView::RelativePosition::None;
   }
-  drawLabel(ctx, rect, real/2.0f, imag/2.0f, "|z|", *Palette::CalculationTrigoAndComplexForeground, CurveView::RelativePosition::None, verticalPosition);
+  drawLabel(ctx, rect, real/2.0f, imag/2.0f, "|z|", Palette::CalculationTrigoAndComplexForeground, CurveView::RelativePosition::None, verticalPosition);
   // 'arg(z)' label, the absolute and relative horizontal/vertical positions of this label depends on the quadrant
   CurveView::RelativePosition horizontalPosition = real >= 0.0f ? CurveView::RelativePosition::After : CurveView::RelativePosition::None;
   verticalPosition = imag >= 0.0f ? CurveView::RelativePosition::After : CurveView::RelativePosition::Before;
@@ -88,7 +88,7 @@ void ComplexGraphView::drawRect(KDContext * ctx, KDRect rect) const {
    * and for the left half plan, we position the label at the half angle. The
    * relative position is chosen accordingly. */
   float anglePositionRatio = real >= 0.0f ? 0.0f : 0.5f;
-  drawLabel(ctx, rect, a*std::cos(anglePositionRatio*th), b*std::sin(anglePositionRatio*th), "arg(z)", *Palette::CalculationTrigoAndComplexForeground, horizontalPosition, verticalPosition);
+  drawLabel(ctx, rect, a*std::cos(anglePositionRatio*th), b*std::sin(anglePositionRatio*th), "arg(z)", Palette::CalculationTrigoAndComplexForeground, horizontalPosition, verticalPosition);
 }
 
 }

apps/calculation/additional_outputs/expression_with_equal_sign_view.cpp

@@ -15,7 +15,7 @@ void ExpressionWithEqualSignView::drawRect(KDContext * ctx, KDRect rect) const {
   // Do not color the whole background to avoid coloring behind the equal symbol
   KDSize expressionSize = ExpressionView::minimalSizeForOptimalDisplay();
   ctx->fillRect(KDRect(0, 0, expressionSize), m_backgroundColor);
-  m_layout.draw(ctx, drawingOrigin(), m_textColor, m_backgroundColor, m_selectionStart, m_selectionEnd, *Palette::Select);
+  m_layout.draw(ctx, drawingOrigin(), m_textColor, m_backgroundColor, m_selectionStart, m_selectionEnd, Palette::Select);
 }
 
 View * ExpressionWithEqualSignView::subviewAtIndex(int index) {

apps/calculation/additional_outputs/expression_with_equal_sign_view.h

@@ -11,7 +11,7 @@ namespace Calculation {
 class ExpressionWithEqualSignView : public ExpressionView {
 public:
   ExpressionWithEqualSignView() :
-    m_equalSign(KDFont::LargeFont, I18n::Message::Equal, 0.5f, 0.5f, *Palette::PrimaryText)
+    m_equalSign(KDFont::LargeFont, I18n::Message::Equal, 0.5f, 0.5f, Palette::PrimaryText)
   {}
   KDSize minimalSizeForOptimalDisplay() const override;
   void drawRect(KDContext * ctx, KDRect rect) const override;

apps/calculation/additional_outputs/illustration_cell.cpp

@@ -10,7 +10,7 @@ void IllustrationCell::layoutSubviews(bool force) {
 }
 
 void IllustrationCell::drawRect(KDContext * ctx, KDRect rect) const {
-  drawBorderOfRect(ctx, bounds(), *Palette::ListCellBorder);
+  drawBorderOfRect(ctx, bounds(), Palette::ListCellBorder);
 }
 
 }

apps/calculation/additional_outputs/list_controller.cpp

@@ -22,7 +22,7 @@ void ListController::InnerListController::didBecomeFirstResponder() {
 /* List Controller */
 
 ListController::ListController(EditExpressionController * editExpressionController, SelectableTableViewDelegate * delegate) :
-  StackViewController(nullptr, &m_listController, *Palette::ToolboxHeaderText, *Palette::ToolboxHeaderBackground, *Palette::ToolboxHeaderBorder),
+  StackViewController(nullptr, &m_listController, Palette::ToolboxHeaderText, Palette::ToolboxHeaderBackground, Palette::ToolboxHeaderBorder),
   m_listController(this, delegate),
   m_editExpressionController(editExpressionController)
 {

apps/calculation/additional_outputs/scrollable_three_expressions_cell.h

@@ -17,7 +17,7 @@ public:
   static constexpr KDCoordinate k_margin = Metric::CommonSmallMargin;
   ScrollableThreeExpressionsView(Responder * parentResponder) : Shared::AbstractScrollableMultipleExpressionsView(parentResponder, &m_contentCell), m_contentCell() {
     setMargins(k_margin, k_margin, k_margin, k_margin); // Left Right margins are already added by TableCell
-    setBackgroundColor(*Palette::BackgroundApps);
+    setBackgroundColor(Palette::BackgroundApps);
   }
   void resetMemoization();
   void setCalculation(Calculation * calculation, bool canChangeDisplayOutput);
@@ -28,7 +28,7 @@ private:
   class ContentCell : public Shared::AbstractScrollableMultipleExpressionsView::ContentCell {
   public:
     ContentCell() : m_leftExpressionView() {}
-    KDColor backgroundColor() const override { return *Palette::BackgroundApps; }
+    KDColor backgroundColor() const override { return Palette::BackgroundApps; }
     void setEven(bool even) override { return; }
     ExpressionView * leftExpressionView() const override { return const_cast<ExpressionWithEqualSignView *>(&m_leftExpressionView); }
   private:

apps/calculation/additional_outputs/second_degree_list_controller.cpp

@@ -29,12 +29,6 @@ void SecondDegreeListController::setExpression(Poincare::Expression e) {
   
   Context * context = App::app()->localContext();
   Preferences * preferences = Preferences::sharedPreferences();
-  Poincare::ExpressionNode::ReductionContext reductionContext = Poincare::ExpressionNode::ReductionContext(context, 
-          preferences->complexFormat(), preferences->angleUnit(), 
-          GlobalPreferences::sharedGlobalPreferences()->unitFormat(), 
-          ExpressionNode::ReductionTarget::SystemForApproximation, 
-          ExpressionNode::SymbolicComputation::ReplaceAllDefinedSymbolsWithDefinition, 
-          Poincare::ExpressionNode::UnitConversion::Default);
 
   PoincareHelpers::Reduce(&m_expression, context, ExpressionNode::ReductionTarget::SystemForAnalysis);
 
@@ -52,108 +46,60 @@ void SecondDegreeListController::setExpression(Poincare::Expression e) {
   Expression a = polynomialCoefficients[2];
   Expression b = polynomialCoefficients[1];
   Expression c = polynomialCoefficients[0];
-  
+
+  bool aIsNotOne = !(a.type() == ExpressionNode::Type::Rational && static_cast<const Rational &>(a).isOne());
+
   Expression delta = Subtraction::Builder(Power::Builder(b.clone(), Rational::Builder(2)), Multiplication::Builder(Rational::Builder(4), a.clone(), c.clone()));
   PoincareHelpers::Simplify(&delta, context, ExpressionNode::ReductionTarget::SystemForApproximation);
 
-  // Alpha is -b/2a, but because after we use -α, we immediately store -α=-(-b/2a)=b/2a.
-  Expression minusAlpha = Division::Builder(b.clone(), Multiplication::Builder(Rational::Builder(2), a.clone()));
-  PoincareHelpers::Reduce(&minusAlpha, context, ExpressionNode::ReductionTarget::SystemForApproximation);
+  Expression alpha = Opposite::Builder(Division::Builder(b.clone(), Multiplication::Builder(Rational::Builder(2), a.clone())));
+  PoincareHelpers::Simplify(&alpha, context, ExpressionNode::ReductionTarget::User);
 
-  // Same thing for β
-  Expression minusBeta = Division::Builder(delta.clone(), Multiplication::Builder(Rational::Builder(4), a.clone()));
-  PoincareHelpers::Reduce(&minusBeta, context, ExpressionNode::ReductionTarget::SystemForApproximation);
-
-  enum MultiplicationTypeForA {
-    Nothing,
-    Minus,
-    Parenthesis,
-    Normal
-  };
-
-  MultiplicationTypeForA multiplicationTypeForA;
-  
-  if (a.type() == ExpressionNode::Type::Rational && static_cast<const Rational &>(a).isOne()) {
-    multiplicationTypeForA = MultiplicationTypeForA::Nothing;
-  }
-  else if(a.type() == ExpressionNode::Type::Rational &&  static_cast<const Rational &>(a).isMinusOne()){
-    multiplicationTypeForA = MultiplicationTypeForA::Minus;
-  }
-  else if (a.type() == ExpressionNode::Type::Addition) {
-    multiplicationTypeForA = MultiplicationTypeForA::Parenthesis;
-  }
-  else {
-    multiplicationTypeForA = MultiplicationTypeForA::Normal;
-  }
-
-  PoincareHelpers::Simplify(&a, context, ExpressionNode::ReductionTarget::User);
+  Expression beta = Opposite::Builder(Division::Builder(delta.clone(), Multiplication::Builder(Rational::Builder(4), a.clone())));
+  PoincareHelpers::Simplify(&beta, context, ExpressionNode::ReductionTarget::User);
 
   /* 
-   * Because when can't apply reduce or simplify to keep the 
-   * canonized form we must beautify the expression manually 
+   * Because when can't apply reduce or simplify to keep the canonised 
+   * we must beautify the expression manually 
   */
 
-  Expression xMinusAlphaPowerTwo;
-  Expression alpha = getOppositeIfExists(minusAlpha, &reductionContext);
-
-  if (alpha.isUninitialized()) {
-    PoincareHelpers::Simplify(&minusAlpha, context, ExpressionNode::ReductionTarget::User);
-    xMinusAlphaPowerTwo = Power::Builder(Parenthesis::Builder(Addition::Builder(Symbol::Builder("x", strlen("x")), minusAlpha)), Rational::Builder(2));
+  Expression canonised;
+  if (alpha.type() == ExpressionNode::Type::Opposite) {
+    canonised = Addition::Builder(Symbol::Builder("x", strlen("x")), alpha.childAtIndex(0).clone());
   }
   else {
-    PoincareHelpers::Simplify(&alpha, context, ExpressionNode::ReductionTarget::User);
-    xMinusAlphaPowerTwo = Power::Builder(Parenthesis::Builder(Subtraction::Builder(Symbol::Builder("x", strlen("x")), alpha)), Rational::Builder(2));
+    canonised = Subtraction::Builder(Symbol::Builder("x", strlen("x")), alpha.clone());
   }
-  
-  Expression xMinusAlphaPowerTwoWithFactor;
-
-  switch (multiplicationTypeForA)
-  {
-    case MultiplicationTypeForA::Nothing:
-      xMinusAlphaPowerTwoWithFactor = xMinusAlphaPowerTwo;
-      break;
-    case MultiplicationTypeForA::Minus:
-      xMinusAlphaPowerTwoWithFactor = Multiplication::Builder(a.clone(), xMinusAlphaPowerTwo);
-      break;
-    case MultiplicationTypeForA::Parenthesis:
-      xMinusAlphaPowerTwoWithFactor = Multiplication::Builder(Parenthesis::Builder(a.clone()), xMinusAlphaPowerTwo);
-      break;
-    case MultiplicationTypeForA::Normal:
-      xMinusAlphaPowerTwoWithFactor = Multiplication::Builder(a.clone(), xMinusAlphaPowerTwo);
-      break;
-    default:
-      assert(false);
-      break;
+  canonised = Power::Builder(Parenthesis::Builder(canonised.clone()), Rational::Builder(2));
+  if (aIsNotOne) {
+    canonised = Multiplication::Builder(a.clone(), canonised.clone());
   }
-  
-  Expression canonized;
-  Expression beta = getOppositeIfExists(minusBeta, &reductionContext);
-  if (beta.isUninitialized()) {
-    PoincareHelpers::Simplify(&minusBeta, context, ExpressionNode::ReductionTarget::User);
-    canonized = Subtraction::Builder(xMinusAlphaPowerTwoWithFactor, minusBeta);
+  if (beta.type() == ExpressionNode::Type::Opposite) {
+    canonised = Subtraction::Builder(canonised.clone(), beta.childAtIndex(0).clone());
   }
   else {
-    PoincareHelpers::Simplify(&beta, context, ExpressionNode::ReductionTarget::User);
-    canonized = Addition::Builder(xMinusAlphaPowerTwoWithFactor, beta);
+    canonised = Addition::Builder(canonised.clone(), beta.clone());
   }
+
  
   Expression x0;
   Expression x1;
 
+
   if (delta.nullStatus(context) == ExpressionNode::NullStatus::Null) {
     // x0 = x1 = -b/(2a)
-    x0 = Division::Builder(Opposite::Builder(b.clone()), Multiplication::Builder(Rational::Builder(2), a.clone()));
+    x0 = Division::Builder(Opposite::Builder(b), Multiplication::Builder(Rational::Builder(2), a));
     m_numberOfSolutions = 1;
-    PoincareHelpers::Simplify(&x0, context, ExpressionNode::ReductionTarget::SystemForApproximation);
+    PoincareHelpers::Simplify(&x0, context, ExpressionNode::ReductionTarget::User);
   } 
   else {
     // x0 = (-b-sqrt(delta))/(2a)
     x0 = Division::Builder(Subtraction::Builder(Opposite::Builder(b.clone()), SquareRoot::Builder(delta.clone())), Multiplication::Builder(Rational::Builder(2), a.clone()));
     // x1 = (-b+sqrt(delta))/(2a)
-    x1 = Division::Builder(Addition::Builder(Opposite::Builder(b.clone()), SquareRoot::Builder(delta.clone())), Multiplication::Builder(Rational::Builder(2), a.clone()));
+    x1 = Division::Builder(Addition::Builder(Opposite::Builder(b), SquareRoot::Builder(delta.clone())), Multiplication::Builder(Rational::Builder(2), a));
     m_numberOfSolutions = 2;
-    PoincareHelpers::Simplify(&x0, context, ExpressionNode::ReductionTarget::SystemForApproximation);
-    PoincareHelpers::Simplify(&x1, context, ExpressionNode::ReductionTarget::SystemForApproximation);
+    PoincareHelpers::Simplify(&x0, context, ExpressionNode::ReductionTarget::User);
+    PoincareHelpers::Simplify(&x1, context, ExpressionNode::ReductionTarget::User);
     if (x0.type() == ExpressionNode::Type::Unreal) {
       assert(x1.type() == ExpressionNode::Type::Unreal);
       m_numberOfSolutions = 0;
@@ -163,87 +109,40 @@ void SecondDegreeListController::setExpression(Poincare::Expression e) {
   Expression factorized;
 
   if (m_numberOfSolutions == 2) {
-    Expression firstFactor;
-    Expression secondFactor;
-
-    Expression x0Opposite = getOppositeIfExists(x0, &reductionContext);
-    if (x0Opposite.isUninitialized()) {
-      PoincareHelpers::Simplify(&x0, context, ExpressionNode::ReductionTarget::User);
-      firstFactor = Subtraction::Builder(Symbol::Builder("x", strlen("x")), x0);
-    }
-    else {
-      PoincareHelpers::Simplify(&x0Opposite, context, ExpressionNode::ReductionTarget::User);
-      firstFactor = Addition::Builder(Symbol::Builder("x", strlen("x")), x0Opposite);
-    }
     if (x0.type() == ExpressionNode::Type::Opposite) {
       factorized = Parenthesis::Builder(Addition::Builder(Symbol::Builder("x", strlen("x")), x0.childAtIndex(0).clone()));
     }
-
-    Expression x1Opposite = getOppositeIfExists(x1, &reductionContext);
-    if (x1Opposite.isUninitialized()) {
-      PoincareHelpers::Simplify(&x1, context, ExpressionNode::ReductionTarget::User);
-      secondFactor = Subtraction::Builder(Symbol::Builder("x", strlen("x")), x1);
+    else {
+      factorized = Parenthesis::Builder(Subtraction::Builder(Symbol::Builder("x", strlen("x")), x0.clone()));
+    }
+    
+    if (x1.type() == ExpressionNode::Type::Opposite) {
+      factorized = Multiplication::Builder(factorized.clone(), Parenthesis::Builder(Addition::Builder(Symbol::Builder("x", strlen("x")), x1.childAtIndex(0).clone())));
     }
     else {
-      PoincareHelpers::Simplify(&x1Opposite, context, ExpressionNode::ReductionTarget::User);
-      secondFactor = Addition::Builder(Symbol::Builder("x", strlen("x")), x1Opposite);
+      factorized = Multiplication::Builder(factorized.clone(), Parenthesis::Builder(Subtraction::Builder(Symbol::Builder("x", strlen("x")), x1.clone())));
     }
 
-    Expression solutionProduct = Multiplication::Builder(Parenthesis::Builder(firstFactor), Parenthesis::Builder(secondFactor));
-    switch (multiplicationTypeForA)
-    {
-      case MultiplicationTypeForA::Nothing:
-        factorized = solutionProduct;
-        break;
-      case MultiplicationTypeForA::Minus:
-        factorized = Multiplication::Builder(a.clone(), solutionProduct);
-        break;
-      case MultiplicationTypeForA::Parenthesis:
-        factorized = Multiplication::Builder(Parenthesis::Builder(a.clone()), solutionProduct);
-        break;
-      case MultiplicationTypeForA::Normal:
-        factorized = Multiplication::Builder(a.clone(), solutionProduct);
-        break;
-      default:
-        assert(false);
-        break;
+    if (aIsNotOne) {
+      factorized = Multiplication::Builder(a.clone(), factorized.clone());
     }
   }
   else if (m_numberOfSolutions == 1) {
-    Expression x0Opposite = getOppositeIfExists(x0, &reductionContext);
-    Expression factor;
-    if (x0Opposite.isUninitialized()) {
-      PoincareHelpers::Simplify(&x0, context, ExpressionNode::ReductionTarget::User);
-      factor = Subtraction::Builder(Symbol::Builder("x", strlen("x")), x0);
+    if (x0.type() == ExpressionNode::Type::Opposite) {
+      factorized = Power::Builder(Parenthesis::Builder(Addition::Builder(Symbol::Builder("x", strlen("x")), x0.childAtIndex(0).clone())), Rational::Builder(2));
     }
     else {
-      PoincareHelpers::Simplify(&x0Opposite, context, ExpressionNode::ReductionTarget::User);
-      factor = Addition::Builder(Symbol::Builder("x", strlen("x")), x0Opposite);
+      factorized = Power::Builder(Parenthesis::Builder(Subtraction::Builder(Symbol::Builder("x", strlen("x")), x0.clone())), Rational::Builder(2));
     }
-    Expression solutionProduct = Power::Builder(Parenthesis::Builder(factor), Rational::Builder(2));
-    switch (multiplicationTypeForA)
-    {
-      case MultiplicationTypeForA::Nothing:
-        factorized = solutionProduct;
-        break;
-      case MultiplicationTypeForA::Minus:
-        factorized = Multiplication::Builder(a.clone(), solutionProduct);
-        break;
-      case MultiplicationTypeForA::Parenthesis:
-        factorized = Multiplication::Builder(Parenthesis::Builder(a.clone()), solutionProduct);
-        break;
-      case MultiplicationTypeForA::Normal:
-        factorized = Multiplication::Builder(a.clone(), solutionProduct);
-        break;
-      default:
-        assert(false);
-        break;
+
+    if (aIsNotOne) {
+      factorized = Multiplication::Builder(a.clone(), factorized.clone());
     }
   }
   
   PoincareHelpers::Simplify(&delta, context, ExpressionNode::ReductionTarget::User);
 
-  m_layouts[0] = PoincareHelpers::CreateLayout(canonized);
+  m_layouts[0] = PoincareHelpers::CreateLayout(canonised);
   if (m_numberOfSolutions > 0) {
     m_layouts[1] = PoincareHelpers::CreateLayout(factorized);
     m_layouts[2] = PoincareHelpers::CreateLayout(delta);
@@ -257,27 +156,6 @@ void SecondDegreeListController::setExpression(Poincare::Expression e) {
   }
 }
 
-Expression SecondDegreeListController::getOppositeIfExists(Expression e, Poincare::ExpressionNode::ReductionContext * reductionContext) {
-  if (e.isNumber() && e.sign(reductionContext->context()) == ExpressionNode::Sign::Negative) {
-    Number n = static_cast<Number&>(e);
-    return std::move(n.setSign(ExpressionNode::Sign::Positive));
-  }
-  else if (e.type() == ExpressionNode::Type::Multiplication && e.numberOfChildren() > 0 && e.childAtIndex(0).isNumber() && e.childAtIndex(0).sign(reductionContext->context()) == ExpressionNode::Sign::Negative) {
-    Multiplication m = static_cast<Multiplication&>(e);
-    if (m.childAtIndex(0).type() == ExpressionNode::Type::Rational && static_cast<Rational&>(e).isMinusOne()) {
-      // The negative numeral factor is -1, we just remove it
-      m.removeChildAtIndexInPlace(0);
-    } else {
-      Expression firstChild = m.childAtIndex(0);
-      Number n = static_cast<Number&>(firstChild);
-      m.childAtIndex(0).setChildrenInPlace(n.setSign(ExpressionNode::Sign::Positive));
-    }
-    PoincareHelpers::Simplify(&m, reductionContext->context(), ExpressionNode::ReductionTarget::User);
-    return std::move(m);
-  }
-  return Expression();
-}
-
 I18n::Message SecondDegreeListController::messageAtIndex(int index) {
   if (m_numberOfSolutions > 0) {
     if (index == 0) {

apps/calculation/additional_outputs/second_degree_list_controller.h

@@ -14,7 +14,6 @@ public:
   void setExpression(Poincare::Expression e) override;
 
 private:
-  Poincare::Expression getOppositeIfExists(Poincare::Expression e, Poincare::ExpressionNode::ReductionContext * reductionContext);
   I18n::Message messageAtIndex(int index) override;
   int m_numberOfSolutions;
 };

apps/calculation/additional_outputs/trigonometry_graph_cell.cpp

@@ -15,24 +15,24 @@ TrigonometryGraphView::TrigonometryGraphView(TrigonometryModel * model) :
 void TrigonometryGraphView::drawRect(KDContext * ctx, KDRect rect) const {
   float s = std::sin(m_model->angle());
   float c = std::cos(m_model->angle());
-  ctx->fillRect(rect, *Palette::BackgroundApps);
+  ctx->fillRect(rect, Palette::BackgroundApps);
   drawGrid(ctx, rect);
   drawAxes(ctx, rect);
   // Draw the circle
   drawCurve(ctx, rect, 0.0f, 2.0f*M_PI, M_PI/180.0f, [](float t, void * model, void * context) {
       return Poincare::Coordinate2D<float>(std::cos(t), std::sin(t));
-    }, nullptr, nullptr, true, *Palette::SecondaryText, false);
+    }, nullptr, nullptr, true, Palette::SecondaryText, false);
   // Draw dashed segment to indicate sine and cosine
-  drawHorizontalOrVerticalSegment(ctx, rect, Axis::Vertical, c, 0.0f, s, *Palette::CalculationTrigoAndComplexForeground, 1, 3);
-  drawHorizontalOrVerticalSegment(ctx, rect, Axis::Horizontal, s, 0.0f, c, *Palette::CalculationTrigoAndComplexForeground, 1, 3);
+  drawHorizontalOrVerticalSegment(ctx, rect, Axis::Vertical, c, 0.0f, s, Palette::CalculationTrigoAndComplexForeground, 1, 3);
+  drawHorizontalOrVerticalSegment(ctx, rect, Axis::Horizontal, s, 0.0f, c, Palette::CalculationTrigoAndComplexForeground, 1, 3);
   // Draw angle position on the circle
-  drawDot(ctx, rect, c, s, *Palette::CalculationTrigoAndComplexForeground, Size::Large);
+  drawDot(ctx, rect, c, s, Palette::CalculationTrigoAndComplexForeground, Size::Large);
   // Draw graduations
   drawLabelsAndGraduations(ctx, rect, Axis::Vertical, false, true);
   drawLabelsAndGraduations(ctx, rect, Axis::Horizontal, false, true);
   // Draw labels
-  drawLabel(ctx, rect, 0.0f, s, "sin(θ)", *Palette::CalculationTrigoAndComplexForeground, c >= 0.0f ? CurveView::RelativePosition::Before : CurveView::RelativePosition::After, CurveView::RelativePosition::None);
-  drawLabel(ctx, rect, c, 0.0f, "cos(θ)", *Palette::CalculationTrigoAndComplexForeground, CurveView::RelativePosition::None, s >= 0.0f ? CurveView::RelativePosition::Before : CurveView::RelativePosition::After);
+  drawLabel(ctx, rect, 0.0f, s, "sin(θ)", Palette::CalculationTrigoAndComplexForeground, c >= 0.0f ? CurveView::RelativePosition::Before : CurveView::RelativePosition::After, CurveView::RelativePosition::None);
+  drawLabel(ctx, rect, c, 0.0f, "cos(θ)", Palette::CalculationTrigoAndComplexForeground, CurveView::RelativePosition::None, s >= 0.0f ? CurveView::RelativePosition::Before : CurveView::RelativePosition::After);
 }
 
 }

apps/calculation/history_view_cell.cpp

@@ -81,7 +81,7 @@ void HistoryViewCell::reloadSubviewHighlight() {
   m_ellipsis.setHighlighted(false);
   if (isHighlighted()) {
     if (m_dataSource->selectedSubviewType() == HistoryViewCellDataSource::SubviewType::Input) {
-      m_inputView.setExpressionBackgroundColor(*Palette::Select);
+      m_inputView.setExpressionBackgroundColor(Palette::ListCellBackgroundSelected);
     } else if (m_dataSource->selectedSubviewType() == HistoryViewCellDataSource::SubviewType::Output) {
       m_scrollableOutputView.evenOddCell()->setHighlighted(true);
     } else {

apps/calculation/history_view_cell.h

@@ -49,7 +49,7 @@ public:
     return this;
   }
   Poincare::Layout layout() const override;
-  KDColor backgroundColor() const override { return m_even ? *Palette::CalculationBackgroundEven : *Palette::CalculationBackgroundOdd; }
+  KDColor backgroundColor() const override { return m_even ? Palette::CalculationBackgroundEven : Palette::CalculationBackgroundOdd; }
   void resetMemoization();
   void setCalculation(Calculation * calculation, bool expanded, bool canChangeDisplayOutput = false);
   int numberOfSubviews() const override { return 2 + displayedEllipsis(); }

apps/code/Makefile

@@ -1,8 +1,6 @@
 apps += Code::App
 app_headers += apps/code/app.h
 
-SFLAGS += -DHAS_CODE
-
 app_code_src = $(addprefix apps/code/,\
   app.cpp \
   console_controller.cpp \

apps/code/console_controller.cpp

@@ -40,7 +40,7 @@ ConsoleController::ConsoleController(Responder * parentResponder, App * pythonDe
 #endif
 {
   m_selectableTableView.setMargins(0, Metric::CommonRightMargin, 0, Metric::TitleBarExternHorizontalMargin);
-  m_selectableTableView.setBackgroundColor(*Palette::CodeBackground);
+  m_selectableTableView.setBackgroundColor(Palette::CodeBackground);
   m_editCell.setPrompt(sStandardPromptText);
   for (int i = 0; i < k_numberOfLineCells; i++) {
     m_cells[i].setParentResponder(&m_selectableTableView);

apps/code/console_line_cell.cpp

@@ -18,8 +18,8 @@ void ConsoleLineCell::ScrollableConsoleLineView::ConsoleLineView::setLine(Consol
 }
 
 void ConsoleLineCell::ScrollableConsoleLineView::ConsoleLineView::drawRect(KDContext * ctx, KDRect rect) const {
-  ctx->fillRect(bounds(), *Palette::CodeBackground);
-  ctx->drawString(m_line->text(), KDPointZero, GlobalPreferences::sharedGlobalPreferences()->font(), textColor(m_line), isHighlighted()? *Palette::Select : *Palette::BackgroundApps);
+  ctx->fillRect(bounds(), Palette::CodeBackground);
+  ctx->drawString(m_line->text(), KDPointZero, GlobalPreferences::sharedGlobalPreferences()->font(), textColor(m_line), isHighlighted()? Palette::Select : Palette::BackgroundApps);
 }
 
 KDSize ConsoleLineCell::ScrollableConsoleLineView::ConsoleLineView::minimalSizeForOptimalDisplay() const {

apps/code/console_line_cell.h

@@ -53,7 +53,7 @@ private:
     ConsoleLineView m_consoleLineView;
   };
   static KDColor textColor(ConsoleLine * line) {
-    return line->isFromCurrentSession() ? *Palette::CodeText : *Palette::SecondaryText;
+    return line->isFromCurrentSession() ? Palette::CodeText : Palette::SecondaryText;
   }
   MessageTextView m_promptView;
   ScrollableConsoleLineView m_scrollableView;

apps/code/editor_view.cpp

@@ -57,8 +57,8 @@ void EditorView::layoutSubviews(bool force) {
 /* EditorView::GutterView */
 
 void EditorView::GutterView::drawRect(KDContext * ctx, KDRect rect) const {
-  KDColor textColor = *Palette::PrimaryText;
-  KDColor backgroundColor = *Palette::CodeGutterViewBackground;
+  KDColor textColor = Palette::PrimaryText;
+  KDColor backgroundColor = Palette::CodeGutterViewBackground;
 
   ctx->fillRect(rect, backgroundColor);
 
@@ -102,7 +102,7 @@ void EditorView::GutterView::setOffset(KDCoordinate offset) {
 
 KDSize EditorView::GutterView::minimalSizeForOptimalDisplay() const {
   int numberOfChars = 2; // TODO: Could be computed
-  return KDSize(2 * k_margin + numberOfChars * m_font->glyphSize().width(), 0);
+  return KDSize(2 * k_margin + numberOfChars * Poincare::Preferences::sharedPreferences()->KDPythonFont()->glyphSize().width(), 0);
 }
 
 }

apps/code/python_text_area.cpp

@@ -14,12 +14,22 @@ extern "C" {
 
 namespace Code {
 
+constexpr KDColor CommentColor = Palette::CodeComment;
+constexpr KDColor NumberColor =  Palette::CodeNumber;
+constexpr KDColor KeywordColor = Palette::CodeKeyword;
+// constexpr KDColor BuiltinColor = KDColor::RGB24(0x0086B3);
+constexpr KDColor OperatorColor = Palette::CodeOperator;
+constexpr KDColor StringColor = Palette::CodeString;
+constexpr KDColor BackgroundColor = Palette::CodeBackground;
+constexpr KDColor HighlightColor = Palette::CodeBackgroundSelected;
+constexpr KDColor AutocompleteColor = KDColor::RGB24(0xC6C6C6); // TODO Palette change
+
 static inline KDColor TokenColor(mp_token_kind_t tokenKind) {
   if (tokenKind == MP_TOKEN_STRING) {
-    return *Palette::CodeString;
+    return StringColor;
   }
   if (tokenKind == MP_TOKEN_INTEGER || tokenKind == MP_TOKEN_FLOAT_OR_IMAG) {
-    return *Palette::CodeNumber;
+    return NumberColor;
   }
   static_assert(MP_TOKEN_ELLIPSIS + 1 == MP_TOKEN_KW_FALSE
       && MP_TOKEN_KW_FALSE      + 1 == MP_TOKEN_KW_NONE
@@ -59,7 +69,7 @@ static inline KDColor TokenColor(mp_token_kind_t tokenKind) {
       && MP_TOKEN_KW_YIELD      + 1 == MP_TOKEN_OP_TILDE,
     "MP_TOKEN order changed, so Code::PythonTextArea::TokenColor might need to change too.");
   if (tokenKind >= MP_TOKEN_KW_FALSE && tokenKind <= MP_TOKEN_KW_YIELD) {
-    return *Palette::CodeKeyword;
+    return KeywordColor;
   }
   static_assert(MP_TOKEN_OP_TILDE       + 1 == MP_TOKEN_OP_LESS
       && MP_TOKEN_OP_LESS               + 1 == MP_TOKEN_OP_MORE
@@ -111,9 +121,9 @@ static inline KDColor TokenColor(mp_token_kind_t tokenKind) {
       || tokenKind == MP_TOKEN_DEL_EQUAL
       || tokenKind == MP_TOKEN_DEL_MINUS_MORE)
   {
-    return *Palette::CodeOperator;
+    return OperatorColor;
   }
-  return *Palette::CodeText;
+  return Palette::CodeText;
 }
 
 static inline size_t TokenLength(mp_lexer_t * lex, const char * tokenPosition) {
@@ -206,7 +216,7 @@ void PythonTextArea::ContentView::unloadSyntaxHighlighter() {
 }
 
 void PythonTextArea::ContentView::clearRect(KDContext * ctx, KDRect rect) const {
-  ctx->fillRect(rect, *Palette::CodeBackground);
+  ctx->fillRect(rect, BackgroundColor);
 }
 
 #define LOG_DRAWING 0
@@ -236,11 +246,11 @@ void PythonTextArea::ContentView::drawLine(KDContext * ctx, int line, const char
         fromColumn,
         spacesStart,
         std::min(text + byteLength, firstNonSpace) - spacesStart,
-        *Palette::CodeString,
-        *Palette::CodeBackground,
+        StringColor,
+        BackgroundColor,
         selectionStart,
         selectionEnd,
-        *Palette::CodeBackgroundSelected);
+        HighlightColor);
   }
   if (UTF8Helper::CodePointIs(firstNonSpace, UCodePointNull)) {
     return;
@@ -266,17 +276,17 @@ void PythonTextArea::ContentView::drawLine(KDContext * ctx, int line, const char
             UTF8Helper::GlyphOffsetAtCodePoint(text, tokenEnd),
             tokenEnd,
             std::min(text + byteLength, tokenFrom) - tokenEnd,
-            *Palette::CodeString,
-            *Palette::CodeBackground,
+            StringColor,
+            BackgroundColor,
             selectionStart,
             selectionEnd,
-            *Palette::CodeBackgroundSelected);
+            HighlightColor);
       }
       tokenLength = TokenLength(lex, tokenFrom);
       tokenEnd = tokenFrom + tokenLength;
 
       // If the token is being autocompleted, use DefaultColor
-      KDColor color = (tokenFrom <= autocompleteStart && autocompleteStart < tokenEnd) ? *Palette::CodeText : TokenColor(lex->tok_kind);
+      KDColor color = (tokenFrom <= autocompleteStart && autocompleteStart < tokenEnd) ? Palette::CodeText : TokenColor(lex->tok_kind);
 
       LOG_DRAW("Draw \"%.*s\" for token %d\n", tokenLength, tokenFrom, lex->tok_kind);
       drawStringAt(ctx, line,
@@ -284,10 +294,10 @@ void PythonTextArea::ContentView::drawLine(KDContext * ctx, int line, const char
         tokenFrom,
         tokenLength,
         color,
-        *Palette::CodeBackground,
+        BackgroundColor,
         selectionStart,
         selectionEnd,
-        *Palette::CodeBackgroundSelected);
+        HighlightColor);
 
       mp_lexer_to_next(lex);
       LOG_DRAW("Pop token %d\n", lex->tok_kind);
@@ -295,18 +305,18 @@ void PythonTextArea::ContentView::drawLine(KDContext * ctx, int line, const char
 
     tokenFrom += tokenLength;
 
-    // Even if the token is being autocompleted, use *Palette::CodeComment
+    // Even if the token is being autocompleted, use CommentColor
     if (tokenFrom < text + byteLength) {
       LOG_DRAW("Draw comment \"%.*s\" from %d\n", byteLength - (tokenFrom - text), firstNonSpace, tokenFrom);
       drawStringAt(ctx, line,
           UTF8Helper::GlyphOffsetAtCodePoint(text, tokenFrom),
           tokenFrom,
           text + byteLength - tokenFrom,
-          *Palette::CodeComment,
-          *Palette::CodeBackground,
+          CommentColor,
+          BackgroundColor,
           selectionStart,
           selectionEnd,
-          *Palette::CodeBackgroundSelected);
+          HighlightColor);
     }
 
     mp_lexer_free(lex);
@@ -322,11 +332,11 @@ void PythonTextArea::ContentView::drawLine(KDContext * ctx, int line, const char
         UTF8Helper::GlyphOffsetAtCodePoint(text, autocompleteStart),
         autocompleteStart,
         std::min(text + byteLength, m_autocompletionEnd) - autocompleteStart,
-        KDColor::RGB24(0xC6C6C6),
-        *Palette::CodeBackground,
+        AutocompleteColor,
+        BackgroundColor,
         nullptr,
         nullptr,
-        *Palette::CodeBackgroundSelected);
+        HighlightColor);
   }
 }
 

apps/code/sandbox_controller.cpp

@@ -9,7 +9,7 @@ namespace Code {
 
 SandboxController::SandboxController(Responder * parentResponder) :
   ViewController(parentResponder),
-  m_solidColorView(*Palette::CodeBackground)
+  m_solidColorView(Palette::CodeBackground)
 {
 }
 

apps/code/script_node_cell.cpp

@@ -8,12 +8,12 @@ constexpr char ScriptNodeCell::k_parentheses[];
 constexpr char ScriptNodeCell::k_parenthesesWithEmpty[];
 
 void ScriptNodeCell::ScriptNodeView::drawRect(KDContext * ctx, KDRect rect) const {
-  const KDColor backgroundColor = isHighlighted()? *Palette::CodeBackgroundSelected : *Palette::CodeBackground;
+  const KDColor backgroundColor = isHighlighted()? Palette::CodeBackgroundSelected : Palette::CodeBackground;
 
   // If it exists, draw the description name.
   const char * descriptionName = m_scriptNode->description();
   if (descriptionName != nullptr) {
-    ctx->drawString(descriptionName, KDPoint(0, m_frame.height() - k_bottomMargin - k_font->glyphSize().height()), k_font, *Palette::GrayDark, backgroundColor);
+    ctx->drawString(descriptionName, KDPoint(0, m_frame.height() - k_bottomMargin - k_font->glyphSize().height()), k_font, Palette::GrayDark, backgroundColor);
   }
 
   // Draw the node name
@@ -21,10 +21,10 @@ void ScriptNodeCell::ScriptNodeView::drawRect(KDContext * ctx, KDRect rect) cons
   const int nodeNameLength = m_scriptNode->nameLength();
   KDSize nameSize = k_font->stringSize(nodeName, nodeNameLength);
   const KDCoordinate nodeNameY = k_topMargin;
-  ctx->drawString(nodeName, KDPoint(0, nodeNameY), k_font, *Palette::PrimaryText, backgroundColor, nodeNameLength);
+  ctx->drawString(nodeName, KDPoint(0, nodeNameY), k_font, KDColorBlack, backgroundColor, nodeNameLength);
   // If it is needed, draw the parentheses
   if (m_scriptNode->type() == ScriptNode::Type::WithParentheses) {
-    ctx->drawString(ScriptNodeCell::k_parentheses, KDPoint(nameSize.width(), nodeNameY), k_font, *Palette::PrimaryText, backgroundColor);
+    ctx->drawString(ScriptNodeCell::k_parentheses, KDPoint(nameSize.width(), nodeNameY), k_font, KDColorBlack, backgroundColor);
   }
 
   /* If it exists, draw the source name. If it did not fit, we would have put
@@ -32,7 +32,7 @@ void ScriptNodeCell::ScriptNodeView::drawRect(KDContext * ctx, KDRect rect) cons
   const char * sourceName = m_scriptNode->nodeSourceName();
   if (sourceName != nullptr) {
     KDSize sourceNameSize = k_font->stringSize(sourceName);
-    ctx->drawString(sourceName, KDPoint(m_frame.width() - sourceNameSize.width(), nodeNameY), k_font, *Palette::CodeText, backgroundColor);
+    ctx->drawString(sourceName, KDPoint(m_frame.width() - sourceNameSize.width(), nodeNameY), k_font, Palette::CodeText, backgroundColor);
   }
 }
 

apps/code/script_parameter_controller.cpp

@@ -100,7 +100,7 @@ void ScriptParameterController::willDisplayCellForIndex(HighlightCell * cell, in
     MessageTableCellWithBuffer * myCell = (MessageTableCellWithBuffer *)cell;
     GetScriptSize(myCell);
     myCell->setAccessoryFont(KDFont::SmallFont);
-    myCell->setAccessoryTextColor(*Palette::SecondaryText);
+    myCell->setAccessoryTextColor(Palette::SecondaryText);
   }
 }
 

apps/code/script_store.cpp

@@ -8,9 +8,11 @@ bool ScriptStore::ScriptNameIsFree(const char * baseName) {
   return ScriptBaseNamed(baseName).isNull();
 }
 
-// Here we add "base" script
 ScriptStore::ScriptStore() {
-  
+  addScriptFromTemplate(ScriptTemplate::Squares());
+  addScriptFromTemplate(ScriptTemplate::Parabola());
+  addScriptFromTemplate(ScriptTemplate::Mandelbrot());
+  addScriptFromTemplate(ScriptTemplate::Polynomial());
 }
 
 void ScriptStore::deleteAllScripts() {

apps/code/script_template.cpp

@@ -5,9 +5,103 @@ namespace Code {
 constexpr ScriptTemplate emptyScriptTemplate(".py", "\x01" R"(from math import *
 )");
 
+constexpr ScriptTemplate squaresScriptTemplate("squares.py", "\x01" R"(from math import *
+from turtle import *
+def squares(angle=0.5):
+  reset()
+  L=330
+  speed(10)
+  penup()
+  goto(-L/2,-L/2)
+  pendown()
+  for i in range(660):
+    forward(L)
+    left(90+angle)
+    L=L-L*sin(angle*pi/180)
+  hideturtle())");
+
+constexpr ScriptTemplate mandelbrotScriptTemplate("mandelbrot.py", "\x01" R"(# This script draws a Mandelbrot fractal set
+# N_iteration: degree of precision
+import kandinsky
+def mandelbrot(N_iteration):
+  for x in range(320):
+    for y in range(222):
+# Compute the mandelbrot sequence for the point c = (c_r, c_i) with start value z = (z_r, z_i)
+      z = complex(0,0)
+# Rescale to fit the drawing screen 320x222
+      c = complex(3.5*x/319-2.5, -2.5*y/221+1.25)
+      i = 0
+      while (i < N_iteration) and abs(z) < 2:
+        i = i + 1
+        z = z*z+c
+# Choose the color of the dot from the Mandelbrot sequence
+      rgb = int(255*i/N_iteration)
+      col = kandinsky.color(int(rgb*0.82),int(rgb*0.13),int(rgb*0.18))
+# Draw a pixel colored in 'col' at position (x,y)
+      kandinsky.set_pixel(x,y,col))");
+
+constexpr ScriptTemplate polynomialScriptTemplate("polynomial.py", "\x01" R"(from math import *
+# roots(a,b,c) computes the solutions of the equation a*x**2+b*x+c=0
+def roots(a,b,c):
+  delta = b*b-4*a*c
+  if delta == 0:
+    return -b/(2*a)
+  elif delta > 0:
+    x_1 = (-b-sqrt(delta))/(2*a)
+    x_2 = (-b+sqrt(delta))/(2*a)
+    return x_1, x_2
+  else:
+    return None)");
+
+constexpr ScriptTemplate parabolaScriptTemplate("parabola.py", "\x01" R"(from matplotlib.pyplot import *
+from math import *
+
+g=9.81
+
+def x(t,v_0,alpha):
+  return v_0*cos(alpha)*t
+def y(t,v_0,alpha,h_0):
+  return -0.5*g*t**2+v_0*sin(alpha)*t+h_0
+
+def vx(v_0,alpha):
+  return v_0*cos(alpha)
+def vy(t,v_0,alpha):
+  return -g*t+v_0*sin(alpha)
+
+def t_max(v_0,alpha,h_0):
+  return (v_0*sin(alpha)+sqrt((v_0**2)*(sin(alpha)**2)+2*g*h_0))/g
+
+def simulation(v_0=15,alpha=pi/4,h_0=2):
+  tMax=t_max(v_0,alpha,h_0)
+  accuracy=1/10**(floor(log10(tMax))-1)
+  T_MAX=floor(tMax*accuracy)+1
+  X=[x(t/accuracy,v_0,alpha) for t in range(T_MAX)]
+  Y=[y(t/accuracy,v_0,alpha,h_0) for t in range(T_MAX)]
+  VX=[vx(v_0,alpha) for t in range(T_MAX)]
+  VY=[vy(t/accuracy,v_0,alpha) for t in range(T_MAX)]
+  for i in range(T_MAX):
+    arrow(X[i],Y[i],VX[i]/accuracy,VY[i]/accuracy)
+  grid()
+  show())");
 
 const ScriptTemplate * ScriptTemplate::Empty() {
   return &emptyScriptTemplate;
 }
 
+const ScriptTemplate * ScriptTemplate::Squares() {
+  return &squaresScriptTemplate;
+}
+
+const ScriptTemplate * ScriptTemplate::Mandelbrot() {
+  return &mandelbrotScriptTemplate;
+}
+
+const ScriptTemplate * ScriptTemplate::Polynomial() {
+  return &polynomialScriptTemplate;
+}
+
+const ScriptTemplate * ScriptTemplate::Parabola() {
+  return &parabolaScriptTemplate;
+}
+
 }

apps/code/script_template.h

@@ -9,6 +9,10 @@ class ScriptTemplate {
 public:
   constexpr ScriptTemplate(const char * name, const char * value) : m_name(name), m_value(value) {}
   static const ScriptTemplate * Empty();
+  static const ScriptTemplate * Squares();
+  static const ScriptTemplate * Mandelbrot();
+  static const ScriptTemplate * Polynomial();
+  static const ScriptTemplate * Parabola();
   const char * name() const { return m_name; }
   const char * content() const { return m_value + Script::StatusSize(); }
   const char * value() const { return m_value; }

apps/code/toolbox_ion_keys.cpp

@@ -37,10 +37,10 @@ namespace Code {
     }
 
   void toolboxIonKeys::toolboxIonView::drawRect(KDContext * ctx, KDRect rect) const {
-    ctx->fillRect(rect, *Palette::WallScreen);
-    ctx->strokeRect(rect, *Palette::ListCellBorder);
-    ctx->drawString(I18n::translate(I18n::Message::PressAKey),KDPoint(rect.left()+80, rect.top()+20),KDFont::LargeFont,*Palette::PrimaryText,*Palette::WallScreen);
-  
+    ctx->fillRect(rect, Palette::GrayBright);
+    ctx->strokeRect(rect, Palette::GrayDark);
+    ctx->drawString(I18n::translate(I18n::Message::PressAKey),KDPoint(rect.left()+80, rect.top()+20));
+
   }
 
   View * toolboxIonKeys::view(){

apps/code/variable_box_controller.cpp

@@ -44,8 +44,8 @@ VariableBoxController::VariableBoxController(ScriptStore * scriptStore) :
   m_importedNodesCount(0)
 {
   for (int i = 0; i < k_scriptOriginsCount; i++) {
-    m_subtitleCells[i].setBackgroundColor(*Palette::WallScreen);
-    m_subtitleCells[i].setTextColor(*Palette::SecondaryText);
+    m_subtitleCells[i].setBackgroundColor(Palette::WallScreen);
+    m_subtitleCells[i].setTextColor(Palette::SecondaryText);
   }
 }
 

apps/external/main_controller.cpp

@@ -90,40 +90,40 @@ void MainController::willDisplayCellForIndex(HighlightCell * cell, int index) {
     #if defined(DEVICE_N0100) && !defined(EXTERNAL_BUILTIN)
       if(index == 0){
         myTextCell->setText(I18n::translate(I18n::Message::ExternalNotCompatible));
-        myTextCell->setTextColor(*Palette::Red);
+        myTextCell->setTextColor(Palette::Red);
       } else {
         myTextCell->setText(I18n::translate(I18n::Message::WithN0100));
-        myTextCell->setTextColor(*Palette::Red);
+        myTextCell->setTextColor(Palette::Red);
       }
     #else
       if(index == k_numberOfCells-1){
         myTextCell->setText(I18n::translate(I18n::Message::URL));
-        myTextCell->setTextColor(*Palette::AccentText);
+        myTextCell->setTextColor(Palette::AccentText);
         return;
       }
       if(index == k_numberOfCells-2){
         myTextCell->setText(I18n::translate(I18n::Message::GetMoreAppsAt));
-        myTextCell->setTextColor(*Palette::AccentText);
+        myTextCell->setTextColor(Palette::AccentText);
         return;
       }
       if(index == 0 && numberOfFiles() == 0){
         myTextCell->setText(I18n::translate(I18n::Message::NoAppsInstalled));
-        myTextCell->setTextColor(*Palette::Red);
+        myTextCell->setTextColor(Palette::Red);
       }
       if(numberOfFiles() > 0){
         if(fileAtIndex(index, f)) {
           myTextCell->setText(f.name);
-          myTextCell->setTextColor(f.isExecutable ? *Palette::PrimaryText : *Palette::Palette::SecondaryText);
+          myTextCell->setTextColor(f.isExecutable ? Palette::PrimaryText : Palette::Palette::SecondaryText);
         }
       }
     #endif
   #else
   if(index == 0){
     myTextCell->setText(I18n::translate(I18n::Message::ExternalNotCompatible));
-    myTextCell->setTextColor(*Palette::Red);
+    myTextCell->setTextColor(Palette::Red);
   } else {
     myTextCell->setText(I18n::translate(I18n::Message::WithSimulator));
-    myTextCell->setTextColor(*Palette::Red);
+    myTextCell->setTextColor(Palette::Red);
   }
   #endif
 }

apps/external/pointer_text_table_cell.cpp

@@ -19,7 +19,7 @@ const char * PointerTextTableCell::text() const {
 
 void PointerTextTableCell::setHighlighted(bool highlight) {
   HighlightCell::setHighlighted(highlight);
-  KDColor backgroundColor = highlight? *Palette::ListCellBackgroundSelected : *Palette::ListCellBackground;
+  KDColor backgroundColor = highlight? Palette::ListCellBackgroundSelected : Palette::ListCellBackground;
   m_pointerTextView.setBackgroundColor(backgroundColor);
 }
 

apps/graph/graph/graph_view.cpp

@@ -75,7 +75,7 @@ void GraphView::drawRect(KDContext * ctx, KDRect rect) const {
         // To represent the tangent, we draw segment from and to abscissas at the extremity of the drawn rect
         float minAbscissa = pixelToFloat(Axis::Horizontal, rect.left());
         float maxAbscissa = pixelToFloat(Axis::Horizontal, rect.right());
-        drawSegment(ctx, rect, minAbscissa, tangentParameterA*minAbscissa+tangentParameterB, maxAbscissa, tangentParameterA*maxAbscissa+tangentParameterB, *Palette::GraphTangent, false);
+        drawSegment(ctx, rect, minAbscissa, tangentParameterA*minAbscissa+tangentParameterB, maxAbscissa, tangentParameterA*maxAbscissa+tangentParameterB, Palette::GraphTangent, false);
       }
     } else if (type == Shared::ContinuousFunction::PlotType::Polar) {
       // Polar

apps/graph/list/list_controller.cpp

@@ -167,7 +167,7 @@ void ListController::willDisplayTitleCellAtIndex(HighlightCell * cell, int j) {
     // Set name and color if the name is not being edited
     ExpiringPointer<ContinuousFunction> function = modelStore()->modelForRecord(modelStore()->recordAtIndex(j));
     setFunctionNameInTextField(function, titleCell->textField());
-    KDColor functionNameColor = function->isActive() ? function->color() : *Palette::SecondaryText;
+    KDColor functionNameColor = function->isActive() ? function->color() : Palette::SecondaryText;
     titleCell->setColor(functionNameColor);
   }
 }
@@ -178,7 +178,7 @@ void ListController::willDisplayExpressionCellAtIndex(HighlightCell * cell, int
   Shared::FunctionListController::willDisplayExpressionCellAtIndex(cell, j);
   FunctionExpressionCell * myCell = (FunctionExpressionCell *)cell;
   ExpiringPointer<ContinuousFunction> f = modelStore()->modelForRecord(modelStore()->recordAtIndex(j));
-  KDColor textColor = f->isActive() ? *Palette::PrimaryText : *Palette::SecondaryText;
+  KDColor textColor = f->isActive() ? Palette::PrimaryText : Palette::SecondaryText;
   myCell->setTextColor(textColor);
 }
 

apps/graph/list/text_field_with_max_length_and_extension.h

@@ -17,8 +17,8 @@ public:
       const KDFont * size = KDFont::LargeFont,
       float horizontalAlignment = 0.0f,
       float verticalAlignment = 0.5f,
-      KDColor textColor = *Palette::PrimaryText,
-      KDColor backgroundColor = *Palette::BackgroundHard) :
+      KDColor textColor = Palette::PrimaryText,
+      KDColor backgroundColor = Palette::BackgroundHard) :
     TextFieldWithExtension(extensionLength, parentResponder, textBuffer, textBufferSize, draftTextBufferSize, inputEventHandlerDelegate, delegate, size, horizontalAlignment, verticalAlignment, textColor, backgroundColor) {}
   void setDraftTextBufferSize(size_t size) { m_contentView.setDraftTextBufferSize(size); }
 };

apps/hardware_test/arrow_view.cpp

@@ -30,7 +30,7 @@ const uint8_t arrowDownMask[10][9] = {
 
 ArrowView::ArrowView() :
   m_directionIsUp(true),
-  m_color(*Palette::PrimaryText)
+  m_color(Palette::PrimaryText)
 {
 }
 
@@ -50,7 +50,7 @@ void ArrowView::setColor(KDColor color) {
 
 void ArrowView::drawRect(KDContext * ctx, KDRect rect) const {
   KDColor arrowWorkingBuffer[10*9];
-  ctx->fillRect(bounds(), *Palette::BackgroundHard);
+  ctx->fillRect(bounds(), Palette::BackgroundHard);
   KDCoordinate startLine = m_directionIsUp ? k_arrowHeight : 0;
   KDCoordinate startArrow = m_directionIsUp ? 0 : bounds().height()-k_arrowHeight;
   ctx->fillRect(KDRect((Ion::Display::Width-k_arrowThickness)/2, startLine, k_arrowThickness, bounds().height()-k_arrowHeight), m_color);

apps/hardware_test/keyboard_view.cpp

@@ -59,7 +59,7 @@ void KeyboardView::drawKey(int keyIndex, KDContext * ctx, KDRect rect) const {
 
 KDColor KeyboardView::keyColor(Ion::Keyboard::Key key) const {
   if (!m_keyboardModel.belongsToTestedKeysSubset(key)) {
-    return *Palette::ListCellBorder;
+    return Palette::ListCellBorder;
   }
   if (m_keyboardModel.testedKey() == key) {
     return KDColorBlue;

apps/home/app_cell.cpp

@@ -7,7 +7,7 @@ namespace Home {
 
 AppCell::AppCell() :
   HighlightCell(),
-  m_nameView(KDFont::SmallFont, (I18n::Message)0, 0.5f, 0.5f, *Palette::HomeCellText, *Palette::HomeCellBackground),
+  m_nameView(KDFont::SmallFont, (I18n::Message)0, 0.5f, 0.5f, Palette::HomeCellText, Palette::HomeCellBackground),
   m_backgroundView(nullptr),
   m_visible(true), m_external_app(false)
 {
@@ -39,7 +39,7 @@ void AppCell::setExtAppDescriptor(const char* name, const uint8_t *icon, size_t
   m_iconView.setImage(icon, iconLength);
   m_iconView.setImage(nullptr);
   m_nameView.setText(name);
-  m_nameView.setTextColor(*Palette::HomeCellTextExternal);
+  m_nameView.setTextColor(Palette::HomeCellTextExternal);
   m_nameView.setMessage(I18n::Message::Default);
   layoutSubviews();
 }
@@ -49,7 +49,7 @@ void AppCell::setExtAppDescriptor(const char* name, const Image* icon) {
   m_iconView.setImage(icon);
   m_iconView.setImage(nullptr, 0);
   m_nameView.setText(name);
-  m_nameView.setTextColor(*Palette::HomeCellTextExternal);
+  m_nameView.setTextColor(Palette::HomeCellTextExternal);
   m_nameView.setMessage(I18n::Message::Default);
   layoutSubviews();
 }
@@ -59,7 +59,7 @@ void AppCell::setAppDescriptor(::App::Descriptor * descriptor) {
   m_iconView.setImage(descriptor->icon());
   m_iconView.setImage(nullptr, 0);
   m_nameView.setMessage(descriptor->name());
-  m_nameView.setTextColor(*Palette::HomeCellText);
+  m_nameView.setTextColor(Palette::HomeCellText);
   m_nameView.setText(nullptr);
   layoutSubviews();
 }
@@ -76,8 +76,8 @@ void AppCell::setBackgroundView(const BackgroundView * backgroundView) {
 }
 
 void AppCell::reloadCell() {
-  m_nameView.setTextColor(isHighlighted() ? (m_external_app ? *Palette::HomeCellTextExternalActive : *Palette::HomeCellTextActive) : (m_external_app ? *Palette::HomeCellTextExternal : *Palette::HomeCellText));
-  m_nameView.setBackgroundColor(isHighlighted() ? *Palette::HomeCellBackgroundActive : *Palette::HomeCellBackground);
+  m_nameView.setTextColor(isHighlighted() ? (m_external_app ? Palette::HomeCellTextExternalActive : Palette::HomeCellTextActive) : (m_external_app ? Palette::HomeCellTextExternal : Palette::HomeCellText));
+  m_nameView.setBackgroundColor(isHighlighted() ? Palette::HomeCellBackgroundActive : Palette::HomeCellBackground);
 }
 
 }

apps/home/controller.cpp

@@ -73,7 +73,7 @@ Controller::Controller(Responder * parentResponder, SelectableTableViewDataSourc
     m_cells[i].setBackgroundView(m_view.backgroundView());
   }
 
-  m_view.backgroundView()->setDefaultColor(*Palette::HomeBackground);
+  m_view.backgroundView()->setDefaultColor(Palette::HomeBackground);
 
       
 #ifdef HOME_DISPLAY_EXTERNALS

apps/lock_view.cpp

@@ -15,7 +15,7 @@ const uint8_t lockMask[LockView::k_lockHeight][LockView::k_lockWidth] = {
 void LockView::drawRect(KDContext * ctx, KDRect rect) const {
   KDRect frame((bounds().width() - k_lockWidth)/2,  (bounds().height()-k_lockHeight)/2, k_lockWidth, k_lockHeight);
   KDColor lockWorkingBuffer[LockView::k_lockHeight*LockView::k_lockWidth];
-  ctx->blendRectWithMask(frame, *Palette::ToolbarText, (const uint8_t *)lockMask, lockWorkingBuffer);
+  ctx->blendRectWithMask(frame, Palette::ToolbarText, (const uint8_t *)lockMask, lockWorkingBuffer);
 }
 
 KDSize LockView::minimalSizeForOptimalDisplay() const {

apps/math_variable_box_empty_controller.cpp

@@ -5,7 +5,7 @@
 
 MathVariableBoxEmptyController::MathVariableBoxEmptyView::MathVariableBoxEmptyView() :
   ModalViewEmptyView(),
-  m_layoutExample(0.5f, 0.5f, *Palette::PrimaryText, *Palette::WallScreen)
+  m_layoutExample(0.5f, 0.5f, KDColorBlack, Palette::WallScreen)
 {
   initMessageViews();
 }

apps/on_boarding/logo_view.cpp

@@ -11,7 +11,7 @@ LogoView::LogoView() :
 }
 
 void LogoView::drawRect(KDContext * ctx, KDRect rect) const {
-  ctx->fillRect(bounds(), *Palette::BackgroundHard);
+  ctx->fillRect(bounds(), Palette::BackgroundHard);
 }
 
 int LogoView::numberOfSubviews() const {

apps/on_boarding/prompt_controller.cpp

@@ -4,7 +4,7 @@
 
 namespace OnBoarding {
 
-PromptController::MessageViewWithSkip::MessageViewWithSkip(I18n::Message * messages, KDColor const * fgcolors[], KDColor const * bgcolors[], uint8_t numberOfMessages) :
+PromptController::MessageViewWithSkip::MessageViewWithSkip(I18n::Message * messages, KDColor * fgcolors, KDColor * bgcolors, uint8_t numberOfMessages) :
   MessageView(messages, fgcolors, bgcolors, numberOfMessages),
   m_skipView(KDFont::SmallFont, I18n::Message::Skip, 1.0f, 0.5f),
   m_okView()
@@ -42,7 +42,7 @@ void PromptController::MessageViewWithSkip::layoutSubviews(bool force) {
   m_okView.setFrame(KDRect(width - okSize.width()-k_okMargin, height-okSize.height()-k_okMargin, okSize), force);
 }
 
-PromptController::PromptController(I18n::Message * messages, KDColor const * fgcolors[], KDColor const * bgcolors[], uint8_t numberOfMessages) :
+PromptController::PromptController(I18n::Message * messages, KDColor * fgcolors, KDColor * bgcolors, uint8_t numberOfMessages) :
   ViewController(nullptr),
   m_messageViewWithSkip(messages, fgcolors, bgcolors, numberOfMessages)
 {

apps/on_boarding/prompt_controller.h

@@ -10,13 +10,13 @@ namespace OnBoarding {
 
 class PromptController : public ViewController {
 public:
-  PromptController(I18n::Message * messages, KDColor const * fgcolors[], KDColor const * bgcolors[], uint8_t numberOfMessages);
+  PromptController(I18n::Message * messages, KDColor * fgcolors, KDColor * bgcolors, uint8_t numberOfMessages);
   View * view() override { return &m_messageViewWithSkip; }
   bool handleEvent(Ion::Events::Event event) override;
 private:
   class MessageViewWithSkip : public MessageView {
   public:
-    MessageViewWithSkip(I18n::Message * messages, KDColor const * fgcolors[], KDColor const * bgcolors[], uint8_t numberOfMessages);
+    MessageViewWithSkip(I18n::Message * messages, KDColor * fgcolors, KDColor * bgcolors, uint8_t numberOfMessages);
   protected:
     int numberOfSubviews() const override;
     View * subviewAtIndex(int index) override;

apps/probability/app.cpp

@@ -85,11 +85,11 @@ App::App(Snapshot * snapshot) :
 {
     switch (snapshot->activePage()) {
     case Snapshot::Page::Parameters:
-      m_stackViewController.push(&m_parametersController, *Palette::BannerFirstText, *Palette::BannerFirstBackground, *Palette::BannerFirstBorder);
+      m_stackViewController.push(&m_parametersController, Palette::BannerFirstText, Palette::BannerFirstBackground, Palette::BannerFirstBorder);
       break;
     case Snapshot::Page::Calculations:
-      m_stackViewController.push(&m_parametersController, *Palette::BannerFirstText, *Palette::BannerFirstBackground, *Palette::BannerFirstBorder);
-      m_stackViewController.push(&m_calculationController, *Palette::BannerSecondText, *Palette::BannerSecondBackground, *Palette::BannerSecondBorder);
+      m_stackViewController.push(&m_parametersController, Palette::BannerFirstText, Palette::BannerFirstBackground, Palette::BannerFirstBorder);
+      m_stackViewController.push(&m_calculationController, Palette::BannerSecondText, Palette::BannerSecondBackground, Palette::BannerSecondBorder);
     default:
       break;
   }

apps/probability/calculation_cell.cpp

@@ -38,10 +38,10 @@ KDSize CalculationCell::minimalSizeForOptimalDisplay() const {
 }
 
 void CalculationCell::drawRect(KDContext * ctx, KDRect rect) const {
-  ctx->fillRect(bounds(), *Palette::BackgroundHard);
+  ctx->fillRect(bounds(), Palette::BackgroundHard);
   if (m_isResponder) {
     KDSize textSize = m_text.minimalSizeForOptimalDisplay();
-    ctx->strokeRect(KDRect(2*k_margin+textSize.width(), 0, calculationCellWidth()+2*ResponderImageCell::k_outline, ImageCell::k_height+2*ResponderImageCell::k_outline), *Palette::ProbabilityCellBorder);
+    ctx->strokeRect(KDRect(2*k_margin+textSize.width(), 0, calculationCellWidth()+2*ResponderImageCell::k_outline, ImageCell::k_height+2*ResponderImageCell::k_outline), Palette::ProbabilityCellBorder);
   }
 }
 

apps/probability/calculation_controller.cpp

@@ -26,7 +26,7 @@ namespace Probability {
 constexpr int CalculationController::k_titleBufferSize;
 
 CalculationController::ContentView::ContentView(SelectableTableView * selectableTableView, Distribution * distribution, Calculation * calculation) :
-  m_titleView(KDFont::SmallFont, I18n::Message::ComputeProbability, 0.5f, 0.5f, *Palette::SecondaryText, *Palette::BackgroundApps),
+  m_titleView(KDFont::SmallFont, I18n::Message::ComputeProbability, 0.5f, 0.5f, Palette::SecondaryText, Palette::BackgroundApps),
   m_selectableTableView(selectableTableView),
   m_distributionCurveView(distribution, calculation)
 {
@@ -68,7 +68,7 @@ CalculationController::CalculationController(Responder * parentResponder, InputE
   m_selectableTableView.setMargins(k_tableMargin);
   m_selectableTableView.setVerticalCellOverlap(0);
   m_selectableTableView.setDecoratorType(ScrollView::Decorator::Type::None);
-  m_selectableTableView.setBackgroundColor(*Palette::BackgroundHard);
+  m_selectableTableView.setBackgroundColor(Palette::BackgroundHard);
 
 
   for (int i = 0; i < k_numberOfCalculationCells; i++) {

apps/probability/cell.cpp

@@ -5,7 +5,7 @@ namespace Probability {
 
 Cell::Cell() :
   HighlightCell(),
-  m_labelView(KDFont::LargeFont, (I18n::Message)0, 0, 0.5, *Palette::PrimaryText, *Palette::BackgroundHard),
+  m_labelView(KDFont::LargeFont, (I18n::Message)0, 0, 0.5, Palette::PrimaryText, Palette::BackgroundHard),
   m_icon(nullptr),
   m_focusedIcon(nullptr)
 {
@@ -36,7 +36,7 @@ void Cell::layoutSubviews(bool force) {
 
 void Cell::reloadCell() {
   HighlightCell::reloadCell();
-  KDColor backgroundColor = isHighlighted()? *Palette::ListCellBackgroundSelected : *Palette::ListCellBackground;
+  KDColor backgroundColor = isHighlighted()? Palette::ListCellBackgroundSelected : Palette::ListCellBackground;
   m_labelView.setBackgroundColor(backgroundColor);
   if (isHighlighted()) {
     m_iconView.setImage(m_focusedIcon);
@@ -57,12 +57,12 @@ void Cell::setImage(const Image * image, const Image * focusedImage) {
 void Cell::drawRect(KDContext * ctx, KDRect rect) const {
   KDCoordinate width = bounds().width();
   KDCoordinate height = bounds().height();
-  KDColor backgroundColor = isHighlighted() ? *Palette::ListCellBackgroundSelected : *Palette::ListCellBackground;
+  KDColor backgroundColor = isHighlighted() ? Palette::ListCellBackgroundSelected : Palette::ListCellBackground;
   ctx->fillRect(KDRect(1, 1, width-2, height-1), backgroundColor);
-  ctx->fillRect(KDRect(0, 0, width, 1), *Palette::ProbabilityCellBorder);
-  ctx->fillRect(KDRect(0, 1, 1, height-1), *Palette::ProbabilityCellBorder);
-  ctx->fillRect(KDRect(width-1, 1, 1, height-1), *Palette::ProbabilityCellBorder);
-  ctx->fillRect(KDRect(0, height-1, width, 1), *Palette::ProbabilityCellBorder);
+  ctx->fillRect(KDRect(0, 0, width, 1), Palette::ProbabilityCellBorder);
+  ctx->fillRect(KDRect(0, 1, 1, height-1), Palette::ProbabilityCellBorder);
+  ctx->fillRect(KDRect(width-1, 1, 1, height-1), Palette::ProbabilityCellBorder);
+  ctx->fillRect(KDRect(0, height-1, width, 1), Palette::ProbabilityCellBorder);
  }
 
 }

apps/probability/distribution_controller.cpp

@@ -90,7 +90,7 @@ bool Probability::DistributionController::handleEvent(Ion::Events::Event event)
   if (event == Ion::Events::OK || event == Ion::Events::EXE || event == Ion::Events::Right) {
     StackViewController * stack = (StackViewController *)parentResponder();
     setDistributionAccordingToIndex(selectedRow());
-    stack->push(m_parametersController, *Palette::BannerFirstText, *Palette::BannerFirstBackground, *Palette::BannerFirstBorder);
+    stack->push(m_parametersController, Palette::BannerFirstText, Palette::BannerFirstBackground, Palette::BannerFirstBorder);
     return true;
   }
   return false;

apps/probability/distribution_controller.h

@@ -26,7 +26,7 @@ private:
   class ContentView : public View {
   public:
     ContentView(SelectableTableView * selectableTableView) :
-      m_titleView(KDFont::SmallFont, I18n::Message::ChooseDistribution, 0.5f, 0.5f, *Palette::SecondaryText, *Palette::BackgroundApps),
+      m_titleView(KDFont::SmallFont, I18n::Message::ChooseDistribution, 0.5f, 0.5f, Palette::SecondaryText, Palette::BackgroundApps),
       m_selectableTableView(selectableTableView)
     {}
     constexpr static KDCoordinate k_titleMargin = 8;

apps/probability/distribution_curve_view.cpp

@@ -6,7 +6,7 @@ using namespace Shared;
 
 namespace Probability {
 
-KDColor const * DistributionCurveView::k_backgroundColor = Palette::BackgroundApps;
+constexpr KDColor DistributionCurveView::k_backgroundColor;
 
 void DistributionCurveView::reload() {
   CurveView::reload();
@@ -16,9 +16,9 @@ void DistributionCurveView::reload() {
 void DistributionCurveView::drawRect(KDContext * ctx, KDRect rect) const {
   float lowerBound = m_calculation->lowerBound();
   float upperBound = m_calculation->upperBound();
-  ctx->fillRect(bounds(), *k_backgroundColor);
+  ctx->fillRect(bounds(), k_backgroundColor);
   drawAxis(ctx, rect, Axis::Horizontal);
-  drawLabelsAndGraduations(ctx, rect, Axis::Horizontal, false, false, false, 0, *k_backgroundColor);
+  drawLabelsAndGraduations(ctx, rect, Axis::Horizontal, false, false, false, 0, k_backgroundColor);
   if (m_distribution->type() == Distribution::Type::Normal) {
     /* Special case for the normal distribution, which has always the same curve
      * We indicate the pixels from and to which we color under the curve, not
@@ -29,9 +29,9 @@ void DistributionCurveView::drawRect(KDContext * ctx, KDRect rect) const {
     return;
   }
   if (m_distribution->isContinuous()) {
-    drawCartesianCurve(ctx, rect, -INFINITY, INFINITY, EvaluateXYAtAbscissa, m_distribution, nullptr, *Palette::ProbabilityCurve, true, true, lowerBound, upperBound);
+    drawCartesianCurve(ctx, rect, -INFINITY, INFINITY, EvaluateXYAtAbscissa, m_distribution, nullptr, Palette::ProbabilityCurve, true, true, lowerBound, upperBound);
   } else {
-    drawHistogram(ctx, rect, EvaluateAtAbscissa, m_distribution, nullptr, 0, 1, false, *Palette::ProbabilityHistogramBar, *Palette::ProbabilityCurve, lowerBound, upperBound+0.5f);
+    drawHistogram(ctx, rect, EvaluateAtAbscissa, m_distribution, nullptr, 0, 1, false, Palette::ProbabilityHistogramBar, Palette::ProbabilityCurve, lowerBound, upperBound+0.5f);
   }
 }
 
@@ -59,7 +59,7 @@ void DistributionCurveView::drawStandardNormal(KDContext * ctx, KDRect rect, flo
   // Draw a centered reduced normal curve
   NormalDistribution n;
   constCastedThis->setCurveViewRange(&n);
-  drawCartesianCurve(ctx, rect, -INFINITY, INFINITY, EvaluateXYAtAbscissa, &n, nullptr, *Palette::ProbabilityCurve, true, true, pixelToFloat(Axis::Horizontal, colorLowerBoundPixel), pixelToFloat(Axis::Horizontal, colorUpperBoundPixel));
+  drawCartesianCurve(ctx, rect, -INFINITY, INFINITY, EvaluateXYAtAbscissa, &n, nullptr, Palette::ProbabilityCurve, true, true, pixelToFloat(Axis::Horizontal, colorLowerBoundPixel), pixelToFloat(Axis::Horizontal, colorUpperBoundPixel));
 
   // Put back the previous curve view range
   constCastedThis->setCurveViewRange(previousRange);

apps/probability/distribution_curve_view.h

@@ -30,7 +30,7 @@ protected:
 private:
   static float EvaluateAtAbscissa(float abscissa, void * model, void * context);
   static Poincare::Coordinate2D<float> EvaluateXYAtAbscissa(float abscissa, void * model, void * context);
-  static KDColor const * k_backgroundColor;
+  static constexpr KDColor k_backgroundColor = Palette::BackgroundApps;
   void drawStandardNormal(KDContext * ctx, KDRect rect, float colorLowerBound, float colorUpperBound) const;
   char m_labels[k_maxNumberOfXLabels][k_labelBufferMaxSize];
   Distribution * m_distribution;

apps/probability/parameters_controller.cpp

@@ -8,16 +8,16 @@ namespace Probability {
 
 ParametersController::ContentView::ContentView(SelectableTableView * selectableTableView) :
   m_numberOfParameters(1),
-  m_titleView(KDFont::SmallFont, I18n::Message::ChooseParameters, 0.5f, 0.5f, *Palette::SecondaryText, *Palette::BackgroundApps),
-  m_firstParameterDefinition(KDFont::SmallFont, (I18n::Message)0, 0.5f, 0.5f, *Palette::PrimaryText, *Palette::BackgroundApps),
-  m_secondParameterDefinition(KDFont::SmallFont, (I18n::Message)0, 0.5f, 0.5f, *Palette::PrimaryText, *Palette::BackgroundApps),
+  m_titleView(KDFont::SmallFont, I18n::Message::ChooseParameters, 0.5f, 0.5f, Palette::SecondaryText, Palette::BackgroundApps),
+  m_firstParameterDefinition(KDFont::SmallFont, (I18n::Message)0, 0.5f, 0.5f, Palette::PrimaryText, Palette::BackgroundApps),
+  m_secondParameterDefinition(KDFont::SmallFont, (I18n::Message)0, 0.5f, 0.5f, Palette::PrimaryText, Palette::BackgroundApps),
   m_selectableTableView(selectableTableView)
 {
 }
 
 void ParametersController::ContentView::drawRect(KDContext * ctx, KDRect rect) const {
   int tableHeight = m_selectableTableView->minimalSizeForOptimalDisplay().height();
-  ctx->fillRect(KDRect(0, tableHeight, bounds().width(), bounds().height() - tableHeight), *Palette::BackgroundApps);
+  ctx->fillRect(KDRect(0, tableHeight, bounds().width(), bounds().height() - tableHeight), Palette::BackgroundApps);
 }
 
 MessageTextView * ParametersController::ContentView::parameterDefinitionAtIndex(int index) {
@@ -161,7 +161,7 @@ bool ParametersController::textFieldDidFinishEditing(TextField * textField, cons
 
 void ParametersController::buttonAction() {
   StackViewController * stack = stackController();
-  stack->push(m_calculationController, *Palette::BannerSecondText, *Palette::BannerSecondBackground, *Palette::BannerSecondBorder);
+  stack->push(m_calculationController, Palette::BannerSecondText, Palette::BannerSecondBackground, Palette::BannerSecondBorder);
 }
 
 }

apps/probability/responder_image_cell.cpp

@@ -11,8 +11,8 @@ ResponderImageCell::ResponderImageCell(Responder * parentResponder, Distribution
 }
 
 void ResponderImageCell::drawRect(KDContext * ctx, KDRect rect) const {
-  ctx->fillRect(bounds(), *Palette::BackgroundHard);
-  ctx->strokeRect(KDRect(0, 0, ImageCell::k_width+2*k_outline, ImageCell::k_height+2*k_outline), *Palette::ProbabilityCellBorder);
+  ctx->fillRect(bounds(), Palette::BackgroundHard);
+  ctx->strokeRect(KDRect(0, 0, ImageCell::k_width+2*k_outline, ImageCell::k_height+2*k_outline), Palette::ProbabilityCellBorder);
 }
 
 KDSize ResponderImageCell::minimalSizeForOptimalDisplay() const {

apps/reader/Makefile

@@ -1,12 +1,15 @@
 apps += Reader::App
 app_headers += apps/reader/app.h
 
+SFLAGS += -DHAS_READER
+
 app_sreader_src = $(addprefix apps/reader/,\
   app.cpp \
   list_book_controller.cpp \
   utility.cpp \
   read_book_controller \
   word_wrap_view.cpp \
+  tex_parser.cpp \
 )
 
 apps_src += $(app_sreader_src)

apps/reader/README.md

@@ -6,8 +6,10 @@ Thanks to [Gabriel79](https://github.com/Gabriel79) for the original reader app,
 # Rich text format
 Reader app supports now a rich text format : 
 
- * `$` around a mathematical expression **without spaces** to render it
+ * `$` around a LaTeX expression to render it
  * `%` around a color-code (see below) to change the color of the text
+### LaTeX expressions
+You can read the documentation for the LaTeX Parser [here](TexParser.md).
 ### Color codes :
 |code|color|
 | --:| ---:|

apps/reader/TexParser.md

@@ -0,0 +1,51 @@
+# LaTeX Parser
+
+In the reader app, you can read a txt file. You can also read a txt file with LaTeX expression inside of it.
+
+All the symbols you can use are listed here :
+
+|Command|Output||Command|Output|
+|--:|:--:|--:|--:|:--:|
+|Math|Expressions||||
+|`\frac{ab}{cd}`|$\frac{ab}{cd}$||`\sqrt[n]{x}`|$\sqrt[n]{x}$|
+|Math|Symbols|||
+|`\times`|$\times$||`\div`|$\div$|
+|`\forall`|$\forall$||`\exists`|$\exists$|
+|`\partial`|$\partial$||`\pm`|$\pm$|
+|`\infty`|$\infty$||`\approx`|$\approx$|
+|`\neq`|$\neq$||`\equiv`|$\equiv$|
+|`\leq`|$\leq$||`\geq`|$\geq$|
+|Simple|Arrows||Double|Arrows|
+|`\leftarrow`|$\leftarrow$||`\Leftarrow`|$\Leftarrow$|
+|`\rightarrow`|$\rightarrow$||`\Rightarrow`|$\Rightarrow$|
+|`\uparrow`|$\uparrow$||`\Uparrow`|$\Uparrow$|
+|`\downarrow`|$\downarrow$||`\Downarrow`|$\Downarrow$|
+|`\leftrightarrow`|$\leftrightarrow$||||
+|`\updownarrow`|$\updownarrow$||||
+|Greek Capital|Letters||Greek Small|Letters|
+|`\Alpha`|$\Alpha$||`\alpha`|$\alpha$|
+|`\Beta`|$\Beta$||`\beta`|$\beta$|
+|`\Gamma`|$\Gamma$||`\gamma`|$\gamma$|
+|`\Delta`|$\Delta$||`\delta`|$\delta$|
+|`\Epsilon`|$\Epsilon$||`\epsilon`|$\epsilon$|
+|`\Zeta`|$\Zeta$||`\zeta`|$\zeta$|
+|`\Eta`|$\Eta$||`\eta`|$\eta$|
+|`\Theta`|$\Theta$||`\theta`|$\theta$|
+|`\Iota`|$\Iota$||`\iota`|$\iota$|
+|`\Kappa`|$\Kappa$||`\kappa`|$\kappa$|
+|`\Lambda`|$\Lambda$||`\lambda`|$\lambda$|
+|`\Mu`|$\Mu$||`\mu`|$\mu$|
+|`\Nu`|$\Nu$||`\nu`|$\nu$|
+|`\Xi`|$\Xi$||`\xi`|$\xi$|
+|`\Omicron`|$\Omicron$|||
+|`\Pi`|$\Pi$||`\pi`|$\pi$|
+|`\Rho`|$\Rho$||`\rho`|$\rho$|
+|`\Sigma`|$\Sigma$||`\sigma`|$\sigma$|
+|`\Tau`|$\Tau$||`\tau`|$\tau$|
+|`\Upsilon`|$\Upsilon$||`\upsilon`|$\upsilon$|
+|`\Phi`|$\Phi$||`\phi`|$\phi$|
+|`\Chi`|$\Chi$||`\chi`|$\chi$|
+|`\Psi`|$\Psi$||`\psi`|$\psi$|
+|`\Omega`|$\Omega$||`\omega`|$\omega$|
+
+

apps/reader/read_book_controller.cpp

@@ -55,7 +55,7 @@ void ReadBookController::loadPosition() {
   else {
     m_readerView.setBookSave({
       0,
-      *Palette::PrimaryText
+      Palette::PrimaryText
     });
   }
 }

apps/reader/tex_parser.cpp

@@ -0,0 +1,210 @@
+#include "tex_parser.h"
+#include <ion/unicode/utf8_decoder.h>
+
+namespace Reader {
+
+// List of available Symbols
+  static constexpr char const * k_SymbolsCommands[] = {
+    "times", "div", "forall", "partial", "exists", "pm", "approx", "infty", "neq", "equiv", "leq", "geq", 
+    "leftarrow", "uparrow", "rightarrow", "downarrow", "leftrightarrow", "updownarrow", "Leftarrow", "Uparrow", "Rightarrow", "Downarrow",
+    "Alpha", "Beta", "Gamma", "Delta", "Epsilon", "Zeta", "Eta", "Theta", "Iota", "Kappa", "Lambda", 
+    "Mu", "Nu", "Xi", "Omicron", "Pi", "Rho", "Sigma", "Tau", "Upsilon", "Phi", "Chi", "Psi","Omega",
+    "alpha", "beta", "gamma", "delta", "epsilon", "zeta", "eta", "theta", "iota", "kappa", "lambda", 
+    "mu", "nu", "xi", "omicron", "pi", "rho", "sigma", "tau", "upsilon", "phi", "chi", "psi", "omega",
+  };
+
+  //List of the available Symbol's CodePoints in the same order of the Symbol's list
+  static constexpr uint32_t const k_SymbolsCodePoints[] = {
+    0xd7, 0xf7, 0x2200, 0x2202, 0x2203, 0xb1, 0x2248, 0x221e, 0x2260, 0x2261, 0x2264, 0x2265, 
+    0x2190, 0x2191, 0x2192, 0x2193, 0x2194, 0x2195, 0x21d0, 0x21d1, 0x21d2, 0x21d3, 
+    0x391, 0x392, 0x393, 0x394, 0x395, 0x396, 0x397, 0x398, 0x399, 0x39a, 0x39b, 
+    0x39c, 0x39d, 0x39e, 0x39f, 0x3a0, 0x3a1, 0x3a3, 0x3a4, 0x3a5, 0x3a6, 0x3a7, 0x3a8, 0x3a9, 
+    0x3b1, 0x3b2, 0x3b3, 0x3b4, 0x3b5, 0x3b6, 0x3b7, 0x3b8, 0x3b9, 0x3ba, 0x3bb, 
+    0x3bc, 0x3bd, 0x3be, 0x3bf, 0x3c0, 0x3c1, 0x3c3, 0x3c4, 0x3c5, 0x3c6, 0x3c7, 0x3c8, 0x3c9
+  };
+  
+  // List of available Function Commands that don't require a specific handling
+  static constexpr char const * k_FunctionCommands[] = {
+    "arcos", "arcsin", "arctan", "arg", "cos", "cosh", "cot", "coth", 
+    "csc", "deg", "det", "dim", "exp", "gcd", "hom", "inf", 
+    "ker", "lg", "lim", "liminf", "limsup", "ln", "log", "max", 
+    "min", "Pr", "sec", "sin", "sinh", "sup", "tan", "tanh"
+  };
+
+TexParser::TexParser(const char * text, const char * endOfText) : 
+  m_text(text), 
+  m_endOfText(endOfText),
+  m_hasError(false)
+{
+    
+}
+
+Layout TexParser::getLayout() {
+  Layout layout = popText(0);
+
+  if (m_hasError) {
+    return CodePointLayout::Builder(CodePoint(0xfffd));
+  }
+
+  return layout;
+}
+
+Layout TexParser::popBlock() {
+  while (*m_text == ' ') {
+    m_text ++;
+  }
+
+  if (*m_text == '{') {
+    m_text ++;
+    return popText('}');
+  }
+
+  if (*m_text == '\\') {
+    m_text ++;
+    return popCommand();
+  }
+
+  if (m_text >= m_endOfText) {
+    m_hasError = true;
+  }
+
+  UTF8Decoder decoder(m_text);
+  m_text ++;
+  return CodePointLayout::Builder(decoder.nextCodePoint());
+}
+
+Layout TexParser::popText(char stop) {
+  HorizontalLayout layout = HorizontalLayout::Builder();
+  const char * start = m_text;
+  
+  while (m_text < m_endOfText && *m_text != stop) {
+    switch (*m_text) {
+      // TODO: Factorize this code
+      case '\\':
+        if (start != m_text) {
+          layout.addOrMergeChildAtIndex(LayoutHelper::String(start, m_text - start), layout.numberOfChildren(), false);
+        }
+        m_text ++;
+        layout.addOrMergeChildAtIndex(popCommand(), layout.numberOfChildren(), false);
+        start = m_text;
+        break;
+      case ' ':
+        if (start != m_text) {
+          layout.addOrMergeChildAtIndex(LayoutHelper::String(start, m_text - start), layout.numberOfChildren(), false);
+        }
+        m_text ++;
+        start = m_text;
+        break;
+      case '^':
+        if (start != m_text) {
+          layout.addOrMergeChildAtIndex(LayoutHelper::String(start, m_text - start), layout.numberOfChildren(), false);
+        }
+        m_text ++;
+        layout.addOrMergeChildAtIndex(VerticalOffsetLayout::Builder(popBlock(), VerticalOffsetLayoutNode::Position::Superscript), layout.numberOfChildren(), false);
+        start = m_text;
+        break;
+      case '_':
+        if (start != m_text) {
+          layout.addOrMergeChildAtIndex(LayoutHelper::String(start, m_text - start), layout.numberOfChildren(), false);
+        }
+        m_text ++;
+        layout.addOrMergeChildAtIndex(VerticalOffsetLayout::Builder(popBlock(), VerticalOffsetLayoutNode::Position::Subscript), layout.numberOfChildren(), false);
+        start = m_text;
+        break;
+      default:
+        m_text ++;
+    }
+  }
+
+  if (start != m_text) {
+    layout.addOrMergeChildAtIndex(LayoutHelper::String(start, m_text - start), layout.numberOfChildren(), false);
+  }
+  
+  m_text ++;
+
+  if (layout.numberOfChildren() == 1) {
+    return layout.squashUnaryHierarchyInPlace();
+  }
+
+  return layout;
+}
+
+Layout TexParser::popCommand() {
+  // TODO: Factorize this code
+  if (strncmp(k_fracCommand, m_text, strlen(k_fracCommand)) == 0) {
+    if (isCommandEnded(*(m_text + strlen(k_fracCommand)))) {
+      m_text += strlen(k_fracCommand);
+      return popFracCommand();
+    } 
+  }
+  if (strncmp(k_sqrtCommand, m_text, strlen(k_sqrtCommand)) == 0) {
+    if (isCommandEnded(*(m_text + strlen(k_sqrtCommand)))) {
+      m_text += strlen(k_sqrtCommand);
+      return popSqrtCommand();
+    }
+  }
+  if (strncmp(k_overrightArrowCommand, m_text, strlen(k_overrightArrowCommand)) == 0) {
+    if (isCommandEnded(*(m_text + strlen(k_overrightArrowCommand)))) {
+      m_text += strlen(k_overrightArrowCommand);
+      return popOverrightarrowCommand();
+    }
+  }
+
+  for (int i = 0; i < k_NumberOfSymbols; i++) {
+    if (strncmp(k_SymbolsCommands[i], m_text, strlen(k_SymbolsCommands[i])) == 0) {
+      if (isCommandEnded(*(m_text + strlen(k_SymbolsCommands[i])))) {
+        m_text += strlen(k_SymbolsCommands[i]);
+        return popSymbolCommand(i);
+      }
+    }
+  }
+
+  for (int i = 0; i < k_NumberOfFunctionCommands; i++) {
+    if (strncmp(k_FunctionCommands[i], m_text, strlen(k_FunctionCommands[i])) == 0) {
+      if (isCommandEnded(*(m_text + strlen(k_FunctionCommands[i])))) {
+        m_text += strlen(k_FunctionCommands[i]);
+        return LayoutHelper::String(k_FunctionCommands[i], strlen(k_FunctionCommands[i]));
+      }
+    }
+  }	
+
+  m_hasError = true; 
+  return LayoutHelper::String(m_text, strlen(m_text));
+}
+
+// Expressions
+Layout TexParser::popFracCommand() {
+  Layout numerator = popBlock();
+  Layout denominator = popBlock();
+  FractionLayout l = FractionLayout::Builder(numerator, denominator);
+  return l;
+}
+
+Layout TexParser::popSqrtCommand() {
+  while (*m_text == ' ') {
+    m_text ++;
+  }
+  if (*m_text == '[') {
+    m_text ++;
+    Layout rootFactor = popText(']');
+    Layout belowRoot = popBlock();
+    return NthRootLayout::Builder(belowRoot, rootFactor);
+  }
+  else {
+    return NthRootLayout::Builder(popBlock());
+  }
+}
+
+Layout TexParser::popOverrightarrowCommand() {
+  return VectorLayout::Builder(popBlock());
+}
+
+Layout TexParser::popSymbolCommand(int SymbolIndex) {
+  uint32_t codePoint = k_SymbolsCodePoints[SymbolIndex];
+  return CodePointLayout::Builder(codePoint);
+}
+
+inline bool TexParser::isCommandEnded(char c) const {
+  return !(c >= 'a' && c <= 'z') && !(c >= 'A' && c <= 'Z');
+}
+}

apps/reader/tex_parser.h

@@ -0,0 +1,47 @@
+#ifndef __TEX_PARSER_H__
+#define __TEX_PARSER_H__
+
+#include <poincare_layouts.h>
+#include <poincare/layout_helper.h>
+#include <string.h>
+
+using namespace Poincare;
+
+namespace Reader
+{
+/// @brief Class used in the WordWrapTextView class to parse a Tex expression
+class TexParser {
+public:
+  TexParser(const char * text, const char * endOfText);
+  Layout getLayout();
+private:
+  Layout popBlock();
+  Layout popText(char stop);
+  Layout popCommand();
+
+  // Expressions
+  Layout popFracCommand();
+  Layout popSqrtCommand();
+  Layout popOverrightarrowCommand();
+
+  //Symbols
+  Layout popSymbolCommand(int SymbolIndex);
+
+  const char * m_text;
+  const char * m_endOfText;
+  bool m_hasError;
+
+  inline bool isCommandEnded(char c) const;
+
+  // Expressions that require specific handling
+  static constexpr char const * k_fracCommand = "frac";
+  static constexpr char const * k_sqrtCommand = "sqrt";
+  static constexpr char const * k_overrightArrowCommand = "overrightarrow";
+
+  static constexpr int const k_NumberOfSymbols = 70;
+  static constexpr int const k_NumberOfFunctionCommands = 32;
+};
+  
+}
+
+#endif

apps/reader/utility.cpp

@@ -117,7 +117,7 @@ const char * EndOfPrintableWord(const char * word, const char * end) {
   UTF8Decoder decoder(word);
   CodePoint codePoint = decoder.nextCodePoint();
   const char * result = word;
-  while (codePoint != '\n' && codePoint != ' ' && codePoint != '%') {
+  while (codePoint != '\n' && codePoint != ' ' && codePoint != '%' && codePoint != '$') {
     result = decoder.stringPosition();
     if (result >= end) {
       break;
@@ -127,4 +127,21 @@ const char * EndOfPrintableWord(const char * word, const char * end) {
   return result;
 }
 
+const char * StartOfPrintableWord(const char * word, const char * start) {
+  if (word == start) {
+    return word;
+  }
+  UTF8Decoder decoder(start, word);
+  CodePoint codePoint = decoder.previousCodePoint();
+  const char * result = word;
+  while (codePoint != '\n' && codePoint != ' ' && codePoint != '%' && codePoint != '$') {
+    result = decoder.stringPosition();
+    if (result >= start) {
+      break;
+    }
+    codePoint = decoder.previousCodePoint();
+  }
+  return result;
+}
+
 }

apps/reader/utility.h

@@ -12,6 +12,7 @@ bool stringEndsWith(const char* str, const char* end);
 int filesWithExtension(const char* extension, External::Archive::File* files, int filesSize);
 void stringNCopy(char* dest, int max, const char* src, int len);
 const char * EndOfPrintableWord(const char * word, const char * end);
+const char * StartOfPrintableWord(const char * word, const char * start);
   
 }
 #endif

apps/reader/word_wrap_view.cpp

@@ -1,6 +1,7 @@
 
 #include "word_wrap_view.h"
 #include "utility.h"
+#include "tex_parser.h"
 #include <poincare/expression.h>
 #include "../shared/poincare_helpers.h"
 #include <poincare/undefined.h>
@@ -38,16 +39,17 @@ void WordWrapTextView::previousPage() {
   const int charWidth = m_font->glyphSize().width();
   const int charHeight = m_font->glyphSize().height();
 
-  const char * endOfWord = text() + m_pageOffset - 1;
-  const char * startOfWord = UTF8Helper::BeginningOfWord(text(), endOfWord);
+  const char * endOfFile = text() + m_length;
+  const char * endOfWord = text() + m_pageOffset;
+  const char * startOfWord = StartOfPrintableWord(endOfWord, text());
 
   KDSize textSize = KDSizeZero;
 
   KDPoint textEndPosition(m_frame.width() - k_margin, m_frame.height() - k_margin);
 
   while(startOfWord>=text()) {
-    startOfWord = UTF8Helper::BeginningOfWord(text(), endOfWord);
-    endOfWord = UTF8Helper::EndOfWord(startOfWord);
+    startOfWord = StartOfPrintableWord(endOfWord-1, text());
+    //endOfWord = EndOfPrintableWord(startOfWord, endOfFile);
 
     if (*startOfWord == '%') {
       if (updateTextColorBackward(startOfWord)) {
@@ -55,20 +57,28 @@ void WordWrapTextView::previousPage() {
         continue;
       }
     }
-    if (*startOfWord == '$' && *(endOfWord-1) == '$') {
-      const int wordMaxLength = 128;
-      char word[wordMaxLength];
-      stringNCopy(word, wordMaxLength, startOfWord + 1, endOfWord-startOfWord-2);
-      Poincare::Expression expr = Poincare::Expression::Parse(word, nullptr);
-      if (expr.isUninitialized()) {
-        expr = Poincare::Undefined::Builder();
+
+    if (*endOfWord == '$') {
+      startOfWord = endOfWord - 1;
+      while (*startOfWord != '$') {
+        if (startOfWord < text()) {
+          break; // File isn't rightly formated
+        }
+        startOfWord --;
       }
-      Poincare::Layout layout = Shared::PoincareHelpers::CreateLayout(expr);
-      textSize = layout.layoutSize();
-      
+      startOfWord --;
+
+      TexParser parser = TexParser(startOfWord + 1, endOfWord - 2);
+      Poincare::Layout layout = parser.getLayout();
+      textSize = layout.layoutSize(); 
     }
     else {
-      textSize = m_font->stringSizeUntil(startOfWord, endOfWord);
+      if (*startOfWord == '\\' || *(startOfWord + 1) == '$') {
+      textSize = m_font->stringSizeUntil(startOfWord + 1, endOfWord);
+      }
+      else {
+        textSize = m_font->stringSizeUntil(startOfWord, endOfWord);
+      }
     }
     KDPoint textStartPosition = KDPoint(textEndPosition.x()-textSize.width(), textEndPosition.y());
 
@@ -109,7 +119,7 @@ void WordWrapTextView::previousPage() {
     m_pageOffset = 0;
   }
   else {
-    m_pageOffset = UTF8Helper::EndOfWord(startOfWord) - text() + 1;
+    m_pageOffset = EndOfPrintableWord(startOfWord, endOfFile) - text() + 1;
   }
   markRectAsDirty(bounds());
 }
@@ -119,7 +129,12 @@ void WordWrapTextView::drawRect(KDContext * ctx, KDRect rect) const {
 
   const char * endOfFile = text() + m_length;
   const char * startOfWord = text() + m_pageOffset;
-  const char * endOfWord = EndOfPrintableWord(startOfWord, endOfFile);
+  const char * endOfWord;
+  
+  if (*startOfWord != '$') {
+    endOfWord = EndOfPrintableWord(startOfWord, endOfFile);
+  } // Else we don't need to update endOfWord
+
   KDPoint textPosition(k_margin, k_margin);
 
   const int wordMaxLength = 128;
@@ -152,18 +167,26 @@ void WordWrapTextView::drawRect(KDContext * ctx, KDRect rect) const {
         continue;
       }
     }
-    
-    if (*startOfWord == '$' && *(endOfWord-1) == '$') { // Look for expression
-      stringNCopy(word, wordMaxLength, startOfWord + 1, endOfWord-startOfWord-2);
-      Poincare::Expression expr = Poincare::Expression::Parse(word, nullptr);
-      if (expr.isUninitialized()) {
-        expr = Poincare::Undefined::Builder();
+
+    if (*startOfWord == '$') { // Look for expression
+      endOfWord = startOfWord + 1;
+      while (*endOfWord != '$') {
+        if (endOfWord > endOfFile) {
+          break; // If we are here, it's bad...
+        }
+        endOfWord ++;
       }
-      layout = Shared::PoincareHelpers::CreateLayout(expr);
+      endOfWord ++;
+
+      TexParser parser = TexParser(startOfWord + 1, endOfWord - 1);
+      layout = parser.getLayout();
       textSize = layout.layoutSize();
       toDraw = ToDraw::Expression;
     }
     else {
+      if (*startOfWord == '\\' || *(startOfWord + 1) == '$') {
+        startOfWord ++;
+      }
       textSize = m_font->stringSizeUntil(startOfWord, endOfWord);
       stringNCopy(word, wordMaxLength, startOfWord, endOfWord-startOfWord);
       toDraw = ToDraw::Text;
@@ -222,7 +245,10 @@ void WordWrapTextView::drawRect(KDContext * ctx, KDRect rect) const {
     }
 
     textPosition = nextTextPosition;
-    endOfWord = EndOfPrintableWord(startOfWord+1, endOfFile);
+
+    if (*startOfWord != '$') {
+      endOfWord = EndOfPrintableWord(startOfWord+1, endOfFile);
+    } // Else we don't need to update endOfWord
   }
 
   m_nextPageOffset = startOfWord - text();
@@ -243,7 +269,7 @@ void WordWrapTextView::setBookSave(BookSave save) {
 bool WordWrapTextView::updateTextColorForward(const char * colorStart) const {
 
   if (*(colorStart + 1) == '\\') {
-    m_textColor = *Palette::PrimaryText;
+    m_textColor = Palette::PrimaryText;
     return (*(colorStart + 3) == '%' || *(colorStart + 4) == '%');
   }
 
@@ -254,56 +280,56 @@ bool WordWrapTextView::updateTextColorForward(const char * colorStart) const {
   {
     case 'r':
         if (*(colorStart+2) == 'l') {
-            m_textColor = *Palette::RedLight;
+            m_textColor = Palette::RedLight;
             keySize = 2;
         }
         else {
-            m_textColor = *Palette::Red;
+            m_textColor = Palette::Red;
         }
         break;
     case 'm':
-        m_textColor = *Palette::Magenta;
+        m_textColor = Palette::Magenta;
         break;
     case 't':
-        m_textColor = *Palette::Turquoise;
+        m_textColor = Palette::Turquoise;
         break;
     case 'p':
         if (*(colorStart+2) == 'k') {
-            m_textColor = *Palette::Pink;
+            m_textColor = Palette::Pink;
             keySize = 2;
         }
         else if (*(colorStart+2) == 'p') {
-            m_textColor = *Palette::Purple;
+            m_textColor = Palette::Purple;
             keySize = 2;
         }
         break;
     case 'b':
         if (*(colorStart+2) == 'r') {
-            m_textColor = *Palette::Brown;
+            m_textColor = Palette::Brown;
             keySize = 2;
         }
         if (*(colorStart+2) == 'l') {
-            m_textColor = *Palette::BlueLight;
+            m_textColor = Palette::BlueLight;
             keySize = 2;
         }
         else {
-            m_textColor = *Palette::Blue;
+            m_textColor = Palette::Blue;
         }
         break;
     case 'o':
-        m_textColor = *Palette::Orange;
+        m_textColor = Palette::Orange;
         break;
     case 'g':
         if (*(colorStart+2) == 'l') {
-            m_textColor = *Palette::GreenLight;
+            m_textColor = Palette::GreenLight;
             keySize = 2;
         }
         else {
-            m_textColor = *Palette::Green;
+            m_textColor = Palette::Green;
         }
         break;
     case 'c':
-        m_textColor = *Palette::Cyan;
+        m_textColor = Palette::Cyan;
         break;
 
     default:
@@ -330,56 +356,56 @@ bool WordWrapTextView::updateTextColorBackward(const char * colorStart) const {
   {
     case 'r':
         if (*(colorStart+2) == 'l') {
-            m_textColor = *Palette::RedLight;
+            m_textColor = Palette::RedLight;
             keySize = 2;
         }
         else {
-            m_textColor = *Palette::Red;
+            m_textColor = Palette::Red;
         }
         break;
     case 'm':
-        m_textColor = *Palette::Magenta;
+        m_textColor = Palette::Magenta;
         break;
     case 't':
-        m_textColor = *Palette::Turquoise;
+        m_textColor = Palette::Turquoise;
         break;
     case 'p':
         if (*(colorStart+2) == 'k') {
-            m_textColor = *Palette::Pink;
+            m_textColor = Palette::Pink;
             keySize = 2;
         }
         else if (*(colorStart+2) == 'p') {
-            m_textColor = *Palette::Purple;
+            m_textColor = Palette::Purple;
             keySize = 2;
         }
         break;
     case 'b':
         if (*(colorStart+2) == 'r') {
-            m_textColor = *Palette::Brown;
+            m_textColor = Palette::Brown;
             keySize = 2;
         }
         if (*(colorStart+2) == 'l') {
-            m_textColor = *Palette::BlueLight;
+            m_textColor = Palette::BlueLight;
             keySize = 2;
         }
         else {
-            m_textColor = *Palette::Blue;
+            m_textColor = Palette::Blue;
         }
         break;
     case 'o':
-        m_textColor = *Palette::Orange;
+        m_textColor = Palette::Orange;
         break;
     case 'g':
         if (*(colorStart+2) == 'l') {
-            m_textColor = *Palette::GreenLight;
+            m_textColor = Palette::GreenLight;
             keySize = 2;
         }
         else {
-            m_textColor = *Palette::Green;
+            m_textColor = Palette::Green;
         }
         break;
     case 'c':
-        m_textColor = *Palette::Cyan;
+        m_textColor = Palette::Cyan;
         break;
 
     default:

apps/regression/calculation_controller.cpp

@@ -26,18 +26,18 @@ CalculationController::CalculationController(Responder * parentResponder, Button
 {
   m_r2Layout = HorizontalLayout::Builder(CodePointLayout::Builder('r', KDFont::SmallFont), VerticalOffsetLayout::Builder(CodePointLayout::Builder('2', KDFont::SmallFont), VerticalOffsetLayoutNode::Position::Superscript));
   m_selectableTableView.setVerticalCellOverlap(0);
-  m_selectableTableView.setBackgroundColor(*Palette::BackgroundAppsSecondary);
+  m_selectableTableView.setBackgroundColor(Palette::BackgroundAppsSecondary);
   m_selectableTableView.setMargins(k_margin, k_scrollBarMargin, k_scrollBarMargin, k_margin);
   m_r2TitleCell.setAlignment(1.0f, 0.5f);
   for (int i = 0; i < Store::k_numberOfSeries; i++) {
     m_columnTitleCells[i].setParentResponder(&m_selectableTableView);
   }
   for (int i = 0; i < k_numberOfDoubleCalculationCells; i++) {
-    m_doubleCalculationCells[i].setTextColor(*Palette::SecondaryText);
+    m_doubleCalculationCells[i].setTextColor(Palette::SecondaryText);
     m_doubleCalculationCells[i].setParentResponder(&m_selectableTableView);
   }
   for (int i = 0; i < k_numberOfCalculationCells;i++) {
-    m_calculationCells[i].setTextColor(*Palette::SecondaryText);
+    m_calculationCells[i].setTextColor(Palette::SecondaryText);
   }
   for (int i = 0; i < k_maxNumberOfDisplayableRows; i++) {
     m_titleCells[i].setMessageFont(KDFont::SmallFont);
@@ -167,7 +167,7 @@ void CalculationController::willDisplayCellAtLocation(HighlightCell * cell, int
     buffer[0] = 'Y';
     myCell->setSecondText(buffer);
     assert(seriesNumber < Palette::numberOfDataColors());
-    myCell->setColor(*Palette::DataColor[seriesNumber]);
+    myCell->setColor(Palette::DataColor[seriesNumber]);
     return;
   }
 

apps/regression/column_title_cell.h

@@ -9,7 +9,7 @@ class ColumnTitleCell : public EvenOddDoubleBufferTextCellWithSeparator {
 public:
   ColumnTitleCell(Responder * parentResponder = nullptr) :
     EvenOddDoubleBufferTextCellWithSeparator(parentResponder, 0.5f, 0.5f),
-    m_functionColor(*Palette::Red)
+    m_functionColor(Palette::Red)
   {
   }
   virtual void setColor(KDColor color);

apps/regression/graph_controller.cpp

@@ -391,7 +391,7 @@ void GraphController::setRoundCrossCursorView() {
   if (round) {
     // Set the color although the cursor view stays round
     assert(*m_selectedSeriesIndex < Palette::numberOfDataColors());
-    m_roundCursorView.setColor(*Palette::DataColor[*m_selectedSeriesIndex]);
+    m_roundCursorView.setColor(Palette::DataColor[*m_selectedSeriesIndex]);
   }
   CursorView * nextCursorView = round ? static_cast<Shared::CursorView *>(&m_roundCursorView) : static_cast<Shared::CursorView *>(&m_crossCursorView);
   // Escape if the cursor view stays the same

apps/regression/graph_view.cpp

@@ -15,7 +15,7 @@ GraphView::GraphView(Store * store, CurveViewCursor * cursor, BannerView * banne
 }
 
 void GraphView::drawRect(KDContext * ctx, KDRect rect) const {
-  ctx->fillRect(rect, *Palette::BackgroundHard);
+  ctx->fillRect(rect, Palette::BackgroundHard);
   drawGrid(ctx, rect);
   drawAxes(ctx, rect);
   simpleDrawBothAxesLabels(ctx, rect);
@@ -23,7 +23,7 @@ void GraphView::drawRect(KDContext * ctx, KDRect rect) const {
   for (int series = 0; series < Store::k_numberOfSeries; series++) {
     if (!m_store->seriesIsEmpty(series)) {
       assert(series < Palette::numberOfDataColors());
-      KDColor color = *Palette::DataColor[series];
+      KDColor color = Palette::DataColor[series];
       Model * seriesModel = m_store->modelForSeries(series);
       drawCartesianCurve(ctx, rect, -INFINITY, INFINITY, [](float abscissa, void * model, void * context) {
           Model * regressionModel = static_cast<Model *>(model);
@@ -35,7 +35,7 @@ void GraphView::drawRect(KDContext * ctx, KDRect rect) const {
         drawDot(ctx, rect, m_store->get(series, 0, index), m_store->get(series, 1, index), color);
       }
       drawDot(ctx, rect, m_store->meanOfColumn(series, 0), m_store->meanOfColumn(series, 1), color, Size::Small);
-      drawDot(ctx, rect, m_store->meanOfColumn(series, 0), m_store->meanOfColumn(series, 1), *Palette::BackgroundHard);
+      drawDot(ctx, rect, m_store->meanOfColumn(series, 0), m_store->meanOfColumn(series, 1), Palette::BackgroundHard);
     }
   }
 }

apps/regression/store_controller.cpp

@@ -38,7 +38,7 @@ void StoreController::willDisplayCellAtLocation(HighlightCell * cell, int i, int
   bool isValuesColumn = i%Store::k_numberOfColumnsPerSeries == 0;
   mytitleCell->setSeparatorLeft(isValuesColumn && i > 0);
   int seriesIndex = i/Store::k_numberOfColumnsPerSeries;
-  mytitleCell->setColor(m_store->numberOfPairsOfSeries(seriesIndex) == 0 ? *Palette::SecondaryText : Store::colorOfSeriesAtIndex(seriesIndex)); // TODO Share GreyDark with graph/list_controller and statistics/store_controller
+  mytitleCell->setColor(m_store->numberOfPairsOfSeries(seriesIndex) == 0 ? Palette::SecondaryText : Store::colorOfSeriesAtIndex(seriesIndex)); // TODO Share GreyDark with graph/list_controller and statistics/store_controller
   char name[] = {isValuesColumn ? 'X' : 'Y', static_cast<char>('1' + seriesIndex), 0};
   mytitleCell->setText(name);
 }

apps/sequence/graph/graph_view.cpp

@@ -30,7 +30,7 @@ void GraphView::drawRect(KDContext * ctx, KDRect rect) const {
       }
       drawDot(ctx, rect, x, y, s->color());
       if (x >= m_highlightedStart && x <= m_highlightedEnd && record == m_selectedRecord) {
-        KDColor color = m_shouldColorHighlighted ? s->color() : *Palette::PrimaryText;
+        KDColor color = m_shouldColorHighlighted ? s->color() : Palette::PrimaryText;
         if (y >= 0.0f) {
           drawHorizontalOrVerticalSegment(ctx, rect, Axis::Vertical, x, 0.0f, y, color, 1);
         } else {

apps/sequence/list/list_controller.cpp

@@ -15,7 +15,7 @@ ListController::ListController(Responder * parentResponder, ::InputEventHandlerD
   m_expressionCells{},
   m_parameterController(inputEventHandlerDelegate, this),
   m_typeParameterController(this, this, TableCell::Layout::Vertical),
-  m_typeStackController(nullptr, &m_typeParameterController, *Palette::ToolboxHeaderText, *Palette::ToolboxHeaderBackground, *Palette::ToolboxHeaderBorder),
+  m_typeStackController(nullptr, &m_typeParameterController, Palette::ToolboxHeaderText, Palette::ToolboxHeaderBackground, Palette::ToolboxHeaderBorder),
   m_sequenceToolbox()
 {
   for (int i = 0; i < k_maxNumberOfRows; i++) {
@@ -191,7 +191,7 @@ void ListController::willDisplayTitleCellAtIndex(HighlightCell * cell, int j) {
     myCell->setLayout(sequence->secondInitialConditionName());
   }
   // Set the color
-  KDColor nameColor = sequence->isActive() ? sequence->color() : *Palette::SecondaryText;
+  KDColor nameColor = sequence->isActive() ? sequence->color() : Palette::SecondaryText;
   myCell->setColor(nameColor);
 }
 
@@ -209,7 +209,7 @@ void ListController::willDisplayExpressionCellAtIndex(HighlightCell * cell, int
     myCell->setLayout(sequence->secondInitialConditionLayout());
   }
   bool active = sequence->isActive();
-  KDColor textColor = active ? *Palette::PrimaryText : *Palette::SecondaryText;
+  KDColor textColor = active ? Palette::PrimaryText : Palette::SecondaryText;
   myCell->setTextColor(textColor);
 }
 

apps/settings/cell_with_separator.cpp

@@ -8,7 +8,7 @@ void CellWithSeparator::setHighlighted(bool highlight) {
 }
 
 void CellWithSeparator::drawRect(KDContext * ctx, KDRect rect) const {
-  ctx->fillRect(KDRect(0, Metric::CellSeparatorThickness, bounds().width(), k_margin), *Palette::BackgroundApps);
+  ctx->fillRect(KDRect(0, Metric::CellSeparatorThickness, bounds().width(), k_margin), Palette::BackgroundApps);
 }
 
 int CellWithSeparator::numberOfSubviews() const {

apps/settings/main_controller.cpp

@@ -21,9 +21,7 @@ constexpr SettingsMessageTree s_accessibilityChildren[6] = {SettingsMessageTree(
 constexpr SettingsMessageTree s_contributorsChildren[23] = {SettingsMessageTree(I18n::Message::Developers), SettingsMessageTree(I18n::Message::QuentinGuidee), SettingsMessageTree(I18n::Message::JoachimLeFournis), SettingsMessageTree(I18n::Message::MaximeFriess), SettingsMessageTree(I18n::Message::JeanBaptisteBoric), SettingsMessageTree(I18n::Message::SandraSimmons), SettingsMessageTree(I18n::Message::David), SettingsMessageTree(I18n::Message::DamienNicolet), SettingsMessageTree(I18n::Message::EvannDreumont), SettingsMessageTree(I18n::Message::SzaboLevente), SettingsMessageTree(I18n::Message::VenceslasDuet), SettingsMessageTree(I18n::Message::CharlotteThomas), SettingsMessageTree(I18n::Message::AntoninLoubiere), SettingsMessageTree(I18n::Message::CyprienMejat), SettingsMessageTree(I18n::Message::BetaTesters), SettingsMessageTree(I18n::Message::TimeoArnouts), SettingsMessageTree(I18n::Message::JulieC), SettingsMessageTree(I18n::Message::LelahelHideux), SettingsMessageTree(I18n::Message::Madil), SettingsMessageTree(I18n::Message::HilaireLeRoux), SettingsMessageTree(I18n::Message::HectorNussbaumer), SettingsMessageTree(I18n::Message::RaphaelDyda), SettingsMessageTree(I18n::Message::ThibautC)};
 
 // Code Settings
-#ifdef HAS_CODE
 constexpr SettingsMessageTree s_codeChildren[2] = {SettingsMessageTree(I18n::Message::FontSizes, s_modelFontChildren), SettingsMessageTree(I18n::Message::Autocomplete)};
-#endif
 constexpr SettingsMessageTree s_modelFontChildren[2] = {SettingsMessageTree(I18n::Message::LargeFont), SettingsMessageTree(I18n::Message::SmallFont)};
 
 

apps/settings/main_controller_prompt_beta.cpp

@@ -13,9 +13,7 @@ constexpr SettingsMessageTree s_modelMenu[] =
     SettingsMessageTree(I18n::Message::Language),
     SettingsMessageTree(I18n::Message::Country),
     SettingsMessageTree(I18n::Message::ExamMode, ExamModeConfiguration::s_modelExamChildren),
-#ifdef HAS_CODE
     SettingsMessageTree(I18n::Message::CodeApp, s_codeChildren),
-#endif
     SettingsMessageTree(I18n::Message::BetaPopUp),
     SettingsMessageTree(I18n::Message::About, s_modelAboutChildren),
     SettingsMessageTree(I18n::Message::Accessibility, s_accessibilityChildren)};

apps/settings/main_controller_prompt_none.cpp

@@ -13,9 +13,8 @@ constexpr SettingsMessageTree s_modelMenu[] =
     SettingsMessageTree(I18n::Message::Language),
     SettingsMessageTree(I18n::Message::Country),
     SettingsMessageTree(I18n::Message::ExamMode, ExamModeConfiguration::s_modelExamChildren),
-#ifdef HAS_CODE
     SettingsMessageTree(I18n::Message::CodeApp, s_codeChildren),
-#endif    SettingsMessageTree(I18n::Message::Accessibility, s_accessibilityChildren),
+    SettingsMessageTree(I18n::Message::Accessibility, s_accessibilityChildren),
     SettingsMessageTree(I18n::Message::About, s_modelAboutChildren)};
 
 constexpr SettingsMessageTree s_model = SettingsMessageTree(I18n::Message::SettingsApp, s_modelMenu);

apps/settings/main_controller_prompt_update.cpp

@@ -13,9 +13,8 @@ constexpr SettingsMessageTree s_modelMenu[] =
     SettingsMessageTree(I18n::Message::Language),
     SettingsMessageTree(I18n::Message::Country),
     SettingsMessageTree(I18n::Message::ExamMode, ExamModeConfiguration::s_modelExamChildren),
-#ifdef HAS_CODE
     SettingsMessageTree(I18n::Message::CodeApp, s_codeChildren),
-#endif    SettingsMessageTree(I18n::Message::UpdatePopUp),
+    SettingsMessageTree(I18n::Message::UpdatePopUp),
     SettingsMessageTree(I18n::Message::Accessibility, s_accessibilityChildren),
     SettingsMessageTree(I18n::Message::About, s_modelAboutChildren)};
 

apps/settings/sub_menu/about_controller.cpp

@@ -29,7 +29,7 @@ AboutController::AboutController(Responder * parentResponder) :
   for (int i = 0; i < k_totalNumberOfCell; i++) {
     m_cells[i].setMessageFont(KDFont::LargeFont);
     m_cells[i].setAccessoryFont(KDFont::SmallFont);
-    m_cells[i].setAccessoryTextColor(*Palette::SecondaryText);
+    m_cells[i].setAccessoryTextColor(Palette::SecondaryText);
   }
 }
 

apps/settings/sub_menu/accessibility_controller.cpp

@@ -25,7 +25,7 @@ bool AccessibilityController::handleEvent(Ion::Events::Event event) {
   int redGamma, greenGamma, blueGamma;
   KDIonContext::sharedContext()->gamma.gamma(redGamma, greenGamma, blueGamma);
 
-  if ((event == Ion::Events::OK || event == Ion::Events::EXE || event == Ion::Events::Right) && (selectedRow() <= 2)) {
+  if (event == Ion::Events::OK || event == Ion::Events::EXE || event == Ion::Events::Right) {
     if (selectedRow() == 0) {
       invertEnabled = !invertEnabled;
     }

apps/settings/sub_menu/code_options_controller.cpp

@@ -10,8 +10,12 @@ CodeOptionsController::CodeOptionsController(Responder * parentResponder) :
   GenericSubController(parentResponder),
   m_preferencesController(this)
 {
-  m_chevronCell.setMessageFont(KDFont::LargeFont);
-  m_switchCell.setMessageFont(KDFont::LargeFont);
+  for (int i = 0; i < k_totalNumberOfCell; i++) {
+    m_cells[i].setMessageFont(KDFont::LargeFont);
+  }
+  for (int i = 0; i < k_totalNumberOfSwitchCells; i++) {
+    m_switchCells[i].setMessageFont(KDFont::LargeFont);
+  }
 }
 
 bool CodeOptionsController::handleEvent(Ion::Events::Event event) {
@@ -40,10 +44,7 @@ bool CodeOptionsController::handleEvent(Ion::Events::Event event) {
 HighlightCell * CodeOptionsController::reusableCell(int index, int type) {
   assert(type == 0);
   assert(index >= 0 && index < k_totalNumberOfCell);
-  if (index == 0) {
-    return &m_chevronCell;
-  }
-  return &m_switchCell;
+  return &m_cells[index];
 }
 
 int CodeOptionsController::reusableCellCount(int type) {
@@ -61,14 +62,11 @@ void CodeOptionsController::willDisplayCellForIndex(HighlightCell * cell, int in
     GlobalPreferences::sharedGlobalPreferences()->font() == KDFont::LargeFont
         ? myTextCell->setSubtitle(I18n::Message::LargeFont) 
         : myTextCell->setSubtitle(I18n::Message::SmallFont);
-  } 
-#ifdef HAS_CODE
-  else if (thisLabel == I18n::Message::Autocomplete) {
+  } else if (thisLabel == I18n::Message::Autocomplete) {
     MessageTableCellWithSwitch * mySwitchCell = (MessageTableCellWithSwitch *)cell;
     SwitchView * mySwitch = (SwitchView *)mySwitchCell->accessoryView();
     mySwitch->setState(GlobalPreferences::sharedGlobalPreferences()->autocomplete());
   }
-#endif
 }
 
 }

apps/settings/sub_menu/code_options_controller.h

@@ -14,10 +14,11 @@ public:
   int reusableCellCount(int type) override;
   void willDisplayCellForIndex(HighlightCell * cell, int index) override;
 private:
-  constexpr static int k_totalNumberOfCell = 2;
+  constexpr static int k_totalNumberOfCell = 1;
+  constexpr static int k_totalNumberOfSwitchCells = 1;
   PreferencesController m_preferencesController;
-  MessageTableCellWithChevronAndMessage m_chevronCell;
-  MessageTableCellWithSwitch m_switchCell;
+  MessageTableCellWithChevronAndMessage m_cells[k_totalNumberOfCell];
+  MessageTableCellWithSwitch m_switchCells[k_totalNumberOfCell];
 };
 
 }

apps/settings/sub_menu/contributors_controller.cpp

@@ -9,7 +9,7 @@ ContributorsController::ContributorsController(Responder * parentResponder) :
   for (int i = 0; i < k_totalNumberOfCell; i++) {
     m_cells[i].setMessageFont(KDFont::LargeFont);
     m_cells[i].setAccessoryFont(KDFont::SmallFont);
-    m_cells[i].setAccessoryTextColor(*Palette::SecondaryText);
+    m_cells[i].setAccessoryTextColor(Palette::SecondaryText);
   }
 }
 
@@ -64,15 +64,15 @@ void ContributorsController::willDisplayCellForIndex(HighlightCell * cell, int i
     myTextCell->setTextColor(KDColor::RGB24(0xC03535));
   } else if (index > 0 && index <= s_numberOfDevelopers) {
     myTextCell->setAccessoryText(I18n::translate(s_developersUsernames[index - 1]));
-    myTextCell->setTextColor(*Palette::PrimaryText);
+    myTextCell->setTextColor(Palette::PrimaryText);
   } else if (index == s_numberOfDevelopers + 1) {
     myTextCell->setAccessoryText("");
     myTextCell->setTextColor(KDColor::RGB24(0x1ABC9A));
   } else {
     myTextCell->setAccessoryText(I18n::translate(s_betaTestersUsernames[index - 2 - s_numberOfDevelopers]));
-    myTextCell->setTextColor(*Palette::PrimaryText);
+    myTextCell->setTextColor(Palette::PrimaryText);
   }
-  myTextCell->setAccessoryTextColor(*Palette::SecondaryText);
+  myTextCell->setAccessoryTextColor(Palette::SecondaryText);
   GenericSubController::willDisplayCellForIndex(cell, index);
 }
 

apps/settings/sub_menu/message_table_cell_with_editable_text_with_separator.cpp

@@ -14,8 +14,8 @@ void MessageTableCellWithEditableTextWithSeparator::setHighlighted(bool highligh
 }
 
 void MessageTableCellWithEditableTextWithSeparator::drawRect(KDContext * ctx, KDRect rect) const {
-  ctx->fillRect(KDRect(0, 0, bounds().width(), k_separatorThickness), *Palette::ListCellBorder);
-  ctx->fillRect(KDRect(0, k_separatorThickness, bounds().width(), k_margin-k_separatorThickness), *Palette::BackgroundApps);
+  ctx->fillRect(KDRect(0, 0, bounds().width(), k_separatorThickness), Palette::ListCellBorder);
+  ctx->fillRect(KDRect(0, k_separatorThickness, bounds().width(), k_margin-k_separatorThickness), Palette::BackgroundApps);
 }
 
 int MessageTableCellWithEditableTextWithSeparator::numberOfSubviews() const {

apps/settings/sub_menu/selectable_view_with_messages.cpp

@@ -14,12 +14,12 @@ SelectableViewWithMessages::SelectableViewWithMessages(SelectableTableView * sel
   for (int i = 0; i < k_maxNumberOfLines; i++) {
     m_messageLines[i].setFont(KDFont::SmallFont);
     m_messageLines[i].setAlignment(0.5f, 0.5f);
-    m_messageLines[i].setBackgroundColor(*Palette::BackgroundApps);
+    m_messageLines[i].setBackgroundColor(Palette::BackgroundApps);
   }
 }
 
 void SelectableViewWithMessages::drawRect(KDContext * ctx, KDRect rect) const {
-  ctx->fillRect(bounds(), *Palette::BackgroundApps);
+  ctx->fillRect(bounds(), Palette::BackgroundApps);
 }
 
 void SelectableViewWithMessages::setMessages(I18n::Message * m, int numberOfMessages) {

apps/shared/banner_view.h

@@ -12,9 +12,9 @@ public:
   KDSize minimalSizeForOptimalDisplay() const override;
   KDCoordinate minimalHeightForOptimalDisplayGivenWidth(KDCoordinate width) const;
   void reload() { layoutSubviews(); }
-  static const KDFont * Font() { return KDFont::SmallFont; }
-  static const KDColor TextColor() { return *Palette::PrimaryText; }
-  static const KDColor BackgroundColor() { return *Palette::SubMenuBackground; }
+  static constexpr const KDFont * Font() { return KDFont::SmallFont; }
+  static constexpr KDColor TextColor() { return Palette::PrimaryText; }
+  static constexpr KDColor BackgroundColor() { return Palette::SubMenuBackground; }
 private:
   static constexpr KDCoordinate LineSpacing = 2;
   int numberOfSubviews() const override = 0;

apps/shared/buffer_text_view_with_text_field.cpp

@@ -24,18 +24,18 @@ void BufferTextViewWithTextField::drawRect(KDContext * ctx, KDRect rect) const {
 
   // Fill margins with white
   // Left margin
-  ctx->fillRect(KDRect(0, 0, Metric::TitleBarExternHorizontalMargin, bounds().height()), *Palette::BackgroundHard);
-  ctx->fillRect(KDRect(bounds().width() - Metric::TitleBarExternHorizontalMargin, 0, Metric::TitleBarExternHorizontalMargin, bounds().height()), *Palette::BackgroundHard);
+  ctx->fillRect(KDRect(0, 0, Metric::TitleBarExternHorizontalMargin, bounds().height()), Palette::BackgroundHard);
+  ctx->fillRect(KDRect(bounds().width() - Metric::TitleBarExternHorizontalMargin, 0, Metric::TitleBarExternHorizontalMargin, bounds().height()), Palette::BackgroundHard);
   // Right margin
-  ctx->fillRect(KDRect(bounds().width() - Metric::TitleBarExternHorizontalMargin, 0, Metric::TitleBarExternHorizontalMargin, bounds().height()), *Palette::BackgroundHard);
+  ctx->fillRect(KDRect(bounds().width() - Metric::TitleBarExternHorizontalMargin, 0, Metric::TitleBarExternHorizontalMargin, bounds().height()), Palette::BackgroundHard);
   // Above the text field
-  ctx->fillRect(KDRect(textFieldRect.x() - k_borderWidth, 0, textFieldRect.width() + 2*k_borderWidth, bounds().height()), *Palette::BackgroundHard);
+  ctx->fillRect(KDRect(textFieldRect.x() - k_borderWidth, 0, textFieldRect.width() + 2*k_borderWidth, bounds().height()), Palette::BackgroundHard);
   // Under the text field
-  ctx->fillRect(KDRect(textFieldRect.x() - k_borderWidth, textFieldRect.bottom() + k_borderWidth, textFieldRect.width() + 2*k_borderWidth, bounds().height()), *Palette::BackgroundHard);
+  ctx->fillRect(KDRect(textFieldRect.x() - k_borderWidth, textFieldRect.bottom() + k_borderWidth, textFieldRect.width() + 2*k_borderWidth, bounds().height()), Palette::BackgroundHard);
 
   // Draw the text field border
   KDRect borderRect = KDRect(textFieldRect.x()-k_borderWidth, textFieldRect.y()-k_borderWidth, textFieldRect.width()+2*k_borderWidth, textFieldRect.height()+2*k_borderWidth);
-  ctx->strokeRect(borderRect, *Palette::ListCellBorder);
+  ctx->strokeRect(borderRect, Palette::ListCellBorder);
 }
 
 void BufferTextViewWithTextField::didBecomeFirstResponder() {

apps/shared/button_with_separator.cpp

@@ -1,22 +1,22 @@
 #include "button_with_separator.h"
 
 ButtonWithSeparator::ButtonWithSeparator(Responder * parentResponder, I18n::Message message, Invocation invocation) :
-  Button(parentResponder, message, invocation, KDFont::LargeFont, *Palette::ButtonText)
+  Button(parentResponder, message, invocation, KDFont::LargeFont, Palette::ButtonText)
 {
 }
 
 void ButtonWithSeparator::drawRect(KDContext * ctx, KDRect rect) const {
   KDCoordinate width = bounds().width();
   KDCoordinate height = bounds().height();
-  ctx->fillRect(KDRect(0, 0, width, k_lineThickness), *Palette::ListCellBorder);
-  ctx->fillRect(KDRect(0, k_lineThickness, width, k_margin-k_lineThickness), *Palette::BackgroundApps);
+  ctx->fillRect(KDRect(0, 0, width, k_lineThickness), Palette::ListCellBorder);
+  ctx->fillRect(KDRect(0, k_lineThickness, width, k_margin-k_lineThickness), Palette::BackgroundApps);
   // Draw rectangle around cell
-  ctx->fillRect(KDRect(0, k_margin, width, k_lineThickness), *Palette::ListCellBorder);
-  ctx->fillRect(KDRect(0, k_margin+k_lineThickness, k_lineThickness, height-k_margin), *Palette::ListCellBorder);
-  ctx->fillRect(KDRect(width-k_lineThickness, k_lineThickness+k_margin, k_lineThickness, height-k_margin), *Palette::ListCellBorder);
-  ctx->fillRect(KDRect(0, height-3*k_lineThickness, width, k_lineThickness), *Palette::ButtonBorderOut);
-  ctx->fillRect(KDRect(0, height-2*k_lineThickness, width, k_lineThickness), *Palette::ListCellBorder);
-  ctx->fillRect(KDRect(k_lineThickness, height-k_lineThickness, width-2*k_lineThickness, k_lineThickness), *Palette::ButtonShadow);
+  ctx->fillRect(KDRect(0, k_margin, width, k_lineThickness), Palette::ListCellBorder);
+  ctx->fillRect(KDRect(0, k_margin+k_lineThickness, k_lineThickness, height-k_margin), Palette::ListCellBorder);
+  ctx->fillRect(KDRect(width-k_lineThickness, k_lineThickness+k_margin, k_lineThickness, height-k_margin), Palette::ListCellBorder);
+  ctx->fillRect(KDRect(0, height-3*k_lineThickness, width, k_lineThickness), Palette::ButtonBorderOut);
+  ctx->fillRect(KDRect(0, height-2*k_lineThickness, width, k_lineThickness), Palette::ListCellBorder);
+  ctx->fillRect(KDRect(k_lineThickness, height-k_lineThickness, width-2*k_lineThickness, k_lineThickness), Palette::ButtonShadow);
 }
 
 

apps/shared/cursor_view.cpp

@@ -5,8 +5,8 @@ namespace Shared {
 void CursorView::drawRect(KDContext * ctx, KDRect rect) const {
   KDCoordinate width = bounds().width();
   KDCoordinate height = bounds().height();
-  ctx->fillRect(KDRect((width-1)/2, 0, 1, height), *Palette::PrimaryText);
-  ctx->fillRect(KDRect(0, (height-1)/2, width, 1), *Palette::PrimaryText);
+  ctx->fillRect(KDRect((width-1)/2, 0, 1, height), Palette::PrimaryText);
+  ctx->fillRect(KDRect(0, (height-1)/2, width, 1), Palette::PrimaryText);
 }
 
 KDSize CursorView::minimalSizeForOptimalDisplay() const {

apps/shared/curve_view.cpp

@@ -286,7 +286,7 @@ void CurveView::drawLabel(KDContext * ctx, KDRect rect, float xPosition, float y
   KDPoint position = positionLabel(xCoordinate, yCoordinate, labelSize, horizontalPosition, verticalPosition);
   if (rect.intersects(KDRect(position, labelSize))) {
     // TODO: should we blend?
-    ctx->drawString(label, position, k_font, color, *Palette::BackgroundApps);
+    ctx->drawString(label, position, k_font, color, Palette::BackgroundApps);
   }
 }
 
@@ -369,7 +369,7 @@ void CurveView::drawLabelsAndGraduations(KDContext * ctx, KDRect rect, Axis axis
             labelPosition,
             k_labelGraduationLength,
             1);
-      ctx->fillRect(graduation, *Palette::PrimaryText);
+      ctx->fillRect(graduation, Palette::PrimaryText);
     }
   }
 
@@ -414,7 +414,7 @@ void CurveView::drawLabelsAndGraduations(KDContext * ctx, KDRect rect, Axis axis
 
 DrawLabel:
     if (rect.intersects(KDRect(position, textSize))) {
-      ctx->drawString(labelI, position, k_font, *Palette::PrimaryText, backgroundColor);
+      ctx->drawString(labelI, position, k_font, Palette::PrimaryText, backgroundColor);
     }
   }
 }
@@ -557,8 +557,8 @@ void CurveView::drawArrow(KDContext * ctx, KDRect rect, float x, float y, float
 }
 
 void CurveView::drawGrid(KDContext * ctx, KDRect rect) const {
-  KDColor boldColor = *Palette::GridPrimaryLine;
-  KDColor lightColor = *Palette::GridSecondaryLine;
+  KDColor boldColor = Palette::GridPrimaryLine;
+  KDColor lightColor = Palette::GridSecondaryLine;
   drawGridLines(ctx, rect, Axis::Vertical, m_curveViewRange->xGridUnit(), boldColor, lightColor);
   drawGridLines(ctx, rect, Axis::Horizontal, m_curveViewRange->yGridUnit(), boldColor, lightColor);
 }
@@ -569,7 +569,7 @@ void CurveView::drawAxes(KDContext * ctx, KDRect rect) const {
 }
 
 void CurveView::drawAxis(KDContext * ctx, KDRect rect, Axis axis) const {
-  drawLine(ctx, rect, axis, 0.0f, *Palette::PrimaryText, 1);
+  drawLine(ctx, rect, axis, 0.0f, Palette::PrimaryText, 1);
 }
 
 constexpr KDCoordinate thinCircleDiameter = 1;

apps/shared/curve_view.h

@@ -122,7 +122,7 @@ protected:
   };
   // Draw the label at the above/below and to the left/right of the given position
   void drawLabel(KDContext * ctx, KDRect rect, float xPosition, float yPosition, const char * label, KDColor color, RelativePosition horizontalPosition, RelativePosition verticalPosition) const;
-  void drawLabelsAndGraduations(KDContext * ctx, KDRect rect, Axis axis, bool shiftOrigin, bool graduationOnly = false, bool fixCoordinate = false, KDCoordinate fixedCoordinate = 0, KDColor backgroundColor = *Palette::BackgroundHard) const;
+  void drawLabelsAndGraduations(KDContext * ctx, KDRect rect, Axis axis, bool shiftOrigin, bool graduationOnly = false, bool fixCoordinate = false, KDCoordinate fixedCoordinate = 0, KDColor backgroundColor = Palette::BackgroundHard) const;
   View * m_bannerView;
   CurveViewCursor * m_curveViewCursor;
 private:

apps/shared/double_pair_store.h

@@ -56,12 +56,12 @@ public:
   static KDColor colorOfSeriesAtIndex(int i) {
     assert(i >= 0 && i < k_numberOfSeries);
     assert(i < Palette::numberOfDataColors());
-    return *Palette::DataColor[i];
+    return Palette::DataColor[i];
   }
   static KDColor colorLightOfSeriesAtIndex(int i) {
     assert(i >= 0 && i < k_numberOfSeries);
     assert(i < Palette::numberOfLightDataColors());
-    return *Palette::DataColorLight[i];
+    return Palette::DataColorLight[i];
   }
   double * data() { return reinterpret_cast<double*>(&m_data); }
 protected: