Creation of a protection system against unintentional updates to Epsilon 16 (foundation) + Recovery Improvement (#37)

* Dark Theme changes

* added reader icon for dark mode

* epsilon Dark Theme changes

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,14 +1,29 @@
 ---
 name: Bug report
-about: Omega is not working like it should? Let us know!
+about: Upsilon is not working like it should? Let us know!
 title: ''
-labels: Triage
+labels: 'Status: Triage, Type: Bug'
 assignees: ''
 
 ---
 
-#### Describe the bug
+**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
 
-#### Environment
- - Omega Version: { go to settings > about > Omega Version and type version here}
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Device (please complete the following information):**
+ - The device on which you're running Upsilon (computer, n0110, n0100, etc...)
+ - Upsilon Version: [go to settings > about > Upsilon Version and type the version here]
+ - Upsilon commit: [settings > about > click one time on epsilon version]

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,10 +1,17 @@
 ---
 name: Feature request
-about: Suggest an idea for an improvement of Omega
+about: Suggest an idea for Upsilon
 title: ''
-labels: Triage
+labels: 'Status: Triage, Type: Feature'
 assignees: ''
 
 ---
 
-#### What I want to see in the next version of Omega
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/ISSUE_TEMPLATE/other.md

@@ -1,8 +1,8 @@
 ---
 name: Other
-about: A question? A problem? ...
+about: A question? A problem? …
 title: ''
-labels: Triage
+labels: 'Status: Triage'
 assignees: ''
 
 ---

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

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

.github/workflows/ci-docker.yml

@@ -0,0 +1,12 @@
+name: Docker Image CI
+on: [pull_request, push]
+
+jobs:
+  docker:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+      with:
+       submodules: true
+    - name: Build the Docker image
+      run: docker build . --file docker/Dockerfile --tag omega:$(date +%s)

.github/workflows/ci-workflow.yml

@@ -1,104 +1,199 @@
 name: Continuous integration
-on: [pull_request, push]
+#on: [pull_request, push]
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+    inputs:
+      triggerIos:
+        description: 'Run iOS tests'
+        required: true
+        default: 'no'
+      triggerMacos:
+        description: 'Run macOS tests'
+        required: true
+        default: 'no'
+      trigger3DS:
+        description: 'Run 3DS tests'
+        required: true
+        default: 'no'
 
 jobs:
-  build-simulator-android:
+  nintendo_3ds:
+    if: github.event.inputs.trigger3DS == 'yes'
     runs-on: ubuntu-latest
     steps:
+      - run: wget https://github.com/devkitPro/pacman/releases/download/v1.0.2/devkitpro-pacman.amd64.deb -O /tmp/devkitpro-pacman.deb
+      - run: yes | sudo dpkg -i /tmp/devkitpro-pacman.deb
+      - run: yes | sudo dkp-pacman -Syu --needed devkitARM 3dstools libctru
+      - run: echo ::set-env name=DEVKITPRO::/opt/devkitpro
+      - run: echo ::set-env name=DEVKITARM::/opt/devkitpro/devkitARM
+      - run: echo ::set-env name=PATH::$DEVKITPRO/tools/bin:$DEVKITARM/bin:$PATH
+
       - uses: actions/checkout@v1
+        with:
+          submodules: true
+      - run: make -j2 PLATFORM=simulator TARGET=3ds
+      - run: make -j2 PLATFORM=simulator TARGET=3ds epsilon.cia
+      - uses: actions/upload-artifact@master
+        with:
+          name: epsilon-3ds.3dsx
+          path: output/release/simulator/3ds/epsilon.3dsx
+      - uses: actions/upload-artifact@master
+        with:
+          name: epsilon-3ds.cia
+          path: output/release/simulator/3ds/epsilon.cia
+  android:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: 'recursive'
       - run: make -j2 PLATFORM=simulator TARGET=android
       - uses: actions/upload-artifact@master
         with:
-          name: epsilon-simulator-android.apk
-          path: output/release/simulator/android/app/outputs/apk/release/android-release-unsigned.apk
-  build-device-n0100:
+          name: epsilon-android.apk
+          path: output/release/simulator/android/epsilon.apk
+  n0100:
     runs-on: ubuntu-latest
     steps:
-      - run: sudo apt-get install binutils-arm-none-eabi build-essential gcc-arm-none-eabi imagemagick libfreetype6-dev libjpeg-dev libpng-dev pkg-config
-      - uses: actions/checkout@v1
-      - run: make -j2 MODEL=n0100 epsilon.dfu
-      - run: make -j2 MODEL=n0100 epsilon.onboarding.dfu
-      - run: make -j2 MODEL=n0100 epsilon.onboarding.update.dfu
-      - run: make -j2 MODEL=n0100 flasher.light.dfu
-      - run: make -j2 MODEL=n0100 flasher.verbose.dfu
+      - run: sudo apt-get install build-essential imagemagick libfreetype6-dev libjpeg-dev libpng-dev pkg-config
+      - uses: numworks/setup-arm-toolchain@2020-q2
+      - uses: actions/checkout@v2
+        with:
+          submodules: 'recursive'
+      - run: mkdir final-output
+      - run: make -j2 MODEL=n0100 EPSILON_I18N=en output/release/device/n0100/epsilon.onboarding.two_binaries
+      - run: mv output/release/device/n0100/epsilon.onboarding.internal.bin final-output/epsilon.onboarding.internal.en.bin
+      - run: rm output/release/device/n0100/apps/i18n.o output/release/device/n0100/apps/i18n.cpp
+      - run: make -j2 MODEL=n0100 EPSILON_I18N=fr output/release/device/n0100/epsilon.onboarding.two_binaries
+      - run: mv output/release/device/n0100/epsilon.onboarding.internal.bin final-output/epsilon.onboarding.internal.fr.bin
+      - run: rm output/release/device/n0100/apps/i18n.o output/release/device/n0100/apps/i18n.cpp
+      - run: make -j2 MODEL=n0100 EPSILON_I18N=nl output/release/device/n0100/epsilon.onboarding.two_binaries
+      - run: mv output/release/device/n0100/epsilon.onboarding.internal.bin final-output/epsilon.onboarding.internal.nl.bin
+      - run: rm output/release/device/n0100/apps/i18n.o output/release/device/n0100/apps/i18n.cpp
+      - run: make -j2 MODEL=n0100 EPSILON_I18N=pt output/release/device/n0100/epsilon.onboarding.two_binaries
+      - run: mv output/release/device/n0100/epsilon.onboarding.internal.bin final-output/epsilon.onboarding.internal.pt.bin
+      - run: rm output/release/device/n0100/apps/i18n.o output/release/device/n0100/apps/i18n.cpp
+      - run: make -j2 MODEL=n0100 EPSILON_I18N=it output/release/device/n0100/epsilon.onboarding.two_binaries
+      - run: mv output/release/device/n0100/epsilon.onboarding.internal.bin final-output/epsilon.onboarding.internal.it.bin
+      - run: rm output/release/device/n0100/apps/i18n.o output/release/device/n0100/apps/i18n.cpp
+      - run: make -j2 MODEL=n0100 EPSILON_I18N=de output/release/device/n0100/epsilon.onboarding.two_binaries
+      - run: mv output/release/device/n0100/epsilon.onboarding.internal.bin final-output/epsilon.onboarding.internal.de.bin
+      - run: rm output/release/device/n0100/apps/i18n.o output/release/device/n0100/apps/i18n.cpp
+      - run: make -j2 MODEL=n0100 EPSILON_I18N=es output/release/device/n0100/epsilon.onboarding.two_binaries
+      - run: mv output/release/device/n0100/epsilon.onboarding.internal.bin final-output/epsilon.onboarding.internal.es.bin
+      - run: rm output/release/device/n0100/apps/i18n.o output/release/device/n0100/apps/i18n.cpp
+      - run: make -j2 MODEL=n0100 EPSILON_I18N=hu output/release/device/n0100/epsilon.onboarding.two_binaries
+      - run: mv output/release/device/n0100/epsilon.onboarding.internal.bin final-output/epsilon.onboarding.internal.hu.bin
+      - run: rm output/release/device/n0100/apps/i18n.o output/release/device/n0100/apps/i18n.cpp
+      - run: make -j2 MODEL=n0100 output/release/device/n0100/flasher.light.bin
+      - run: mv output/release/device/n0100/flasher.light.bin final-output/flasher.light.bin
+      - run: find final-output/ -type f -exec bash -c "shasum -a 256 -b {} > {}.sha256" \;
+      - run: tar cvfz binpack-n0100.tgz final-output/*
       - uses: actions/upload-artifact@master
         with:
-          name: epsilon-device-n0100.dfu
-          path: output/release/device/n0100/epsilon.dfu
-      - run: make -j2 MODEL=n0100 test.elf
-  build-device-n0110:
+          name: epsilon-binpack-n0100.tgz
+          path: binpack-n0100.tgz
+  n0110:
     runs-on: ubuntu-latest
     steps:
-      - run: sudo apt-get install binutils-arm-none-eabi build-essential gcc-arm-none-eabi imagemagick libfreetype6-dev libjpeg-dev libpng-dev pkg-config
-      - uses: actions/checkout@v1
+      - run: sudo apt-get install build-essential imagemagick libfreetype6-dev libjpeg-dev libpng-dev pkg-config
+      - uses: numworks/setup-arm-toolchain@2020-q2
+      - uses: actions/checkout@v2
+        with:
+          submodules: 'recursive'
       - run: make -j2 epsilon.dfu
       - run: make -j2 epsilon.onboarding.dfu
       - run: make -j2 epsilon.onboarding.update.dfu
+      - run: make -j2 epsilon.onboarding.beta.dfu
       - run: make -j2 flasher.light.dfu
       - run: make -j2 flasher.verbose.dfu
       - run: make -j2 bench.ram.dfu
       - run: make -j2 bench.flash.dfu
+      - run: make -j2 binpack
+      - run: cp output/release/device/n0110/binpack-n0110-`git rev-parse HEAD | head -c 7`.tgz output/release/device/n0110/binpack-n0110.tgz
       - uses: actions/upload-artifact@master
         with:
-          name: epsilon-device-n0110.dfu
-          path: output/release/device/n0110/epsilon.dfu
-      - run: make -j2 test.elf
-  build-simulator-windows:
+          name: epsilon-binpack-n0110.tgz
+          path: output/release/device/n0110/binpack-n0110.tgz
+  windows:
     runs-on: windows-latest
+    defaults:
+       run:
+         shell: msys2 {0}
     steps:
-      - uses: numworks/setup-msys2@v1
-      - uses: actions/checkout@v1
-      - run: msys2do pacman -S --noconfirm mingw-w64-x86_64-gcc mingw-w64-x86_64-freetype mingw-w64-x86_64-pkg-config make mingw-w64-x86_64-python3 mingw-w64-x86_64-libjpeg-turbo mingw-w64-x86_64-libpng
-      - run: msys2do make -j2 PLATFORM=simulator
+      - uses: msys2/setup-msys2@v2
+      - uses: actions/checkout@v2
+        with:
+          submodules: 'recursive'
+      - run: pacman -S --noconfirm mingw-w64-x86_64-gcc mingw-w64-x86_64-freetype mingw-w64-x86_64-pkg-config make mingw-w64-x86_64-python3 mingw-w64-x86_64-libjpeg-turbo mingw-w64-x86_64-libpng
+      - run: make -j2 PLATFORM=simulator
+      - run: make -j2 PLATFORM=simulator test.exe
+      - run: cmd /c output\release\simulator\windows\test.exe --headless
       - uses: actions/upload-artifact@master
         with:
-          name: epsilon-simulator-windows.exe
+          name: epsilon-windows.exe
           path: output/release/simulator/windows/epsilon.exe
-      - run: msys2do make -j2 PLATFORM=simulator test.headless.exe
-      - run: output\release\simulator\windows\test.headless.exe
-  build-simulator-web:
+  web:
     runs-on: ubuntu-latest
     steps:
       - uses: numworks/setup-emscripten@v1
-      - uses: actions/checkout@v1
-      - run: source $EMSDK/emsdk_env.sh && make -j2 PLATFORM=simulator TARGET=web
+        with:
+          sdk: 1.40.1-fastcomp
+      - uses: actions/checkout@v2
+        with:
+          submodules: 'recursive'
+      - run: make -j2 PLATFORM=simulator TARGET=web
+      - run: make -j2 PLATFORM=simulator TARGET=web test.js
+      - run: node output/release/simulator/web/test.js --headless
       - uses: actions/upload-artifact@master
         with:
-          name: epsilon-simulator-web.zip
-          path: output/release/simulator/web/simulator.zip
-      - run: source $EMSDK/emsdk_env.sh && make -j2 PLATFORM=simulator TARGET=web test.headless.js
-      - run: node output/release/simulator/web/test.headless.js
-  build-simulator-linux:
+          name: epsilon-web.zip
+          path: output/release/simulator/web/epsilon.zip
+  linux:
     runs-on: ubuntu-latest
     steps:
       - run: sudo apt-get install build-essential imagemagick libfreetype6-dev libjpeg-dev libpng-dev pkg-config
-      - uses: actions/checkout@v1
+      - uses: actions/checkout@v2
+        with:
+          submodules: 'recursive'
       - run: make -j2 PLATFORM=simulator
+      - run: make -j2 PLATFORM=simulator test.bin
+      - run: output/release/simulator/linux/test.bin --headless
       - uses: actions/upload-artifact@master
         with:
-          name: epsilon-simulator-linux.bin
+          name: epsilon-linux.bin
           path: output/release/simulator/linux/epsilon.bin
-      - run: make -j2 PLATFORM=simulator test.headless.bin
-      - run: output/release/simulator/linux/test.headless.bin
-  build-simulator-macos:
+  macos:
+    if: github.event.inputs.triggerMacos == 'yes'
     runs-on: macOS-latest
     steps:
       - run: brew install numworks/tap/epsilon-sdk
-      - uses: actions/checkout@v1
+      - uses: actions/checkout@v2
+        with:
+          submodules: 'recursive'
       - run: make -j2 PLATFORM=simulator
+      - run: make -j2 PLATFORM=simulator ARCH=x86_64 test.bin
+      - run: output/release/simulator/macos/x86_64/test.bin --headless
       - uses: actions/upload-artifact@master
         with:
-          name: epsilon-simulator-macos.zip
-          path: output/release/simulator/macos/app/Payload
-      - run: make -j2 PLATFORM=simulator ARCH=x86_64 test.headless.bin
-      - run: output/release/simulator/macos/x86_64/test.headless.bin
-  build-simulator-ios:
+          name: epsilon-macos.zip
+          path: output/release/simulator/macos/epsilon.app
+  ios:
+    if: github.event.inputs.triggerIos == 'yes'
     runs-on: macOS-latest
     steps:
       - run: brew install numworks/tap/epsilon-sdk
-      - uses: actions/checkout@v1
-      - run: make -j2 PLATFORM=simulator TARGET=ios GOOGLE_ANALYTICS=0
+      - uses: actions/checkout@v2
+        with:
+          submodules: 'recursive'
+      - run: make -j2 PLATFORM=simulator TARGET=ios EPSILON_TELEMETRY=0
+      - run: make -j2 PLATFORM=simulator TARGET=ios EPSILON_TELEMETRY=0 APPLE_PLATFORM=ios-simulator
       - uses: actions/upload-artifact@master
         with:
-          name: epsilon-simulator-ios.ipa
-          path: output/release/simulator/ios/app/epsilon.ipa
+          name: epsilon-ios.ipa
+          path: output/release/simulator/ios/epsilon.ipa
+
+env:
+  ACCEPT_OFFICIAL_TOS: 1

.github/workflows/metric-workflow.yml

@@ -0,0 +1,40 @@
+name: Metrics
+on: [pull_request_target]
+
+jobs:
+  binary-size:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Install dependencies
+        run: sudo apt-get install build-essential imagemagick libfreetype6-dev libjpeg-dev libpng-dev pkg-config
+      - name: Install ARM toolchain
+        uses: numworks/setup-arm-toolchain@2020-q2
+      - name: Checkout PR base
+        uses: actions/checkout@v2
+        with:
+          submodules: recursive
+          ref: ${{ github.event.pull_request.base.sha }}
+          path: base
+      - name: Build base
+        run: make -j2 -C base epsilon.elf
+      - name: Checkout PR head
+        uses: actions/checkout@v2
+        with:
+          submodules: recursive
+          ref: ${{ github.event.pull_request.head.sha }}
+          path: head
+      - name: Build head
+        run: make -j2 -C head epsilon.elf
+      - name: Retrieve binary size analysis
+        id: binary_size
+        run: echo "::set-output name=table::$(python3 head/build/metrics/binary_size.py base/output/release/device/n0110/epsilon.elf head/output/release/device/n0110/epsilon.elf --labels Base Head --sections .text .rodata .bss .data --custom 'Total (RAM)' .data .bss --custom 'Total (ROM)' .text .rodata .data --escape)"
+      - name: Add comment
+        uses: actions/github-script@v3.0.0
+        with:
+          script: |
+            await github.issues.createComment({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: context.payload.pull_request.number,
+              body: `${{ steps.binary_size.outputs.table }}`,
+            });

.gitignore

@@ -1,3 +1,10 @@
 /output/
+/build/artifacts/
 build/device/**/*.pyc
-epsilon.elf
+epsilon.elf
+epsilon.map
+.vscode
+.DS_Store
+.gradle
+.idea/
+.vs

.gitlab-ci.yml

@@ -1,25 +0,0 @@
-image: gcc
-
-stages:
-  - build
-
-job:build:
-    stage: build
-    before_script:
-        - "echo 'deb http://httpredir.debian.org/debian jessie main contrib \n deb-src http://httpredir.debian.org/debian jessie main contrib \n deb http://httpredir.debian.org/debian jessie-updates main contrib \n deb-src http://httpredir.debian.org/debian jessie-updates main contrib \n deb http://security.debian.org/ jessie/updates main contrib \n deb-src http://security.debian.org/ jessie/updates main contrib ' > /etc/apt/source.list"
-        - "apt-get update"
-        - "apt -y install build-essential git imagemagick libx11-dev libxext-dev libfreetype6-dev libpng-dev libjpeg-dev pkg-config fltk1.3-dev gcc-arm-none-eabi nodejs npm"
-        - "git submodule update --init --recursive"
-        - "git clone https://github.com/RedGl0w/omega-auto-increment"
-        - "cd omega-auto-increment"
-        - "npm i request exeq"
-        - "PrivateToken=$PrivateToken node index.js"
-        - "cd .."
-    script:
-        - make clean
-        - make MODEL=n0100 epsilon.bin
-    artifacts:
-        paths:
-            - output/release/device/n0100/epsilon.bin
-            - omega-auto-increment/version.txt
-        name: artifact:build:simulator

.gitmodules

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

CODE_OF_CONDUCT.md

@@ -0,0 +1,76 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+ advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+ address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+ professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at getomega.pro@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq

Makefile

@@ -1,40 +1,62 @@
-include build/config.mak
-
 # Disable default Make rules
 .SUFFIXES:
 
-object_for = $(addprefix $(BUILD_DIR)/,$(addsuffix .o,$(basename $(1))))
-
 # Define the default recipe
-
 default:
 
-# Define a standard rule helper
-# If passed a last parameter value of with_local_version, we also define an
-# extra rule that can build source files within the $(BUILD_DIR). This is useful
-# for rules that can be applied for intermediate objects (for example, when
-# going .png -> .cpp -> .o).
+include build/config.mak
+include build/pimp.mak
+include build/defaults.mak
+include build/platform.$(PLATFORM).mak
+include build/toolchain.$(TOOLCHAIN).mak
+include build/variants.mak
+include build/helpers.mk
 
-define rule_label
-@ echo "$(shell printf "%-8s" $(strip $(1)))$(@:$(BUILD_DIR)/%=%)"
-endef
-
-define rule_for
-ifeq ($(strip $(5)),with_local_version)
-$(addprefix $$(BUILD_DIR)/,$(strip $(2))): $(addprefix $$(BUILD_DIR)/,$(strip $(3)))
-	@ echo "$(shell printf "%-8s" $(strip $(1)))$$(@:$$(BUILD_DIR)/%=%)"
-	$(Q) $(4)
+ifeq (${MODEL}, n0100)
+  ifeq ($(filter reader,$(apps_list)),)
+  	$(warning reader app included, removing it on n0100. )
+  	EPSILON_APPS := $(filter-out reader,$(EPSILON_APPS))
+  endif
+  ifneq ($(words $(EPSILON_I18N)), 1)
+  	$(warning Only use 1 language on n0100, defaulting to en. )
+  	EPSILON_I18N := en
+  endif
+  ifeq ($(INCLUDE_ULAB), 1)
+    $(warning Removing uLab on n0100. )
+    INCLUDE_ULAB := 0
+  endif
+endif
+
+ifeq (${MODEL}, n0110)
+  apps_list = ${EPSILON_APPS}
+else
+  apps_list = $(foreach i, ${EPSILON_APPS}, $(if $(filter external, $(i)),,$(i)))
+endif
+
+ifdef FORCE_EXTERNAL
+  apps_list = ${EPSILON_APPS}
+endif
+
+ifeq ($(INCLUDE_ULAB), 1)
+  SFLAGS += -DINCLUDE_ULAB
+endif
+
+ifdef HOME_DISPLAY_EXTERNALS
+  ifneq ($(filter external,$(apps_list)),)
+    SFLAGS += -DHOME_DISPLAY_EXTERNALS
+  else
+    $(warning HOME_DISPLAY_EXTERNALS is set but external isn't included, ignoring flag.)
+  endif
 endif
-$(addprefix $$(BUILD_DIR)/,$(strip $(2))): $(strip $(3)) | $$$$(@D)/.
-	@ echo "$(shell printf "%-8s" $(strip $(1)))$$(@:$$(BUILD_DIR)/%=%)"
-	$(Q) $(4)
-endef
 
 .PHONY: info
 info:
 	@echo "EPSILON_VERSION = $(EPSILON_VERSION)"
 	@echo "EPSILON_APPS = $(EPSILON_APPS)"
 	@echo "EPSILON_I18N = $(EPSILON_I18N)"
+	@echo "THEME_NAME = $(THEME_NAME)"
+	@echo "THEME_REPO = $(THEME_REPO)"
+	@echo "BUILD_DIR = $(BUILD_DIR)"
 	@echo "PLATFORM" = $(PLATFORM)
 	@echo "DEBUG" = $(DEBUG)
 	@echo "EPSILON_GETOPT" = $(EPSILON_GETOPT)
@@ -65,6 +87,18 @@ help:
 	@echo "  make PLATFORM=simulator TARGET=macos"
 	@echo "  make PLATFORM=simulator TARGET=web"
 	@echo "  make PLATFORM=simulator TARGET=windows"
+	@echo "  make PLATFORM=simulator TARGET=3ds"
+
+.PHONY: doc
+doc:
+	@echo "DOXYGEN"
+	@mkdir -p output/doc/
+	$(Q) doxygen build/doc/Doxyfile
+
+.PHONY: print-%
+print-%:
+	@echo $* = $($*)
+	@echo $*\'s origin is $(origin $*)
 
 # Since we're building out-of-tree, we need to make sure the output directories
 # are created, otherwise the receipes will fail (e.g. gcc will fail to create
@@ -83,7 +117,9 @@ $(BUILD_DIR)%/.:
 # Each sub-Makefile can either add sources to $(%_src) variables or define a
 # new executable target. The $(%_src) variables list the sources that can be
 # built and linked to executables being generated.
-
+ifndef USE_LIBA
+  $(error platform.mak should define USE_LIBA)
+endif
 ifeq ($(USE_LIBA),0)
 include liba/Makefile.bridge
 else
@@ -102,7 +138,11 @@ include build/struct_layout/Makefile
 include build/scenario/Makefile
 include quiz/Makefile # Quiz needs to be included at the end
 
-all_src = $(apps_all_src) $(escher_src) $(ion_all_src) $(kandinsky_src) $(liba_src) $(libaxx_src) $(poincare_src) $(python_src) $(epsilon_src) $(runner_src) $(ion_target_device_flasher_light_src) $(ion_target_device_flasher_verbose_src) $(ion_target_device_bench_src) $(tests_src)
+all_src = $(apps_src) $(escher_src) $(ion_src) $(kandinsky_src) $(liba_src) $(libaxx_src) $(poincare_src) $(python_src) $(runner_src) $(ion_device_flasher_src) $(ion_device_bench_src) $(tests_src)
+# Make palette.h a dep for every source-file.
+# This ensures that the theming engine works correctly.
+$(call object_for,$(all_src)): $(BUILD_DIR)/escher/palette.h $(BUILD_DIR)/apps/i18n.h
+
 all_objs = $(call object_for,$(all_src))
 .SECONDARY: $(all_objs)
 
@@ -116,8 +156,7 @@ all_objs = $(call object_for,$(all_src))
 include build/targets.mak
 
 # Fill in the default recipe
-DEFAULT ?= $(BUILD_DIR)/epsilon.$(EXE)
-default: $(DEFAULT)
+default: $(firstword $(HANDY_TARGETS)).$(firstword $(HANDY_TARGETS_EXTENSIONS))
 
 # Load standard build rules
 include build/rules.mk
@@ -127,6 +166,11 @@ clean:
 	@echo "CLEAN"
 	$(Q) rm -rf $(BUILD_DIR)
 
+.PHONY: cleanall
+cleanall:
+	@echo "CLEANALL"
+	$(Q) rm -rf output
+
 .PHONY: cowsay_%
 cowsay_%:
 	@echo " -------"
@@ -141,3 +185,23 @@ cowsay_%:
 .PHONY: clena
 clena: cowsay_CLENA clean
 
+.PHONY: compile
+compile: output/$(BUILD_TYPE)/simulator/$(HOST)/epsilon.$(EXE)
+
+.PHONY: cleanandcompile
+cleanandcompile:
+	${MAKE} cleanall
+	${MAKE} compile
+
+.PHONY: start
+start:
+	@echo "INFO Starting output/$(BUILD_TYPE)/simulator/$(HOST)/epsilon.$(EXE)"
+	@$(Q) output/$(BUILD_TYPE)/simulator/$(HOST)/epsilon.$(EXE) -v
+
+.PHONY: clean_run
+clean_run: cleanandcompile
+	${MAKE} start
+
+.PHONY: run
+run: compile
+	${MAKE} start

README.fr.md

@@ -0,0 +1,183 @@
+<p align="center"><img src="https://github.com/Laporte12974/UpsilonDesign/blob/89a15953ae128aef8aa7d066dcaaf8d5c70f02a5/UPSILogo.png" /></p>
+
+<p align="center">
+  <a href="https://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="cc by-nc-sa 4.0" src="https://img.shields.io/badge/License-CC%20BY--NC--SA%204.0-525252.svg?labelColor=292929&logo=creative%20commons&style=for-the-badge" /></a>
+  <a href="https://github.com/Lauryy06/Upsilon/issues"><img alt="Issues" src="https://img.shields.io/github/issues/Lauryy06/Upsilon.svg?labelColor=292929&logo=git&style=for-the-badge" /></a>
+  <br/>
+  <a href="https://discord.gg/Q9buEMduXG"><img alt="Discord" src="https://img.shields.io/discord/663420259851567114?color=blue&labelColor=292929&label=chat%20-%20discord&logo=discord&style=for-the-badge" /></a>
+</p>
+
+> Don't understand french ? speak english ? here's the [english README](./README.md) !
+
+## À propos
+
+Upsilon est un fork d'Omega, un fork d'Epsilon, l'OS de Numworks tournant sur les calculatrices du même nom, qui apporte beaucoup de fonctionnalités en plus, mais qui fut archivé et fermé pour des raisons légales après un changement de politique de Numworks. Upsilon est fait pour ceux qui aimeraient voir un futur pour les OS créées par les utilisateurs pour Numworks, même après l'arrèt du projet initial.
+
+### Quelques fonctionnalités supplémentaires
+- Un module python kandinsky amélioré
+- Un support pour fonds d'écrans personnalisés
+- Des applications externes
+- Un thème Upsilon
+- La surcharge des opérateurs en python
+- Un tableau périodique légèrement amélioré
+- L'utilisation possible du signe "=" dans les calculs
+- *Ainsi que tout ce qui a été ajouté sur Omega, et bien plus...* [Changelogs complets d'Omega](https://github.com/Omega-Numworks/Omega/wiki/Changelog) | [Fonctionnalités principales d'Omega & captures d'écran](https://github.com/Omega-Numworks/Omega/wiki/Main-features).
+
+## Installation
+
+### Manuelle
+
+*A l'heure actuelle, seule l'installation manuelle est possible.*
+
+Tout d'abord, suivez **la première étape** [ici](https://www.numworks.com/resources/engineering/software/build/), puis :
+
+<details>
+  <summary><b>Modèle n0100</b></summary>
+
+(note : vous pouvez changer `EPSILON_I18N=fr` en `en`, `nl`, `pt`, `it`, `de`, `es` ou `hu`).
+
+```bash
+git clone --recursive https://github.com/Lauryy06/Upsilon.git
+cd Upsilon
+git checkout omega-master
+make MODEL=n0100 clean
+make MODEL=n0100 EPSILON_I18N=fr OMEGA_USERNAME="{Votre nom ici, 15 caractères max}" -j4
+make MODEL=n0100 epsilon_flash
+```
+
+Important : N'oubliez pas l'argument `--recursive`, Upsilon a besoin de sous-modules.
+Vous pouvez aussi changer le nombre de processus parallèles pendant la compilation en changeant la valeur suivant `-j`.
+
+</details>
+
+<details>
+  <summary><b>Modèle n0110</b></summary>
+
+```bash
+git clone --recursive https://github.com/Lauryy06/Upsilon.git
+cd Upsilon
+git checkout omega-master
+make clean
+make OMEGA_USERNAME="{Votre nom ici, 15 caractères max}" -j4
+make epsilon_flash
+```
+
+Important : N'oubliez pas l'argument `--recursive`, Upsilon a besoin de sous-modules.
+Vous pouvez aussi changer le nombre de processus parallèles pendant la compilation en changeant la valeur suivant `-j`.
+
+</details>
+
+<details>
+  <summary><b>Fichiers binaires</b></summary>
+  
+Ces fichiers peuvent être utilisés pour distribuer Upsilon (pour que tout le monde puisse le flasher via [Webdfu_Numworks](https://ti-planet.github.io/webdfu_numworks/)).
+
+```bash
+git clone --recursive https://github.com/Lauryy06/Upsilon.git
+cd Upsilon
+git checkout omega-master
+make clean
+make MODEL=n0100 OMEGA_USERNAME="" -j8
+make MODEL=n0100 OMEGA_USERNAME="" binpack -j8
+make OMEGA_USERNAME="" -j8
+make OMEGA_USERNAME="" binpack -j8
+```
+
+Important : N'oubliez pas l'argument `--recursive`, Upsilon a besoin de sous-modules.
+Vous pouvez aussi changer le nombre de processus parallèles pendant la compilation en changeant la valeur suivant `-j`.
+  
+</details>
+
+<details>
+  <summary><b>Simulateur web</b></summary>
+  
+D'abord, installez emsdk :
+
+```bash
+git clone https://github.com/emscripten-core/emsdk.git
+cd emsdk
+./emsdk install latest-fastcomp
+./emsdk activate latest-fastcomp
+source emsdk_env.sh
+```
+
+Puis, compilez Upsilon :
+
+```bash
+git clone --recursive https://github.com/Lauryy06/Upsilon.git
+cd Upsilon
+git checkout omega-master
+make clean
+make PLATFORM=simulator TARGET=web OMEGA_USERNAME="{Votre nom ici, 15 caractères max}" -j4
+```
+
+Le simulateur se trouve dans `output/release/simulator/web/simulator.zip`
+
+Important : N'oubliez pas l'argument `--recursive`, Upsilon a besoin de sous-modules.
+Vous pouvez aussi changer le nombre de processus parallèles pendant la compilation en changeant la valeur suivant `-j`.
+
+</details>
+
+<details>
+  <summary><b>Simulateur 3DS</b></summary>
+  
+Vous aurez besoin de devkitPro et de devkitARM disponible dans votre `$PATH` (instructions [ici](https://devkitpro.org/wiki/Getting_Started) (en anglais))
+
+```bash
+git clone --recursive https://github.com/Lauryy06/Upsilon.git
+cd Upsilon
+git checkout --recursive upsilon-dev
+make PLATFORM=simulator TARGET=3ds -j
+```
+
+Vous pouvez ensuite copier epsilon.3dsx sur une carte SD pour l'exécuter depuis le HBC ou utiliser 3dslink pour le lancer via le réseau :
+
+```bash
+3dslink output/release/simulator/3ds/epsilon.3dsx -a <ADRESSE IP 3DS>
+```
+
+</details>
+
+Si vous avez besoin d'aide, n'hésitez pas à rejoindre notre serveur discord : https://discord.gg/Q9buEMduXG
+
+<a href="https://discord.gg/Q9buEMduXG"><p align="center"><img alt="Omega Banner Discord" src="https://user-images.githubusercontent.com/12123721/86287349-54ef5800-bbe8-11ea-80c1-34eb1f93eebd.png" /></p></a>
+---
+
+## Liens utiles
+* [Upsilon external (pour installer des applications supplémentaires et des fonds d'écran)](https://lauryy06.github.io/Upsilon-External/)
+* [Documentation d'ulab](https://micropython-ulab.readthedocs.io/en/latest/)
+
+## Contribution
+
+Pour contribuer, merci de lire le [Wiki d'Omega](https://github.com/Omega-Numworks/Omega/wiki/Contributing), les mêmes règles s'appliquent ici.
+
+## Les autres projets
+
+Les anciens projets d'Omega, avant sa fermeture, qui ont été utilisés pour ce projet
+
+* [Omega Themes](https://github.com/Omega-Numworks/Omega-Themes)
+* [Omega Website](https://github.com/Omega-Numworks/Omega-Website)
+* [Omega RPN `APP`](https://github.com/Omega-Numworks/Omega-RPN)
+* [Omega Atomic `APP`](https://github.com/Omega-Numworks/Omega-Atomic)
+* [Omega Design](https://github.com/Omega-Numworks/Omega-Design)
+* [Omega Discord Bot](https://github.com/Omega-Numworks/Omega-Discord-Bot)
+* [Omega App Template `BETA`](https://github.com/Omega-Numworks/Omega-App-Template)
+* [External Apps](https://github.com/Omega-Numworks/External-Apps)
+
+## À propos d'Epsilon
+
+Upsilon est un fork d'Omega, visant a continuer le projet des OS utilisateurs pour Numworks
+
+Omega est un fork d'Epsilon, un système d'exploitation performant pour calculatrices graphiques. Il inclut huit applications pour les mathématiques de lycée et d'études supérieurs
+
+Vous pouvez essayer Epsilon depuis votre navigateur sur le [simulateur en ligne](https://www.numworks.com/simulator/).
+
+## Licence
+
+NumWorks est une marque déposée de NumWorks SAS, 24 Rue Godot de Mauroy, 75009 Paris, France.
+Nintendo est Nintendo 3DS sont des marques déposées de Nintendo of America Inc, 4600 150th Ave NE, Redmond, WA 98052, Etats-Unis.
+NumWorks SAS et Nintendo of America Inc ne sont en aucun cas associés avec ce projet.
+
+* NumWorks Epsilon est disponible sous [Lisense CC BY-NC-SA](https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode).
+* Omega est disponible sous [Lisense CC BY-NC-SA](https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode).
+* Upsilon est disponible sous [Lisense CC BY-NC-SA](https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode).

README.md

@@ -1,56 +1,218 @@
-
-<p align="center"><img src="https://github.com/Omega-Numworks/Omega-Design/blob/master/Omega.png" /></p>
+<p align="center"><img src="https://github.com/Laporte12974/UpsilonDesign/blob/89a15953ae128aef8aa7d066dcaaf8d5c70f02a5/UPSILogo.png" /></p>
 
 <p align="center">
-  <a href="https://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="cc by-nc-sa 4.0" src="https://img.shields.io/badge/License-CC%20BY--NC--SA%204.0-lightgrey.svg?logo=creative%20commons&style=for-the-badge" /></a>
-  <a href="https://github.com/Omega-Numworks/Omega/issues"><img alt="Issues" src="https://img.shields.io/github/issues/Omega-Numworks/Omega.svg?logo=git&style=for-the-badge" /></a>
-  </br>
-  <a href="https://github.com/numworks/epsilon"><img alt="cc by-nc-sa 4.0" src="https://img.shields.io/badge/Epsilon-12.0.0-yellow?style=for-the-badge&logo=github" /></a>
-  <a href="https://gitlab.com/joachim2lefournis/Omega/pipelines"><img alt="Pipeline" src="https://img.shields.io/gitlab/pipeline/joachim2lefournis/Omega/omega-master?logo=gitlab&style=for-the-badge" /></a>
+  <a href="https://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="cc by-nc-sa 4.0" src="https://img.shields.io/badge/License-CC%20BY--NC--SA%204.0-525252.svg?labelColor=292929&logo=creative%20commons&style=for-the-badge" /></a>
+  <a href="https://github.com/Lauryy06/Upsilon/issues"><img alt="Issues" src="https://img.shields.io/github/issues/Lauryy06/Upsilon.svg?labelColor=292929&logo=git&style=for-the-badge" /></a>
+  <br/>
+  <a href="https://discord.gg/Q9buEMduXG"><img alt="Discord" src="https://img.shields.io/discord/663420259851567114?color=blue&labelColor=292929&label=chat%20-%20discord&logo=discord&style=for-the-badge" /></a>
 </p>
 
+> Vous ne comprenez pas l'anglais ? Vous êtes francophone ? Regardez le [*LISEZ-MOI* français](./README.fr.md) !
+
 ## About
 
-Omega is an extension to Numworks' Epsilon, the OS that runs on their calculator, which brings many features to it. Omega is for people who want to add features to the calculator, but cannot because they have been rejected by Numworks (and for reasons that are 100% understandable!). For example, there is no point in having a Dark Mode on the calculator, but it's fun, so we would add it into Omega! In short, Omega is a kind of Jailbreak on Epsilon.
+Upsilon is a fork of Omega, an user-made OS that runs on the Numworks calculator, which brings many features to it, but was discontinued because of a policy change from Numworks. Upsilon is for the people who want to see a future for user-made OSes for Numworks, even after the closure and archiving of Omega.
 
-## Some new features
-- Adding symbolic calculation back into the calculator
-- An app for RPN
-- A periodic table app + all of the molar masses for the elements in the toolbox
-- More steps for brightness (16 instead of 5)
-- Different colors for the LED in exam mode
-- 32 KB Python heap instead of 16 KB
 
-The main new features are listed [here](https://github.com/Omega-Numworks/Omega/wiki/Main-features), and the complete changelog can be found [here](https://github.com/quentinguidee/Omega/wiki/Complete-changelog).
+
+
+### Some new features
+- Enhancements for the Kandinsky python module
+- Support for wallpapers
+- Exernal apps
+- A custom theme
+- Operator overload for python
+- Improvements for the Periodic table application
+- *And everything that has been added to Omega before its termination!* [See Omega's changelog here](https://github.com/Omega-Numworks/Omega/wiki/Changelog) | [Main Omega features + screenshots](https://github.com/Omega-Numworks/Omega/wiki/Main-features).
+
+<br>
 
 ## Installation
 
-First of all, follow **step 1** [here](https://www.numworks.com/resources/engineering/software/build/). Then:
+### Manual
 
-* For **n0100**:
+*As of today, only the manual installation is available. You can refer to this [website](https://www.numworks.com/resources/engineering/software/build/) for the first step if you get errors.*
+
+
+
+### 1. Install SDK
+
+<br>
+
+<details>
+<summary><b>1.1 Linux</b></summary>
+
+<br>
+
+
+<details>
+<summary>Debian or Ubuntu</summary>
+
+<br>
+
+You just have to install dependencies by running these command with superuser privileges in a Terminal:
+
+```bash
+apt-get install build-essential git imagemagick libx11-dev libxext-dev libfreetype6-dev libpng-dev libjpeg-dev pkg-config gcc-arm-none-eabi binutils-arm-none-eabi
 ```
-git clone --recursive https://github.com/Omega-Numworks/Omega.git
-cd Omega
+
+And there you can go to step 2!
+
+<br>
+
+</details>
+
+<details>
+<summary>Fedora</summary>
+
+<br>
+
+First install basics dev tools.
+
+```bash
+dnf install make automake gcc gcc-c++ kernel-devel
+```
+
+Then install required packages.
+
+```bash
+dnf install git ImageMagick libX11-devel libXext-devel freetype-devel libpng-devel libjpeg-devel pkg-config
+```
+
+Then, install GCC cross compiler for ARM.
+
+```bash
+dnf install arm-none-eabi-gcc-cs arm-none-eabi-gcc-cs-c++
+```
+
+<br>
+
+</details>
+
+<br>
+
+</details>
+
+<details>
+<summary><b>1.2 Mac</b></summary>
+
+<br>
+
+It's recommended to use [Homebrew](https://brew.sh/). Once it's installed, just run:
+```bash
+brew install numworks/tap/epsilon-sdk
+```
+and it will install all dependencies.
+
+<br>
+
+And there you can go to step 2!
+
+<br>
+
+
+
+</details>
+
+<details>
+<summary><b>1.3 Windows</b></summary>
+
+<br>
+
+[Msys2](https://www.msys2.org/) environment is recommended to get most of the required tools on Windows easily. It's where you'll paste all the commands of this tutorial. Once it's installed, paste these commands into the Msys2 terminal.
+
+```bash
+pacman -S mingw-w64-x86_64-gcc mingw-w64-x86_64-freetype mingw-w64-x86_64-pkg-config mingw-w64-x86_64-libusb git make python
+echo "export PATH=/mingw64/bin:$PATH" >> .bashrc
+```
+
+Next, you'll need to install the [GCC toolchain for ARM](https://developer.arm.com/tools-and-software/open-source-software/developer-tools/gnu-toolchain/gnu-rm/downloads). When prompted for an install location, choose `C:\msys64\home\User\gcc-arm\`. You'll then need to add this folder to your $PATH. Just enter:
+
+```bash
+echo "export PATH=$PATH:$HOME/gcc-arm/bin" >> .bashrc
+```
+Just restart and you can go to step 2!
+</details>
+
+<br>
+
+### 2. Set up repo
+
+
+Clone repo and use 'upsilon-dev' branch by pasting these two commands:
+
+```bash
+git clone --recursive https://github.com/Lauryy06/Upsilon.git
+cd Upsilon
+git checkout upsilon-dev
+```
+<br>
+
+
+### 3. Choose the target
+
+
+<details>
+  <summary><b>Model n0100</b></summary>
+
+(note: you can change the `EPSILON_I18N=en` flag to `fr`, `nl`, `pt`, `it`, `de`, `es` or `hu`).
+
+```bash
 make MODEL=n0100 clean
-make MODEL=n0100 USERNAME="{Your name, max 15 characters}" -j4
+make MODEL=n0100 EPSILON_I18N=en OMEGA_USERNAME="{Your name, max 15 characters}" -j4
+```
+
+Now, run either:
+
+```bash
 make MODEL=n0100 epsilon_flash
 ```
+to directly flash the calculator after pressing simultaneously `reset` and `6` buttons and pluging in.
 
-<!-- Alternatively, you can use [Omega Installer](https://github.com/Omega-Numworks/installer) `BETA` -->
+<br>
 
-* For **n0110**:
+or:
+
+```bash
+make MODEL=n0100 OMEGA_USERNAME="" binpack -j4
 ```
-git clone --recursive https://github.com/Omega-Numworks/Omega.git
-cd Omega
+to make binpack wich you can flash to the caculator from [Ti-planet's webDFU](https://ti-planet.github.io/webdfu_numworks/n0100/). Binpacks are a great way to share a custom build of Upsilon to friends.
+  
+</details>
+
+<details>
+  <summary><b>Model n0110</b></summary>
+
+
+```bash
 make clean
-make USERNAME="{Your name, max 15 characters}" -j4
+make OMEGA_USERNAME="{Your name, max 15 characters}" -j4
+```
+
+Now, run either:
+
+```bash
 make epsilon_flash
 ```
+to directly flash the calculator after pressing simultaneously `reset` and `6` buttons and pluging in.
 
-* Building the **web simulator** (works under linux):
+<br>
 
-First, install emsdk :
+or:
+
+```bash
+make OMEGA_USERNAME="" binpack -j4
 ```
+to make binpack wich you can flash to the caculator from [Ti-planet's webDFU](https://ti-planet.github.io/webdfu_numworks/n0110/). Binpacks are a great way to share a custom build of Upsilon to friends.
+
+</details>
+
+<details>
+  <summary><b>Web simulator</b></summary>
+  
+First, install emsdk :
+
+```bash
 git clone https://github.com/emscripten-core/emsdk.git
 cd emsdk
 ./emsdk install latest-fastcomp
@@ -58,59 +220,84 @@ cd emsdk
 source emsdk_env.sh
 ```
 
-Then, compile Omega :
-```
-git clone --recursive https://github.com/Omega-Numworks/Omega.git
-cd Omega
+Then, compile Upsilon :
+
+```bash
 make clean
-make PLATFORM=simulator TARGET=web USERNAME="{Your name, max 15 characters}" -j4
+make PLATFORM=simulator TARGET=web OMEGA_USERNAME="{Your name, max 15 characters}" -j4
 ```
 
 The simulator is now in `output/release/simulator/web/simulator.zip`
 
 
-Important: Don't forget the `--recursive` tag, because Omega relies on submodules.
+</details>
+
+<details>
+  <summary><b>3DS Simulator</b></summary>
+  
+You need devkitPro and devkitARM installed and in your path (instructions [here](https://devkitpro.org/wiki/Getting_Started))
+
+```bash
+git clone --recursive https://github.com/Lauryy06/Upsilon.git
+cd Upsilon
+git checkout --recursive upsilon-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:
+
+```bash
+3dslink output/release/simulator/3ds/epsilon.3dsx -a <3DS' IP ADDRESS>
+```
+
+</details>
+
+<br>
+
+Important: Don't forget the `--recursive` tag, because Upsilon relies on submodules.
 Also, you can change the number of processes that run in parallel during the build by changing the value of the `-j` flag.
-<!-- ## Contribute -->
+Don't forget to put your pseudo instead of `{your pseudo, max 15 char}`. If you don't want one, just remove the `OMEGA_USERNAME=""` argument.
 
-## Related repositories
+<br>
 
-* [Omega CLI Installer](https://github.com/Omega-Numworks/Omega-CLI-Installer) `BETA`
-* [Omega WEB Installer](https://github.com/Omega-Numworks/Omega-WEB-Installer) `BETA`
-* [Omega RPN](https://github.com/Omega-Numworks/Omega-RPN)
-* [Omega Atom](https://github.com/Omega-Numworks/Omega-Atom)
-
-## Omega License
-
-Omega is released under a [CC BY-NC-SA License](https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode).
+If you need help, you can join our Discord server here : https://discord.gg/NFvzdCBTQn
 
+<a href="https://discord.gg/NFvzdCBTQn"><p align="center"><img alt="Omega Banner Discord" src="https://user-images.githubusercontent.com/12123721/86287349-54ef5800-bbe8-11ea-80c1-34eb1f93eebd.png" /></p></a>
 ---
-
-<p align="center"><img src="docs/epsilon.svg?sanitize=true" alt="NumWorks Epsilon logo" height="70" ></p>
-
-<!-- [![Build Status](https://github.com/numworks/epsilon/workflows/Continuous%20integration/badge.svg)](https://github.com/numworks/epsilon/actions?workflow=Continuous+integration) -->
-
-<p align="center">
-  <a href="https://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="cc by-nc-sa 4.0" src="https://img.shields.io/badge/License-CC%20BY--NC--SA%204.0-lightgrey.svg?logo=creative%20commons&style=for-the-badge" /></a>
-  <a href="https://github.com/numworks/epsilon/issues"><img alt="Issues" src="https://img.shields.io/github/issues/numworks/epsilon.svg?logo=git&style=for-the-badge" /></a>
-</p>
-
-
-Epsilon is a high-performance graphing calculator operating system. It includes eight apps that cover the high school mathematics curriculum.
-
-You can try Epsilon straight from your browser in the [online simulator](https://www.numworks.com/simulator/).
-
-## Diving in
-
-We highly recommend you start by reading the [online documentation](https://www.numworks.com/resources/engineering/software/) for this project. You'll learn how to install the [SDK](https://www.numworks.com/resources/engineering/software/build/) and about the overall architecture of the Epsilon.
+## Useful links
+* [Upsilon external (to install additional apps and wallpapers)](https://lauryy06.github.io/Upsilon-External/)
+* [Ulab documentation](https://micropython-ulab.readthedocs.io/en/latest/)
 
 ## Contributing
 
-If you run into an issue, we would be very happy if you would file a bug on the [issue tracker](https://github.com/numworks/epsilon/issues).
+To contribute, please refer to [Omega's Wiki](https://github.com/Omega-Numworks/Omega/wiki/Contributing), the same rules apply here.
+  
+## Related repositories
 
-We welcome contributions. For smaller changes just open a pull request straight away. For larger changes we recommend you open an issue first for discussion.
+Here are the main links toward Omega's different websites and repositories, that have been used for the creation of Upsilon.
+
+* [Omega Themes](https://github.com/Omega-Numworks/Omega-Themes)
+* [Omega Website](https://github.com/Omega-Numworks/Omega-Website)
+* [Omega RPN `APP`](https://github.com/Omega-Numworks/Omega-RPN)
+* [Omega Atomic `APP`](https://github.com/Omega-Numworks/Omega-Atomic)
+* [Omega Design](https://github.com/Omega-Numworks/Omega-Design)
+* [Omega Discord Bot](https://github.com/Omega-Numworks/Omega-Discord-Bot)
+* [Omega App Template `BETA`](https://github.com/Omega-Numworks/Omega-App-Template)
+* [External Apps](https://github.com/Omega-Numworks/External-Apps)
+
+## About Epsilon
+
+Upsilon is a fork of Omega, after the project's discontinuation.
+
+Omega is a fork of Epsilon, a high-performance graphing calculator operating system. It includes eight apps that cover the high school mathematics curriculum.
+
+You can try Epsilon straight from your browser in the [online simulator](https://www.numworks.com/simulator/).
 
 ## License
 
-NumWorks Epsilon is released under a [CC BY-NC-SA License](https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode). NumWorks is a registered trademark.
+NumWorks is a registered trademark of NumWorks SAS, 24 Rue Godot de Mauroy, 75009 Paris, France.
+Nintendo and Nintendo 3DS are registered trademarks of Nintendo of America Inc, 4600 150th Ave NE, Redmond, WA 98052, USA.
+NumWorks SAS and Nintendo of America Inc aren't associated in any shape or form with this project.
 
+* NumWorks Epsilon is released under a [CC BY-NC-SA License](https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode).
+* Omega is released under a [CC BY-NC-SA License](https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode).
+* Upsilon is released under a [CC BY-NC-SA License](https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode).

apps/Makefile

@@ -1,41 +1,70 @@
+include apps/helpers.mk
 include apps/shared/Makefile
 include apps/home/Makefile
 include apps/on_boarding/Makefile
 include apps/hardware_test/Makefile
 include apps/usb/Makefile
-apps =
 
+apps =
 # All selected apps are included. Each Makefile below is responsible for setting
 # the $apps variable (name of the app class) and the $app_headers
 # (path to the apps header).
-$(foreach i,${EPSILON_APPS},$(eval include apps/$(i)/Makefile))
+$(foreach i,${apps_list},${eval include apps/$(i)/Makefile})
 
-app_src += $(addprefix apps/,\
+app_equals = $(and $(findstring $(1),$(2)),$(findstring $(2),$(1)))
+# We list all the apps that are missing
+apps_missing = $(foreach i, ${apps_list}, $(if $(call app_equals, apps/$(i)/Makefile, $(wildcard apps/$(i)/Makefile)),, $(i) ) )
+
+# If the two doesn't match, we got an error.
+ifneq ($(strip $(apps_missing)),)
+    miss_modules = 0
+
+    # Check if the missing apps are one that are supposed to be submodules
+    $(foreach i, $(SUBMODULES_APPS), $(if $(call app_equals, $(filter $(i), $(apps_missing)), $(i)), $(eval miss_modules=1)))
+
+    ifeq ($(miss_modules), 1)
+        PLS_IGNORE := $(shell >&2 printf "\nSome submodules apps seem to be missing. To download them, assumming you git clone'd the repo, do\n")
+        PLS_IGNORE := $(shell >&2 printf "  git submodule init\n")
+        PLS_IGNORE := $(shell >&2 printf "  git submodule update\n\n")
+    endif
+    $(error Missing apps: $(strip $(apps_missing)))
+endif
+
+apps_src += $(addprefix apps/,\
+  alternate_empty_nested_menu_controller.cpp \
   apps_container.cpp \
+  apps_container_launch_default.cpp:-onboarding \
+  apps_container_launch_on_boarding.cpp:+onboarding \
+  apps_container_prompt_beta.cpp:+beta \
+  apps_container_prompt_none.cpp:-beta \
+  apps_container_prompt_none.cpp:-update \
+  apps_container_prompt_update.cpp:+update \
   apps_container_storage.cpp \
   apps_window.cpp \
   backlight_dimming_timer.cpp \
   battery_timer.cpp \
   battery_view.cpp \
+  clock_timer.cpp \
   empty_battery_window.cpp \
   exam_pop_up_controller.cpp \
+  exam_mode_configuration_official.cpp:+official \
+  exam_mode_configuration_non_official.cpp:-official \
   global_preferences.cpp \
   i18n.py \
   lock_view.cpp \
   main.cpp \
   math_toolbox.cpp \
+  math_variable_box_controller.cpp \
+  math_variable_box_empty_controller.cpp \
   shift_alpha_lock_view.cpp \
   suspend_timer.cpp \
   title_bar_view.cpp \
-  variable_box_controller.cpp \
-  variable_box_empty_controller.cpp \
 )
 
-apps_launch_on_boarding_src += apps/apps_container_launch_on_boarding.cpp
-apps_launch_default_src += apps/apps_container_launch_default.cpp
-apps_prompt_none_src += apps/apps_container_prompt_none.cpp
-apps_prompt_beta_src += apps/apps_container_prompt_beta.cpp
-apps_prompt_update_src += apps/apps_container_prompt_update.cpp
+tests_src += $(addprefix apps/,\
+  exam_mode_configuration_non_official.cpp \
+)
+
 
 snapshots_declaration = $(foreach i,$(apps),$(i)::Snapshot m_snapshot$(subst :,,$(i))Snapshot;)
 apps_declaration = $(foreach i,$(apps),$(i) m_$(subst :,,$(i));)
@@ -43,61 +72,67 @@ snapshots_construction = $(foreach i,$(apps),,m_snapshot$(subst :,,$(i))Snapshot
 snapshots_list = $(foreach i,$(apps),,&m_snapshot$(subst :,,$(i))Snapshot)
 snapshots_count = $(words $(apps))
 snapshot_includes = $(foreach i,$(app_headers),-include $(i) )
-epsilon_app_names = '$(foreach i,${EPSILON_APPS},"$(i)", )'
+epsilon_app_names = '$(foreach i,${apps_list},"$(i)", )'
 
-$(call object_for,apps/apps_container_storage.cpp apps/apps_container.cpp apps/main.cpp): CXXFLAGS += $(snapshot_includes) -DAPPS_CONTAINER_APPS_DECLARATION="$(apps_declaration)" -DAPPS_CONTAINER_SNAPSHOT_DECLARATIONS="$(snapshots_declaration)" -DAPPS_CONTAINER_SNAPSHOT_CONSTRUCTORS="$(snapshots_construction)" -DAPPS_CONTAINER_SNAPSHOT_LIST="$(snapshots_list)" -DAPPS_CONTAINER_SNAPSHOT_COUNT=$(snapshots_count) -DEPSILON_APPS_NAMES=$(epsilon_app_names) -DUSERNAME="$(USERNAME)"
+$(call object_for,apps/apps_container_storage.cpp apps/apps_container.cpp apps/main.cpp): CXXFLAGS += $(snapshot_includes) -DAPPS_CONTAINER_APPS_DECLARATION="$(apps_declaration)" -DAPPS_CONTAINER_SNAPSHOT_DECLARATIONS="$(snapshots_declaration)" -DAPPS_CONTAINER_SNAPSHOT_CONSTRUCTORS="$(snapshots_construction)" -DAPPS_CONTAINER_SNAPSHOT_LIST="$(snapshots_list)" -DAPPS_CONTAINER_SNAPSHOT_COUNT=$(snapshots_count) -DEPSILON_APPS_NAMES=$(epsilon_app_names) -DOMEGA_USERNAME="$(OMEGA_USERNAME)"
 
 # I18n file generation
 
+country_preferences = apps/country_preferences.csv
+language_preferences = apps/language_preferences.csv
+
 # The header is refered to as <apps/i18n.h> so make sure it's findable this way
 SFLAGS += -I$(BUILD_DIR)
 
 i18n_files += $(addprefix apps/language_,$(addsuffix .universal.i18n, $(EPSILON_I18N)))
-i18n_files += $(addprefix apps/,\
-  shared.de.i18n\
-  shared.en.i18n\
-  shared.es.i18n\
-  shared.fr.i18n\
-  shared.pt.i18n\
-  shared.universal.i18n\
-  toolbox.de.i18n\
-  toolbox.en.i18n\
-  toolbox.es.i18n\
-  toolbox.fr.i18n\
-  toolbox.pt.i18n\
-  variables.de.i18n\
-  variables.en.i18n\
-  variables.es.i18n\
-  variables.fr.i18n\
-  variables.pt.i18n\
-)
+
+i18n_files += $(call i18n_with_universal_for,shared)
+i18n_files += $(call i18n_with_universal_for,toolbox)
+i18n_files += $(call i18n_without_universal_for,variables)
 
 $(eval $(call rule_for, \
   I18N, \
   apps/i18n.cpp, \
   $(i18n_files), \
-  $$(PYTHON) apps/i18n.py --header $$(subst .cpp,.h,$$@) --implementation $$@ --locales $$(EPSILON_I18N) --files $$^ \
+  $$(PYTHON) apps/i18n.py --codepoints $(code_points) --countrypreferences $(country_preferences) --languagepreferences $(language_preferences) --header $$(subst .cpp,.h,$$@) --implementation $$@ --locales $$(EPSILON_I18N) --countries $$(EPSILON_COUNTRIES) --files $$^, \
+  global \
 ))
 
+
+
 $(BUILD_DIR)/apps/i18n.h: $(BUILD_DIR)/apps/i18n.cpp
 
 # Handle PNG files
 
 $(eval $(call depends_on_image,apps/title_bar_view.cpp,apps/exam_icon.png))
 
-all_app_src = $(app_src) $(epsilon_src) $(apps_launch_on_boarding_src) $(apps_launch_default_src) $(apps_prompt_none_src) $(apps_container_prompt_update) $(apps_prompt_beta_src) $(tests_src)
+$(call object_for,$(apps_src) $(tests_src)): $(BUILD_DIR)/apps/i18n.h
+$(call object_for,$(apps_src) $(tests_src)): $(BUILD_DIR)/apps/home/apps_layout.h
+$(call object_for,$(apps_src) $(tests_src)): $(BUILD_DIR)/python/port/genhdr/qstrdefs.generated.h
 
-$(call object_for,$(all_app_src)): $(BUILD_DIR)/apps/i18n.h
-$(call object_for,$(all_app_src)): $(BUILD_DIR)/python/port/genhdr/qstrdefs.generated.h
+$(call object_for,$(apps_src)): $(BUILD_DIR)/apps/home/apps_layout.h
 
-apps_tests_src = $(app_calculation_test_src) $(app_probability_test_src) $(app_regression_test_src) $(app_sequence_test_src) $(app_shared_test_src) $(app_statistics_test_src) $(app_solver_test_src)
+apps_tests_src = $(app_calculation_test_src) $(app_code_test_src) $(app_graph_test_src) $(app_probability_test_src) $(app_regression_test_src) $(app_sequence_test_src) $(app_shared_test_src) $(app_statistics_test_src) $(app_settings_test_src) $(app_solver_test_src)
 
-# Configure variants
-apps_all_src = $(app_src)
-apps_all_src += $(apps_launch_default_src) $(apps_launch_on_boarding_src
-apps_all_src += $(apps_prompt_none_src) $(apps_prompt_update_src) $(apps_prompt_beta_src)
+apps_tests_src += $(addprefix apps/,\
+  alternate_empty_nested_menu_controller.cpp \
+  global_preferences.cpp \
+)
 
-apps_default_src = $(app_src) $(apps_launch_default_src) $(apps_prompt_none_src)
-apps_onboarding_src = $(app_src) $(apps_launch_on_boarding_src) $(apps_prompt_none_src)
-apps_onboarding_update_src = $(app_src) $(apps_launch_on_boarding_src) $(apps_prompt_update_src)
-apps_onboarding_beta_src = $(app_src) $(apps_launch_on_boarding_src) $(apps_prompt_beta_src)
+ifeq ($(THEME_REPO),local)
+$(foreach img,$(image_list), $(eval $(call rule_for, \
+  ICON, \
+  $(img), \
+  $(addprefix themes/themes/local/, $(addsuffix .json, $(THEME_NAME))), \
+  $$(PYTHON) themes/themes_manager.py -i $(THEME_REPO) $(THEME_NAME) $$@ $(BUILD_DIR)/, \
+  global \
+)))
+else
+$(foreach img,$(image_list), $(eval $(call rule_for, \
+  ICON, \
+  $(img), \
+  $(addsuffix /escher/palette.h, $(BUILD_DIR)), \
+  $$(PYTHON) themes/themes_manager.py -i $(THEME_REPO) $(THEME_NAME) $$@ $(BUILD_DIR)/, \
+  global \
+)))
+endif

apps/alternate_empty_nested_menu_controller.cpp

@@ -0,0 +1,18 @@
+#include "alternate_empty_nested_menu_controller.h"
+
+void AlternateEmptyNestedMenuController::viewDidDisappear() {
+  if (isDisplayingEmptyController()) {
+    pop();
+  }
+  NestedMenuController::viewDidDisappear();
+}
+
+bool AlternateEmptyNestedMenuController::displayEmptyControllerIfNeeded() {
+  assert(!isDisplayingEmptyController());
+  // If the content is empty, we push an empty controller.
+  if (numberOfRows() == 0) {
+    push(emptyViewController());
+    return true;
+  }
+  return false;
+}

apps/alternate_empty_nested_menu_controller.h

@@ -0,0 +1,19 @@
+#ifndef APPS_ALTERNATE_EMPTY_NESTED_MENU_CONTROLLER_H
+#define APPS_ALTERNATE_EMPTY_NESTED_MENU_CONTROLLER_H
+
+#include <escher/nested_menu_controller.h>
+
+class AlternateEmptyNestedMenuController : public NestedMenuController {
+public:
+  AlternateEmptyNestedMenuController(I18n::Message title) :
+    NestedMenuController(nullptr, title)
+  {}
+  // View Controller
+  void viewDidDisappear() override;
+protected:
+  virtual ViewController * emptyViewController() = 0;
+  bool isDisplayingEmptyController() { return StackViewController::depth() == 2; }
+  bool displayEmptyControllerIfNeeded();
+};
+
+#endif

apps/apps_container.cpp

@@ -1,14 +1,20 @@
 #include "apps_container.h"
 #include "apps_container_storage.h"
 #include "global_preferences.h"
+#include "exam_mode_configuration.h"
 #include <ion.h>
 #include <poincare/init.h>
 #include <poincare/exception_checkpoint.h>
+#include <ion/backlight.h>
+#include <poincare/preferences.h>
+
+#include <algorithm>
 
 extern "C" {
 #include <assert.h>
 }
 
+using namespace Poincare;
 using namespace Shared;
 
 AppsContainer * AppsContainer::sharedAppsContainer() {
@@ -23,17 +29,18 @@ AppsContainer::AppsContainer() :
   m_globalContext(),
   m_variableBoxController(),
   m_examPopUpController(this),
-  m_promptController(k_promptMessages, k_promptColors, k_promptNumberOfMessages),
+  m_promptController(k_promptMessages, k_promptFGColors, k_promptBGColors, k_promptNumberOfMessages),
   m_batteryTimer(),
   m_suspendTimer(),
   m_backlightDimmingTimer(),
+  m_clockTimer(ClockTimer(this)),
   m_homeSnapshot(),
   m_onBoardingSnapshot(),
   m_hardwareTestSnapshot(),
   m_usbConnectedSnapshot()
 {
-  m_emptyBatteryWindow.setFrame(KDRect(0, 0, Ion::Display::Width, Ion::Display::Height));
-#if __EMSCRIPTEN__
+  m_emptyBatteryWindow.setFrame(KDRect(0, 0, Ion::Display::Width, Ion::Display::Height), false);
+// #if __EMSCRIPTEN__
   /* AppsContainer::poincareCircuitBreaker uses Ion::Keyboard::scan(), which
    * calls emscripten_sleep. If we set the poincare circuit breaker, we would
    * need to whitelist all the methods that might be in the call stack when
@@ -43,15 +50,34 @@ AppsContainer::AppsContainer() :
    * quite painy to maintain).
    * We just remove the circuit breaker for now.
    * TODO: Put the Poincare circuit breaker back on epsilon's web emulator */
-#else
+
+  /*
+   * This can be run in Omega, since it uses WebASM.
+   */
+// #else
   Poincare::Expression::SetCircuitBreaker(AppsContainer::poincareCircuitBreaker);
-#endif
+// #endif
   Ion::Storage::sharedStorage()->setDelegate(this);
 }
 
 bool AppsContainer::poincareCircuitBreaker() {
+  constexpr uint64_t minimalPressDuration = 20;
+  static uint64_t beginningOfInterruption = 0;
   Ion::Keyboard::State state = Ion::Keyboard::scan();
-  return state.keyDown(Ion::Keyboard::Key::Back);
+  bool interrupt = state.keyDown(Ion::Keyboard::Key::Back) || state.keyDown(Ion::Keyboard::Key::Home) || state.keyDown(Ion::Keyboard::Key::OnOff);
+  if (!interrupt) {
+    beginningOfInterruption = 0;
+    return false;
+  }
+  if (beginningOfInterruption == 0) {
+    beginningOfInterruption = Ion::Timing::millis();
+    return false;
+  }
+  if (Ion::Timing::millis() - beginningOfInterruption > minimalPressDuration) {
+    beginningOfInterruption = 0;
+    return true;
+  }
+  return false;
 }
 
 App::Snapshot * AppsContainer::hardwareTestAppSnapshot() {
@@ -84,7 +110,7 @@ MathToolbox * AppsContainer::mathToolbox() {
   return &m_mathToolbox;
 }
 
-VariableBoxController * AppsContainer::variableBoxController() {
+MathVariableBoxController * AppsContainer::variableBoxController() {
   return &m_variableBoxController;
 }
 
@@ -112,7 +138,7 @@ bool AppsContainer::dispatchEvent(Ion::Events::Event event) {
     Ion::LED::updateColorWithPlugAndCharge();
   }
   if (event == Ion::Events::USBEnumeration) {
-    if (Ion::USB::isPlugged()) {
+    if (Ion::USB::isPlugged() && GlobalPreferences::sharedGlobalPreferences()->getDfuLevel() != 3) {
       App::Snapshot * activeSnapshot = (s_activeApp == nullptr ? appSnapshotAtIndex(0) : s_activeApp->snapshot());
       /* Just after a software update, the battery timer does not have time to
        * fire before the calculator enters DFU mode. As the DFU mode blocks the
@@ -121,7 +147,9 @@ bool AppsContainer::dispatchEvent(Ion::Events::Event event) {
        * pictogram. */
       updateBatteryState();
       if (switchTo(usbConnectedAppSnapshot())) {
-        Ion::USB::DFU();
+        Ion::USB::DFU(true, GlobalPreferences::sharedGlobalPreferences()->dfuStatus(), GlobalPreferences::sharedGlobalPreferences()->getDfuLevel());
+        GlobalPreferences::sharedGlobalPreferences()->dfuResetStep();
+        GlobalPreferences::sharedGlobalPreferences()->setDfuStatus(false);
         // Update LED when exiting DFU mode
         Ion::LED::updateColorWithPlugAndCharge();
         bool switched = switchTo(activeSnapshot);
@@ -194,12 +222,19 @@ bool AppsContainer::dispatchEvent(Ion::Events::Event event) {
   return didProcessEvent || alphaLockWantsRedraw;
 }
 
+static constexpr Ion::Events::Event switch_events[] = {
+    Ion::Events::ShiftSeven, Ion::Events::ShiftEight, Ion::Events::ShiftNine,
+    Ion::Events::ShiftFour, Ion::Events::ShiftFive, Ion::Events::ShiftSix,
+    Ion::Events::ShiftOne, Ion::Events::ShiftTwo, Ion::Events::ShiftThree,
+    Ion::Events::ShiftZero, Ion::Events::ShiftDot, Ion::Events::ShiftEE
+};
+
 bool AppsContainer::processEvent(Ion::Events::Event event) {
   // Warning: if the window is dirtied, you need to call window()->redraw()
   if (event == Ion::Events::USBPlug) {
     if (Ion::USB::isPlugged()) {
-      if (GlobalPreferences::sharedGlobalPreferences()->examMode() == GlobalPreferences::ExamMode::Activate) {
-        displayExamModePopUp(false);
+      if (GlobalPreferences::sharedGlobalPreferences()->isInExamMode()) {
+        displayExamModePopUp(GlobalPreferences::ExamMode::Off);
         window()->redraw();
       } else {
         Ion::USB::enable();
@@ -214,10 +249,28 @@ bool AppsContainer::processEvent(Ion::Events::Event event) {
     switchTo(appSnapshotAtIndex(0));
     return true;
   }
+  if (event == Ion::Events::ShiftHome) {
+    switchTo(appSnapshotAtIndex(1));
+    return true;
+  }
+
+  for(int i = 0; i < std::min((int) (sizeof(switch_events) / sizeof(Ion::Events::Event)), APPS_CONTAINER_SNAPSHOT_COUNT); i++) {
+    if (event == switch_events[i]) {
+      m_window.redraw(true);
+      switchTo(appSnapshotAtIndex(i+1));
+      return true;
+    }
+  }
+
   if (event == Ion::Events::OnOff) {
     suspend(true);
     return true;
   }
+  if (event == Ion::Events::BrightnessPlus || event == Ion::Events::BrightnessMinus) {
+      int delta = Ion::Backlight::MaxBrightness/GlobalPreferences::NumberOfBrightnessStates;
+      int direction = (event == Ion::Events::BrightnessPlus) ? Ion::Backlight::NumberOfStepsPerShortcut*delta : -delta*Ion::Backlight::NumberOfStepsPerShortcut;
+      GlobalPreferences::sharedGlobalPreferences()->setBrightnessLevel(GlobalPreferences::sharedGlobalPreferences()->brightnessLevel()+direction);
+  }
   return false;
 }
 
@@ -237,7 +290,15 @@ bool AppsContainer::switchTo(App::Snapshot * snapshot) {
 }
 
 void AppsContainer::run() {
-  window()->setFrame(KDRect(0, 0, Ion::Display::Width, Ion::Display::Height));
+  KDRect screenRect = KDRect(0, 0, Ion::Display::Width, Ion::Display::Height);
+  window()->setFrame(screenRect, false);
+  /* We push a white screen here, because fetching the exam mode takes some time
+   * and it is visible when reflashing a N0100 (there is some noise on the
+   * screen before the logo appears). */
+  Ion::Display::pushRectUniform(screenRect, KDColorWhite);
+  if (GlobalPreferences::sharedGlobalPreferences()->isInExamMode()) {
+    activateExamMode(GlobalPreferences::sharedGlobalPreferences()->examMode());
+  }
   refreshPreferences();
 
   /* ExceptionCheckpoint stores the value of the stack pointer when setjump is
@@ -279,6 +340,10 @@ void AppsContainer::run() {
   switchTo(nullptr);
 }
 
+bool AppsContainer::updateClock() {
+  return m_window.updateClock();
+}
+
 bool AppsContainer::updateBatteryState() {
   bool batteryLevelUpdated = m_window.updateBatteryLevel();
   bool pluggedStateUpdated = m_window.updatePluggedState();
@@ -297,8 +362,8 @@ void AppsContainer::reloadTitleBarView() {
   m_window.reloadTitleBarView();
 }
 
-void AppsContainer::displayExamModePopUp(bool activate) {
-  m_examPopUpController.setActivatingExamMode(activate);
+void AppsContainer::displayExamModePopUp(GlobalPreferences::ExamMode mode) {
+  m_examPopUpController.setTargetExamMode(mode);
   s_activeApp->displayModalViewController(&m_examPopUpController, 0.f, 0.f, Metric::ExamPopUpTopMargin, Metric::PopUpRightMargin, Metric::ExamPopUpBottomMargin, Metric::PopUpLeftMargin);
 }
 
@@ -311,9 +376,9 @@ void AppsContainer::shutdownDueToLowBattery() {
    * case. */
     return;
   }
-  while (Ion::Battery::level() == Ion::Battery::Charge::EMPTY) {
+  while (Ion::Battery::level() == Ion::Battery::Charge::EMPTY && !Ion::USB::isPlugged()) {
     Ion::Backlight::setBrightness(0);
-    if (GlobalPreferences::sharedGlobalPreferences()->examMode() == GlobalPreferences::ExamMode::Deactivate) {
+    if (!GlobalPreferences::sharedGlobalPreferences()->isInExamMode()) {
       /* Unless the LED is lit up for the exam mode, switch off the LED. IF the
        * low battery event happened during the Power-On Self-Test, a LED might
        * have stayed lit up. */
@@ -335,7 +400,7 @@ bool AppsContainer::updateAlphaLock() {
   return m_window.updateAlphaLock();
 }
 
-OnBoarding::PopUpController * AppsContainer::promptController() {
+OnBoarding::PromptController * AppsContainer::promptController() {
   if (k_promptNumberOfMessages == 0) {
     return nullptr;
   }
@@ -346,6 +411,21 @@ void AppsContainer::redrawWindow(bool force) {
   m_window.redraw(force);
 }
 
+void AppsContainer::activateExamMode(GlobalPreferences::ExamMode examMode) {
+  assert(examMode != GlobalPreferences::ExamMode::Off && examMode != GlobalPreferences::ExamMode::Unknown);
+  reset();
+  Ion::LED::setColor(KDColorRed);
+  /* The Dutch exam mode LED is supposed to be orange but we can only make
+   * blink "pure" colors: with RGB leds on or off (as the PWM is used for
+   * blinking). The closest "pure" color is Yellow. Moreover, Orange LED is
+   * already used when the battery is charging. Using yellow, we can assert
+   * that the yellow LED only means that Dutch exam mode is on and avoid
+   * confusing states when the battery is charging and states when the Dutch
+   * exam mode is on. */
+  // Ion::LED::setColor(examMode == GlobalPreferences::ExamMode::Dutch ? KDColorYellow : KDColorRed);
+  Ion::LED::setBlinking(1000, 0.1f);
+}
+
 void AppsContainer::examDeactivatingPopUpIsDismissed() {
   if (Ion::USB::isPlugged()) {
     Ion::USB::enable();
@@ -369,11 +449,11 @@ Window * AppsContainer::window() {
 }
 
 int AppsContainer::numberOfContainerTimers() {
-  return 3;
+  return 4;
 }
 
 Timer * AppsContainer::containerTimerAtIndex(int i) {
-  Timer * timers[3] = {&m_batteryTimer, &m_suspendTimer, &m_backlightDimmingTimer};
+  Timer * timers[4] = {&m_batteryTimer, &m_suspendTimer, &m_backlightDimmingTimer, &m_clockTimer};
   return timers[i];
 }
 

apps/apps_container.h

@@ -8,14 +8,16 @@
 #include "apps_window.h"
 #include "empty_battery_window.h"
 #include "math_toolbox.h"
-#include "variable_box_controller.h"
+#include "math_variable_box_controller.h"
 #include "exam_pop_up_controller.h"
 #include "exam_pop_up_controller_delegate.h"
 #include "battery_timer.h"
 #include "suspend_timer.h"
+#include "global_preferences.h"
 #include "backlight_dimming_timer.h"
 #include "shared/global_context.h"
-#include "on_boarding/pop_up_controller.h"
+#include "clock_timer.h"
+#include "on_boarding/prompt_controller.h"
 
 #include <ion/events.h>
 
@@ -33,19 +35,21 @@ public:
   void reset();
   Poincare::Context * globalContext();
   MathToolbox * mathToolbox();
-  VariableBoxController * variableBoxController();
+  MathVariableBoxController * variableBoxController();
   void suspend(bool checkIfOnOffKeyReleased = false);
-  virtual bool dispatchEvent(Ion::Events::Event event) override;
+  bool dispatchEvent(Ion::Events::Event event) override;
   bool switchTo(App::Snapshot * snapshot) override;
   void run() override;
+  bool updateClock();
   bool updateBatteryState();
   void refreshPreferences();
   void reloadTitleBarView();
-  void displayExamModePopUp(bool activate);
+  void displayExamModePopUp(GlobalPreferences::ExamMode mode);
   void shutdownDueToLowBattery();
   void setShiftAlphaStatus(Ion::Events::ShiftAlphaStatus newStatus);
-  OnBoarding::PopUpController * promptController();
+  OnBoarding::PromptController * promptController();
   void redrawWindow(bool force = false);
+  void activateExamMode(GlobalPreferences::ExamMode examMode);
   // Exam pop-up controller delegate
   void examDeactivatingPopUpIsDismissed() override;
   // Ion::StorageDelegate
@@ -62,18 +66,20 @@ private:
   bool updateAlphaLock();
 
   static I18n::Message k_promptMessages[];
-  static KDColor k_promptColors[];
+  static KDColor k_promptFGColors[];
+  static KDColor k_promptBGColors[];
   static int k_promptNumberOfMessages;
   AppsWindow m_window;
   EmptyBatteryWindow m_emptyBatteryWindow;
   Shared::GlobalContext m_globalContext;
   MathToolbox m_mathToolbox;
-  VariableBoxController m_variableBoxController;
+  MathVariableBoxController m_variableBoxController;
   ExamPopUpController m_examPopUpController;
-  OnBoarding::PopUpController m_promptController;
+  OnBoarding::PromptController m_promptController;
   BatteryTimer m_batteryTimer;
   SuspendTimer m_suspendTimer;
   BacklightDimmingTimer m_backlightDimmingTimer;
+  ClockTimer m_clockTimer;
   Home::App::Snapshot m_homeSnapshot;
   OnBoarding::App::Snapshot m_onBoardingSnapshot;
   HardwareTest::App::Snapshot m_hardwareTestSnapshot;

apps/apps_container_prompt_beta.cpp

@@ -10,7 +10,7 @@ I18n::Message AppsContainer::k_promptMessages[] = {
   I18n::Message::BetaVersionMessage5,
   I18n::Message::BetaVersionMessage6};
 
-KDColor AppsContainer::k_promptColors[] = {
+KDColor AppsContainer::k_promptFGColors[] = {
   KDColorBlack,
   KDColorBlack,
   KDColorBlack,
@@ -18,6 +18,16 @@ KDColor AppsContainer::k_promptColors[] = {
   KDColorWhite,
   KDColorBlack,
   KDColorBlack,
-  Palette::YellowDark};
+  Palette::AccentText};
+
+KDColor AppsContainer::k_promptBGColors[] = {
+    KDColorWhite,
+    KDColorWhite,
+    KDColorWhite,
+    KDColorWhite,
+    KDColorWhite,
+    KDColorWhite,
+    KDColorWhite,
+    KDColorWhite};
 
 int AppsContainer::k_promptNumberOfMessages = 8;

apps/apps_container_prompt_none.cpp

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

apps/apps_container_prompt_update.cpp

@@ -8,12 +8,20 @@ I18n::Message AppsContainer::k_promptMessages[] = {
   I18n::Message::UpdateMessage3,
   I18n::Message::UpdateMessage4};
 
-KDColor AppsContainer::k_promptColors[] = {
+KDColor AppsContainer::k_promptFGColors[] = {
   KDColorBlack,
   KDColorBlack,
   KDColorBlack,
   KDColorWhite,
   KDColorBlack,
-  Palette::YellowDark};
+  Palette::AccentText};
+
+KDColor AppsContainer::k_promptBGColors[] = {
+    KDColorWhite,
+    KDColorWhite,
+    KDColorWhite,
+    KDColorBlack,
+    KDColorWhite,
+    KDColorBlack};
 
 int AppsContainer::k_promptNumberOfMessages = 6;

apps/apps_window.cpp

@@ -3,6 +3,7 @@
 extern "C" {
 #include <assert.h>
 }
+#include <ion/rtc.h>
 
 AppsWindow::AppsWindow() :
   Window(),
@@ -19,6 +20,11 @@ bool AppsWindow::updateBatteryLevel() {
   return m_titleBarView.setChargeState(Ion::Battery::level());
 }
 
+bool AppsWindow::updateClock() {
+  Ion::RTC::DateTime dateTime = Ion::RTC::dateTime();
+  return m_titleBarView.setClock(dateTime.tm_hour, dateTime.tm_min, Ion::RTC::mode() != Ion::RTC::Mode::Disabled);
+}
+
 bool AppsWindow::updateIsChargingState() {
   return m_titleBarView.setIsCharging(Ion::Battery::isCharging());
 }
@@ -58,11 +64,11 @@ View * AppsWindow::subviewAtIndex(int index) {
   return m_contentView;
 }
 
-void AppsWindow::layoutSubviews() {
+void AppsWindow::layoutSubviews(bool force) {
   KDCoordinate titleHeight = m_hideTitleBarView ? 0 : Metric::TitleBarHeight;
-  m_titleBarView.setFrame(KDRect(0, 0, bounds().width(), titleHeight));
+  m_titleBarView.setFrame(KDRect(0, 0, bounds().width(), titleHeight), force);
   if (m_contentView != nullptr) {
-    m_contentView->setFrame(KDRect(0, titleHeight, bounds().width(), bounds().height()-titleHeight));
+    m_contentView->setFrame(KDRect(0, titleHeight, bounds().width(), bounds().height()-titleHeight), force);
   }
 }
 

apps/apps_window.h

@@ -9,6 +9,7 @@ public:
   AppsWindow();
   void setTitle(I18n::Message title);
   bool updateBatteryLevel();
+  bool updateClock();
   bool updateIsChargingState();
   bool updatePluggedState();
   void refreshPreferences();
@@ -17,7 +18,7 @@ public:
   void hideTitleBarView(bool hide);
 private:
   int numberOfSubviews() const override;
-  void layoutSubviews() override;
+  void layoutSubviews(bool force = false) override;
   View * subviewAtIndex(int index) override;
   TitleBarView m_titleBarView;
   bool m_hideTitleBarView;

apps/battery_timer.cpp

@@ -9,7 +9,7 @@ BatteryTimer::BatteryTimer() :
 bool BatteryTimer::fire() {
   AppsContainer * container = AppsContainer::sharedAppsContainer();
   bool needRedrawing = container->updateBatteryState();
-  if (Ion::Battery::level() == Ion::Battery::Charge::EMPTY) {
+  if (Ion::Battery::level() == Ion::Battery::Charge::EMPTY && !Ion::USB::isPlugged()) {
     container->shutdownDueToLowBattery();
   }
   return needRedrawing;

apps/battery_view.cpp

@@ -54,50 +54,49 @@ bool BatteryView::setIsPlugged(bool isPlugged) {
   return false;
 }
 
-KDColor s_flashWorkingBuffer[BatteryView::k_flashHeight*BatteryView::k_flashWidth];
-KDColor s_tickWorkingBuffer[BatteryView::k_tickHeight*BatteryView::k_tickWidth];
-
 void BatteryView::drawRect(KDContext * ctx, KDRect rect) const {
   assert(m_chargeState != Ion::Battery::Charge::EMPTY);
   /* We draw from left to right. The middle part representing the battery
    *'content' depends on the charge */
 
   // Draw the left part
-  ctx->fillRect(KDRect(0, 0, k_elementWidth, k_batteryHeight), KDColorWhite);
+  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::YellowLight);
+    ctx->fillRect(KDRect(batteryInsideX, 0, batteryInsideWidth, k_batteryHeight), Palette::BatteryInCharge);
     KDRect frame((k_batteryWidth-k_flashWidth)/2, 0, k_flashWidth, k_flashHeight);
-    ctx->blendRectWithMask(frame, KDColorWhite, (const uint8_t *)flashMask, s_flashWorkingBuffer);
+    KDColor flashWorkingBuffer[BatteryView::k_flashHeight*BatteryView::k_flashWidth];
+    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::LowBattery);
-    ctx->fillRect(KDRect(3*k_elementWidth+k_separatorThickness, 0, k_batteryWidth-5*k_elementWidth-2*k_separatorThickness, k_batteryHeight), Palette::YellowLight);
+    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));
   } 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), KDColorWhite);
-    ctx->fillRect(KDRect(batteryInsideX+middleChargeWidth, 0, middleChargeWidth, k_batteryHeight), Palette::YellowLight);
+    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));
   } else {
     assert(m_chargeState == Ion::Battery::Charge::FULL);
     // Full but not plugged: Full battery
-    ctx->fillRect(KDRect(batteryInsideX, 0, batteryInsideWidth, k_batteryHeight), KDColorWhite);
+    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);
-      ctx->blendRectWithMask(frame, Palette::YellowDark, (const uint8_t *)tickMask, s_tickWorkingBuffer);
+      KDColor tickWorkingBuffer[BatteryView::k_tickHeight*BatteryView::k_tickWidth];
+      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), KDColorWhite);
-  ctx->fillRect(KDRect(k_batteryWidth-k_elementWidth, (k_batteryHeight-k_capHeight)/2, k_elementWidth, k_capHeight), KDColorWhite);
+  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/Makefile

@@ -7,25 +7,35 @@ app_calculation_test_src += $(addprefix apps/calculation/,\
 )
 
 app_calculation_src = $(addprefix apps/calculation/,\
+  additional_outputs/complex_graph_cell.cpp \
+  additional_outputs/complex_model.cpp \
+  additional_outputs/complex_list_controller.cpp \
+  additional_outputs/expression_with_equal_sign_view.cpp \
+  additional_outputs/expressions_list_controller.cpp \
+  additional_outputs/illustrated_list_controller.cpp \
+  additional_outputs/illustration_cell.cpp \
+  additional_outputs/integer_list_controller.cpp \
+  additional_outputs/scrollable_three_expressions_cell.cpp \
+  additional_outputs/list_controller.cpp \
+  additional_outputs/matrix_list_controller.cpp \
+  additional_outputs/rational_list_controller.cpp \
+  additional_outputs/second_degree_list_controller.cpp \
+  additional_outputs/trigonometry_graph_cell.cpp \
+  additional_outputs/trigonometry_list_controller.cpp \
+  additional_outputs/trigonometry_model.cpp \
+  additional_outputs/unit_list_controller.cpp \
   app.cpp \
   edit_expression_controller.cpp \
   expression_field.cpp \
   history_view_cell.cpp \
   history_controller.cpp \
-  scrollable_expression_view.cpp \
   selectable_table_view.cpp \
 )
 
 app_calculation_src += $(app_calculation_test_src)
-app_src += $(app_calculation_src)
+apps_src += $(app_calculation_src)
 
-i18n_files += $(addprefix apps/calculation/,\
-  base.de.i18n\
-  base.en.i18n\
-  base.es.i18n\
-  base.fr.i18n\
-  base.pt.i18n\
-)
+i18n_files += $(call i18n_without_universal_for,calculation/base)
 
 tests_src += $(addprefix apps/calculation/test/,\
   calculation_store.cpp\

apps/calculation/additional_outputs/complex_graph_cell.cpp

@@ -0,0 +1,94 @@
+#include "complex_graph_cell.h"
+#include <escher/palette.h>
+
+using namespace Shared;
+using namespace Poincare;
+
+namespace Calculation {
+
+ComplexGraphView::ComplexGraphView(ComplexModel * complexModel) :
+  LabeledCurveView(complexModel),
+  m_complex(complexModel)
+{
+}
+
+void ComplexGraphView::drawRect(KDContext * ctx, KDRect rect) const {
+  ctx->fillRect(rect, Palette::BackgroundApps);
+
+  // Draw grid, axes and graduations
+  drawGrid(ctx, rect);
+  drawAxes(ctx, rect);
+  drawLabelsAndGraduations(ctx, rect, Axis::Vertical, true);
+  drawLabelsAndGraduations(ctx, rect, Axis::Horizontal, true);
+
+  float real = m_complex->real();
+  float imag = m_complex->imag();
+
+  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);
+
+  /* Draw the partial ellipse indicating the angle θ
+   * - the ellipse parameters are a = |real|/5 and b = |imag|/5,
+   * - the parametric ellipse equation is x(t) = a*cos(th*t) and y(t) = b*sin(th*t)
+   *   with th computed in order to be the intersection of the line forming an
+   *   angle θ with the abscissa and the ellipsis
+   * - we draw the ellipse for t in [0,1] to represent it from the abscissa axis
+   *   to the phase of the complex
+   */
+  /* Compute th: th is the intersection of ellipsis of equation (a*cos(t), b*sin(t))
+   * and the line of equation (real*t,imag*t).
+   * (a*cos(t), b*sin(t)) = (real*t,imag*t) --> tan(t) = sign(a)*sign(b) (± π)
+   * --> t = π/4 [π/2] according to sign(a) and sign(b). */
+  float th = real < 0.0f ? (float)(3.0*M_PI_4) : (float)M_PI_4;
+  th = imag < 0.0f ? -th : th;
+  // Compute ellipsis parameters a and b
+  float factor = 5.0f;
+  float a = std::fabs(real)/factor;
+  float b = std::fabs(imag)/factor;
+  // Avoid flat ellipsis for edge cases (for real = 0, the case imag = 0 is excluded)
+  if (real == 0.0f) {
+    a = 1.0f/factor;
+    th = imag < 0.0f ? (float)-M_PI_2 : (float)M_PI_2;
+  }
+  std::complex<float> parameters(a,b);
+  drawCurve(ctx, rect, 0.0f, 1.0f, 0.01f,
+      [](float t, void * model, void * context) {
+      std::complex<float> parameters = *(std::complex<float> *)model;
+        float th = *(float *)context;
+        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);
+
+  // 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);
+
+  // Draw complex position on the plan
+  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);
+  // '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);
+  // '|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);
+  // '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;
+  /* anglePositionRatio is the ratio of the angle where we position the label
+   * For the right half plan, we position the label close to the abscissa axis
+   * 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);
+}
+
+}

apps/calculation/additional_outputs/complex_graph_cell.h

@@ -0,0 +1,32 @@
+#ifndef CALCULATION_ADDITIONAL_OUTPUTS_COMPLEX_GRAPH_CELL_H
+#define CALCULATION_ADDITIONAL_OUTPUTS_COMPLEX_GRAPH_CELL_H
+
+#include "../../shared/labeled_curve_view.h"
+#include "complex_model.h"
+#include "illustration_cell.h"
+
+namespace Calculation {
+
+class ComplexGraphView : public Shared::LabeledCurveView {
+public:
+  ComplexGraphView(ComplexModel * complexModel);
+  void drawRect(KDContext * ctx, KDRect rect) const override;
+private:
+  // '-' + significant digits + ".E-" + 2 digits (the represented dot is a float, so it is bounded by 1E38 and 1E-38
+  size_t labelMaxGlyphLengthSize() const override { return 1 + Poincare::Preferences::VeryShortNumberOfSignificantDigits + 3 + 2; }
+  ComplexModel * m_complex;
+};
+
+class ComplexGraphCell : public IllustrationCell {
+public:
+  ComplexGraphCell(ComplexModel * complexModel) : m_view(complexModel) {}
+  void reload() { m_view.reload(); }
+private:
+  View * view() override { return &m_view; }
+  ComplexGraphView m_view;
+};
+
+}
+
+#endif
+

apps/calculation/additional_outputs/complex_list_controller.cpp

@@ -0,0 +1,44 @@
+#include "complex_list_controller.h"
+#include "../app.h"
+#include "../../shared/poincare_helpers.h"
+#include <poincare/imaginary_part.h>
+#include <poincare/real_part.h>
+#include "complex_list_controller.h"
+
+using namespace Poincare;
+using namespace Shared;
+
+namespace Calculation {
+
+void ComplexListController::viewWillAppear() {
+  IllustratedListController::viewWillAppear();
+  m_complexGraphCell.reload(); // compute labels
+}
+
+void ComplexListController::setExpression(Poincare::Expression e) {
+  IllustratedListController::setExpression(e);
+
+  Poincare::Preferences * preferences = Poincare::Preferences::sharedPreferences();
+  Poincare::Preferences::ComplexFormat currentComplexFormat = preferences->complexFormat();
+  if (currentComplexFormat == Poincare::Preferences::ComplexFormat::Real) {
+    // Temporary change complex format to avoid all additional expressions to be "unreal"
+    preferences->setComplexFormat(Poincare::Preferences::ComplexFormat::Cartesian);
+  }
+  Poincare::Context * context = App::app()->localContext();
+  // Fill Calculation Store
+  m_calculationStore.push("im(z)", context, CalculationHeight);
+  m_calculationStore.push("re(z)", context, CalculationHeight);
+  m_calculationStore.push("arg(z)", context, CalculationHeight);
+  m_calculationStore.push("abs(z)", context, CalculationHeight);
+
+  // Set Complex illustration
+  // Compute a and b as in Expression::hasDefinedComplexApproximation to ensure the same defined result
+  float a = Shared::PoincareHelpers::ApproximateToScalar<float>(RealPart::Builder(e.clone()), context);
+  float b = Shared::PoincareHelpers::ApproximateToScalar<float>(ImaginaryPart::Builder(e.clone()), context);
+  m_model.setComplex(std::complex<float>(a,b));
+
+  // Reset complex format as before
+  preferences->setComplexFormat(currentComplexFormat);
+}
+
+}

apps/calculation/additional_outputs/complex_list_controller.h

@@ -0,0 +1,30 @@
+#ifndef CALCULATION_ADDITIONAL_OUTPUTS_COMPLEX_LIST_CONTROLLER_H
+#define CALCULATION_ADDITIONAL_OUTPUTS_COMPLEX_LIST_CONTROLLER_H
+
+#include "complex_graph_cell.h"
+#include "complex_model.h"
+#include "illustrated_list_controller.h"
+
+namespace Calculation {
+
+class ComplexListController : public IllustratedListController {
+public:
+  ComplexListController(EditExpressionController * editExpressionController) :
+    IllustratedListController(editExpressionController),
+    m_complexGraphCell(&m_model) {}
+
+  // ViewController
+  void viewWillAppear() override;
+
+  void setExpression(Poincare::Expression e) override;
+private:
+  CodePoint expressionSymbol() const override { return 'z'; }
+  HighlightCell * illustrationCell() override { return &m_complexGraphCell; }
+  ComplexGraphCell m_complexGraphCell;
+  ComplexModel m_model;
+};
+
+}
+
+#endif
+

apps/calculation/additional_outputs/complex_model.cpp

@@ -0,0 +1,43 @@
+#include "complex_model.h"
+
+namespace Calculation {
+
+ComplexModel::ComplexModel(std::complex<float> c) :
+  Shared::CurveViewRange(),
+  std::complex<float>(c)
+{
+}
+
+float ComplexModel::rangeBound(float direction, bool horizontal) const {
+  float minFactor = k_minVerticalMarginFactor;
+  float maxFactor = k_maxVerticalMarginFactor;
+  float value = imag();
+  if (horizontal) {
+    minFactor = k_minHorizontalMarginFactor;
+    maxFactor = k_maxHorizontalMarginFactor;
+    value = real();
+  }
+  float factor = direction*value >= 0.0f ? maxFactor : minFactor;
+  if (std::isnan(value) || std::isinf(value) || value == 0.0f) {
+    return direction*factor;
+  }
+  return factor*value;
+}
+
+float ComplexModel::xMin() const {
+  return rangeBound(-1.0f, true);
+}
+
+float ComplexModel::xMax() const {
+  return rangeBound(1.0f, true);
+}
+
+float ComplexModel::yMin() const {
+  return rangeBound(-1.0f, false);
+}
+
+float ComplexModel::yMax() const {
+  return rangeBound(1.0f, false);
+}
+
+}

apps/calculation/additional_outputs/complex_model.h

@@ -0,0 +1,75 @@
+#ifndef CALCULATION_ADDITIONAL_OUTPUTS_COMPLEX_MODEL_H
+#define CALCULATION_ADDITIONAL_OUTPUTS_COMPLEX_MODEL_H
+
+#include "../../shared/curve_view_range.h"
+#include "illustrated_list_controller.h"
+#include <complex>
+
+namespace Calculation {
+
+class ComplexModel : public Shared::CurveViewRange, public std::complex<float> {
+public:
+  ComplexModel(std::complex<float> c = std::complex<float>(NAN, NAN));
+  // CurveViewRange
+  float xMin() const override;
+  float xMax() const override;
+  float yMin() const override;
+  float yMax() const override;
+
+  void setComplex(std::complex<float> c) { *this = ComplexModel(c); }
+
+  /* The range is computed from these criteria:
+   * - The real part is centered horizontally
+   * - Both left and right margins are equal to the real length
+   * - The imaginary part is the same length as the real part
+   * - The remaining vertical margin are splitted as one third at the top, 2
+   *   thirds at the bottom
+   *
+   *           |                        | 1/3 * vertical_margin
+   *           +----------+
+   *           |        / |             |
+   *           |      /   |             | Imaginary
+   *           |    /     |             |
+   *           |  /       |             |
+   * ----------+----------+----------
+   *                                    |
+   *                                    | 2/3 * vertical_margin
+   *           -----------
+   *              Real
+   *
+   */
+  // Horizontal range
+  static constexpr float k_minHorizontalMarginFactor = -1.0f;
+  static constexpr float k_maxHorizontalMarginFactor = 2.0f;
+  // Vertical range
+  static constexpr KDCoordinate k_width = Ion::Display::Width - Metric::PopUpRightMargin - Metric::PopUpLeftMargin;
+  static constexpr KDCoordinate k_height = IllustratedListController::k_illustrationHeight;
+  static constexpr KDCoordinate k_unit = k_width/3;
+  /*
+   *  VerticalMaring = k_height - k_unit
+   *
+   *  Values | Coordinates
+   * --------+----------------------------------
+   *  imag   |  k_unit
+   *  Ymax   |  k_unit + (1/3)*VerticalMargin
+   *  Ymin   |  -(2/3)*VerticalMargin
+   *
+   * Thus:
+   * Ymin = -(2/3)*k_verticalMargin*imag/k_unit
+   *      = -(2/3)*(k_height/k_unit - 1)*imag
+   *      = 2/3*(1 - k_height/k_unit)*imag
+   * Ymax = (k_unit + (1/3)*VerticalMargin)*imag/k_unit
+   *      = (1 + (1/3)*(k_height/k_unit - 1))*imag
+   *      = 1/3*(2 + k_height/k_unit)*imag
+   *
+   * */
+  static constexpr float k_minVerticalMarginFactor = 2.0f/3.0f*(1.0f - (float)k_height/(float)k_unit);
+  static constexpr float k_maxVerticalMarginFactor = 1.0f/3.0f*(2.0f + (float)k_height/(float)k_unit);
+
+private:
+  float rangeBound(float direction, bool horizontal) const;
+};
+
+}
+
+#endif

apps/calculation/additional_outputs/expression_with_equal_sign_view.cpp

@@ -0,0 +1,33 @@
+#include "expression_with_equal_sign_view.h"
+
+namespace Calculation {
+
+KDSize ExpressionWithEqualSignView::minimalSizeForOptimalDisplay() const {
+  KDSize expressionSize = ExpressionView::minimalSizeForOptimalDisplay();
+  KDSize equalSize = m_equalSign.minimalSizeForOptimalDisplay();
+  return KDSize(expressionSize.width() + equalSize.width() + Metric::CommonLargeMargin, expressionSize.height());
+}
+
+void ExpressionWithEqualSignView::drawRect(KDContext * ctx, KDRect rect) const {
+  if (m_layout.isUninitialized()) {
+    return;
+  }
+  // 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);
+}
+
+View * ExpressionWithEqualSignView::subviewAtIndex(int index) {
+  assert(index == 0);
+  return &m_equalSign;
+}
+
+void ExpressionWithEqualSignView::layoutSubviews(bool force) {
+  KDSize expressionSize = ExpressionView::minimalSizeForOptimalDisplay();
+  KDSize equalSize = m_equalSign.minimalSizeForOptimalDisplay();
+  KDCoordinate expressionBaseline = layout().baseline();
+  m_equalSign.setFrame(KDRect(expressionSize.width() + Metric::CommonLargeMargin, expressionBaseline - equalSize.height()/2, equalSize), force);
+}
+
+}

apps/calculation/additional_outputs/expression_with_equal_sign_view.h

@@ -0,0 +1,27 @@
+#ifndef CALCULATION_EXPRESSION_WITH_EQUAL_SIGN_VIEW_H
+#define CALCULATION_EXPRESSION_WITH_EQUAL_SIGN_VIEW_H
+
+#include <escher.h>
+#include <apps/i18n.h>
+#include <poincare/layout.h>
+#include <escher/palette.h>
+
+namespace Calculation {
+
+class ExpressionWithEqualSignView : public ExpressionView {
+public:
+  ExpressionWithEqualSignView() :
+    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;
+private:
+  View * subviewAtIndex(int index) override;
+  void layoutSubviews(bool force = false) override;
+  int numberOfSubviews() const override { return 1; }
+  MessageTextView m_equalSign;
+};
+
+}
+
+#endif

apps/calculation/additional_outputs/expressions_list_controller.cpp

@@ -0,0 +1,87 @@
+#include "expressions_list_controller.h"
+#include "../app.h"
+
+using namespace Poincare;
+
+namespace Calculation {
+
+/* Expressions list controller */
+
+ExpressionsListController::ExpressionsListController(EditExpressionController * editExpressionController) :
+  ListController(editExpressionController),
+  m_cells{}
+{
+  for (int i = 0; i < k_maxNumberOfRows; i++) {
+    m_cells[i].setParentResponder(m_listController.selectableTableView());
+  }
+}
+
+void ExpressionsListController::didEnterResponderChain(Responder * previousFirstResponder) {
+  selectCellAtLocation(0, 0);
+}
+
+int ExpressionsListController::reusableCellCount(int type) {
+  return k_maxNumberOfRows;
+}
+
+void ExpressionsListController::viewDidDisappear() {
+  ListController::viewDidDisappear();
+  // Reset layout and cell memoization to avoid taking extra space in the pool
+  for (int i = 0; i < k_maxNumberOfRows; i++) {
+    m_cells[i].setLayout(Layout());
+    /* By reseting m_layouts, numberOfRow will go down to 0, and the highlighted
+     * cells won't be unselected. Therefore we unselect them here. */
+    m_cells[i].setHighlighted(false);
+    m_layouts[i] = Layout();
+  }
+  m_expression = Expression();
+}
+
+HighlightCell * ExpressionsListController::reusableCell(int index, int type) {
+  return &m_cells[index];
+}
+
+KDCoordinate ExpressionsListController::rowHeight(int j) {
+  Layout l = layoutAtIndex(j);
+  assert(!l.isUninitialized());
+  return l.layoutSize().height() + 2 * Metric::CommonSmallMargin + Metric::CellSeparatorThickness;
+}
+
+void ExpressionsListController::willDisplayCellForIndex(HighlightCell * cell, int index) {
+  /* Note : To further optimize memoization space in the pool, layout
+   * serialization could be memoized instead, and layout would be recomputed
+   * here, when setting cell's layout. */
+  ExpressionTableCellWithPointer * myCell = static_cast<ExpressionTableCellWithPointer *>(cell);
+  myCell->setLayout(layoutAtIndex(index));
+  myCell->setAccessoryMessage(messageAtIndex(index));
+  myCell->reloadScroll();
+}
+
+int ExpressionsListController::numberOfRows() const {
+  int nbOfRows = 0;
+  for (size_t i = 0; i < k_maxNumberOfRows; i++) {
+    if (!m_layouts[i].isUninitialized()) {
+      nbOfRows++;
+    }
+  }
+  return nbOfRows;
+}
+
+void ExpressionsListController::setExpression(Poincare::Expression e) {
+  // Reinitialize memoization
+  for (int i = 0; i < k_maxNumberOfRows; i++) {
+    m_layouts[i] = Layout();
+  }
+  m_expression = e;
+}
+
+Poincare::Layout ExpressionsListController::layoutAtIndex(int index) {
+  assert(!m_layouts[index].isUninitialized());
+  return m_layouts[index];
+}
+
+int ExpressionsListController::textAtIndex(char * buffer, size_t bufferSize, int index) {
+  return m_layouts[index].serializeParsedExpression(buffer, bufferSize, App::app()->localContext());
+}
+
+}

apps/calculation/additional_outputs/expressions_list_controller.h

@@ -0,0 +1,46 @@
+#ifndef CALCULATION_ADDITIONAL_OUTPUTS_EXPRESSIONS_LIST_CONTROLLER_H
+#define CALCULATION_ADDITIONAL_OUTPUTS_EXPRESSIONS_LIST_CONTROLLER_H
+
+#include <escher.h>
+#include <poincare/expression.h>
+#include <apps/i18n.h>
+#include "list_controller.h"
+
+namespace Calculation {
+
+class ExpressionsListController : public ListController {
+public:
+  ExpressionsListController(EditExpressionController * editExpressionController);
+
+  // Responder
+  void viewDidDisappear() override;
+  void didEnterResponderChain(Responder * previousFirstResponder) override;
+
+  //ListViewDataSource
+  int reusableCellCount(int type) override;
+  HighlightCell * reusableCell(int index, int type) override;
+  KDCoordinate rowHeight(int j) override;
+  int typeAtLocation(int i, int j) override { return 0; }
+  void willDisplayCellForIndex(HighlightCell * cell, int index) override;
+  int numberOfRows() const override;
+
+  // IllustratedListController
+  void setExpression(Poincare::Expression e) override;
+
+protected:
+  constexpr static int k_maxNumberOfRows = 5;
+  int textAtIndex(char * buffer, size_t bufferSize, int index) override;
+  Poincare::Expression m_expression;
+  // Memoization of layouts
+  mutable Poincare::Layout m_layouts[k_maxNumberOfRows];
+private:
+  Poincare::Layout layoutAtIndex(int index);
+  virtual I18n::Message messageAtIndex(int index) = 0;
+  // Cells
+  ExpressionTableCellWithPointer m_cells[k_maxNumberOfRows];
+};
+
+}
+
+#endif
+

apps/calculation/additional_outputs/illustrated_list_controller.cpp

@@ -0,0 +1,133 @@
+#include "illustrated_list_controller.h"
+#include <poincare/exception_checkpoint.h>
+#include <poincare/symbol.h>
+#include "../app.h"
+
+using namespace Poincare;
+
+namespace Calculation {
+
+/* Illustrated list controller */
+
+IllustratedListController::IllustratedListController(EditExpressionController * editExpressionController) :
+  ListController(editExpressionController, this),
+  m_calculationStore(m_calculationStoreBuffer, k_calculationStoreBufferSize),
+  m_additionalCalculationCells{}
+{
+  for (int i = 0; i < k_maxNumberOfAdditionalCalculations; i++) {
+    m_additionalCalculationCells[i].setParentResponder(m_listController.selectableTableView());
+  }
+}
+
+void IllustratedListController::didEnterResponderChain(Responder * previousFirstResponder) {
+  // Select the left subview on all cells and reinitialize scroll
+  for (int i = 0; i < k_maxNumberOfAdditionalCalculations; i++) {
+    m_additionalCalculationCells[i].reinitSelection();
+  }
+  selectCellAtLocation(0, 1);
+}
+
+void IllustratedListController::viewDidDisappear() {
+  ListController::viewDidDisappear();
+  // Reset the context as it was before displaying the IllustratedListController
+  Poincare::Context * context = App::app()->localContext();
+  if (m_savedExpression.isUninitialized()) {
+    /* If no expression was stored in the symbol used by the
+     * IllustratedListController, we delete the record we stored */
+    char symbolName[3];
+    size_t length = UTF8Decoder::CodePointToChars(expressionSymbol(), symbolName, 3);
+    assert(length < 3);
+    symbolName[length] = 0;
+    const char * const extensions[2] = {"exp", "func"};
+    Ion::Storage::sharedStorage()->recordBaseNamedWithExtensions(symbolName, extensions, 2).destroy();
+  } else {
+    Poincare::Symbol s = Poincare::Symbol::Builder(expressionSymbol());
+    context->setExpressionForSymbolAbstract(m_savedExpression, s);
+  }
+  // Reset cell memoization to avoid taking extra space in the pool
+  for (int i = 0; i < k_maxNumberOfAdditionalCalculations; i++) {
+     m_additionalCalculationCells[i].resetMemoization();
+   }
+}
+
+int IllustratedListController::numberOfRows() const {
+  return m_calculationStore.numberOfCalculations() + 1;
+}
+
+int IllustratedListController::reusableCellCount(int type) {
+  assert(type < 2);
+  if (type == 0) {
+    return 1;
+  }
+  return k_maxNumberOfAdditionalCalculations;
+}
+
+HighlightCell * IllustratedListController::reusableCell(int index, int type) {
+  assert(type < 2);
+  assert(index >= 0);
+  if (type == 0) {
+    return illustrationCell();
+  }
+  return &m_additionalCalculationCells[index];
+}
+
+KDCoordinate IllustratedListController::rowHeight(int j) {
+  if (j == 0) {
+    return k_illustrationHeight;
+  }
+  int calculationIndex = j-1;
+  if (calculationIndex >= m_calculationStore.numberOfCalculations()) {
+    return 0;
+  }
+  Shared::ExpiringPointer<Calculation> calculation = m_calculationStore.calculationAtIndex(calculationIndex);
+  constexpr bool expanded = true;
+  return calculation->height(expanded) + Metric::CellSeparatorThickness;
+}
+
+int IllustratedListController::typeAtLocation(int i, int j) {
+  return j == 0 ? 0 : 1;
+}
+
+void IllustratedListController::willDisplayCellForIndex(HighlightCell * cell, int index) {
+  if (index == 0) {
+    return;
+  }
+  Poincare::Context * context = App::app()->localContext();
+  ScrollableThreeExpressionsCell * myCell = (ScrollableThreeExpressionsCell *)cell;
+  Calculation * c = m_calculationStore.calculationAtIndex(index-1).pointer();
+  myCell->setCalculation(c);
+  myCell->setDisplayCenter(c->displayOutput(context) != Calculation::DisplayOutput::ApproximateOnly);
+}
+
+void IllustratedListController::tableViewDidChangeSelection(SelectableTableView * t, int previousSelectedCellX, int previousSelectedCellY, bool withinTemporarySelection) {
+  if (withinTemporarySelection) {
+    return;
+  }
+  // Forbid selecting Illustration cell
+  if (t->selectedRow() == 0) {
+    t->selectCellAtLocation(0, 1);
+  }
+  /* But scroll to the top when we select the first
+   * ScrollableThreeExpressionsCell in order display the
+   * illustration cell. */
+  if (t->selectedRow() == 1) {
+    t->scrollToCell(0, 0);
+  }
+}
+
+void IllustratedListController::setExpression(Poincare::Expression e) {
+  m_calculationStore.deleteAll();
+  Poincare::Context * context = App::app()->localContext();
+  Poincare::Symbol s = Poincare::Symbol::Builder(expressionSymbol());
+  m_savedExpression = context->expressionForSymbolAbstract(s, false);
+  context->setExpressionForSymbolAbstract(e, s);
+}
+
+int IllustratedListController::textAtIndex(char * buffer, size_t bufferSize, int index) {
+  ScrollableThreeExpressionsCell * myCell = static_cast<ScrollableThreeExpressionsCell *>(m_listController.selectableTableView()->selectedCell());
+  Shared::ExpiringPointer<Calculation> c =  m_calculationStore.calculationAtIndex(index-1);
+  const char * text = myCell->selectedSubviewPosition() == ScrollableThreeExpressionsView::SubviewPosition::Right ? c->approximateOutputText(Calculation::NumberOfSignificantDigits::Maximal) : c->exactOutputText();
+  return strlcpy(buffer, text, bufferSize);
+}
+
+}

apps/calculation/additional_outputs/illustrated_list_controller.h

@@ -0,0 +1,54 @@
+#ifndef CALCULATION_ADDITIONAL_OUTPUTS_ILLUSTRATED_LIST_CONTROLLER_H
+#define CALCULATION_ADDITIONAL_OUTPUTS_ILLUSTRATED_LIST_CONTROLLER_H
+
+#include <escher.h>
+#include "scrollable_three_expressions_cell.h"
+#include "list_controller.h"
+#include "../calculation_store.h"
+#include <apps/i18n.h>
+
+namespace Calculation {
+
+class IllustratedListController : public ListController, public SelectableTableViewDelegate {
+public:
+  IllustratedListController(EditExpressionController * editExpressionController);
+
+  // Responder
+  void viewDidDisappear() override;
+  void didEnterResponderChain(Responder * previousFirstResponder) override;
+
+  //ListViewDataSource
+  int numberOfRows() const override;
+  int reusableCellCount(int type) override;
+  HighlightCell * reusableCell(int index, int type) override;
+  KDCoordinate rowHeight(int j) override;
+  int typeAtLocation(int i, int j) override;
+  void willDisplayCellForIndex(HighlightCell * cell, int index) override;
+
+  // SelectableTableViewDelegate
+  void tableViewDidChangeSelection(SelectableTableView * t, int previousSelectedCellX, int previousSelectedCellY, bool withinTemporarySelection) override;
+
+  // IllustratedListController
+  void setExpression(Poincare::Expression e) override;
+
+  constexpr static KDCoordinate k_illustrationHeight = 120;
+protected:
+  static KDCoordinate CalculationHeight(Calculation * c, bool expanded) { return ScrollableThreeExpressionsCell::Height(c); }
+  Poincare::Expression m_savedExpression;
+  CalculationStore m_calculationStore;
+private:
+  int textAtIndex(char * buffer, size_t bufferSize, int index) override;
+  virtual CodePoint expressionSymbol() const = 0;
+  // Set the size of the buffer needed to store the additional calculation
+  constexpr static int k_maxNumberOfAdditionalCalculations = 4;
+  constexpr static int k_calculationStoreBufferSize = k_maxNumberOfAdditionalCalculations * (sizeof(Calculation) + Calculation::k_numberOfExpressions * Constant::MaxSerializedExpressionSize + sizeof(Calculation *));
+  char m_calculationStoreBuffer[k_calculationStoreBufferSize];
+  // Cells
+  virtual HighlightCell * illustrationCell() = 0;
+  ScrollableThreeExpressionsCell m_additionalCalculationCells[k_maxNumberOfAdditionalCalculations];
+};
+
+}
+
+#endif
+

apps/calculation/additional_outputs/illustration_cell.cpp

@@ -0,0 +1,16 @@
+#include "illustration_cell.h"
+
+using namespace Shared;
+using namespace Poincare;
+
+namespace Calculation {
+
+void IllustrationCell::layoutSubviews(bool force) {
+  view()->setFrame(KDRect(Metric::CellSeparatorThickness, Metric::CellSeparatorThickness, bounds().width() - 2*Metric::CellSeparatorThickness, bounds().height() - 2*Metric::CellSeparatorThickness), force);
+}
+
+void IllustrationCell::drawRect(KDContext * ctx, KDRect rect) const {
+  drawBorderOfRect(ctx, bounds(), Palette::ListCellBorder);
+}
+
+}

apps/calculation/additional_outputs/illustration_cell.h

@@ -0,0 +1,23 @@
+#ifndef CALCULATION_ADDITIONAL_OUTPUTS_ILLUSTRATION_CELL_H
+#define CALCULATION_ADDITIONAL_OUTPUTS_ILLUSTRATION_CELL_H
+
+#include <escher/bordered.h>
+#include <escher/highlight_cell.h>
+
+namespace Calculation {
+
+class IllustrationCell : public Bordered, public HighlightCell {
+public:
+  void setHighlighted(bool highlight) override { return; }
+  void drawRect(KDContext * ctx, KDRect rect) const override;
+private:
+  int numberOfSubviews() const override { return 1; }
+  View * subviewAtIndex(int index) override { return view(); }
+  void layoutSubviews(bool force = false) override;
+  virtual View * view() = 0;
+};
+
+}
+
+#endif
+

apps/calculation/additional_outputs/integer_list_controller.cpp

@@ -0,0 +1,55 @@
+#include "integer_list_controller.h"
+#include <poincare/based_integer.h>
+#include <poincare/integer.h>
+#include <poincare/empty_layout.h>
+#include <poincare/factor.h>
+#include "../app.h"
+#include "../../shared/poincare_helpers.h"
+
+using namespace Poincare;
+using namespace Shared;
+
+namespace Calculation {
+
+Integer::Base baseAtIndex(int index) {
+  switch (index) {
+    case 0:
+      return Integer::Base::Decimal;
+    case 1:
+      return Integer::Base::Hexadecimal;
+    default:
+      assert(index == 2);
+      return Integer::Base::Binary;
+  }
+}
+
+void IntegerListController::setExpression(Poincare::Expression e) {
+  ExpressionsListController::setExpression(e);
+  static_assert(k_maxNumberOfRows >= k_indexOfFactorExpression + 1, "k_maxNumberOfRows must be greater than k_indexOfFactorExpression");
+  assert(!m_expression.isUninitialized() && m_expression.type() == ExpressionNode::Type::BasedInteger);
+  Integer integer = static_cast<BasedInteger &>(m_expression).integer();
+  for (int index = 0; index < k_indexOfFactorExpression; ++index) {
+    m_layouts[index] = integer.createLayout(baseAtIndex(index));
+  }
+  // Computing factorExpression
+  Expression factor = Factor::Builder(m_expression.clone());
+  PoincareHelpers::Simplify(&factor, App::app()->localContext(), ExpressionNode::ReductionTarget::User);
+  if (!factor.isUndefined()) {
+    m_layouts[k_indexOfFactorExpression] = PoincareHelpers::CreateLayout(factor);
+  }
+}
+
+I18n::Message IntegerListController::messageAtIndex(int index) {
+  switch (index) {
+    case 0:
+      return I18n::Message::DecimalBase;
+    case 1:
+      return I18n::Message::HexadecimalBase;
+    case 2:
+      return I18n::Message::BinaryBase;
+    default:
+      return I18n::Message::PrimeFactors;
+  }
+}
+
+}

apps/calculation/additional_outputs/integer_list_controller.h

@@ -0,0 +1,24 @@
+#ifndef CALCULATION_ADDITIONAL_OUTPUTS_INTEGER_LIST_CONTROLLER_H
+#define CALCULATION_ADDITIONAL_OUTPUTS_INTEGER_LIST_CONTROLLER_H
+
+#include "expressions_list_controller.h"
+
+namespace Calculation {
+
+class IntegerListController : public ExpressionsListController {
+public:
+  IntegerListController(EditExpressionController * editExpressionController) :
+    ExpressionsListController(editExpressionController) {}
+
+  void setExpression(Poincare::Expression e) override;
+
+private:
+  static constexpr int k_indexOfFactorExpression = 3;
+  I18n::Message messageAtIndex(int index) override;
+};
+
+}
+
+#endif
+
+

apps/calculation/additional_outputs/list_controller.cpp

@@ -0,0 +1,50 @@
+#include "list_controller.h"
+#include "../edit_expression_controller.h"
+
+using namespace Poincare;
+
+namespace Calculation {
+
+/* Inner List Controller */
+
+ListController::InnerListController::InnerListController(ListController * dataSource, SelectableTableViewDelegate * delegate) :
+  ViewController(dataSource),
+  m_selectableTableView(this, dataSource, dataSource, delegate)
+{
+  m_selectableTableView.setMargins(0);
+  m_selectableTableView.setDecoratorType(ScrollView::Decorator::Type::None);
+}
+
+void ListController::InnerListController::didBecomeFirstResponder() {
+  m_selectableTableView.reloadData();
+}
+
+/* List Controller */
+
+ListController::ListController(EditExpressionController * editExpressionController, SelectableTableViewDelegate * delegate) :
+  StackViewController(nullptr, &m_listController, Palette::ToolboxHeaderText, Palette::ToolboxHeaderBackground, Palette::ToolboxHeaderBorder),
+  m_listController(this, delegate),
+  m_editExpressionController(editExpressionController)
+{
+}
+
+bool ListController::handleEvent(Ion::Events::Event event) {
+  if (event == Ion::Events::OK || event == Ion::Events::EXE) {
+    char buffer[Constant::MaxSerializedExpressionSize];
+    textAtIndex(buffer, Constant::MaxSerializedExpressionSize, selectedRow());
+    /* The order is important here: we dismiss the pop-up first because it
+     * clears the Poincare pool from the layouts used to display the pop-up.
+     * Thereby it frees memory to do Poincare computations required by
+     * insertTextBody. */
+    Container::activeApp()->dismissModalViewController();
+    m_editExpressionController->insertTextBody(buffer);
+    return true;
+  }
+  return false;
+}
+
+void ListController::didBecomeFirstResponder() {
+  Container::activeApp()->setFirstResponder(&m_listController);
+}
+
+}

apps/calculation/additional_outputs/list_controller.h

@@ -0,0 +1,41 @@
+#ifndef CALCULATION_ADDITIONAL_OUTPUTS_LIST_CONTROLLER_H
+#define CALCULATION_ADDITIONAL_OUTPUTS_LIST_CONTROLLER_H
+
+#include <escher.h>
+#include <apps/i18n.h>
+
+namespace Calculation {
+
+class EditExpressionController;
+
+class ListController : public StackViewController, public ListViewDataSource, public SelectableTableViewDataSource {
+public:
+  ListController(EditExpressionController * editExpressionController, SelectableTableViewDelegate * delegate = nullptr);
+
+  // Responder
+  bool handleEvent(Ion::Events::Event event) override;
+  void didBecomeFirstResponder() override;
+
+  // ListController
+  virtual void setExpression(Poincare::Expression e) = 0;
+
+protected:
+  class InnerListController : public ViewController {
+  public:
+    InnerListController(ListController * dataSource, SelectableTableViewDelegate * delegate = nullptr);
+    const char * title() override { return I18n::translate(I18n::Message::AdditionalResults); }
+    View * view() override { return &m_selectableTableView; }
+    void didBecomeFirstResponder() override;
+    SelectableTableView * selectableTableView() { return &m_selectableTableView; }
+  private:
+    SelectableTableView m_selectableTableView;
+  };
+  virtual int textAtIndex(char * buffer, size_t bufferSize, int index) = 0;
+  InnerListController m_listController;
+  EditExpressionController * m_editExpressionController;
+};
+
+}
+
+#endif
+

apps/calculation/additional_outputs/matrix_list_controller.cpp

@@ -0,0 +1,106 @@
+#include "matrix_list_controller.h"
+#include "../app.h"
+#include "../../shared/poincare_helpers.h"
+#include <apps/global_preferences.h>
+#include <poincare_nodes.h>
+#include <poincare/matrix.h>
+#include <string.h>
+
+using namespace Poincare;
+using namespace Shared;
+
+namespace Calculation {
+
+void MatrixListController::setExpression(Poincare::Expression e) {
+  ExpressionsListController::setExpression(e);
+  assert(!m_expression.isUninitialized());
+  static_assert(k_maxNumberOfRows >= k_maxNumberOfOutputRows, "k_maxNumberOfRows must be greater than k_maxNumberOfOutputRows");
+
+  Poincare::Preferences * preferences = Poincare::Preferences::sharedPreferences();
+  Poincare::Preferences::ComplexFormat currentComplexFormat = preferences->complexFormat();
+  if (currentComplexFormat == Poincare::Preferences::ComplexFormat::Real) {
+    /* Temporary change complex format to avoid all additional expressions to be
+     * "unreal" (with [i] for instance). As additional results are computed from
+     * the output, which is built taking ComplexFormat into account, there are
+     * no risks of displaying additional results on an unreal output. */
+    preferences->setComplexFormat(Poincare::Preferences::ComplexFormat::Cartesian);
+  }
+
+  Context * context = App::app()->localContext();
+  ExpressionNode::ReductionContext reductionContext(
+    context,
+    preferences->complexFormat(),
+    preferences->angleUnit(),
+    GlobalPreferences::sharedGlobalPreferences()->unitFormat(),
+    ExpressionNode::ReductionTarget::SystemForApproximation,
+    ExpressionNode::SymbolicComputation::ReplaceAllSymbolsWithDefinitionsOrUndefined);
+
+  // The expression must be reduced to call methods such as determinant or trace
+  assert(m_expression.type() == ExpressionNode::Type::Matrix);
+
+  bool mIsSquared = (static_cast<Matrix &>(m_expression).numberOfRows() == static_cast<Matrix &>(m_expression).numberOfColumns());
+  size_t index = 0;
+  size_t messageIndex = 0;
+  // 1. Matrix determinant if square matrix
+  if (mIsSquared) {
+    /* Determinant is reduced so that a null determinant can be detected.
+     * However, some exceptions remain such as cos(x)^2+sin(x)^2-1 which will
+     * not be reduced to a rational, but will be null in theory. */
+    Expression determinant = Determinant::Builder(m_expression.clone()).reduce(reductionContext);
+    m_indexMessageMap[index] = messageIndex++;
+    m_layouts[index++] = getLayoutFromExpression(determinant, context, preferences);
+    // 2. Matrix inverse if invertible matrix
+    // A squared matrix is invertible if and only if determinant is non null
+    if (!determinant.isUndefined() && determinant.nullStatus(context) != ExpressionNode::NullStatus::Null) {
+      // TODO: Handle ExpressionNode::NullStatus::Unknown
+      m_indexMessageMap[index] = messageIndex++;
+      m_layouts[index++] = getLayoutFromExpression(MatrixInverse::Builder(m_expression.clone()), context, preferences);
+    }
+  }
+  // 3. Matrix row echelon form
+  messageIndex = 2;
+  Expression rowEchelonForm = MatrixRowEchelonForm::Builder(m_expression.clone());
+  m_indexMessageMap[index] = messageIndex++;
+  m_layouts[index++] = getLayoutFromExpression(rowEchelonForm, context, preferences);
+  /* 4. Matrix reduced row echelon form
+   *    it can be computed from row echelon form to save computation time.*/
+  m_indexMessageMap[index] = messageIndex++;
+  m_layouts[index++] = getLayoutFromExpression(MatrixReducedRowEchelonForm::Builder(rowEchelonForm), context, preferences);
+  // 5. Matrix trace if square matrix
+  if (mIsSquared) {
+    m_indexMessageMap[index] = messageIndex++;
+    m_layouts[index++] = getLayoutFromExpression(MatrixTrace::Builder(m_expression.clone()), context, preferences);
+  }
+  // Reset complex format as before
+  preferences->setComplexFormat(currentComplexFormat);
+}
+
+Poincare::Layout MatrixListController::getLayoutFromExpression(Expression e, Context * context, Poincare::Preferences * preferences) {
+  assert(!e.isUninitialized());
+  // Simplify or approximate expression
+  Expression approximateExpression;
+  Expression simplifiedExpression;
+  e.simplifyAndApproximate(&simplifiedExpression, &approximateExpression, context,
+    preferences->complexFormat(), preferences->angleUnit(), GlobalPreferences::sharedGlobalPreferences()->unitFormat(),
+    ExpressionNode::SymbolicComputation::ReplaceAllSymbolsWithDefinitionsOrUndefined);
+  // simplify might have been interrupted, in which case we use approximate
+  if (simplifiedExpression.isUninitialized()) {
+    assert(!approximateExpression.isUninitialized());
+    return Shared::PoincareHelpers::CreateLayout(approximateExpression);
+  }
+  return Shared::PoincareHelpers::CreateLayout(simplifiedExpression);
+}
+
+I18n::Message MatrixListController::messageAtIndex(int index) {
+  // Message index is mapped in setExpression because it depends on the Matrix.
+  assert(index < k_maxNumberOfOutputRows && index >=0);
+  I18n::Message messages[k_maxNumberOfOutputRows] = {
+    I18n::Message::AdditionalDeterminant,
+    I18n::Message::AdditionalInverse,
+    I18n::Message::AdditionalRowEchelonForm,
+    I18n::Message::AdditionalReducedRowEchelonForm,
+    I18n::Message::AdditionalTrace};
+  return messages[m_indexMessageMap[index]];
+}
+
+}

apps/calculation/additional_outputs/matrix_list_controller.h

@@ -0,0 +1,27 @@
+#ifndef CALCULATION_ADDITIONAL_OUTPUTS_MATRIX_LIST_CONTROLLER_H
+#define CALCULATION_ADDITIONAL_OUTPUTS_MATRIX_LIST_CONTROLLER_H
+
+#include "expressions_list_controller.h"
+
+namespace Calculation {
+
+class MatrixListController : public ExpressionsListController {
+public:
+  MatrixListController(EditExpressionController * editExpressionController) :
+    ExpressionsListController(editExpressionController) {}
+
+  void setExpression(Poincare::Expression e) override;
+
+private:
+  I18n::Message messageAtIndex(int index) override;
+  Poincare::Layout getLayoutFromExpression(Poincare::Expression e, Poincare::Context * context, Poincare::Preferences * preferences);
+  // Map from cell index to message index
+  constexpr static int k_maxNumberOfOutputRows = 5;
+  int m_indexMessageMap[k_maxNumberOfOutputRows];
+};
+
+}
+
+#endif
+
+

apps/calculation/additional_outputs/rational_list_controller.cpp

@@ -0,0 +1,60 @@
+#include "rational_list_controller.h"
+#include "../app.h"
+#include "../../shared/poincare_helpers.h"
+#include <poincare_nodes.h>
+#include <string.h>
+
+using namespace Poincare;
+using namespace Shared;
+
+namespace Calculation {
+
+Integer extractInteger(const Expression e) {
+  assert(e.type() == ExpressionNode::Type::BasedInteger);
+  return static_cast<const BasedInteger &>(e).integer();
+}
+
+void RationalListController::setExpression(Poincare::Expression e) {
+  ExpressionsListController::setExpression(e);
+  assert(!m_expression.isUninitialized());
+  static_assert(k_maxNumberOfRows >= 2, "k_maxNumberOfRows must be greater than 2");
+
+  bool negative = false;
+  Expression div = m_expression;
+  if (m_expression.type() == ExpressionNode::Type::Opposite) {
+    negative = true;
+    div = m_expression.childAtIndex(0);
+  }
+
+  assert(div.type() == ExpressionNode::Type::Division);
+  Integer numerator = extractInteger(div.childAtIndex(0));
+  numerator.setNegative(negative);
+  Integer denominator = extractInteger(div.childAtIndex(1));
+
+  int index = 0;
+  m_layouts[index++] = PoincareHelpers::CreateLayout(Integer::CreateMixedFraction(numerator, denominator));
+  m_layouts[index++] = PoincareHelpers::CreateLayout(Integer::CreateEuclideanDivision(numerator, denominator));
+}
+
+I18n::Message RationalListController::messageAtIndex(int index) {
+  switch (index) {
+    case 0:
+      return I18n::Message::MixedFraction;
+    default:
+      return I18n::Message::EuclideanDivision;
+  }
+}
+
+int RationalListController::textAtIndex(char * buffer, size_t bufferSize, int index) {
+  int length = ExpressionsListController::textAtIndex(buffer, bufferSize, index);
+  if (index == 1) {
+    // Get rid of the left part of the equality
+    char * equalPosition = strchr(buffer, '=');
+    assert(equalPosition != nullptr);
+    strlcpy(buffer, equalPosition + 1, bufferSize);
+    return buffer + length - 1 - equalPosition;
+  }
+  return length;
+}
+
+}

apps/calculation/additional_outputs/rational_list_controller.h

@@ -0,0 +1,24 @@
+#ifndef CALCULATION_ADDITIONAL_OUTPUTS_RATIONAL_LIST_CONTROLLER_H
+#define CALCULATION_ADDITIONAL_OUTPUTS_RATIONAL_LIST_CONTROLLER_H
+
+#include "expressions_list_controller.h"
+
+namespace Calculation {
+
+class RationalListController : public ExpressionsListController {
+public:
+  RationalListController(EditExpressionController * editExpressionController) :
+    ExpressionsListController(editExpressionController) {}
+
+  void setExpression(Poincare::Expression e) override;
+
+private:
+  I18n::Message messageAtIndex(int index) override;
+  int textAtIndex(char * buffer, size_t bufferSize, int index) override;
+};
+
+}
+
+#endif
+
+

apps/calculation/additional_outputs/scrollable_three_expressions_cell.cpp

@@ -0,0 +1,101 @@
+#include "scrollable_three_expressions_cell.h"
+#include <poincare/exception_checkpoint.h>
+#include "../app.h"
+
+namespace Calculation {
+
+void ScrollableThreeExpressionsView::resetMemoization() {
+  setLayouts(Poincare::Layout(), Poincare::Layout(), Poincare::Layout());
+}
+
+// TODO: factorize with HistoryViewCell!
+void ScrollableThreeExpressionsView::setCalculation(Calculation * calculation, bool canChangeDisplayOutput) {
+  Poincare::Context * context = App::app()->localContext();
+
+  // Clean the layouts to make room in the pool
+  resetMemoization();
+
+  // Create the input layout
+  Poincare::Layout inputLayout = calculation->createInputLayout();
+
+  // Create the exact output layout
+  Poincare::Layout exactOutputLayout = Poincare::Layout();
+  if (Calculation::DisplaysExact(calculation->displayOutput(context))) {
+    bool couldNotCreateExactLayout = false;
+    exactOutputLayout = calculation->createExactOutputLayout(&couldNotCreateExactLayout);
+    if (couldNotCreateExactLayout) {
+      if (canChangeDisplayOutput && calculation->displayOutput(context) != ::Calculation::Calculation::DisplayOutput::ExactOnly) {
+        calculation->forceDisplayOutput(::Calculation::Calculation::DisplayOutput::ApproximateOnly);
+      } else {
+        Poincare::ExceptionCheckpoint::Raise();
+      }
+    }
+  }
+  Calculation::DisplayOutput displayOutput = calculation->displayOutput(context);
+
+  // Create the approximate output layout
+  Poincare::Layout approximateOutputLayout = Poincare::Layout();
+  if (displayOutput == Calculation::DisplayOutput::ExactOnly) {
+    approximateOutputLayout = exactOutputLayout;
+  } else {
+    bool couldNotCreateApproximateLayout = false;
+    approximateOutputLayout = calculation->createApproximateOutputLayout(context, &couldNotCreateApproximateLayout);
+    if (couldNotCreateApproximateLayout) {
+      if (canChangeDisplayOutput && calculation->displayOutput(context) != ::Calculation::Calculation::DisplayOutput::ApproximateOnly) {
+        /* Set the display output to ApproximateOnly, make room in the pool by
+         * erasing the exact layout, and retry to create the approximate layout */
+        calculation->forceDisplayOutput(::Calculation::Calculation::DisplayOutput::ApproximateOnly);
+        exactOutputLayout = Poincare::Layout();
+        couldNotCreateApproximateLayout = false;
+        approximateOutputLayout = calculation->createApproximateOutputLayout(context, &couldNotCreateApproximateLayout);
+        if (couldNotCreateApproximateLayout) {
+          Poincare::ExceptionCheckpoint::Raise();
+        }
+      } else {
+        Poincare::ExceptionCheckpoint::Raise();
+      }
+    }
+
+  }
+  setLayouts(inputLayout, exactOutputLayout, approximateOutputLayout);
+  I18n::Message equalMessage = calculation->exactAndApproximateDisplayedOutputsAreEqual(context) == Calculation::EqualSign::Equal ? I18n::Message::Equal : I18n::Message::AlmostEqual;
+  setEqualMessage(equalMessage);
+
+  /* The displayed input and outputs have changed. We need to re-layout the cell
+   * and re-initialize the scroll. */
+  layoutSubviews();
+}
+
+KDCoordinate ScrollableThreeExpressionsCell::Height(Calculation * calculation) {
+  ScrollableThreeExpressionsCell cell;
+  cell.setCalculation(calculation, true);
+  KDRect leftFrame = KDRectZero;
+  KDRect centerFrame = KDRectZero;
+  KDRect approximateSignFrame = KDRectZero;
+  KDRect rightFrame = KDRectZero;
+  cell.subviewFrames(&leftFrame, &centerFrame, &approximateSignFrame, &rightFrame);
+  KDRect unionedFrame = leftFrame.unionedWith(centerFrame).unionedWith(rightFrame);
+  return unionedFrame.height() + 2 * ScrollableThreeExpressionsView::k_margin;
+}
+
+void ScrollableThreeExpressionsCell::didBecomeFirstResponder() {
+  reinitSelection();
+  Container::activeApp()->setFirstResponder(&m_view);
+}
+
+void ScrollableThreeExpressionsCell::reinitSelection() {
+  m_view.setSelectedSubviewPosition(ScrollableThreeExpressionsView::SubviewPosition::Left);
+  m_view.reloadScroll();
+}
+
+void ScrollableThreeExpressionsCell::setCalculation(Calculation * calculation, bool canChangeDisplayOutput) {
+  m_view.setCalculation(calculation, canChangeDisplayOutput);
+  layoutSubviews();
+}
+
+void ScrollableThreeExpressionsCell::setDisplayCenter(bool display) {
+  m_view.setDisplayCenter(display);
+  layoutSubviews();
+}
+
+}

apps/calculation/additional_outputs/scrollable_three_expressions_cell.h

@@ -0,0 +1,81 @@
+#ifndef CALCULATION_SCROLLABLE_THREE_EXPRESSIONS_CELL_H
+#define CALCULATION_SCROLLABLE_THREE_EXPRESSIONS_CELL_H
+
+#include <escher.h>
+#include "../../shared/scrollable_multiple_expressions_view.h"
+#include "../calculation.h"
+#include "expression_with_equal_sign_view.h"
+#include <escher/palette.h>
+
+namespace Calculation {
+
+/* TODO There is factorizable code between this and Calculation::HistoryViewCell
+ * (at least setCalculation). */
+
+class ScrollableThreeExpressionsView : public Shared::AbstractScrollableMultipleExpressionsView {
+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);
+  }
+  void resetMemoization();
+  void setCalculation(Calculation * calculation, bool canChangeDisplayOutput);
+  void subviewFrames(KDRect * leftFrame, KDRect * centerFrame, KDRect * approximateSignFrame, KDRect * rightFrame) {
+    return m_contentCell.subviewFrames(leftFrame, centerFrame, approximateSignFrame, rightFrame);
+  }
+private:
+  class ContentCell : public Shared::AbstractScrollableMultipleExpressionsView::ContentCell {
+  public:
+    ContentCell() : m_leftExpressionView() {}
+    KDColor backgroundColor() const override { return Palette::BackgroundApps; }
+    void setEven(bool even) override { return; }
+    ExpressionView * leftExpressionView() const override { return const_cast<ExpressionWithEqualSignView *>(&m_leftExpressionView); }
+  private:
+    ExpressionWithEqualSignView m_leftExpressionView;
+  };
+
+  ContentCell *  contentCell() override { return &m_contentCell; };
+  const ContentCell * constContentCell() const override { return &m_contentCell; };
+  ContentCell m_contentCell;
+};
+
+class ScrollableThreeExpressionsCell : public TableCell, public Responder {
+public:
+  static KDCoordinate Height(Calculation * calculation);
+  ScrollableThreeExpressionsCell() :
+    Responder(nullptr),
+    m_view(this) {}
+
+  // Cell
+  Poincare::Layout layout() const override { return m_view.layout(); }
+
+  // Responder cell
+  Responder * responder() override {
+    return this;
+  }
+  void didBecomeFirstResponder() override;
+
+  // Table cell
+  View * labelView() const override { return (View *)&m_view; }
+
+  void setHighlighted(bool highlight) override { m_view.evenOddCell()->setHighlighted(highlight); }
+  void resetMemoization() { m_view.resetMemoization(); }
+  void setCalculation(Calculation * calculation, bool canChangeDisplayOutput = false);
+  void setDisplayCenter(bool display);
+  ScrollableThreeExpressionsView::SubviewPosition selectedSubviewPosition() { return m_view.selectedSubviewPosition(); }
+  void setSelectedSubviewPosition(ScrollableThreeExpressionsView::SubviewPosition subviewPosition) { m_view.setSelectedSubviewPosition(subviewPosition); }
+
+  void reinitSelection();
+  void subviewFrames(KDRect * leftFrame, KDRect * centerFrame, KDRect * approximateSignFrame, KDRect * rightFrame) {
+    return m_view.subviewFrames(leftFrame, centerFrame, approximateSignFrame, rightFrame);
+  }
+private:
+  // Remove label margin added by TableCell because they're already handled by ScrollableThreeExpressionsView
+  KDCoordinate labelMargin() const override { return 0; }
+  ScrollableThreeExpressionsView m_view;
+};
+
+}
+
+#endif

apps/calculation/additional_outputs/second_degree_list_controller.cpp

@@ -0,0 +1,312 @@
+#include "../app.h"
+#include <apps/global_preferences.h>
+#include "../../shared/poincare_helpers.h"
+#include <poincare/layout_helper.h>
+#include <poincare/code_point_layout.h>
+#include <poincare/rational.h>
+#include <poincare/opposite.h>
+#include <poincare/addition.h>
+#include <poincare/parenthesis.h>
+#include <poincare/equal.h>
+#include <poincare/subtraction.h>
+#include <poincare/multiplication.h>
+#include <poincare/division.h>
+#include <poincare/square_root.h>
+#include <poincare/symbol.h>
+#include <poincare/power.h>
+#include "second_degree_list_controller.h"
+
+using namespace Poincare;
+using namespace Shared;
+
+namespace Calculation {
+    
+void SecondDegreeListController::setExpression(Poincare::Expression e) {
+  ExpressionsListController::setExpression(e);
+  assert(!m_expression.isUninitialized());
+
+  Expression polynomialCoefficients[Expression::k_maxNumberOfPolynomialCoefficients];
+  
+  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);
+
+  int degree = m_expression.getPolynomialReducedCoefficients(
+          "x",
+          polynomialCoefficients,
+          context,
+          Expression::UpdatedComplexFormatWithExpressionInput(preferences->complexFormat(), m_expression, context),
+          preferences->angleUnit(),
+          GlobalPreferences::sharedGlobalPreferences()->unitFormat(),
+          ExpressionNode::SymbolicComputation::ReplaceAllDefinedSymbolsWithDefinition);
+
+  assert(degree == 2);
+
+  Expression a = polynomialCoefficients[2];
+  Expression b = polynomialCoefficients[1];
+  Expression c = polynomialCoefficients[0];
+  
+  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);
+
+  // 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);
+
+  /* 
+   * Because when can't apply reduce or simplify to keep the 
+   * canonized form 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));
+  }
+  else {
+    PoincareHelpers::Simplify(&alpha, context, ExpressionNode::ReductionTarget::User);
+    xMinusAlphaPowerTwo = Power::Builder(Parenthesis::Builder(Subtraction::Builder(Symbol::Builder("x", strlen("x")), alpha)), Rational::Builder(2));
+  }
+  
+  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;
+  }
+  
+  Expression canonized;
+  Expression beta = getOppositeIfExists(minusBeta, &reductionContext);
+  if (beta.isUninitialized()) {
+    PoincareHelpers::Simplify(&minusBeta, context, ExpressionNode::ReductionTarget::User);
+    canonized = Subtraction::Builder(xMinusAlphaPowerTwoWithFactor, minusBeta);
+  }
+  else {
+    PoincareHelpers::Simplify(&beta, context, ExpressionNode::ReductionTarget::User);
+    canonized = Addition::Builder(xMinusAlphaPowerTwoWithFactor, beta);
+  }
+ 
+  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()));
+    m_numberOfSolutions = 1;
+    PoincareHelpers::Simplify(&x0, context, ExpressionNode::ReductionTarget::SystemForApproximation);
+  } 
+  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()));
+    m_numberOfSolutions = 2;
+    PoincareHelpers::Simplify(&x0, context, ExpressionNode::ReductionTarget::SystemForApproximation);
+    PoincareHelpers::Simplify(&x1, context, ExpressionNode::ReductionTarget::SystemForApproximation);
+    if (x0.type() == ExpressionNode::Type::Unreal) {
+      assert(x1.type() == ExpressionNode::Type::Unreal);
+      m_numberOfSolutions = 0;
+    }
+  }
+
+  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 {
+      PoincareHelpers::Simplify(&x1Opposite, context, ExpressionNode::ReductionTarget::User);
+      secondFactor = Addition::Builder(Symbol::Builder("x", strlen("x")), x1Opposite);
+    }
+
+    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;
+    }
+  }
+  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);
+    }
+    else {
+      PoincareHelpers::Simplify(&x0Opposite, context, ExpressionNode::ReductionTarget::User);
+      factor = Addition::Builder(Symbol::Builder("x", strlen("x")), x0Opposite);
+    }
+    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;
+    }
+  }
+  
+  PoincareHelpers::Simplify(&delta, context, ExpressionNode::ReductionTarget::User);
+
+  m_layouts[0] = PoincareHelpers::CreateLayout(canonized);
+  if (m_numberOfSolutions > 0) {
+    m_layouts[1] = PoincareHelpers::CreateLayout(factorized);
+    m_layouts[2] = PoincareHelpers::CreateLayout(delta);
+    m_layouts[3] = PoincareHelpers::CreateLayout(x0);
+    if (m_numberOfSolutions > 1) {
+      m_layouts[4] = PoincareHelpers::CreateLayout(x1);
+    }
+  }
+  else {
+    m_layouts[1] = PoincareHelpers::CreateLayout(delta);
+  }
+}
+
+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) {
+      return I18n::Message::CanonicalForm;
+    } 
+    if (index == 1) {
+      return I18n::Message::FactorizedForm;
+    }
+    if (index == 2) {
+      return I18n::Message::Discriminant;
+    }
+    if (index == 3) {
+      if (m_numberOfSolutions == 1) {
+        return I18n::Message::OnlyRoot;
+      }
+      else {
+        return I18n::Message::FirstRoot;
+      }
+    }
+    return I18n::Message::SecondRoot;
+  }
+  else {
+    switch (index) {
+      case 0:
+        return I18n::Message::CanonicalForm;
+      default:
+        return I18n::Message::Discriminant;
+    }
+  }
+}
+
+}

apps/calculation/additional_outputs/second_degree_list_controller.h

@@ -0,0 +1,26 @@
+#ifndef CALCULATION_ADDITIONAL_OUTPUTS_SECOND_DEGREE_CONTROLLER_H
+#define CALCULATION_ADDITIONAL_OUTPUTS_SECOND_DEGREE_CONTROLLER_H
+
+#include "expressions_list_controller.h"
+
+namespace Calculation {
+
+class SecondDegreeListController : public ExpressionsListController {
+public:
+  SecondDegreeListController(EditExpressionController * editExpressionController) :
+    ExpressionsListController(editExpressionController),
+    m_numberOfSolutions(0) {}
+
+  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;
+};
+
+}
+
+#endif
+
+

apps/calculation/additional_outputs/trigonometry_graph_cell.cpp

@@ -0,0 +1,38 @@
+#include "trigonometry_graph_cell.h"
+#include <escher/palette.h>
+
+using namespace Shared;
+using namespace Poincare;
+
+namespace Calculation {
+
+TrigonometryGraphView::TrigonometryGraphView(TrigonometryModel * model) :
+  CurveView(model),
+  m_model(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);
+  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);
+  // 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);
+  // Draw angle position on the circle
+  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);
+}
+
+}

apps/calculation/additional_outputs/trigonometry_graph_cell.h

@@ -0,0 +1,29 @@
+#ifndef CALCULATION_ADDITIONAL_OUTPUTS_TRIGONOMETRY_GRAPH_CELL_H
+#define CALCULATION_ADDITIONAL_OUTPUTS_TRIGONOMETRY_GRAPH_CELL_H
+
+#include "../../shared/curve_view.h"
+#include "trigonometry_model.h"
+#include "illustration_cell.h"
+
+namespace Calculation {
+
+class TrigonometryGraphView : public Shared::CurveView {
+public:
+  TrigonometryGraphView(TrigonometryModel * model);
+  void drawRect(KDContext * ctx, KDRect rect) const override;
+private:
+  TrigonometryModel * m_model;
+};
+
+class TrigonometryGraphCell : public IllustrationCell {
+public:
+  TrigonometryGraphCell(TrigonometryModel * model) : m_view(model) {}
+private:
+  View * view() override { return &m_view; }
+  TrigonometryGraphView m_view;
+};
+
+}
+
+#endif
+

apps/calculation/additional_outputs/trigonometry_list_controller.cpp

@@ -0,0 +1,23 @@
+#include "trigonometry_list_controller.h"
+#include "../app.h"
+
+using namespace Poincare;
+
+namespace Calculation {
+
+void TrigonometryListController::setExpression(Poincare::Expression e) {
+  assert(e.type() == ExpressionNode::Type::Cosine || e.type() == ExpressionNode::Type::Sine);
+  IllustratedListController::setExpression(e.childAtIndex(0));
+
+  // Fill calculation store
+  Poincare::Context * context = App::app()->localContext();
+  m_calculationStore.push("sin(θ)", context, CalculationHeight);
+  m_calculationStore.push("cos(θ)", context, CalculationHeight);
+  m_calculationStore.push("θ", context, CalculationHeight);
+
+  // Set trigonometry illustration
+  float angle = Shared::PoincareHelpers::ApproximateToScalar<float>(m_calculationStore.calculationAtIndex(0)->approximateOutput(context, Calculation::NumberOfSignificantDigits::Maximal), context);
+  m_model.setAngle(angle);
+}
+
+}

apps/calculation/additional_outputs/trigonometry_list_controller.h

@@ -0,0 +1,25 @@
+#ifndef CALCULATION_ADDITIONAL_OUTPUTS_TRIGONOMETRY_LIST_CONTROLLER_H
+#define CALCULATION_ADDITIONAL_OUTPUTS_TRIGONOMETRY_LIST_CONTROLLER_H
+
+#include "trigonometry_graph_cell.h"
+#include "trigonometry_model.h"
+#include "illustrated_list_controller.h"
+
+namespace Calculation {
+
+class TrigonometryListController : public IllustratedListController {
+public:
+  TrigonometryListController(EditExpressionController * editExpressionController) :
+    IllustratedListController(editExpressionController),
+    m_graphCell(&m_model) {}
+  void setExpression(Poincare::Expression e) override;
+private:
+  CodePoint expressionSymbol() const override { return UCodePointGreekSmallLetterTheta; }
+  HighlightCell * illustrationCell() override { return &m_graphCell; }
+  TrigonometryGraphCell m_graphCell;
+  TrigonometryModel m_model;
+};
+
+}
+
+#endif

apps/calculation/additional_outputs/trigonometry_model.cpp

@@ -0,0 +1,11 @@
+#include "trigonometry_model.h"
+
+namespace Calculation {
+
+TrigonometryModel::TrigonometryModel() :
+  Shared::CurveViewRange(),
+  m_angle(NAN)
+{
+}
+
+}

apps/calculation/additional_outputs/trigonometry_model.h

@@ -0,0 +1,40 @@
+#ifndef CALCULATION_ADDITIONAL_OUTPUTS_TRIGONOMETRY_MODEL_H
+#define CALCULATION_ADDITIONAL_OUTPUTS_TRIGONOMETRY_MODEL_H
+
+#include "../../shared/curve_view_range.h"
+#include "illustrated_list_controller.h"
+#include <complex>
+#include <poincare/trigonometry.h>
+
+namespace Calculation {
+
+class TrigonometryModel : public Shared::CurveViewRange {
+public:
+  TrigonometryModel();
+  // CurveViewRange
+  float xMin() const override { return -k_xHalfRange; }
+  float xMax() const override { return k_xHalfRange; }
+  float yMin() const override { return yCenter() - yHalfRange(); }
+  float yMax() const override { return yCenter() + yHalfRange(); }
+
+  void setAngle(float f) { m_angle = f; }
+  float angle() const { return m_angle*(float)M_PI/(float)Poincare::Trigonometry::PiInAngleUnit(Poincare::Preferences::sharedPreferences()->angleUnit()); }
+private:
+  constexpr static float k_xHalfRange = 2.1f;
+  // We center the yRange around the semi-circle where the angle is
+  float yCenter() const { return std::sin(angle()) >= 0.0f ? 0.5f : -0.5f; }
+
+  /* We want to normalize the displayed trigonometry circle:
+   * - On the X axis, we display 4.4 units on an available pixel width of
+   *   (Ion::Display::Width - Metric::PopUpRightMargin - Metric::PopUpLeftMargin)
+   * - On the Y axis, the available pixel height is
+   *   IllustratedListController::k_illustrationHeight
+   */
+  float yHalfRange() const { return IllustratedListController::k_illustrationHeight*k_xHalfRange/(Ion::Display::Width - Metric::PopUpRightMargin - Metric::PopUpLeftMargin); }
+
+  float m_angle;
+};
+
+}
+
+#endif

apps/calculation/additional_outputs/unit_list_controller.cpp

@@ -0,0 +1,96 @@
+#include "unit_list_controller.h"
+#include "../app.h"
+#include "../../shared/poincare_helpers.h"
+#include <poincare/unit_convert.h>
+#include <poincare/multiplication.h>
+#include <poincare/power.h>
+#include <poincare/undefined.h>
+#include <poincare/unit.h>
+
+using namespace Poincare;
+using namespace Shared;
+
+namespace Calculation {
+
+void UnitListController::setExpression(Poincare::Expression e) {
+  ExpressionsListController::setExpression(e);
+  assert(!m_expression.isUninitialized());
+  static_assert(k_maxNumberOfRows >= 3, "k_maxNumberOfRows must be greater than 3");
+
+  Poincare::Expression expressions[k_maxNumberOfRows];
+  // Initialize expressions
+  for (size_t i = 0; i < k_maxNumberOfRows; i++) {
+    expressions[i] = Expression();
+  }
+
+  /* 1. First rows: miscellaneous classic units for some dimensions, in both
+   * metric and imperial units. */
+  Expression copy = m_expression.clone();
+  Expression units;
+  // Reduce to be able to recognize units
+  PoincareHelpers::ReduceAndRemoveUnit(&copy, App::app()->localContext(), ExpressionNode::ReductionTarget::User, &units);
+  double value = Shared::PoincareHelpers::ApproximateToScalar<double>(copy, App::app()->localContext());
+  ExpressionNode::ReductionContext reductionContext(
+      App::app()->localContext(),
+      Preferences::sharedPreferences()->complexFormat(),
+      Preferences::sharedPreferences()->angleUnit(),
+      GlobalPreferences::sharedGlobalPreferences()->unitFormat(),
+      ExpressionNode::ReductionTarget::User,
+      ExpressionNode::SymbolicComputation::ReplaceAllSymbolsWithDefinitionsOrUndefined);
+  int numberOfExpressions = Unit::SetAdditionalExpressions(units, value, expressions, k_maxNumberOfRows, reductionContext);
+
+  // 2. SI units only
+  assert(numberOfExpressions < k_maxNumberOfRows - 1);
+  expressions[numberOfExpressions] = m_expression.clone();
+  Shared::PoincareHelpers::Simplify(&expressions[numberOfExpressions], App::app()->localContext(), ExpressionNode::ReductionTarget::User, Poincare::ExpressionNode::SymbolicComputation::ReplaceAllDefinedSymbolsWithDefinition, Poincare::ExpressionNode::UnitConversion::InternationalSystem);
+  numberOfExpressions++;
+
+  /* 3. Get rid of duplicates
+   * We find duplicates by comparing the serializations, to eliminate
+   * expressions that only differ by the types of their number nodes. */
+  Expression reduceExpression = m_expression.clone();
+  // Make m_expression comparable to expressions (turn BasedInteger into Rational for instance)
+  Shared::PoincareHelpers::Simplify(&reduceExpression, App::app()->localContext(), ExpressionNode::ReductionTarget::User, Poincare::ExpressionNode::SymbolicComputation::ReplaceAllDefinedSymbolsWithDefinition, Poincare::ExpressionNode::UnitConversion::None);
+  int currentExpressionIndex = 0;
+  while (currentExpressionIndex < numberOfExpressions) {
+    bool duplicateFound = false;
+    constexpr int buffersSize = Constant::MaxSerializedExpressionSize;
+    char buffer1[buffersSize];
+    int size1 = PoincareHelpers::Serialize(expressions[currentExpressionIndex], buffer1, buffersSize);
+    for (int i = 0; i < currentExpressionIndex + 1; i++) {
+      // Compare the currentExpression to all previous expressions and to m_expression
+      Expression comparedExpression = i == currentExpressionIndex ? reduceExpression : expressions[i];
+      assert(!comparedExpression.isUninitialized());
+      char buffer2[buffersSize];
+      int size2 = PoincareHelpers::Serialize(comparedExpression, buffer2, buffersSize);
+      if (size1 == size2 && strcmp(buffer1, buffer2) == 0) {
+        numberOfExpressions--;
+        // Shift next expressions
+        for (int j = currentExpressionIndex; j < numberOfExpressions; j++) {
+          expressions[j] = expressions[j+1];
+        }
+        // Remove last expression
+        expressions[numberOfExpressions] = Expression();
+        // The current expression has been discarded, no need to increment the current index
+        duplicateFound = true;
+        break;
+      }
+    }
+    if (!duplicateFound) {
+      // The current expression is not a duplicate, check next expression
+      currentExpressionIndex++;
+    }
+  }
+  // Memoize layouts
+  for (size_t i = 0; i < k_maxNumberOfRows; i++) {
+    if (!expressions[i].isUninitialized()) {
+      m_layouts[i] = Shared::PoincareHelpers::CreateLayout(expressions[i]);
+    }
+  }
+}
+
+I18n::Message UnitListController::messageAtIndex(int index) {
+  return (I18n::Message)0;
+}
+
+}

apps/calculation/additional_outputs/unit_list_controller.h

@@ -0,0 +1,21 @@
+#ifndef CALCULATION_ADDITIONAL_OUTPUTS_UNIT_LIST_CONTROLLER_H
+#define CALCULATION_ADDITIONAL_OUTPUTS_UNIT_LIST_CONTROLLER_H
+
+#include "expressions_list_controller.h"
+
+namespace Calculation {
+
+class UnitListController : public ExpressionsListController {
+public:
+  UnitListController(EditExpressionController * editExpressionController) :
+    ExpressionsListController(editExpressionController) {}
+
+  void setExpression(Poincare::Expression e) override;
+
+private:
+  I18n::Message messageAtIndex(int index) override;
+};
+
+}
+
+#endif

apps/calculation/app.cpp

@@ -17,6 +17,10 @@ I18n::Message App::Descriptor::upperName() {
   return I18n::Message::CalculAppCapital;
 }
 
+App::Descriptor::ExaminationLevel App::Descriptor::examinationLevel() {
+  return App::Descriptor::ExaminationLevel::Strict;
+}
+
 const Image * App::Descriptor::icon() {
   return ImageStore::CalculationIcon;
 }
@@ -27,6 +31,8 @@ App * App::Snapshot::unpack(Container * container) {
 
 void App::Snapshot::reset() {
   m_calculationStore.deleteAll();
+  m_cacheBuffer[0] = 0;
+  m_cacheBufferInformation = 0;
 }
 
 App::Descriptor * App::Snapshot::descriptor() {
@@ -34,14 +40,14 @@ App::Descriptor * App::Snapshot::descriptor() {
   return &descriptor;
 }
 
-void App::Snapshot::tidy() {
-  m_calculationStore.tidy();
+App::Snapshot::Snapshot() : m_calculationStore(m_calculationBuffer, k_calculationBufferSize)
+{
 }
 
 App::App(Snapshot * snapshot) :
   ExpressionFieldDelegateApp(snapshot, &m_editExpressionController),
   m_historyController(&m_editExpressionController, snapshot->calculationStore()),
-  m_editExpressionController(&m_modalViewController, this, &m_historyController, snapshot->calculationStore())
+  m_editExpressionController(&m_modalViewController, this, snapshot->cacheBuffer(), snapshot->cacheBufferInformationAddress(), &m_historyController, snapshot->calculationStore())
 {
 }
 
@@ -62,11 +68,21 @@ bool App::layoutFieldDidReceiveEvent(::LayoutField * layoutField, Ion::Events::E
 bool App::isAcceptableExpression(const Poincare::Expression expression) {
   {
     Expression ansExpression = static_cast<Snapshot *>(snapshot())->calculationStore()->ansExpression(localContext());
-    if (!TextFieldDelegateApp::ExpressionCanBeSerialized(expression, true, ansExpression)) {
+    if (!TextFieldDelegateApp::ExpressionCanBeSerialized(expression, true, ansExpression, localContext())) {
       return false;
     }
   }
   return !expression.isUninitialized();
 }
 
+void App::didBecomeActive(Window * window) {
+  m_editExpressionController.restoreInput();
+  Shared::ExpressionFieldDelegateApp::didBecomeActive(window);
+}
+
+void App::willBecomeInactive() {
+  m_editExpressionController.memoizeInput();
+  Shared::ExpressionFieldDelegateApp::willBecomeInactive();
+}
+
 }

apps/calculation/app.h

@@ -6,6 +6,7 @@
 #include "history_controller.h"
 #include "../shared/text_field_delegate_app.h"
 #include <escher.h>
+#include "../shared/shared_app.h"
 
 namespace Calculation {
 
@@ -15,29 +16,40 @@ public:
   public:
     I18n::Message name() override;
     I18n::Message upperName() override;
+    App::Descriptor::ExaminationLevel examinationLevel() override;
     const Image * icon() override;
   };
-  class Snapshot : public ::App::Snapshot {
+  class Snapshot : public ::SharedApp::Snapshot {
   public:
+    Snapshot();
     App * unpack(Container * container) override;
     void reset() override;
     Descriptor * descriptor() override;
     CalculationStore * calculationStore() { return &m_calculationStore; }
+    char * cacheBuffer() { return m_cacheBuffer; }
+    size_t * cacheBufferInformationAddress() { return &m_cacheBufferInformation; }
   private:
-    void tidy() override;
     CalculationStore m_calculationStore;
+    // Set the size of the buffer needed to store the calculations
+    static constexpr int k_calculationBufferSize = 10 * (sizeof(Calculation) + Calculation::k_numberOfExpressions * Constant::MaxSerializedExpressionSize + sizeof(Calculation *));
+    char m_calculationBuffer[k_calculationBufferSize];
+    char m_cacheBuffer[EditExpressionController::k_cacheBufferSize];
+    size_t m_cacheBufferInformation;
   };
   static App * app() {
     return static_cast<App *>(Container::activeApp());
   }
+  TELEMETRY_ID("Calculation");
   bool textFieldDidReceiveEvent(::TextField * textField, Ion::Events::Event event) override;
   bool layoutFieldDidReceiveEvent(::LayoutField * layoutField, Ion::Events::Event event) override;
   // TextFieldDelegateApp
-
   bool isAcceptableExpression(const Poincare::Expression expression) override;
+
 private:
   App(Snapshot * snapshot);
   HistoryController m_historyController;
+  void didBecomeActive(Window * window) override;
+  void willBecomeInactive() override;
   EditExpressionController m_editExpressionController;
 };
 

apps/calculation/base.de.i18n

@@ -1,2 +1,20 @@
 CalculApp = "Berechnung"
 CalculAppCapital = "BERECHNUNG"
+AdditionalResults = "Weitere Ergebnisse"
+DecimalBase = "Dezimal"
+HexadecimalBase = "Hexadezimal"
+BinaryBase = "Binär"
+PrimeFactors = "Primfaktoren"
+MixedFraction = "Gemischte Zahl"
+EuclideanDivision = "Division mit Rest"
+AdditionalDeterminant = "Determinante"
+AdditionalInverse = "Inverse"
+AdditionalRowEchelonForm = "Stufenform"
+AdditionalReducedRowEchelonForm = "Reduzierte Stufenform"
+AdditionalTrace = "Spur"
+CanonicalForm = "Kanonische Form"
+FactorizedForm = "Factorisierte Form"
+Discriminant = "Diskriminante"
+OnlyRoot = "Wurzel"
+FirstRoot = "Erste Wurzel"
+SecondRoot = "Zweite Wurzel"

apps/calculation/base.en.i18n

@@ -1,2 +1,20 @@
 CalculApp = "Calculation"
 CalculAppCapital = "CALCULATION"
+AdditionalResults = "Additional results"
+DecimalBase = "Decimal"
+HexadecimalBase = "Hexadecimal"
+BinaryBase = "Binary"
+PrimeFactors = "Prime factors"
+MixedFraction = "Mixed fraction"
+EuclideanDivision = "Euclidean division"
+AdditionalDeterminant = "Determinant"
+AdditionalInverse = "Inverse"
+AdditionalRowEchelonForm = "Row echelon form"
+AdditionalReducedRowEchelonForm = "Reduced row echelon form"
+AdditionalTrace = "Trace"
+CanonicalForm = "Canonical form"
+FactorizedForm = "Factorized form"
+Discriminant = "Discriminant"
+OnlyRoot = "Root"
+FirstRoot = "First root"
+SecondRoot = "Second root"

apps/calculation/base.es.i18n

@@ -1,2 +1,20 @@
 CalculApp = "Cálculo"
 CalculAppCapital = "CÁLCULO"
+AdditionalResults = "Resultados adicionales"
+DecimalBase = "Decimal"
+HexadecimalBase = "Hexadecimal"
+BinaryBase = "Binario"
+PrimeFactors = "Factores primos"
+MixedFraction = "Fracción mixta"
+EuclideanDivision = "División euclidiana"
+AdditionalDeterminant = "Determinante"
+AdditionalInverse = "Inversa"
+AdditionalRowEchelonForm = "Matriz escalonada"
+AdditionalReducedRowEchelonForm = "Matriz escalonada reducida"
+AdditionalTrace = "Traza"
+CanonicalForm = "Forma canónica"
+FactorizedForm = "Forma factorizada"
+Discriminant = "Discriminante"
+OnlyRoot = "Raíz"
+FirstRoot = "Primera raíz"
+SecondRoot = "Segunda raíz"

apps/calculation/base.fr.i18n

@@ -1,2 +1,20 @@
 CalculApp = "Calculs"
 CalculAppCapital = "CALCULS"
+AdditionalResults = "Résultats complémentaires"
+DecimalBase = "Décimal"
+HexadecimalBase = "Hexadécimal"
+BinaryBase = "Binaire"
+PrimeFactors = "Facteurs premiers"
+MixedFraction = "Fraction mixte"
+EuclideanDivision = "Division euclidienne"
+AdditionalDeterminant = "Déterminant"
+AdditionalInverse = "Inverse"
+AdditionalRowEchelonForm = "Forme échelonnée"
+AdditionalReducedRowEchelonForm = "Forme échelonnée réduite"
+AdditionalTrace = "Trace"
+CanonicalForm = "Forme canonique"
+FactorizedForm = "Forme factorisée"
+Discriminant = "Discriminant"
+OnlyRoot = "Racine"
+FirstRoot = "Première racine"
+SecondRoot = "Seconde racine"

apps/calculation/base.hu.i18n

@@ -0,0 +1,20 @@
+CalculApp = "Számolás"
+CalculAppCapital = "SZÁMOLÁS"
+AdditionalResults = "További eredmények"
+DecimalBase = "Decimális"
+HexadecimalBase = "Hexadecimális"
+BinaryBase = "Bináris"
+PrimeFactors = "Alapvetö tényezök"
+MixedFraction = "Vegyes frakció"
+EuclideanDivision = "Euklideszi osztás"
+AdditionalDeterminant = "Meghatározó"
+AdditionalInverse = "inverz"
+AdditionalRowEchelonForm = "Sor echelon forma"
+AdditionalReducedRowEchelonForm = "Csökkentett sorú Echelon forma"
+AdditionalTrace = "Nyomkövetés"
+CanonicalForm = "Kanonikus forma"
+FactorizedForm = "Factorizált forma"
+Discriminant = "Discriminant"
+OnlyRoot = "Gyökér"
+FirstRoot = "Első gyökér"
+SecondRoot = "Második gyökér"

apps/calculation/base.it.i18n

@@ -0,0 +1,20 @@
+CalculApp = "Calcolo"
+CalculAppCapital = "CALCOLO"
+AdditionalResults = "Risultati complementari"
+DecimalBase = "Decimale"
+HexadecimalBase = "Esadecimale"
+BinaryBase = "Binario"
+PrimeFactors = "Fattorizzazione"
+MixedFraction = "Frazione mista"
+EuclideanDivision = "Divisione euclidea"
+AdditionalDeterminant = "Determinante"
+AdditionalInverse = "Inversa"
+AdditionalRowEchelonForm = "Matrice a scalini"
+AdditionalReducedRowEchelonForm = "Matrice ridotta a scalini"
+AdditionalTrace = "Traccia"
+CanonicalForm = "Forma canonica"
+FactorizedForm = "Forma fattorizzata"
+Discriminant = "Discriminante"
+OnlyRoot = "Radice"
+FirstRoot = "Prima radice"
+SecondRoot = "Seconda radice"

apps/calculation/base.nl.i18n

@@ -0,0 +1,20 @@
+CalculApp = "Rekenen"
+CalculAppCapital = "REKENEN"
+AdditionalResults = "Aanvullende resultaten"
+DecimalBase = "Decimaal"
+HexadecimalBase = "Hexadecimaal"
+BinaryBase = "Binair"
+PrimeFactors = "Ontbinding"
+MixedFraction = "Gemengde breuk"
+EuclideanDivision = "Geheeltallige deling"
+AdditionalDeterminant = "Determinant"
+AdditionalInverse = "Inverse"
+AdditionalRowEchelonForm = "Echelonvorm"
+AdditionalReducedRowEchelonForm = "Gereduceerde echelonvorm"
+AdditionalTrace = "Spoor"
+CanonicalForm = "Canonische vorm"
+FactorizedForm = "Factorized vorm"
+Discriminant = "Discriminant"
+OnlyRoot = "Wortel"
+FirstRoot = "Eerste wortel"
+SecondRoot = "Tweede wortel"

apps/calculation/base.pt.i18n

@@ -1,2 +1,20 @@
 CalculApp = "Cálculo"
 CalculAppCapital = "CÁLCULO"
+AdditionalResults = "Resultados adicionais"
+DecimalBase = "Decimal"
+HexadecimalBase = "Hexadecimal"
+BinaryBase = "Binário"
+PrimeFactors = "Fatorização"
+MixedFraction = "Fração mista"
+EuclideanDivision = "Divisão euclidiana"
+AdditionalDeterminant = "Determinante"
+AdditionalInverse = "Matriz inversa"
+AdditionalRowEchelonForm = "Matriz escalonada"
+AdditionalReducedRowEchelonForm = "Matriz escalonada reduzida"
+AdditionalTrace = "Traço"
+CanonicalForm = "Forma canónica"
+FactorizedForm = "Factorized form"
+Discriminant = "Discriminante"
+OnlyRoot = "Raiz"
+FirstRoot = "Primeira raiz"
+SecondRoot = "Segunda raiz"

apps/calculation/calculation.cpp

@@ -1,21 +1,27 @@
 #include "calculation.h"
 #include "../shared/poincare_helpers.h"
+#include "../shared/scrollable_multiple_expressions_view.h"
+#include "../global_preferences.h"
+#include "../exam_mode_configuration.h"
+#include "app.h"
 #include <poincare/exception_checkpoint.h>
 #include <poincare/undefined.h>
+#include <poincare/unit.h>
 #include <poincare/unreal.h>
+#include <poincare/symbol_abstract.h>
 #include <string.h>
 #include <cmath>
+#include <algorithm>
 
 using namespace Poincare;
 using namespace Shared;
 
 namespace Calculation {
 
-static inline KDCoordinate maxCoordinate(KDCoordinate x, KDCoordinate y) { return x > y ? x : y; }
-
 bool Calculation::operator==(const Calculation& c) {
   return strcmp(inputText(), c.inputText()) == 0
-      && strcmp(approximateOutputText(), c.approximateOutputText()) == 0
+      && strcmp(approximateOutputText(NumberOfSignificantDigits::Maximal), c.approximateOutputText(NumberOfSignificantDigits::Maximal)) == 0
+      && strcmp(approximateOutputText(NumberOfSignificantDigits::UserDefined), c.approximateOutputText(NumberOfSignificantDigits::UserDefined)) == 0
       /* Some calculations can make appear trigonometric functions in their
        * exact output. Their argument will be different with the angle unit
        * preferences but both input and approximate output will be the same.
@@ -27,26 +33,23 @@ bool Calculation::operator==(const Calculation& c) {
 
 Calculation * Calculation::next() const {
   const char * result = reinterpret_cast<const char *>(this) + sizeof(Calculation);
-  for (int i = 0; i < 3; i++) {
-    result = result + strlen(result) + 1; // Pass inputText, exactOutputText, ApproximateOutputText
+  for (int i = 0; i < k_numberOfExpressions; i++) {
+    result = result + strlen(result) + 1; // Pass inputText, exactOutputText, ApproximateOutputText x2
   }
   return reinterpret_cast<Calculation *>(const_cast<char *>(result));
 }
 
-void Calculation::tidy() {
-  /* Reset height memoization (the complex format could have changed when
-   * re-entering Calculation app which would impact the heights). */
-  m_height = -1;
-  m_expandedHeight = -1;
-}
-
-const char * Calculation::approximateOutputText() const {
+const char * Calculation::approximateOutputText(NumberOfSignificantDigits numberOfSignificantDigits) const {
   const char * exactOutput = exactOutputText();
-  return exactOutput + strlen(exactOutput) + 1;
+  const char * approximateOutputTextWithMaxNumberOfDigits = exactOutput + strlen(exactOutput) + 1;
+  if (numberOfSignificantDigits == NumberOfSignificantDigits::Maximal) {
+    return approximateOutputTextWithMaxNumberOfDigits;
+  }
+  return approximateOutputTextWithMaxNumberOfDigits + strlen(approximateOutputTextWithMaxNumberOfDigits) + 1;
 }
 
 Expression Calculation::input() {
-  return Expression::Parse(m_inputText);
+  return Expression::Parse(m_inputText, nullptr);
 }
 
 Expression Calculation::exactOutput() {
@@ -54,67 +57,79 @@ Expression Calculation::exactOutput() {
    * thereby avoid turning cos(Pi/4) into sqrt(2)/2 and displaying
    * 'sqrt(2)/2 = 0.999906' (which is totally wrong) instead of
    * 'cos(pi/4) = 0.999906' (which is true in degree). */
-  Expression exactOutput = Expression::Parse(exactOutputText());
+  Expression exactOutput = Expression::Parse(exactOutputText(), nullptr);
   assert(!exactOutput.isUninitialized());
   return exactOutput;
 }
 
-Expression Calculation::approximateOutput(Context * context) {
-  /* To ensure that the expression 'm_output' is a matrix or a complex, we
-   * call 'evaluate'. */
-  Expression exp = Expression::Parse(approximateOutputText());
+Expression Calculation::approximateOutput(Context * context, NumberOfSignificantDigits numberOfSignificantDigits) {
+  Expression exp = Expression::Parse(approximateOutputText(numberOfSignificantDigits), nullptr);
   assert(!exp.isUninitialized());
-  return PoincareHelpers::Approximate<double>(exp, context);
+  /* Warning:
+   * Since quite old versions of Epsilon, the Expression 'exp' was used to be
+   * approximated again to ensure its content was in the expected form - a
+   * linear combination of Decimal.
+   * However, since the approximate output may contain units and that a
+   * Poincare::Unit approximates to undef, thus it must not be approximated
+   * anymore.
+   * We have to keep two serializations of the approximation outputs:
+   * - one with the maximal significant digits, to be used by 'ans' or when
+   *   handling 'OK' event on the approximation output.
+   * - one with the displayed number of significant digits that we parse to
+   *   create the displayed layout. If we used the other serialization to
+   *   create the layout, the result of the parsing could be an Integer which
+   *   does not take the number of significant digits into account when creating
+   *   its layout. This would lead to wrong number of significant digits in the
+   *   layout.
+   *   For instance:
+   *        Number of asked significant digits: 7
+   *        Input: "123456780", Approximate output: "1.234567E8"
+   *
+   *  |--------------------------------------------------------------------------------------|
+   *  | Number of significant digits | Approximate text | Parse expression    | Layout       |
+   *  |------------------------------+------------------+---------------------+--------------|
+   *  | Maximal                      | "123456780"      | Integer(123456780)  | "123456780"  |
+   *  |------------------------------+------------------+---------------------+--------------|
+   *  | User defined                 | "1.234567E8"     | Decimal(1.234567E8) | "1.234567E8" |
+   *  |--------------------------------------------------------------------------------------|
+   *
+   */
+   return exp;
 }
 
 Layout Calculation::createInputLayout() {
   return input().createLayout(Preferences::PrintFloatMode::Decimal, PrintFloat::k_numberOfStoredSignificantDigits);
 }
 
-Layout Calculation::createExactOutputLayout() {
-  return PoincareHelpers::CreateLayout(exactOutput());
-}
-
-Layout Calculation::createApproximateOutputLayout(Context * context) {
-  return PoincareHelpers::CreateLayout(approximateOutput(context));
-}
-
-KDCoordinate Calculation::height(Context * context, bool expanded) {
-  KDCoordinate result =  expanded ? m_expandedHeight : m_height;
-  if (result < 0) {
-    DisplayOutput display = displayOutput(context);
-    Layout inputLayout = createInputLayout();
-    KDCoordinate inputHeight = inputLayout.layoutSize().height();
-    if (display == DisplayOutput::ExactOnly) {
-      KDCoordinate exactOutputHeight = createExactOutputLayout().layoutSize().height();
-      result = inputHeight+exactOutputHeight;
-    } else if (display == DisplayOutput::ApproximateOnly || (!expanded && display == DisplayOutput::ExactAndApproximateToggle)) {
-      KDCoordinate approximateOutputHeight = createApproximateOutputLayout(context).layoutSize().height();
-      result = inputHeight+approximateOutputHeight;
-    } else {
-      assert(display == DisplayOutput::ExactAndApproximate || (display == DisplayOutput::ExactAndApproximateToggle && expanded));
-      Layout approximateLayout = createApproximateOutputLayout(context);
-      Layout exactLayout = createExactOutputLayout();
-      KDCoordinate approximateOutputHeight = approximateLayout.layoutSize().height();
-      KDCoordinate exactOutputHeight = exactLayout.layoutSize().height();
-      KDCoordinate outputHeight = maxCoordinate(exactLayout.baseline(), approximateLayout.baseline()) + maxCoordinate(exactOutputHeight-exactLayout.baseline(), approximateOutputHeight-approximateLayout.baseline());
-      result = inputHeight + outputHeight;
-    }
-    /* For all display output except ExactAndApproximateToggle, the selected
-     * height and the usual height are identical. We update both heights in
-     * theses cases. */
-    if (display != DisplayOutput::ExactAndApproximateToggle) {
-      m_height = result;
-      m_expandedHeight = result;
-    } else {
-      if (expanded) {
-        m_expandedHeight = result;
-      } else {
-        m_height = result;
-      }
-    }
+Layout Calculation::createExactOutputLayout(bool * couldNotCreateExactLayout) {
+  Poincare::ExceptionCheckpoint ecp;
+  if (ExceptionRun(ecp)) {
+    return PoincareHelpers::CreateLayout(exactOutput());
+  } else {
+    *couldNotCreateExactLayout = true;
+    return Layout();
   }
-  return result;
+}
+
+Layout Calculation::createApproximateOutputLayout(Context * context, bool * couldNotCreateApproximateLayout) {
+  Poincare::ExceptionCheckpoint ecp;
+  if (ExceptionRun(ecp)) {
+    return PoincareHelpers::CreateLayout(approximateOutput(context, NumberOfSignificantDigits::UserDefined));
+  } else {
+    *couldNotCreateApproximateLayout = true;
+    return Layout();
+  }
+}
+
+KDCoordinate Calculation::height(bool expanded) {
+  KDCoordinate h = expanded ? m_expandedHeight : m_height;
+  assert(h >= 0);
+  return h;
+}
+
+void Calculation::setHeights(KDCoordinate height, KDCoordinate expandedHeight) {
+  m_height = height;
+  m_expandedHeight = expandedHeight;
 }
 
 Calculation::DisplayOutput Calculation::displayOutput(Context * context) {
@@ -123,13 +138,31 @@ Calculation::DisplayOutput Calculation::displayOutput(Context * context) {
   }
   if (shouldOnlyDisplayExactOutput()) {
     m_displayOutput = DisplayOutput::ExactOnly;
-  } else if (input().recursivelyMatches(
+  } else if (
+      /* If the exact and approximate outputs are equal (with the
+       * UserDefined number of significant digits), do not display the exact
+       * output. Indeed, in this case, the layouts are identical. */
+      strcmp(exactOutputText(), approximateOutputText(NumberOfSignificantDigits::UserDefined)) == 0
+      ||
+      // If the approximate output is 'unreal' or the exact result is 'undef'
+      strcmp(exactOutputText(), Undefined::Name()) == 0 ||
+      strcmp(approximateOutputText(NumberOfSignificantDigits::Maximal), Unreal::Name()) == 0
+      ||
+      /* If the approximate output is 'undef' and the input and exactOutput are
+       * equal */
+      (strcmp(approximateOutputText(NumberOfSignificantDigits::Maximal), Undefined::Name()) == 0 &&
+       strcmp(inputText(), exactOutputText()) == 0)
+      ||
+      // Force all outputs to be ApproximateOnly if required by the exam mode configuration
+      ExamModeConfiguration::exactExpressionsAreForbidden(GlobalPreferences::sharedGlobalPreferences()->examMode())
+      ||
+      /* If the input contains the following types, we only display the
+       * approximate output. */
+      input().recursivelyMatches(
         [](const Expression e, Context * c) {
-          constexpr int approximateOnlyTypesCount = 9;
-          /* If the input contains the following types, we only display the
-           * approximate output. */
-          ExpressionNode::Type approximateOnlyTypes[approximateOnlyTypesCount] = {
+          ExpressionNode::Type approximateOnlyTypes[] = {
             ExpressionNode::Type::Random,
+            ExpressionNode::Type::Unit,
             ExpressionNode::Type::Round,
             ExpressionNode::Type::FracPart,
             ExpressionNode::Type::Integral,
@@ -137,29 +170,14 @@ Calculation::DisplayOutput Calculation::displayOutput(Context * context) {
             ExpressionNode::Type::Sum,
             ExpressionNode::Type::Derivative,
             ExpressionNode::Type::ConfidenceInterval,
-            ExpressionNode::Type::PredictionInterval
+            ExpressionNode::Type::PredictionInterval,
+            ExpressionNode::Type::Sequence
           };
-          return e.isOfType(approximateOnlyTypes, approximateOnlyTypesCount);
-        }, context, true))
+          return e.isOfType(approximateOnlyTypes, sizeof(approximateOnlyTypes)/sizeof(ExpressionNode::Type));
+        }, context)
+  )
   {
     m_displayOutput = DisplayOutput::ApproximateOnly;
-  } else if (strcmp(exactOutputText(), approximateOutputText()) == 0) {
-    /* If the exact and approximate results' texts are equal and their layouts
-     * too, do not display the exact result. If the two layouts are not equal
-     * because of the number of significant digits, we display both. */
-    m_displayOutput = exactAndApproximateDisplayedOutputsAreEqual(context) == Calculation::EqualSign::Equal ? DisplayOutput::ApproximateOnly : DisplayOutput::ExactAndApproximate;
-  } else if (strcmp(exactOutputText(), Undefined::Name()) == 0
-      || strcmp(approximateOutputText(), Unreal::Name()) == 0
-      || exactOutput().type() == ExpressionNode::Type::Undefined)
-  {
-    // If the approximate result is 'unreal' or the exact result is 'undef'
-    m_displayOutput = DisplayOutput::ApproximateOnly;
-  } else if (strcmp(approximateOutputText(), Undefined::Name()) == 0
-      && strcmp(inputText(), exactOutputText()) == 0)
-  {
-    /* If the approximate result is 'undef' and the input and exactOutput are
-     * equal */
-    m_displayOutput = DisplayOutput::ApproximateOnly;
   } else if (input().recursivelyMatches(Expression::IsApproximate, context)
       || exactOutput().recursivelyMatches(Expression::IsApproximate, context))
   {
@@ -170,12 +188,18 @@ Calculation::DisplayOutput Calculation::displayOutput(Context * context) {
   return m_displayOutput;
 }
 
+void Calculation::forceDisplayOutput(DisplayOutput d) {
+  // Heights haven't been computed yet
+  assert(m_height == -1 && m_expandedHeight == -1);
+  m_displayOutput = d;
+}
+
 bool Calculation::shouldOnlyDisplayExactOutput() {
   /* If the input is a "store in a function", do not display the approximate
    * result. This prevents x->f(x) from displaying x = undef. */
   Expression i = input();
-  return i.type() == ExpressionNode::Type::Store
-    && i.childAtIndex(1).type() == ExpressionNode::Type::Function;
+  return (i.type() == ExpressionNode::Type::Store && i.childAtIndex(1).type() == ExpressionNode::Type::Function)
+    || strcmp(approximateOutputText(NumberOfSignificantDigits::Maximal), Undefined::Name()) == 0;
 }
 
 Calculation::EqualSign Calculation::exactAndApproximateDisplayedOutputsAreEqual(Poincare::Context * context) {
@@ -193,15 +217,10 @@ Calculation::EqualSign Calculation::exactAndApproximateDisplayedOutputsAreEqual(
    * Store in the exactOutput. */
   Poincare::ExceptionCheckpoint ecp;
   if (ExceptionRun(ecp)) {
-    constexpr int bufferSize = Constant::MaxSerializedExpressionSize + 30;
-    char buffer[bufferSize];
     Preferences * preferences = Preferences::sharedPreferences();
-    Expression exactOutputExpression = PoincareHelpers::ParseAndSimplify(exactOutputText(), context, false);
-    if (exactOutputExpression.isUninitialized()) {
-      exactOutputExpression = Undefined::Builder();
-    }
+    // TODO: complex format should not be needed here (as it is not used to create layouts)
     Preferences::ComplexFormat complexFormat = Expression::UpdatedComplexFormatWithTextInput(preferences->complexFormat(), m_inputText);
-    m_equalSign = exactOutputExpression.isEqualToItsApproximationLayout(approximateOutput(context), buffer, bufferSize, complexFormat, preferences->angleUnit(), preferences->displayMode(), preferences->numberOfSignificantDigits(), context) ? EqualSign::Equal : EqualSign::Approximation;
+    m_equalSign = Expression::ParsedExpressionsAreEqual(exactOutputText(), approximateOutputText(NumberOfSignificantDigits::UserDefined), context, complexFormat, preferences->angleUnit(), GlobalPreferences::sharedGlobalPreferences()->unitFormat()) ? EqualSign::Equal : EqualSign::Approximation;
     return m_equalSign;
   } else {
     /* Do not override m_equalSign in case there is enough room in the pool
@@ -210,4 +229,54 @@ Calculation::EqualSign Calculation::exactAndApproximateDisplayedOutputsAreEqual(
   }
 }
 
+Calculation::AdditionalInformationType Calculation::additionalInformationType(Context * context) {
+  if (ExamModeConfiguration::exactExpressionsAreForbidden(GlobalPreferences::sharedGlobalPreferences()->examMode())) {
+    return AdditionalInformationType::None;
+  }
+  Preferences * preferences = Preferences::sharedPreferences();
+  Preferences::ComplexFormat complexFormat = Expression::UpdatedComplexFormatWithTextInput(preferences->complexFormat(), m_inputText);
+  Expression i = input();
+  Expression o = exactOutput();
+  /* Special case for Equal and Store:
+   * Equal/Store nodes have to be at the root of the expression, which prevents
+   * from creating new expressions with equal/store node as a child. We don't
+   * return any additional outputs for them to avoid bothering with special
+   * cases. */
+  if (i.type() == ExpressionNode::Type::Equal || i.type() == ExpressionNode::Type::Store) {
+    return AdditionalInformationType::None;
+  }
+  /* Trigonometry additional results are displayed if either input or output is a sin or a cos. Indeed, we want to capture both cases:
+   * - > input: cos(60)
+   *   > output: 1/2
+   * - > input: 2cos(2) - cos(2)
+   *   > output: cos(2)
+   */
+  if (input().isDefinedCosineOrSine(context, complexFormat, preferences->angleUnit()) || o.isDefinedCosineOrSine(context, complexFormat, preferences->angleUnit())) {
+    return AdditionalInformationType::Trigonometry;
+  }
+  if (o.hasUnit()) {
+    Expression unit;
+    PoincareHelpers::ReduceAndRemoveUnit(&o, App::app()->localContext(), ExpressionNode::ReductionTarget::User, &unit, ExpressionNode::SymbolicComputation::ReplaceAllSymbolsWithDefinitionsOrUndefined, ExpressionNode::UnitConversion::None);
+    double value = PoincareHelpers::ApproximateToScalar<double>(o, App::app()->localContext());
+    return (Unit::ShouldDisplayAdditionalOutputs(value, unit, GlobalPreferences::sharedGlobalPreferences()->unitFormat())) ? AdditionalInformationType::Unit : AdditionalInformationType::None;
+  }
+  if (o.isBasedIntegerCappedBy(k_maximalIntegerWithAdditionalInformation)) {
+    return AdditionalInformationType::Integer;
+  }
+  // Find forms like [12]/[23] or -[12]/[23]
+  if (o.isDivisionOfIntegers() || (o.type() == ExpressionNode::Type::Opposite && o.childAtIndex(0).isDivisionOfIntegers())) {
+    return AdditionalInformationType::Rational;
+  }
+  if (o.hasDefinedComplexApproximation(context, complexFormat, preferences->angleUnit())) {
+    return AdditionalInformationType::Complex;
+  }
+  if (o.type() == ExpressionNode::Type::Matrix) {
+    return AdditionalInformationType::Matrix;
+  }
+  if (o.polynomialDegree(context, "x") == 2) {
+    return AdditionalInformationType::SecondDegree;
+  }
+  return AdditionalInformationType::None;
+}
+
 }

apps/calculation/calculation.h

@@ -5,6 +5,7 @@
 #include <escher.h>
 #include <poincare/context.h>
 #include <poincare/expression.h>
+#include "../shared/poincare_helpers.h"
 
 namespace Calculation {
 
@@ -18,7 +19,9 @@ class CalculationStore;
  * */
 
 class Calculation {
+friend CalculationStore;
 public:
+  static constexpr int k_numberOfExpressions = 4;
   enum class EqualSign : uint8_t {
     Unknown,
     Approximation,
@@ -32,12 +35,23 @@ public:
     ExactAndApproximate,
     ExactAndApproximateToggle
   };
+  enum class AdditionalInformationType {
+    None = 0,
+    Integer,
+    Rational,
+    SecondDegree,
+    Trigonometry,
+    Unit,
+    Matrix,
+    Complex
+  };
+  static bool DisplaysExact(DisplayOutput d) { return d != DisplayOutput::ApproximateOnly; }
 
   /* It is not really the minimal size, but it clears enough space for most
    * calculations instead of clearing less space, then fail to serialize, clear
    * more space, fail to serialize, clear more space, etc., until reaching
    * sufficient free space. */
-  static int MinimalSize() { return sizeof(uint8_t) + 2*sizeof(KDCoordinate) + sizeof(uint8_t) + 3*Constant::MaxSerializedExpressionSize; }
+  static int MinimalSize() { return sizeof(uint8_t) + 2*sizeof(KDCoordinate) + sizeof(uint8_t) + 3*Constant::MaxSerializedExpressionSize + sizeof(Calculation *); }
 
   Calculation() :
     m_displayOutput(DisplayOutput::Unknown),
@@ -50,29 +64,43 @@ public:
   bool operator==(const Calculation& c);
   Calculation * next() const;
 
-  void tidy();
-
   // Texts
+  enum class NumberOfSignificantDigits {
+    Maximal,
+    UserDefined
+  };
   const char * inputText() const { return m_inputText; }
   const char * exactOutputText() const { return m_inputText + strlen(m_inputText) + 1; }
-  const char * approximateOutputText() const;
+  // See comment in approximateOutput implementation explaining the need of two approximateOutputTexts
+  const char * approximateOutputText(NumberOfSignificantDigits numberOfSignificantDigits) const;
 
   // Expressions
   Poincare::Expression input();
   Poincare::Expression exactOutput();
-  Poincare::Expression approximateOutput(Poincare::Context * context);
+  Poincare::Expression approximateOutput(Poincare::Context * context, NumberOfSignificantDigits numberOfSignificantDigits);
 
   // Layouts
   Poincare::Layout createInputLayout();
-  Poincare::Layout createExactOutputLayout();
-  Poincare::Layout createApproximateOutputLayout(Poincare::Context * context);
+  Poincare::Layout createExactOutputLayout(bool * couldNotCreateExactLayout);
+  Poincare::Layout createApproximateOutputLayout(Poincare::Context * context, bool * couldNotCreateApproximateLayout);
 
-  KDCoordinate height(Poincare::Context * context, bool expanded = false);
+  // Heights
+  KDCoordinate height(bool expanded);
+
+  // Displayed output
   DisplayOutput displayOutput(Poincare::Context * context);
+  void forceDisplayOutput(DisplayOutput d);
   bool shouldOnlyDisplayExactOutput();
   EqualSign exactAndApproximateDisplayedOutputsAreEqual(Poincare::Context * context);
+
+  // Additional Information
+  AdditionalInformationType additionalInformationType(Poincare::Context * context);
 private:
   static constexpr KDCoordinate k_heightComputationFailureHeight = 50;
+  static constexpr const char * k_maximalIntegerWithAdditionalInformation = "10000000000000000";
+
+  void setHeights(KDCoordinate height, KDCoordinate expandedHeight);
+
   /* Buffers holding text expressions have to be longer than the text written
    * by user (of maximum length TextField::maxBufferSize()) because when we
    * print an expression we add omitted signs (multiplications, parenthesis...) */

apps/calculation/calculation_store.cpp

@@ -1,8 +1,10 @@
 #include "calculation_store.h"
 #include "../shared/poincare_helpers.h"
+#include "../global_preferences.h"
 #include <poincare/rational.h>
 #include <poincare/symbol.h>
 #include <poincare/undefined.h>
+#include "../exam_mode_configuration.h"
 #include <assert.h>
 
 using namespace Poincare;
@@ -10,58 +12,47 @@ using namespace Shared;
 
 namespace Calculation {
 
-CalculationStore::CalculationStore() :
-  m_bufferEnd(m_buffer),
-  m_numberOfCalculations(0),
-  m_slidedBuffer(false),
-  m_indexOfFirstMemoizedCalculationPointer(0)
+CalculationStore::CalculationStore(char * buffer, int size) :
+  m_buffer(buffer),
+  m_bufferSize(size),
+  m_calculationAreaEnd(m_buffer),
+  m_numberOfCalculations(0)
 {
-  resetMemoizedModelsAfterCalculationIndex(-1);
+  assert(m_buffer != nullptr);
+  assert(m_bufferSize > 0);
 }
 
+// Returns an expiring pointer to the calculation of index i
 ExpiringPointer<Calculation> CalculationStore::calculationAtIndex(int i) {
-  assert(!m_slidedBuffer);
   assert(i >= 0 && i < m_numberOfCalculations);
-  assert(m_indexOfFirstMemoizedCalculationPointer >= 0);
-  if (i >= m_indexOfFirstMemoizedCalculationPointer && i < m_indexOfFirstMemoizedCalculationPointer + k_numberOfMemoizedCalculationPointers) {
-    // The calculation is within the range of memoized calculations
-    Calculation * c = m_memoizedCalculationPointers[i-m_indexOfFirstMemoizedCalculationPointer];
-    if (c != nullptr) {
-      // The pointer was memoized
-      return ExpiringPointer<Calculation>(c);
-    }
-    c = bufferCalculationAtIndex(i);
-    m_memoizedCalculationPointers[i-m_indexOfFirstMemoizedCalculationPointer] = c;
-    return c;
+  // m_buffer is the adress of the oldest calculation in calculation store
+  Calculation * c = (Calculation *) m_buffer;
+  if (i != m_numberOfCalculations-1) {
+    // The calculation we want is not the oldest one so we get its pointer
+    c = *reinterpret_cast<Calculation**>(addressOfPointerToCalculationOfIndex(i+1));
   }
-  // Slide the memoization buffer
-  if (i >= m_indexOfFirstMemoizedCalculationPointer) {
-    // Slide the memoization buffer to the left
-    memmove(m_memoizedCalculationPointers, m_memoizedCalculationPointers+1, (k_numberOfMemoizedCalculationPointers - 1) * sizeof(Calculation *));
-    m_memoizedCalculationPointers[k_numberOfMemoizedCalculationPointers - 1] = nullptr;
-    m_indexOfFirstMemoizedCalculationPointer++;
-  } else {
-    // Slide the memoization buffer to the right
-    memmove(m_memoizedCalculationPointers+1, m_memoizedCalculationPointers, (k_numberOfMemoizedCalculationPointers - 1) * sizeof(Calculation *));
-    m_memoizedCalculationPointers[0] = nullptr;
-    m_indexOfFirstMemoizedCalculationPointer--;
-  }
-  return calculationAtIndex(i);
+  return ExpiringPointer<Calculation>(c);
 }
 
-ExpiringPointer<Calculation> CalculationStore::push(const char * text, Context * context) {
-  /* Compute ans now, before the buffer is slided and before the calculation
+// Pushes an expression in the store
+ExpiringPointer<Calculation> CalculationStore::push(const char * text, Context * context, HeightComputer heightComputer) {
+  /* Compute ans now, before the buffer is updated and before the calculation
    * might be deleted */
   Expression ans = ansExpression(context);
 
-  // Prepare the buffer for the new calculation
-  int minSize = Calculation::MinimalSize();
-  assert(k_bufferSize > minSize);
-  while (remainingBufferSize() < minSize || m_numberOfCalculations > k_maxNumberOfCalculations) {
-    deleteLastCalculation();
+  /* Prepare the buffer for the new calculation
+   *The minimal size to store the new calculation is the minimal size of a calculation plus the pointer to its end */
+  int minSize = Calculation::MinimalSize() + sizeof(Calculation *);
+  assert(m_bufferSize > minSize);
+  while (remainingBufferSize() < minSize) {
+    // If there is no more space to store a calculation, we delete the oldest one
+    deleteOldestCalculation();
   }
-  char * newCalculationsLocation = slideCalculationsToEndOfBuffer();
-  char * nextSerializationLocation = m_buffer;
+
+  // Getting the adresses of the limits of the free space
+  char * beginingOfFreeSpace = (char *)m_calculationAreaEnd;
+  char * endOfFreeSpace = beginingOfMemoizationArea();
+  char * previousCalc = beginingOfFreeSpace;
 
   // Add the beginning of the calculation
   {
@@ -69,89 +60,112 @@ ExpiringPointer<Calculation> CalculationStore::push(const char * text, Context *
      * available, so this memmove will not overide anything. */
     Calculation newCalc = Calculation();
     size_t calcSize = sizeof(newCalc);
-    memmove(nextSerializationLocation, &newCalc, calcSize);
-    nextSerializationLocation += calcSize;
+    memcpy(beginingOfFreeSpace, &newCalc, calcSize);
+    beginingOfFreeSpace += calcSize;
   }
 
   /* Add the input expression.
    * We do not store directly the text entered by the user because we do not
    * want to keep Ans symbol in the calculation store. */
-  const char * inputSerialization = nextSerializationLocation;
+  const char * inputSerialization = beginingOfFreeSpace;
   {
-    Expression input = Expression::Parse(text).replaceSymbolWithExpression(Symbol::Ans(), ans);
-    if (!serializeExpression(input, nextSerializationLocation, &newCalculationsLocation)) {
+    Expression input = Expression::Parse(text, context).replaceSymbolWithExpression(Symbol::Ans(), ans);
+    if (!pushSerializeExpression(input, beginingOfFreeSpace, &endOfFreeSpace)) {
       /* If the input does not fit in the store (event if the current
        * calculation is the only calculation), just replace the calculation with
        * undef. */
-      return emptyStoreAndPushUndef(context);
+      return emptyStoreAndPushUndef(context, heightComputer);
     }
-    nextSerializationLocation += strlen(nextSerializationLocation) + 1;
+    beginingOfFreeSpace += strlen(beginingOfFreeSpace) + 1;
   }
 
   // Compute and serialize the outputs
+  /* The serialized outputs are:
+   * - the exact ouput
+   * - the approximate output with the maximal number of significant digits
+   * - the approximate output with the displayed number of significant digits */
   {
-    Expression outputs[] = {Expression(), Expression()};
-    PoincareHelpers::ParseAndSimplifyAndApproximate(inputSerialization, &(outputs[0]), &(outputs[1]), context, true); // Symbolic computation
-    for (int i = 0; i < 2; i++) {
-      if (!serializeExpression(outputs[i], nextSerializationLocation, &newCalculationsLocation)) {
+    // Outputs hold exact output, approximate output and its duplicate
+    constexpr static int numberOfOutputs = Calculation::k_numberOfExpressions - 1;
+    Expression outputs[numberOfOutputs] = {Expression(), Expression(), Expression()};
+    PoincareHelpers::ParseAndSimplifyAndApproximate(inputSerialization, &(outputs[0]), &(outputs[1]), context, GlobalPreferences::sharedGlobalPreferences()->isInExamModeSymbolic() ? Poincare::ExpressionNode::SymbolicComputation::ReplaceAllDefinedSymbolsWithDefinition : Poincare::ExpressionNode::SymbolicComputation::ReplaceAllSymbolsWithDefinitionsOrUndefined);
+    if (ExamModeConfiguration::exactExpressionsAreForbidden(GlobalPreferences::sharedGlobalPreferences()->examMode()) && outputs[1].hasUnit()) {
+      // Hide results with units on units if required by the exam mode configuration
+      outputs[1] = Undefined::Builder();
+    }
+    outputs[2] = outputs[1];
+    int numberOfSignificantDigits = Poincare::PrintFloat::k_numberOfStoredSignificantDigits;
+    for (int i = 0; i < numberOfOutputs; i++) {
+      if (i == numberOfOutputs - 1) {
+        numberOfSignificantDigits = Poincare::Preferences::sharedPreferences()->numberOfSignificantDigits();
+      }
+      if (!pushSerializeExpression(outputs[i], beginingOfFreeSpace, &endOfFreeSpace, numberOfSignificantDigits)) {
         /* If the exat/approximate output does not fit in the store (event if the
          * current calculation is the only calculation), replace the output with
          * undef if it fits, else replace the whole calcualtion with undef. */
         Expression undef = Undefined::Builder();
-        if (!serializeExpression(undef, nextSerializationLocation, &newCalculationsLocation)) {
-          return emptyStoreAndPushUndef(context);
+        if (!pushSerializeExpression(undef, beginingOfFreeSpace, &endOfFreeSpace)) {
+          return emptyStoreAndPushUndef(context, heightComputer);
         }
       }
-      nextSerializationLocation += strlen(nextSerializationLocation) + 1;
+      beginingOfFreeSpace += strlen(beginingOfFreeSpace) + 1;
     }
   }
+  // Storing the pointer of the end of the new calculation
+  memcpy(endOfFreeSpace-sizeof(Calculation*),&beginingOfFreeSpace,sizeof(beginingOfFreeSpace));
 
-  // Restore the other calculations
-  size_t slideSize = m_buffer + k_bufferSize - newCalculationsLocation;
-  memcpy(nextSerializationLocation, newCalculationsLocation, slideSize);
-  m_slidedBuffer = false;
+  // The new calculation is now stored
   m_numberOfCalculations++;
-  m_bufferEnd+= nextSerializationLocation - m_buffer;
 
-  // Clean the memoization
-  resetMemoizedModelsAfterCalculationIndex(-1);
-
-  return ExpiringPointer<Calculation>(reinterpret_cast<Calculation *>(m_buffer));
+  // The end of the calculation storage area is updated
+  m_calculationAreaEnd += beginingOfFreeSpace - previousCalc;
+  ExpiringPointer<Calculation> calculation = ExpiringPointer<Calculation>(reinterpret_cast<Calculation *>(previousCalc));
+  /* Heights are computed now to make sure that the display output is decided
+   * accordingly to the remaining size in the Poincare pool. Once it is, it
+   * can't change anymore: the calculation heights are fixed which ensures that
+   * scrolling computation is right. */
+  calculation->setHeights(
+      heightComputer(calculation.pointer(), false),
+      heightComputer(calculation.pointer(), true));
+  return calculation;
 }
 
+// Delete the calculation of index i
 void CalculationStore::deleteCalculationAtIndex(int i) {
   assert(i >= 0 && i < m_numberOfCalculations);
-  assert(!m_slidedBuffer);
-  ExpiringPointer<Calculation> calcI = calculationAtIndex(i);
-  char * nextCalc = reinterpret_cast<char *>(calcI->next());
-  assert(m_bufferEnd >= nextCalc);
-  size_t slidingSize = m_bufferEnd - nextCalc;
-  memmove((char *)(calcI.pointer()), nextCalc, slidingSize);
-  m_bufferEnd -= (nextCalc - (char *)(calcI.pointer()));
-  m_numberOfCalculations--;
-  resetMemoizedModelsAfterCalculationIndex(i);
-}
-
-void CalculationStore::deleteAll() {
-  /* We might call deleteAll because the app closed due to a pool allocation
-   * failure, so we cannot assert that m_slidedBuffer is false. */
-  m_slidedBuffer = false;
-  m_bufferEnd = m_buffer;
-  m_numberOfCalculations = 0;
-  resetMemoizedModelsAfterCalculationIndex(-1);
-}
-
-void CalculationStore::tidy() {
-  if (m_slidedBuffer) {
-    deleteAll();
+  if (i == 0) {
+    ExpiringPointer<Calculation> lastCalculationPointer = calculationAtIndex(0);
+    m_calculationAreaEnd = (char *)(lastCalculationPointer.pointer());
+    m_numberOfCalculations--;
     return;
   }
-  resetMemoizedModelsAfterCalculationIndex(-1);
-  for (Calculation * c : *this) {
-    c->tidy();
-  }
+  char * calcI = (char *)calculationAtIndex(i).pointer();
+  char * nextCalc = (char *) calculationAtIndex(i-1).pointer();
+  assert(m_calculationAreaEnd >= nextCalc);
+  size_t slidingSize = m_calculationAreaEnd - nextCalc;
+  // Slide the i-1 most recent calculations right after the i+1'th
+  memmove(calcI, nextCalc, slidingSize);
+  m_calculationAreaEnd -= nextCalc - calcI;
+  // Recompute pointer to calculations after the i'th
+  recomputeMemoizedPointersAfterCalculationIndex(i);
+  m_numberOfCalculations--;
 }
 
+// Delete the oldest calculation in the store and returns the amount of space freed by the operation
+size_t CalculationStore::deleteOldestCalculation() {
+  char * oldBufferEnd = (char *) m_calculationAreaEnd;
+  deleteCalculationAtIndex(numberOfCalculations()-1);
+  char * newBufferEnd = (char *) m_calculationAreaEnd;
+  return oldBufferEnd - newBufferEnd;
+}
+
+// Delete all calculations
+void CalculationStore::deleteAll() {
+  m_calculationAreaEnd = m_buffer;
+  m_numberOfCalculations = 0;
+}
+
+// Replace "Ans" by its expression
 Expression CalculationStore::ansExpression(Context * context) {
   if (numberOfCalculations() == 0) {
     return Rational::Builder(0);
@@ -162,107 +176,50 @@ Expression CalculationStore::ansExpression(Context * context) {
    * To avoid turning 'ans->A' in '2->A->A' or '2=A->A' (which cannot be
    * parsed), ans is replaced by the approximation output when any Store or
    * Equal expression appears. */
-  bool exactOuptutInvolvesStoreEqual = mostRecentCalculation->exactOutput().recursivelyMatches([](const Expression e, Context * context) {
-          return e.type() == ExpressionNode::Type::Store || e.type() == ExpressionNode::Type::Equal;
-        }, context, false);
+  Expression e = mostRecentCalculation->exactOutput();
+  bool exactOuptutInvolvesStoreEqual = e.type() == ExpressionNode::Type::Store || e.type() == ExpressionNode::Type::Equal;
   if (mostRecentCalculation->input().recursivelyMatches(Expression::IsApproximate, context) || exactOuptutInvolvesStoreEqual) {
-    return mostRecentCalculation->approximateOutput(context);
+    return mostRecentCalculation->approximateOutput(context, Calculation::NumberOfSignificantDigits::Maximal);
   }
   return mostRecentCalculation->exactOutput();
 }
 
-Calculation * CalculationStore::bufferCalculationAtIndex(int i) {
-  int currentIndex = 0;
-  for (Calculation * c : *this) {
-    if (currentIndex == i) {
-      return c;
-    }
-    currentIndex++;
-  }
-  assert(false);
-  return nullptr;
-}
-
-bool CalculationStore::serializeExpression(Expression e, char * location, char * * newCalculationsLocation) {
-  assert(m_slidedBuffer);
-  return pushExpression(
-      [](char * location, size_t locationSize, void * e) {
-        return PoincareHelpers::Serialize(*(Expression *)e, location, locationSize) < (int)locationSize-1;
-      }, &e, location, newCalculationsLocation);
-}
-
-char * CalculationStore::slideCalculationsToEndOfBuffer() {
-  int calculationsSize = m_bufferEnd - m_buffer;
-  char * calculationsNewPosition = m_buffer + k_bufferSize - calculationsSize;
-  memmove(calculationsNewPosition, m_buffer, calculationsSize);
-  m_slidedBuffer = true;
-  return calculationsNewPosition;
-}
-
-size_t CalculationStore::deleteLastCalculation(const char * calculationsStart) {
-  assert(m_numberOfCalculations > 0);
-  size_t result;
-  if (!m_slidedBuffer) {
-    assert(calculationsStart == nullptr);
-    const char * previousBufferEnd = m_bufferEnd;
-    m_bufferEnd = lastCalculationPosition(m_buffer);
-    assert(previousBufferEnd > m_bufferEnd);
-    result = previousBufferEnd - m_bufferEnd;
-  } else {
-    assert(calculationsStart != nullptr);
-    const char * lastCalc = lastCalculationPosition(calculationsStart);
-    assert(*lastCalc == 0);
-    result = m_buffer + k_bufferSize - lastCalc;
-    memmove(const_cast<char *>(calculationsStart + result), calculationsStart, m_buffer + k_bufferSize - calculationsStart - result);
-  }
-  m_numberOfCalculations--;
-  resetMemoizedModelsAfterCalculationIndex(-1);
-  return result;
-}
-
-const char * CalculationStore::lastCalculationPosition(const char * calculationsStart) const {
-  assert(calculationsStart >= m_buffer && calculationsStart < m_buffer + k_bufferSize);
-  Calculation * c = reinterpret_cast<Calculation *>(const_cast<char *>(calculationsStart));
-  int calculationIndex = 0;
-  while (calculationIndex < m_numberOfCalculations - 1) {
-    c = c->next();
-    calculationIndex++;
-  }
-  return reinterpret_cast<const char *>(c);
-}
-
-bool CalculationStore::pushExpression(ValueCreator valueCreator, Expression * expression, char * location, char * * newCalculationsLocation) {
-  assert(*newCalculationsLocation <= m_buffer + k_bufferSize);
+// Push converted expression in the buffer
+bool CalculationStore::pushSerializeExpression(Expression e, char * location, char * * newCalculationsLocation, int numberOfSignificantDigits) {
+  assert(*newCalculationsLocation <= m_buffer + m_bufferSize);
   bool expressionIsPushed = false;
   while (true) {
-    expressionIsPushed = valueCreator(location, *newCalculationsLocation - location, expression);
-    if (expressionIsPushed || *newCalculationsLocation >= m_buffer + k_bufferSize) {
+    size_t locationSize = *newCalculationsLocation - location;
+    expressionIsPushed = (PoincareHelpers::Serialize(e, location, locationSize, numberOfSignificantDigits) < (int)locationSize-1);
+    if (expressionIsPushed || *newCalculationsLocation >= m_buffer + m_bufferSize) {
       break;
     }
-    *newCalculationsLocation = *newCalculationsLocation + deleteLastCalculation();
-    assert(*newCalculationsLocation <= m_buffer + k_bufferSize);
+    *newCalculationsLocation = *newCalculationsLocation + deleteOldestCalculation();
+    assert(*newCalculationsLocation <= m_buffer + m_bufferSize);
   }
   return expressionIsPushed;
 }
 
-Shared::ExpiringPointer<Calculation> CalculationStore::emptyStoreAndPushUndef(Context * context) {
+
+
+Shared::ExpiringPointer<Calculation> CalculationStore::emptyStoreAndPushUndef(Context * context, HeightComputer heightComputer) {
   /* We end up here as a result of a failed calculation push. The store
    * attributes are not necessarily clean, so we need to reset them. */
-  m_slidedBuffer = false;
   deleteAll();
-  return push(Undefined::Name(), context);
+  return push(Undefined::Name(), context, heightComputer);
 }
 
-void CalculationStore::resetMemoizedModelsAfterCalculationIndex(int index) {
-  if (index < m_indexOfFirstMemoizedCalculationPointer) {
-    memset(&m_memoizedCalculationPointers, 0, k_numberOfMemoizedCalculationPointers * sizeof(Calculation *));
-    return;
-  }
-  if (index >= m_indexOfFirstMemoizedCalculationPointer + k_numberOfMemoizedCalculationPointers) {
-    return;
-  }
-  for (int i = index - m_indexOfFirstMemoizedCalculationPointer; i < k_numberOfMemoizedCalculationPointers; i++) {
-    m_memoizedCalculationPointers[i] = nullptr;
+// Recompute memoized pointers to the calculations after index i
+void CalculationStore::recomputeMemoizedPointersAfterCalculationIndex(int index) {
+  assert(index < m_numberOfCalculations);
+  // Clear pointer and recompute new ones
+  Calculation * c = calculationAtIndex(index).pointer();
+  Calculation * nextCalc;
+  while (index != 0) {
+    nextCalc = c->next();
+    memcpy(addressOfPointerToCalculationOfIndex(index), &nextCalc, sizeof(Calculation *));
+    c = nextCalc;
+    index--;
   }
 }
 

apps/calculation/calculation_store.h

@@ -3,39 +3,49 @@
 
 #include "calculation.h"
 #include <apps/shared/expiring_pointer.h>
+#include <poincare/print_float.h>
 
 namespace Calculation {
 
-/* To optimize the storage space, we use one big buffer for all calculations.
- *
- * The previous solution was to keep 10 calculations, each containing 3 buffers
- * (for input and outputs). To optimize the storage, we then wanted to put all
- * outputs in a cache where they could be deleted to add a new entry, and
- * recomputed on cache miss. However, the computation depends too much on the
- * state of the memory for this to be possible. For instance:
- * 6->a
- * a+1
- * Perform some big computations that remove a+1 from the cache
- * Delete a from the variable box.
- * Scroll up to display a+1 : a does not exist anymore so the outputs won't be
- * recomputed correctly.
- *
- * Now we do not cap the number of calculations and just delete the oldests to
- * create space for a new calculation. */
+/*
+  To optimize the storage space, we use one big buffer for all calculations.
+  The calculations are stored one after another while pointers to the end of each
+  calculation are stored at the end of the buffer, in the opposite direction.
+  By doing so, we can memoize every calculation entered while not limiting
+  the number of calculation stored in the buffer.
+
+  If the remaining space is too small for storing a new calculation, we
+  delete the oldest one.
+
+ Memory layout :
+                                                                <- Available space for new calculations ->
++--------------------------------------------------------------------------------------------------------------------+
+|               |               |               |               |                                        |  |  |  |  |
+| Calculation 3 | Calculation 2 | Calculation 1 | Calculation O |                                        |p0|p1|p2|p3|
+|     Oldest    |               |               |               |                                        |  |  |  |  |
++--------------------------------------------------------------------------------------------------------------------+
+^               ^               ^               ^               ^                                        ^
+m_buffer        p3              p2              p1              p0                                       a
+
+m_calculationAreaEnd = p0
+a = addressOfPointerToCalculation(0)
+*/
 
 class CalculationStore {
 public:
   CalculationStore();
+  CalculationStore(char * buffer, int size);
   Shared::ExpiringPointer<Calculation> calculationAtIndex(int i);
-  Shared::ExpiringPointer<Calculation> push(const char * text, Poincare::Context * context);
+  typedef KDCoordinate (*HeightComputer)(Calculation * c, bool expanded);
+  Shared::ExpiringPointer<Calculation> push(const char * text, Poincare::Context * context, HeightComputer heightComputer);
   void deleteCalculationAtIndex(int i);
   void deleteAll();
+  int remainingBufferSize() const { assert(m_calculationAreaEnd >= m_buffer); return m_bufferSize - (m_calculationAreaEnd - m_buffer) - m_numberOfCalculations*sizeof(Calculation*); }
   int numberOfCalculations() const { return m_numberOfCalculations; }
   Poincare::Expression ansExpression(Poincare::Context * context);
-  void tidy();
+  int bufferSize() { return m_bufferSize; }
+
 private:
-  static constexpr int k_maxNumberOfCalculations = 25;
-  static constexpr int k_bufferSize = 10 * 3 * Constant::MaxSerializedExpressionSize;
 
   class CalculationIterator {
   public:
@@ -51,28 +61,22 @@ private:
   };
 
   CalculationIterator begin() const { return CalculationIterator(m_buffer); }
-  CalculationIterator end() const { return CalculationIterator(m_bufferEnd); }
+  CalculationIterator end() const { return CalculationIterator(m_calculationAreaEnd); }
 
-  Calculation * bufferCalculationAtIndex(int i);
-  int remainingBufferSize() const { assert(m_bufferEnd >= m_buffer); return k_bufferSize - (m_bufferEnd - m_buffer); }
-  bool serializeExpression(Poincare::Expression e, char * location, char * * newCalculationsLocation);
-  char * slideCalculationsToEndOfBuffer(); // returns the new position of the calculations
-  size_t deleteLastCalculation(const char * calculationsStart = nullptr);
-  const char * lastCalculationPosition(const char * calculationsStart) const;
-  typedef bool (*ValueCreator)(char * location, size_t locationSize, void * e);
-  bool pushExpression(ValueCreator valueCrator, Poincare::Expression * expression, char * location, char * * newCalculationsLocation);
-  Shared::ExpiringPointer<Calculation> emptyStoreAndPushUndef(Poincare::Context * context);
+  bool pushSerializeExpression(Poincare::Expression e, char * location, char * * newCalculationsLocation, int numberOfSignificantDigits = Poincare::PrintFloat::k_numberOfStoredSignificantDigits);
+  Shared::ExpiringPointer<Calculation> emptyStoreAndPushUndef(Poincare::Context * context, HeightComputer heightComputer);
 
-  char m_buffer[k_bufferSize];
-  const char * m_bufferEnd;
+  char * m_buffer;
+  int m_bufferSize;
+  const char * m_calculationAreaEnd;
   int m_numberOfCalculations;
-  bool m_slidedBuffer;
+
+  size_t deleteOldestCalculation();
+  char * addressOfPointerToCalculationOfIndex(int i) {return m_buffer + m_bufferSize - (m_numberOfCalculations - i)*sizeof(Calculation *);}
 
   // Memoization
-  static constexpr int k_numberOfMemoizedCalculationPointers = 10;
-  void resetMemoizedModelsAfterCalculationIndex(int index);
-  int m_indexOfFirstMemoizedCalculationPointer;
-  mutable Calculation * m_memoizedCalculationPointers[k_numberOfMemoizedCalculationPointers];
+  char * beginingOfMemoizationArea() {return addressOfPointerToCalculationOfIndex(0);};
+  void recomputeMemoizedPointersAfterCalculationIndex(int index);
 };
 
 }

apps/calculation/edit_expression_controller.cpp

@@ -9,7 +9,7 @@ using namespace Poincare;
 
 namespace Calculation {
 
-EditExpressionController::ContentView::ContentView(Responder * parentResponder, TableView * subview, InputEventHandlerDelegate * inputEventHandlerDelegate, TextFieldDelegate * textFieldDelegate, LayoutFieldDelegate * layoutFieldDelegate) :
+EditExpressionController::ContentView::ContentView(Responder * parentResponder, CalculationSelectableTableView * subview, InputEventHandlerDelegate * inputEventHandlerDelegate, TextFieldDelegate * textFieldDelegate, LayoutFieldDelegate * layoutFieldDelegate) :
   View(),
   m_mainView(subview),
   m_expressionField(parentResponder, inputEventHandlerDelegate, textFieldDelegate, layoutFieldDelegate)
@@ -25,12 +25,12 @@ View * EditExpressionController::ContentView::subviewAtIndex(int index) {
   return &m_expressionField;
 }
 
-void EditExpressionController::ContentView::layoutSubviews() {
+void EditExpressionController::ContentView::layoutSubviews(bool force) {
   KDCoordinate inputViewFrameHeight = m_expressionField.minimalSizeForOptimalDisplay().height();
   KDRect mainViewFrame(0, 0, bounds().width(), bounds().height() - inputViewFrameHeight);
-  m_mainView->setFrame(mainViewFrame);
+  m_mainView->setFrame(mainViewFrame, force);
   KDRect inputViewFrame(0, bounds().height() - inputViewFrameHeight, bounds().width(), inputViewFrameHeight);
-  m_expressionField.setFrame(inputViewFrame);
+  m_expressionField.setFrame(inputViewFrame, force);
 }
 
 void EditExpressionController::ContentView::reload() {
@@ -38,29 +38,38 @@ void EditExpressionController::ContentView::reload() {
   markRectAsDirty(bounds());
 }
 
-EditExpressionController::EditExpressionController(Responder * parentResponder, InputEventHandlerDelegate * inputEventHandlerDelegate, HistoryController * historyController, CalculationStore * calculationStore) :
+EditExpressionController::EditExpressionController(Responder * parentResponder, InputEventHandlerDelegate * inputEventHandlerDelegate, char * cacheBuffer, size_t * cacheBufferInformation, HistoryController * historyController, CalculationStore * calculationStore) :
   ViewController(parentResponder),
+  m_cacheBuffer(cacheBuffer),
+  m_cacheBufferInformation(cacheBufferInformation),
   m_historyController(historyController),
   m_calculationStore(calculationStore),
-  m_contentView(this, (TableView *)m_historyController->view(), inputEventHandlerDelegate, this, this),
-  m_inputViewHeightIsMaximal(false)
+  m_contentView(this, static_cast<CalculationSelectableTableView *>(m_historyController->view()), inputEventHandlerDelegate, this, this)
 {
-  m_cacheBuffer[0] = 0;
-}
-
-View * EditExpressionController::view() {
-  return &m_contentView;
 }
 
 void EditExpressionController::insertTextBody(const char * text) {
-  ((ContentView *)view())->expressionField()->handleEventWithText(text, false, true);
+  Container::activeApp()->setFirstResponder(this);
+  m_contentView.expressionField()->handleEventWithText(text, false, true);
 }
 
 void EditExpressionController::didBecomeFirstResponder() {
-  int lastRow = m_calculationStore->numberOfCalculations() > 0 ? m_calculationStore->numberOfCalculations()-1 : 0;
-  m_historyController->scrollToCell(0, lastRow);
-  ((ContentView *)view())->expressionField()->setEditing(true, false);
-  Container::activeApp()->setFirstResponder(((ContentView *)view())->expressionField());
+  m_contentView.mainView()->scrollToBottom();
+  m_contentView.expressionField()->setEditing(true, false);
+  Container::activeApp()->setFirstResponder(m_contentView.expressionField());
+}
+
+void EditExpressionController::restoreInput() {
+  m_contentView.expressionField()->restoreContent(m_cacheBuffer, *m_cacheBufferInformation);
+  clearCacheBuffer();
+}
+
+void EditExpressionController::memoizeInput() {
+  *m_cacheBufferInformation = m_contentView.expressionField()->moveCursorAndDumpContent(m_cacheBuffer, k_cacheBufferSize);
+}
+
+void EditExpressionController::viewWillAppear() {
+  m_historyController->viewWillAppear();
 }
 
 bool EditExpressionController::textFieldDidReceiveEvent(::TextField * textField, Ion::Events::Event event) {
@@ -96,23 +105,23 @@ bool EditExpressionController::layoutFieldDidAbortEditing(::LayoutField * layout
 }
 
 void EditExpressionController::layoutFieldDidChangeSize(::LayoutField * layoutField) {
-  /* Reload the view only if the ExpressionField height actually changes, i.e.
-   * not if the height is already maximal and stays maximal. */
-  if (view()) {
-    bool newInputViewHeightIsMaximal = static_cast<ContentView *>(view())->expressionField()->heightIsMaximal();
-    if (!m_inputViewHeightIsMaximal || !newInputViewHeightIsMaximal) {
-      m_inputViewHeightIsMaximal = newInputViewHeightIsMaximal;
-      reloadView();
-    }
+  if (m_contentView.expressionField()->inputViewHeightDidChange()) {
+    /* Reload the whole view only if the ExpressionField's height did actually
+     * change. */
+    reloadView();
+  } else {
+    /* The input view is already at maximal size so we do not need to relayout
+     * the view underneath, but the view inside the input view might still need
+     * to be relayouted.
+     * We force the relayout because the frame stays the same but we need to
+     * propagate a relayout to the content of the field scroll view. */
+    m_contentView.expressionField()->layoutSubviews(true);
   }
 }
 
 void EditExpressionController::reloadView() {
-  ((ContentView *)view())->reload();
+  m_contentView.reload();
   m_historyController->reload();
-  if (m_historyController->numberOfRows() > 0) {
-    ((ContentView *)view())->mainView()->scrollToCell(0, m_historyController->numberOfRows()-1);
-  }
 }
 
 bool EditExpressionController::inputViewDidReceiveEvent(Ion::Events::Event event, bool shouldDuplicateLastCalculation) {
@@ -123,15 +132,14 @@ bool EditExpressionController::inputViewDidReceiveEvent(Ion::Events::Event event
     if (!myApp->isAcceptableText(m_cacheBuffer)) {
       return true;
     }
-    m_calculationStore->push(m_cacheBuffer, myApp->localContext());
+    m_calculationStore->push(m_cacheBuffer, myApp->localContext(), HistoryViewCell::Height);
     m_historyController->reload();
-    ((ContentView *)view())->mainView()->scrollToCell(0, m_historyController->numberOfRows()-1);
     return true;
   }
   if (event == Ion::Events::Up) {
     if (m_calculationStore->numberOfCalculations() > 0) {
-      m_cacheBuffer[0] = 0;
-      ((ContentView *)view())->expressionField()->setEditing(false, false);
+      clearCacheBuffer();
+      m_contentView.expressionField()->setEditing(false, false);
       Container::activeApp()->setFirstResponder(m_historyController);
     }
     return true;
@@ -139,31 +147,27 @@ bool EditExpressionController::inputViewDidReceiveEvent(Ion::Events::Event event
   return false;
 }
 
-
 bool EditExpressionController::inputViewDidFinishEditing(const char * text, Layout layoutR) {
+  Context * context = textFieldDelegateApp()->localContext();
   if (layoutR.isUninitialized()) {
     assert(text);
     strlcpy(m_cacheBuffer, text, k_cacheBufferSize);
   } else {
-    layoutR.serializeParsedExpression(m_cacheBuffer, k_cacheBufferSize);
+    layoutR.serializeParsedExpression(m_cacheBuffer, k_cacheBufferSize, context);
   }
-  m_calculationStore->push(m_cacheBuffer, textFieldDelegateApp()->localContext());
+  m_calculationStore->push(m_cacheBuffer, context, HistoryViewCell::Height);
   m_historyController->reload();
-  ((ContentView *)view())->mainView()->scrollToCell(0, m_historyController->numberOfRows()-1);
-  ((ContentView *)view())->expressionField()->setEditing(true, true);
+  m_contentView.expressionField()->setEditing(true, true);
+  telemetryReportEvent("Input", m_cacheBuffer);
   return true;
 }
 
 bool EditExpressionController::inputViewDidAbortEditing(const char * text) {
   if (text != nullptr) {
-    ((ContentView *)view())->expressionField()->setEditing(true, true);
-    ((ContentView *)view())->expressionField()->setText(text);
+    m_contentView.expressionField()->setEditing(true, true);
+    m_contentView.expressionField()->setText(text);
   }
   return false;
 }
 
-void EditExpressionController::viewDidDisappear() {
-  m_historyController->viewDidDisappear();
-}
-
 }

apps/calculation/edit_expression_controller.h

@@ -7,19 +7,30 @@
 #include "../shared/text_field_delegate.h"
 #include "../shared/layout_field_delegate.h"
 #include "history_controller.h"
-#include "calculation_store.h"
+#include "selectable_table_view.h"
 
 namespace Calculation {
-class HistoryController;
 
 /* TODO: implement a split view */
 class EditExpressionController : public ViewController, public Shared::TextFieldDelegate, public Shared::LayoutFieldDelegate {
 public:
-  EditExpressionController(Responder * parentResponder, InputEventHandlerDelegate * inputEventHandlerDelegate, HistoryController * historyController, CalculationStore * calculationStore);
-  View * view() override;
+  EditExpressionController(Responder * parentResponder, InputEventHandlerDelegate * inputEventHandlerDelegate, char * cacheBuffer, size_t * cacheBufferInformation, HistoryController * historyController, CalculationStore * calculationStore);
+
+  /* k_layoutBufferMaxSize dictates the size under which the expression being
+   * edited can be remembered when the user leaves Calculation. */
+  static constexpr int k_layoutBufferMaxSize = 1024;
+  /* k_cacheBufferSize is the size of the array to which m_cacheBuffer points.
+   * It is used both as a way to buffer expression when pushing them the
+   * CalculationStore, and as a storage for the current input when leaving the
+   * application. */
+  static constexpr int k_cacheBufferSize = (k_layoutBufferMaxSize < Constant::MaxSerializedExpressionSize) ? Constant::MaxSerializedExpressionSize : k_layoutBufferMaxSize;
+
+  View * view() override { return &m_contentView; }
   void didBecomeFirstResponder() override;
-  void viewDidDisappear() override;
+  void viewWillAppear() override;
   void insertTextBody(const char * text);
+  void restoreInput();
+  void memoizeInput();
 
   /* TextFieldDelegate */
   bool textFieldDidReceiveEvent(::TextField * textField, Ion::Events::Event event) override;
@@ -35,28 +46,27 @@ public:
 private:
   class ContentView : public View {
   public:
-    ContentView(Responder * parentResponder, TableView * subview, InputEventHandlerDelegate * inputEventHandlerDelegate, TextFieldDelegate * textFieldDelegate, LayoutFieldDelegate * layoutFieldDelegate);
+    ContentView(Responder * parentResponder, CalculationSelectableTableView * subview, InputEventHandlerDelegate * inputEventHandlerDelegate, TextFieldDelegate * textFieldDelegate, LayoutFieldDelegate * layoutFieldDelegate);
     void reload();
-    TableView * mainView() { return m_mainView; }
+    CalculationSelectableTableView * mainView() { return m_mainView; }
     ExpressionField * expressionField() { return &m_expressionField; }
-    /* View */
+  private:
     int numberOfSubviews() const override { return 2; }
     View * subviewAtIndex(int index) override;
-    void layoutSubviews() override;
-  private:
-    TableView * m_mainView;
+    void layoutSubviews(bool force = false) override;
+    CalculationSelectableTableView * m_mainView;
     ExpressionField m_expressionField;
   };
   void reloadView();
+  void clearCacheBuffer() { m_cacheBuffer[0] = 0; *m_cacheBufferInformation = 0; }
   bool inputViewDidReceiveEvent(Ion::Events::Event event, bool shouldDuplicateLastCalculation);
   bool inputViewDidFinishEditing(const char * text, Poincare::Layout layoutR);
   bool inputViewDidAbortEditing(const char * text);
-  static constexpr int k_cacheBufferSize = Constant::MaxSerializedExpressionSize;
-  char m_cacheBuffer[k_cacheBufferSize];
+  char * m_cacheBuffer;
+  size_t * m_cacheBufferInformation;
   HistoryController * m_historyController;
   CalculationStore * m_calculationStore;
   ContentView m_contentView;
-  bool m_inputViewHeightIsMaximal;
 };
 
 }

apps/calculation/expression_field.cpp

@@ -17,7 +17,8 @@ bool ExpressionField::handleEvent(Ion::Events::Event event) {
        event == Ion::Events::Power ||
        event == Ion::Events::Square ||
        event == Ion::Events::Division ||
-       event == Ion::Events::Sto)) {
+       event == Ion::Events::Sto ||
+       event == Ion::Events::EE)) {
     handleEventWithText(Poincare::Symbol::k_ans);
   }
   return(::ExpressionField::handleEvent(event));

apps/calculation/expression_field.h

@@ -7,7 +7,10 @@ namespace Calculation {
 
 class ExpressionField : public ::ExpressionField {
 public:
-  using ::ExpressionField::ExpressionField;
+  ExpressionField(Responder * parentResponder, InputEventHandlerDelegate * inputEventHandler, TextFieldDelegate * textFieldDelegate, LayoutFieldDelegate * layoutFieldDelegate) :
+  ::ExpressionField(parentResponder, inputEventHandler, textFieldDelegate, layoutFieldDelegate) {
+    setLayoutInsertionCursorEvent(Ion::Events::Up);
+  }
 protected:
   bool handleEvent(Ion::Events::Event event) override;
 };

apps/calculation/history_controller.cpp

@@ -1,16 +1,25 @@
 #include "history_controller.h"
 #include "app.h"
+#include <poincare/exception_checkpoint.h>
 #include <assert.h>
 
 using namespace Shared;
+using namespace Poincare;
 
 namespace Calculation {
 
-HistoryController::HistoryController(Responder * parentResponder, CalculationStore * calculationStore) :
-  ViewController(parentResponder),
+HistoryController::HistoryController(EditExpressionController * editExpressionController, CalculationStore * calculationStore) :
+  ViewController(editExpressionController),
   m_selectableTableView(this, this, this, this),
   m_calculationHistory{},
-  m_calculationStore(calculationStore)
+  m_calculationStore(calculationStore),
+  m_complexController(editExpressionController),
+  m_integerController(editExpressionController),
+  m_rationalController(editExpressionController),
+  m_secondDegreeController(editExpressionController),
+  m_trigonometryController(editExpressionController),
+  m_unitController(editExpressionController),
+  m_matrixController(editExpressionController)
 {
   for (int i = 0; i < k_maxNumberOfDisplayedRows; i++) {
     m_calculationHistory[i].setParentResponder(&m_selectableTableView);
@@ -19,7 +28,28 @@ HistoryController::HistoryController(Responder * parentResponder, CalculationSto
 }
 
 void HistoryController::reload() {
+  /* When reloading, we might not used anymore cell that hold previous layouts.
+   * We clean them all before reloading their content to avoid taking extra
+   * useless space in the Poincare pool. */
+  for (int i = 0; i < k_maxNumberOfDisplayedRows; i++) {
+    m_calculationHistory[i].resetMemoization();
+  }
+
   m_selectableTableView.reloadData();
+  /* TODO
+   * Replace the following by selectCellAtLocation in order to avoid laying out
+   * the table view twice.
+   */
+  if (numberOfRows() > 0) {
+    m_selectableTableView.scrollToBottom();
+    // Force to reload last added cell (hide the burger and exact output if necessary)
+    tableViewDidChangeSelectionAndDidScroll(&m_selectableTableView, 0, numberOfRows()-1);
+  }
+}
+
+void HistoryController::viewWillAppear() {
+  ViewController::viewWillAppear();
+  reload();
 }
 
 void HistoryController::didBecomeFirstResponder() {
@@ -28,6 +58,9 @@ void HistoryController::didBecomeFirstResponder() {
 }
 
 void HistoryController::willExitResponderChain(Responder * nextFirstResponder) {
+  if (nextFirstResponder == nullptr) {
+    return;
+  }
   if (nextFirstResponder == parentResponder()) {
     m_selectableTableView.deselectTable();
   }
@@ -47,20 +80,47 @@ bool HistoryController::handleEvent(Ion::Events::Event event) {
     HistoryViewCell * selectedCell = (HistoryViewCell *)m_selectableTableView.selectedCell();
     SubviewType subviewType = selectedSubviewType();
     EditExpressionController * editController = (EditExpressionController *)parentResponder();
-    m_selectableTableView.deselectTable();
-    Container::activeApp()->setFirstResponder(editController);
-    Shared::ExpiringPointer<Calculation> calculation = calculationAtIndex(focusRow);
     if (subviewType == SubviewType::Input) {
-      editController->insertTextBody(calculation->inputText());
-    } else {
-      ScrollableExactApproximateExpressionsView::SubviewPosition outputSubviewPosition = selectedCell->outputView()->selectedSubviewPosition();
-      if (outputSubviewPosition == ScrollableExactApproximateExpressionsView::SubviewPosition::Right
+      m_selectableTableView.deselectTable();
+      editController->insertTextBody(calculationAtIndex(focusRow)->inputText());
+    } else if (subviewType == SubviewType::Output) {
+      m_selectableTableView.deselectTable();
+      Shared::ExpiringPointer<Calculation> calculation = calculationAtIndex(focusRow);
+      ScrollableTwoExpressionsView::SubviewPosition outputSubviewPosition = selectedCell->outputView()->selectedSubviewPosition();
+      if (outputSubviewPosition == ScrollableTwoExpressionsView::SubviewPosition::Right
           && !calculation->shouldOnlyDisplayExactOutput())
       {
-        editController->insertTextBody(calculation->approximateOutputText());
+        editController->insertTextBody(calculation->approximateOutputText(Calculation::NumberOfSignificantDigits::Maximal));
       } else {
         editController->insertTextBody(calculation->exactOutputText());
       }
+    } else {
+      assert(subviewType == SubviewType::Ellipsis);
+      Calculation::AdditionalInformationType additionalInfoType = selectedCell->additionalInformationType();
+      ListController * vc = nullptr;
+      Expression e = calculationAtIndex(focusRow)->exactOutput();
+      if (additionalInfoType == Calculation::AdditionalInformationType::Complex) {
+        vc = &m_complexController;
+      } else if (additionalInfoType == Calculation::AdditionalInformationType::SecondDegree) {
+        vc = &m_secondDegreeController;
+      } else if (additionalInfoType == Calculation::AdditionalInformationType::Trigonometry) {
+        vc = &m_trigonometryController;
+        // Find which of the input or output is the cosine/sine
+        ExpressionNode::Type t = e.type();
+        e = t == ExpressionNode::Type::Cosine || t == ExpressionNode::Type::Sine ? e : calculationAtIndex(focusRow)->input();
+      } else if (additionalInfoType == Calculation::AdditionalInformationType::Integer) {
+        vc = &m_integerController;
+      } else if (additionalInfoType == Calculation::AdditionalInformationType::Rational) {
+        vc = &m_rationalController;
+      } else if (additionalInfoType == Calculation::AdditionalInformationType::Unit) {
+        vc = &m_unitController;
+      } else if (additionalInfoType == Calculation::AdditionalInformationType::Matrix) {
+        vc = &m_matrixController;
+      }
+      if (vc) {
+        vc->setExpression(e);
+        Container::activeApp()->displayModalViewController(vc, 0.f, 0.f, Metric::CommonTopMargin, Metric::PopUpLeftMargin, 0, Metric::PopUpRightMargin);
+      }
     }
     return true;
   }
@@ -68,24 +128,16 @@ bool HistoryController::handleEvent(Ion::Events::Event event) {
     int focusRow = selectedRow();
     SubviewType subviewType = selectedSubviewType();
     m_selectableTableView.deselectTable();
-    EditExpressionController * editController = (EditExpressionController *)parentResponder();
     m_calculationStore->deleteCalculationAtIndex(storeIndex(focusRow));
     reload();
     if (numberOfRows()== 0) {
-      Container::activeApp()->setFirstResponder(editController);
+      Container::activeApp()->setFirstResponder(parentResponder());
       return true;
     }
-    if (focusRow > 0) {
-      m_selectableTableView.selectCellAtLocation(0, focusRow-1);
-    } else {
-      m_selectableTableView.selectCellAtLocation(0, 0);
-    }
-    if (subviewType == SubviewType::Input) {
-      tableViewDidChangeSelection(&m_selectableTableView, 0, selectedRow());
-    } else {
-      tableViewDidChangeSelection(&m_selectableTableView, 0, -1);
-    }
-    m_selectableTableView.scrollToCell(0, selectedRow());
+    m_selectableTableView.selectCellAtLocation(0, focusRow > 0 ? focusRow - 1 : 0);
+    /* The parameters 'sameCell' and 'previousSelectedY' are chosen to enforce
+     * toggling of the output when necessary. */
+    setSelectedSubviewType(subviewType, false, 0, (subviewType == SubviewType::Input) ? selectedRow() : -1);
     return true;
   }
   if (event == Ion::Events::Clear) {
@@ -96,9 +148,8 @@ bool HistoryController::handleEvent(Ion::Events::Event event) {
     return true;
   }
   if (event == Ion::Events::Back) {
-    EditExpressionController * editController = (EditExpressionController *)parentResponder();
     m_selectableTableView.deselectTable();
-    Container::activeApp()->setFirstResponder(editController);
+    Container::activeApp()->setFirstResponder(parentResponder());
     return true;
   }
   return false;
@@ -108,18 +159,23 @@ Shared::ExpiringPointer<Calculation> HistoryController::calculationAtIndex(int i
   return m_calculationStore->calculationAtIndex(storeIndex(i));
 }
 
-void HistoryController::tableViewDidChangeSelection(SelectableTableView * t, int previousSelectedCellX, int previousSelectedCellY, bool withinTemporarySelection) {
+void HistoryController::tableViewDidChangeSelectionAndDidScroll(SelectableTableView * t, int previousSelectedCellX, int previousSelectedCellY, bool withinTemporarySelection) {
   if (withinTemporarySelection || previousSelectedCellY == selectedRow()) {
     return;
   }
-  HistoryViewCell * cell = static_cast<HistoryViewCell *>(t->selectedCell());
   if (previousSelectedCellY == -1) {
-    setSelectedSubviewType(SubviewType::Output, cell);
-  } else if (selectedRow() < previousSelectedCellY) {
-    setSelectedSubviewType(SubviewType::Output, cell);
-  } else if (selectedRow() > previousSelectedCellY) {
-    setSelectedSubviewType(SubviewType::Input, cell);
+    setSelectedSubviewType(SubviewType::Output, false, previousSelectedCellX, previousSelectedCellY);
+  } else if (selectedRow() == -1) {
+    setSelectedSubviewType(SubviewType::Input, false, previousSelectedCellX, previousSelectedCellY);
+  } else {
+    HistoryViewCell * selectedCell = (HistoryViewCell *)(t->selectedCell());
+    SubviewType nextSelectedSubviewType = selectedSubviewType();
+    if (selectedCell && !selectedCell->displaysSingleLine()) {
+      nextSelectedSubviewType = previousSelectedCellY < selectedRow() ? SubviewType::Input : SubviewType::Output;
+    }
+    setSelectedSubviewType(nextSelectedSubviewType, false, previousSelectedCellX, previousSelectedCellY);
   }
+  // The selectedCell may change during setSelectedSubviewType
   HistoryViewCell * selectedCell = (HistoryViewCell *)(t->selectedCell());
   if (selectedCell == nullptr) {
     return;
@@ -147,7 +203,7 @@ void HistoryController::willDisplayCellForIndex(HighlightCell * cell, int index)
   HistoryViewCell * myCell = (HistoryViewCell *)cell;
   myCell->setCalculation(calculationAtIndex(index).pointer(), index == selectedRow() && selectedSubviewType() == SubviewType::Output);
   myCell->setEven(index%2 == 0);
-  myCell->setHighlighted(myCell->isHighlighted());
+  myCell->reloadSubviewHighlight();
 }
 
 KDCoordinate HistoryController::rowHeight(int j) {
@@ -155,21 +211,49 @@ KDCoordinate HistoryController::rowHeight(int j) {
     return 0;
   }
   Shared::ExpiringPointer<Calculation> calculation = calculationAtIndex(j);
-  return calculation->height(App::app()->localContext(), j == selectedRow() && selectedSubviewType() == SubviewType::Output) + 4 * Metric::CommonSmallMargin;
+  bool expanded = j == selectedRow() && selectedSubviewType() == SubviewType::Output;
+  return calculation->height(expanded);
 }
 
 int HistoryController::typeAtLocation(int i, int j) {
   return 0;
 }
 
-void HistoryController::scrollToCell(int i, int j) {
-  m_selectableTableView.scrollToCell(i, j);
+bool HistoryController::calculationAtIndexToggles(int index) {
+  Context * context = App::app()->localContext();
+  return index >= 0 && index < m_calculationStore->numberOfCalculations() && calculationAtIndex(index)->displayOutput(context) == Calculation::DisplayOutput::ExactAndApproximateToggle;
 }
 
-void HistoryController::historyViewCellDidChangeSelection() {
-  /* Update the whole table as the height of the selected cell row might have
-   * changed. */
-  m_selectableTableView.reloadData();
+
+void HistoryController::setSelectedSubviewType(SubviewType subviewType, bool sameCell, int previousSelectedX, int previousSelectedY) {
+  // Avoid selecting non-displayed ellipsis
+  HistoryViewCell * selectedCell = static_cast<HistoryViewCell *>(m_selectableTableView.selectedCell());
+  if (subviewType == SubviewType::Ellipsis && selectedCell && selectedCell->additionalInformationType() == Calculation::AdditionalInformationType::None) {
+    subviewType = SubviewType::Output;
+  }
+  HistoryViewCellDataSource::setSelectedSubviewType(subviewType, sameCell, previousSelectedX, previousSelectedY);
+}
+
+void HistoryController::historyViewCellDidChangeSelection(HistoryViewCell ** cell, HistoryViewCell ** previousCell, int previousSelectedCellX, int previousSelectedCellY, SubviewType type, SubviewType previousType) {
+  /* If the selection change triggers the toggling of the outputs, we update
+   * the whole table as the height of the selected cell row might have changed. */
+  if ((type == SubviewType::Output || previousType == SubviewType::Output) && (calculationAtIndexToggles(selectedRow()) || calculationAtIndexToggles(previousSelectedCellY))) {
+    m_selectableTableView.reloadData();
+  }
+
+  // It might be necessary to scroll to the sub type if the cell overflows the screen
+  if (selectedRow() >= 0) {
+    m_selectableTableView.scrollToSubviewOfTypeOfCellAtLocation(type, m_selectableTableView.selectedColumn(), m_selectableTableView.selectedRow());
+  }
+  // Fill the selected cell and the previous selected cell because cells repartition might have changed
+  *cell = static_cast<HistoryViewCell *>(m_selectableTableView.selectedCell());
+  *previousCell = static_cast<HistoryViewCell *>(m_selectableTableView.cellAtLocation(previousSelectedCellX, previousSelectedCellY));
+  /* 'reloadData' calls 'willDisplayCellForIndex' for each cell while the table
+   * has been deselected. To reload the expanded cell, we call one more time
+   * 'willDisplayCellForIndex' but once the right cell has been selected. */
+  if (*cell) {
+    willDisplayCellForIndex(*cell, selectedRow());
+  }
 }
 
 }

apps/calculation/history_controller.h

@@ -5,6 +5,13 @@
 #include "history_view_cell.h"
 #include "calculation_store.h"
 #include "selectable_table_view.h"
+#include "additional_outputs/complex_list_controller.h"
+#include "additional_outputs/integer_list_controller.h"
+#include "additional_outputs/rational_list_controller.h"
+#include "additional_outputs/second_degree_list_controller.h"
+#include "additional_outputs/trigonometry_list_controller.h"
+#include "additional_outputs/unit_list_controller.h"
+#include "additional_outputs/matrix_list_controller.h"
 
 namespace Calculation {
 
@@ -12,9 +19,11 @@ class App;
 
 class HistoryController : public ViewController, public ListViewDataSource, public SelectableTableViewDataSource, public SelectableTableViewDelegate, public HistoryViewCellDataSource {
 public:
-  HistoryController(Responder * parentResponder, CalculationStore * calculationStore);
+  HistoryController(EditExpressionController * editExpressionController, CalculationStore * calculationStore);
   View * view() override { return &m_selectableTableView; }
   bool handleEvent(Ion::Events::Event event) override;
+  void viewWillAppear() override;
+  TELEMETRY_ID("");
   void didBecomeFirstResponder() override;
   void willExitResponderChain(Responder * nextFirstResponder) override;
   void reload();
@@ -24,17 +33,25 @@ public:
   void willDisplayCellForIndex(HighlightCell * cell, int index) override;
   KDCoordinate rowHeight(int j) override;
   int typeAtLocation(int i, int j) override;
-  void tableViewDidChangeSelection(SelectableTableView * t, int previousSelectedCellX, int previousSelectedCellY, bool withinTemporarySelection = false) override;
-  void scrollToCell(int i, int j);
+  void setSelectedSubviewType(SubviewType subviewType, bool sameCell, int previousSelectedX = -1, int previousSelectedY = -1) override;
+  void tableViewDidChangeSelectionAndDidScroll(SelectableTableView * t, int previousSelectedCellX, int previousSelectedCellY, bool withinTemporarySelection = false) override;
 private:
   int storeIndex(int i) { return numberOfRows() - i - 1; }
   Shared::ExpiringPointer<Calculation> calculationAtIndex(int i);
   CalculationSelectableTableView * selectableTableView();
-  void historyViewCellDidChangeSelection() override;
-  constexpr static int k_maxNumberOfDisplayedRows = 5;
+  bool calculationAtIndexToggles(int index);
+  void historyViewCellDidChangeSelection(HistoryViewCell ** cell, HistoryViewCell ** previousCell, int previousSelectedCellX, int previousSelectedCellY, SubviewType type, SubviewType previousType) override;
+  constexpr static int k_maxNumberOfDisplayedRows = 8;
   CalculationSelectableTableView m_selectableTableView;
   HistoryViewCell m_calculationHistory[k_maxNumberOfDisplayedRows];
   CalculationStore * m_calculationStore;
+  ComplexListController m_complexController;
+  IntegerListController m_integerController;
+  RationalListController m_rationalController;
+  SecondDegreeListController m_secondDegreeController;
+  TrigonometryListController m_trigonometryController;
+  UnitListController m_unitController;
+  MatrixListController m_matrixController;
 };
 
 }

apps/calculation/history_view_cell.cpp

@@ -2,42 +2,58 @@
 #include "app.h"
 #include "../constant.h"
 #include "selectable_table_view.h"
+#include <poincare/exception_checkpoint.h>
 #include <assert.h>
 #include <string.h>
+#include <algorithm>
 
 namespace Calculation {
 
-static inline KDCoordinate minCoordinate(KDCoordinate x, KDCoordinate y) { return x < y ? x : y; }
-static inline KDCoordinate maxCoordinate(KDCoordinate x, KDCoordinate y) { return x > y ? x : y; }
-
 /* HistoryViewCellDataSource */
 
-HistoryViewCellDataSource::HistoryViewCellDataSource() :
-  m_selectedSubviewType(SubviewType::Output) {}
-
-void HistoryViewCellDataSource::setSelectedSubviewType(SubviewType subviewType, HistoryViewCell * cell) {
+void HistoryViewCellDataSource::setSelectedSubviewType(SubviewType subviewType, bool sameCell, int previousSelectedCellX, int previousSelectedCellY) {
+  HistoryViewCell * selectedCell = nullptr;
+  HistoryViewCell * previouslySelectedCell = nullptr;
+  SubviewType previousSubviewType = m_selectedSubviewType;
   m_selectedSubviewType = subviewType;
-  if (cell) {
-    cell->setHighlighted(cell->isHighlighted());
-    cell->cellDidSelectSubview(subviewType);
+  /* We need to notify the whole table that the selection changed if it
+   * involves the selection/deselection of an output. Indeed, only them can
+   * trigger change in the displayed expressions. */
+  historyViewCellDidChangeSelection(&selectedCell, &previouslySelectedCell, previousSelectedCellX, previousSelectedCellY, subviewType, previousSubviewType);
+
+  previousSubviewType = sameCell ? previousSubviewType : SubviewType::None;
+  if (selectedCell) {
+    selectedCell->reloadSubviewHighlight();
+    selectedCell->cellDidSelectSubview(subviewType, previousSubviewType);
+    Container::activeApp()->setFirstResponder(selectedCell);
+  }
+  if (previouslySelectedCell) {
+    previouslySelectedCell->cellDidSelectSubview(SubviewType::Input);
   }
-  historyViewCellDidChangeSelection();
 }
 
 /* HistoryViewCell */
 
-HistoryViewCell::HistoryViewCell(Responder * parentResponder) :
-  Responder(parentResponder),
-  m_calculationDisplayOutput(Calculation::DisplayOutput::Unknown),
-  m_calculationExpanded(false),
-  m_inputView(this),
-  m_scrollableOutputView(this)
-{
-  m_calculationCRC32 = 0;
+KDCoordinate HistoryViewCell::Height(Calculation * calculation, bool expanded) {
+  HistoryViewCell cell(nullptr);
+  cell.setCalculation(calculation, expanded, true);
+  KDRect ellipsisFrame = KDRectZero;
+  KDRect inputFrame = KDRectZero;
+  KDRect outputFrame = KDRectZero;
+  cell.computeSubviewFrames(Ion::Display::Width, KDCOORDINATE_MAX, &ellipsisFrame, &inputFrame, &outputFrame);
+  return k_margin + inputFrame.unionedWith(outputFrame).height() + k_margin;
 }
 
-Shared::ScrollableExactApproximateExpressionsView * HistoryViewCell::outputView() {
-  return &m_scrollableOutputView;
+HistoryViewCell::HistoryViewCell(Responder * parentResponder) :
+  Responder(parentResponder),
+  m_calculationCRC32(0),
+  m_calculationDisplayOutput(Calculation::DisplayOutput::Unknown),
+  m_calculationAdditionInformation(Calculation::AdditionalInformationType::None),
+  m_inputView(this, k_inputViewHorizontalMargin, k_inputOutputViewsVerticalMargin),
+  m_scrollableOutputView(this),
+  m_calculationExpanded(false),
+  m_calculationSingleLine(false)
+{
 }
 
 void HistoryViewCell::setEven(bool even) {
@@ -45,18 +61,32 @@ void HistoryViewCell::setEven(bool even) {
   m_inputView.setBackgroundColor(backgroundColor());
   m_scrollableOutputView.setBackgroundColor(backgroundColor());
   m_scrollableOutputView.evenOddCell()->setEven(even);
+  m_ellipsis.setEven(even);
 }
 
 void HistoryViewCell::setHighlighted(bool highlight) {
-  assert(m_dataSource);
+  if (m_highlighted == highlight) {
+    return;
+  }
   m_highlighted = highlight;
+  reloadSubviewHighlight();
+  // Re-layout as the ellispsis subview might have appear/disappear
+  layoutSubviews();
+}
+
+void HistoryViewCell::reloadSubviewHighlight() {
+  assert(m_dataSource);
   m_inputView.setExpressionBackgroundColor(backgroundColor());
   m_scrollableOutputView.evenOddCell()->setHighlighted(false);
+  m_ellipsis.setHighlighted(false);
   if (isHighlighted()) {
     if (m_dataSource->selectedSubviewType() == HistoryViewCellDataSource::SubviewType::Input) {
       m_inputView.setExpressionBackgroundColor(Palette::Select);
-    } else {
+    } else if (m_dataSource->selectedSubviewType() == HistoryViewCellDataSource::SubviewType::Output) {
       m_scrollableOutputView.evenOddCell()->setHighlighted(true);
+    } else {
+      assert(m_dataSource->selectedSubviewType() == HistoryViewCellDataSource::SubviewType::Ellipsis);
+      m_ellipsis.setHighlighted(true);
     }
   }
 }
@@ -75,30 +105,35 @@ void HistoryViewCell::reloadScroll() {
   m_scrollableOutputView.reloadScroll();
 }
 
-void HistoryViewCell::reloadOutputSelection() {
+void HistoryViewCell::reloadOutputSelection(HistoryViewCellDataSource::SubviewType previousType) {
   /* Select the right output according to the calculation display output. This
    * will reload the scroll to display the selected output. */
   if (m_calculationDisplayOutput == Calculation::DisplayOutput::ExactAndApproximate) {
-    m_scrollableOutputView.setSelectedSubviewPosition(Shared::ScrollableExactApproximateExpressionsView::SubviewPosition::Left);
+    m_scrollableOutputView.setSelectedSubviewPosition(
+        previousType == HistoryViewCellDataSource::SubviewType::Ellipsis ?
+          Shared::ScrollableTwoExpressionsView::SubviewPosition::Right :
+          Shared::ScrollableTwoExpressionsView::SubviewPosition::Center
+        );
   } else {
     assert((m_calculationDisplayOutput == Calculation::DisplayOutput::ApproximateOnly)
         || (m_calculationDisplayOutput == Calculation::DisplayOutput::ExactAndApproximateToggle)
         || (m_calculationDisplayOutput == Calculation::DisplayOutput::ExactOnly));
-    m_scrollableOutputView.setSelectedSubviewPosition(Shared::ScrollableExactApproximateExpressionsView::SubviewPosition::Right);
+    m_scrollableOutputView.setSelectedSubviewPosition(Shared::ScrollableTwoExpressionsView::SubviewPosition::Right);
   }
 }
 
-void HistoryViewCell::cellDidSelectSubview(HistoryViewCellDataSource::SubviewType type) {
+void HistoryViewCell::cellDidSelectSubview(HistoryViewCellDataSource::SubviewType type, HistoryViewCellDataSource::SubviewType previousType) {
   // Init output selection
   if (type == HistoryViewCellDataSource::SubviewType::Output) {
-    reloadOutputSelection();
+    reloadOutputSelection(previousType);
   }
 
+  // Update m_calculationExpanded
+  m_calculationExpanded = (type == HistoryViewCellDataSource::SubviewType::Output && m_calculationDisplayOutput == Calculation::DisplayOutput::ExactAndApproximateToggle);
   /* The selected subview has changed. The displayed outputs might have changed.
    * For example, for the calculation 1.2+2 --> 3.2, selecting the output would
    * display 1.2+2 --> 16/5 = 3.2. */
-  m_calculationExpanded = (type == HistoryViewCellDataSource::SubviewType::Output);
-  m_scrollableOutputView.setDisplayLeftLayout(displayLeftLayout());
+  m_scrollableOutputView.setDisplayCenter(m_calculationDisplayOutput == Calculation::DisplayOutput::ExactAndApproximate || m_calculationExpanded);
 
   /* The displayed outputs have changed. We need to re-layout the cell
    * and re-initialize the scroll. */
@@ -106,62 +141,167 @@ void HistoryViewCell::cellDidSelectSubview(HistoryViewCellDataSource::SubviewTyp
   reloadScroll();
 }
 
-KDColor HistoryViewCell::backgroundColor() const {
-  KDColor background = m_even ? KDColorWhite : Palette::WallScreen;
-  return background;
-}
-
-int HistoryViewCell::numberOfSubviews() const {
-  return 2;
-}
-
 View * HistoryViewCell::subviewAtIndex(int index) {
-  View * views[2] = {&m_inputView, &m_scrollableOutputView};
+  /* The order of the subviews should not matter here as they don't overlap.
+   * However, the order determines the order of redrawing as well. For several
+   * reasons listed after, changing subview selection often redraws the entire
+   * m_scrollableOutputView even if it seems unecessary:
+   * - Before feeding new Layouts to ExpressionViews, we reset the hold layouts
+   *   in order to empty the Poincare pool and have more space to compute new
+   *   layouts.
+   * - Even if we did not do that, ExpressionView::setLayout doesn't avoid
+   *   redrawing when the previous expression is identical (for reasons
+   *   explained in expression_view.cpp)
+   * - Because of the toggling burger view, ExpressionViews often have the same
+   *   absolute frame but a different relative frame which leads to redrawing
+   *   them anyway.
+   * All these reasons cause a blinking which can be avoided if we redraw the
+   * output view before the input view (starting with redrawing the more
+   * complex view enables to redraw it before the vblank thereby preventing
+   * blinking).
+   * TODO: this is a dirty hack which should be fixed! */
+  View * views[3] = {&m_scrollableOutputView, &m_inputView, &m_ellipsis};
   return views[index];
 }
 
-void HistoryViewCell::layoutSubviews() {
-  KDCoordinate maxFrameWidth = bounds().width();
-  KDSize inputSize = m_inputView.minimalSizeForOptimalDisplay();
-  m_inputView.setFrame(KDRect(
-    0,
-    0,
-    minCoordinate(maxFrameWidth, inputSize.width()),
-    inputSize.height()
-  ));
-  KDSize outputSize = m_scrollableOutputView.minimalSizeForOptimalDisplay();
-  m_scrollableOutputView.setFrame(KDRect(
-    maxCoordinate(0, maxFrameWidth - outputSize.width()),
-    inputSize.height(),
-    minCoordinate(maxFrameWidth, outputSize.width()),
-    outputSize.height()
-  ));
+bool HistoryViewCell::ViewsCanBeSingleLine(KDCoordinate inputViewWidth, KDCoordinate outputViewWidth) {
+  // k_margin is the separation between the input and output.
+  return (inputViewWidth + k_margin + outputViewWidth) < Ion::Display::Width - Metric::EllipsisCellWidth;
 }
 
-void HistoryViewCell::setCalculation(Calculation * calculation, bool expanded) {
+void HistoryViewCell::layoutSubviews(bool force) {
+  KDRect frameBounds = bounds();
+  if (bounds().width() <= 0 || bounds().height() <= 0) {
+    // TODO Make this behaviour in a non-virtual layoutSublviews, and all layout subviews should become privateLayoutSubviews
+    return;
+  }
+  KDRect ellipsisFrame = KDRectZero;
+  KDRect inputFrame = KDRectZero;
+  KDRect outputFrame = KDRectZero;
+  computeSubviewFrames(frameBounds.width(), frameBounds.height(), &ellipsisFrame, &inputFrame, &outputFrame);
+
+  m_ellipsis.setFrame(ellipsisFrame, force); // Required even if ellipsisFrame is KDRectZero, to mark previous rect as dirty
+  m_inputView.setFrame(inputFrame,force);
+  m_scrollableOutputView.setFrame(outputFrame, force);
+}
+
+void HistoryViewCell::computeSubviewFrames(KDCoordinate frameWidth, KDCoordinate frameHeight, KDRect * ellipsisFrame, KDRect * inputFrame, KDRect * outputFrame) {
+  assert(ellipsisFrame != nullptr && inputFrame != nullptr && outputFrame != nullptr);
+
+  if (displayedEllipsis()) {
+    *ellipsisFrame = KDRect(frameWidth - Metric::EllipsisCellWidth, 0, Metric::EllipsisCellWidth, frameHeight);
+    frameWidth -= Metric::EllipsisCellWidth;
+  } else {
+    *ellipsisFrame = KDRectZero;
+  }
+
+  KDSize inputSize = m_inputView.minimalSizeForOptimalDisplay();
+  KDSize outputSize = m_scrollableOutputView.minimalSizeForOptimalDisplay();
+
+  /* To compute if the calculation is on a single line, use the expanded width
+   * if there is both an exact and an approximate layout. */
+  m_calculationSingleLine = ViewsCanBeSingleLine(inputSize.width(), m_scrollableOutputView.minimalSizeForOptimalDisplayFullSize().width());
+
+  KDCoordinate inputY = k_margin;
+  KDCoordinate outputY = k_margin;
+  if (m_calculationSingleLine && !m_inputView.layout().isUninitialized()) {
+    KDCoordinate inputBaseline = m_inputView.layout().baseline();
+    KDCoordinate outputBaseline = m_scrollableOutputView.baseline();
+    KDCoordinate baselineDifference = outputBaseline - inputBaseline;
+    if (baselineDifference > 0) {
+      inputY += baselineDifference;
+    } else {
+      outputY += -baselineDifference;
+    }
+  } else {
+    outputY += inputSize.height();
+  }
+
+  *inputFrame = KDRect(
+        0,
+        inputY,
+        std::min(frameWidth, inputSize.width()),
+        inputSize.height());
+  *outputFrame = KDRect(
+        std::max(0, frameWidth - outputSize.width()),
+        outputY,
+        std::min(frameWidth, outputSize.width()),
+        outputSize.height());
+}
+
+void HistoryViewCell::resetMemoization() {
+  // Clean the layouts to make room in the pool
+  // TODO: maybe do this only when the layout won't change to avoid blinking
+  m_inputView.setLayout(Poincare::Layout());
+  m_scrollableOutputView.setLayouts(Poincare::Layout(), Poincare::Layout(), Poincare::Layout());
+  m_calculationCRC32 = 0;
+}
+
+void HistoryViewCell::setCalculation(Calculation * calculation, bool expanded, bool canChangeDisplayOutput) {
   uint32_t newCalculationCRC = Ion::crc32Byte((const uint8_t *)calculation, ((char *)calculation->next()) - ((char *) calculation));
-  if (m_calculationExpanded == expanded && newCalculationCRC == m_calculationCRC32) {
+  if (newCalculationCRC == m_calculationCRC32 && m_calculationExpanded == expanded) {
     return;
   }
   Poincare::Context * context = App::app()->localContext();
 
-  // Clean the layouts to make room in the pool
-  m_inputView.setLayout(Poincare::Layout());
-  m_scrollableOutputView.setLayouts(Poincare::Layout(), Poincare::Layout());
+  // TODO: maybe do this only when the layout won't change to avoid blinking
+  resetMemoization();
 
   // Memoization
   m_calculationCRC32 = newCalculationCRC;
-  m_calculationExpanded = expanded;
-  m_calculationDisplayOutput = calculation->displayOutput(context);
+  m_calculationExpanded = expanded && calculation->displayOutput(context) == ::Calculation::Calculation::DisplayOutput::ExactAndApproximateToggle;
+  m_calculationAdditionInformation = calculation->additionalInformationType(context);
   m_inputView.setLayout(calculation->createInputLayout());
-  /* Both output expressions have to be updated at the same time. Otherwise,
+
+  /* All expressions have to be updated at the same time. Otherwise,
    * when updating one layout, if the second one still points to a deleted
    * layout, calling to layoutSubviews() would fail. */
-  Poincare::Layout leftOutputLayout = calculation->createExactOutputLayout();
-  Poincare::Layout rightOutputLayout = (m_calculationDisplayOutput == Calculation::DisplayOutput::ExactOnly) ? leftOutputLayout :
-    calculation->createApproximateOutputLayout(context);
-  m_scrollableOutputView.setDisplayLeftLayout(displayLeftLayout()); // Must be before the setLayouts fo the reload
-  m_scrollableOutputView.setLayouts(rightOutputLayout, leftOutputLayout);
+
+  // Create the exact output layout
+  Poincare::Layout exactOutputLayout = Poincare::Layout();
+  if (Calculation::DisplaysExact(calculation->displayOutput(context))) {
+    bool couldNotCreateExactLayout = false;
+    exactOutputLayout = calculation->createExactOutputLayout(&couldNotCreateExactLayout);
+    if (couldNotCreateExactLayout) {
+      if (canChangeDisplayOutput && calculation->displayOutput(context) != ::Calculation::Calculation::DisplayOutput::ExactOnly) {
+        calculation->forceDisplayOutput(::Calculation::Calculation::DisplayOutput::ApproximateOnly);
+      } else {
+        /* We should only display the exact result, but we cannot create it
+         * -> raise an exception. */
+        Poincare::ExceptionCheckpoint::Raise();
+      }
+    }
+  }
+
+  // Create the approximate output layout
+  Poincare::Layout approximateOutputLayout;
+  if (calculation->displayOutput(context) == ::Calculation::Calculation::DisplayOutput::ExactOnly) {
+    approximateOutputLayout = exactOutputLayout;
+  } else {
+    bool couldNotCreateApproximateLayout = false;
+    approximateOutputLayout = calculation->createApproximateOutputLayout(context, &couldNotCreateApproximateLayout);
+    if (couldNotCreateApproximateLayout) {
+      if (canChangeDisplayOutput && calculation->displayOutput(context) != ::Calculation::Calculation::DisplayOutput::ApproximateOnly) {
+        /* Set the display output to ApproximateOnly, make room in the pool by
+         * erasing the exact layout, and retry to create the approximate layout */
+        calculation->forceDisplayOutput(::Calculation::Calculation::DisplayOutput::ApproximateOnly);
+        exactOutputLayout = Poincare::Layout();
+        couldNotCreateApproximateLayout = false;
+        approximateOutputLayout = calculation->createApproximateOutputLayout(context, &couldNotCreateApproximateLayout);
+        if (couldNotCreateApproximateLayout) {
+          Poincare::ExceptionCheckpoint::Raise();
+        }
+      } else {
+        Poincare::ExceptionCheckpoint::Raise();
+      }
+    }
+  }
+  m_calculationDisplayOutput = calculation->displayOutput(context);
+
+  // We must set which subviews are displayed before setLayouts to mark the right rectangle as dirty
+  m_scrollableOutputView.setDisplayableCenter(m_calculationDisplayOutput == Calculation::DisplayOutput::ExactAndApproximate || m_calculationDisplayOutput == Calculation::DisplayOutput::ExactAndApproximateToggle);
+  m_scrollableOutputView.setDisplayCenter(m_calculationDisplayOutput == Calculation::DisplayOutput::ExactAndApproximate || m_calculationExpanded);
+  m_scrollableOutputView.setLayouts(Poincare::Layout(), exactOutputLayout, approximateOutputLayout);
   I18n::Message equalMessage = calculation->exactAndApproximateDisplayedOutputsAreEqual(context) == Calculation::EqualSign::Equal ? I18n::Message::Equal : I18n::Message::AlmostEqual;
   m_scrollableOutputView.setEqualMessage(equalMessage);
 
@@ -175,28 +315,47 @@ void HistoryViewCell::didBecomeFirstResponder() {
   assert(m_dataSource);
   if (m_dataSource->selectedSubviewType() == HistoryViewCellDataSource::SubviewType::Input) {
     Container::activeApp()->setFirstResponder(&m_inputView);
-  } else {
+  } else if (m_dataSource->selectedSubviewType() == HistoryViewCellDataSource::SubviewType::Output) {
     Container::activeApp()->setFirstResponder(&m_scrollableOutputView);
   }
 }
 
 bool HistoryViewCell::handleEvent(Ion::Events::Event event) {
-  assert(m_dataSource);
-  if ((event == Ion::Events::Down && m_dataSource->selectedSubviewType() == HistoryViewCellDataSource::SubviewType::Input) ||
-    (event == Ion::Events::Up && m_dataSource->selectedSubviewType() == HistoryViewCellDataSource::SubviewType::Output)) {
-    HistoryViewCellDataSource::SubviewType otherSubviewType = m_dataSource->selectedSubviewType() == HistoryViewCellDataSource::SubviewType::Input ? HistoryViewCellDataSource::SubviewType::Output : HistoryViewCellDataSource::SubviewType::Input;
-    m_dataSource->setSelectedSubviewType(otherSubviewType, this);
-    CalculationSelectableTableView * tableView = (CalculationSelectableTableView *)parentResponder();
-    tableView->scrollToSubviewOfTypeOfCellAtLocation(otherSubviewType, tableView->selectedColumn(), tableView->selectedRow());
-    Container::activeApp()->setFirstResponder(this);
-    return true;
+  assert(m_dataSource != nullptr);
+  HistoryViewCellDataSource::SubviewType type = m_dataSource->selectedSubviewType();
+  assert(type != HistoryViewCellDataSource::SubviewType::None);
+  HistoryViewCellDataSource::SubviewType otherSubviewType = HistoryViewCellDataSource::SubviewType::None;
+  if (m_calculationSingleLine) {
+    static_assert(
+        static_cast<int>(HistoryViewCellDataSource::SubviewType::None) == 0
+        && static_cast<int>(HistoryViewCellDataSource::SubviewType::Input) == 1
+        && static_cast<int>(HistoryViewCellDataSource::SubviewType::Output) == 2
+        && static_cast<int>(HistoryViewCellDataSource::SubviewType::Ellipsis) == 3,
+        "The array types is not well-formed anymore");
+    HistoryViewCellDataSource::SubviewType types[] = {
+      HistoryViewCellDataSource::SubviewType::None,
+      HistoryViewCellDataSource::SubviewType::Input,
+      HistoryViewCellDataSource::SubviewType::Output,
+      displayedEllipsis() ? HistoryViewCellDataSource::SubviewType::Ellipsis : HistoryViewCellDataSource::SubviewType::None,
+      HistoryViewCellDataSource::SubviewType::None,
+    };
+    if (event == Ion::Events::Right || event == Ion::Events::Left) {
+      otherSubviewType = types[static_cast<int>(type) + (event == Ion::Events::Right ? 1 : -1)];
+    }
+  } else if ((event == Ion::Events::Down && type == HistoryViewCellDataSource::SubviewType::Input)
+      || (event == Ion::Events::Left && type == HistoryViewCellDataSource::SubviewType::Ellipsis))
+  {
+    otherSubviewType = HistoryViewCellDataSource::SubviewType::Output;
+  } else if (event == Ion::Events::Up && type == HistoryViewCellDataSource::SubviewType::Output) {
+    otherSubviewType = HistoryViewCellDataSource::SubviewType::Input;
+  } else if (event == Ion::Events::Right && type != HistoryViewCellDataSource::SubviewType::Ellipsis && displayedEllipsis()) {
+    otherSubviewType = HistoryViewCellDataSource::SubviewType::Ellipsis;
   }
-  return false;
-}
-
-bool HistoryViewCell::displayLeftLayout() const {
-  return (m_calculationDisplayOutput == Calculation::DisplayOutput::ExactAndApproximate)
-    || (m_calculationDisplayOutput == Calculation::DisplayOutput::ExactAndApproximateToggle && m_calculationExpanded);
+  if (otherSubviewType == HistoryViewCellDataSource::SubviewType::None) {
+    return false;
+  }
+  m_dataSource->setSelectedSubviewType(otherSubviewType, true);
+  return true;
 }
 
 }

apps/calculation/history_view_cell.h

@@ -3,8 +3,7 @@
 
 #include <escher.h>
 #include "calculation.h"
-#include "scrollable_expression_view.h"
-#include "../shared/scrollable_exact_approximate_expressions_view.h"
+#include "../shared/scrollable_multiple_expressions_view.h"
 
 namespace Calculation {
 
@@ -13,50 +12,71 @@ class HistoryViewCell;
 class HistoryViewCellDataSource {
 public:
   enum class SubviewType {
-    Input,
-    Output
+    None = 0,
+    Input = 1,
+    Output = 2,
+    Ellipsis = 3
   };
-  HistoryViewCellDataSource();
-  void setSelectedSubviewType(SubviewType subviewType, HistoryViewCell * cell = nullptr);
-  SubviewType selectedSubviewType() { return m_selectedSubviewType; }
+  HistoryViewCellDataSource() : m_selectedSubviewType(SubviewType::Output) {}
+  virtual void setSelectedSubviewType(SubviewType subviewType, bool sameCell, int previousSelectedX = -1, int previousSelectedY = -1);
+  SubviewType selectedSubviewType() const { return m_selectedSubviewType; }
 private:
   /* This method should belong to a delegate instead of a data source but as
    * both the data source and the delegate will be the same controller, we
    * avoid keeping 2 pointers in HistoryViewCell. */
-  virtual void historyViewCellDidChangeSelection() = 0;
+  // It returns the selected cell at the end of the method
+  virtual void historyViewCellDidChangeSelection(HistoryViewCell ** cell, HistoryViewCell ** previousCell, int previousSelectedCellX, int previousSelectedCellY, SubviewType type, SubviewType previousType) = 0;
   SubviewType m_selectedSubviewType;
 };
 
 class HistoryViewCell : public ::EvenOddCell, public Responder {
 public:
+  constexpr static KDCoordinate k_margin = Metric::CommonSmallMargin;
+  constexpr static KDCoordinate k_inputOutputViewsVerticalMargin = k_margin;
+  constexpr static KDCoordinate k_inputViewHorizontalMargin = Shared::AbstractScrollableMultipleExpressionsView::k_horizontalMargin;
+  static KDCoordinate Height(Calculation * calculation, bool expanded);
   HistoryViewCell(Responder * parentResponder = nullptr);
-  void cellDidSelectSubview(HistoryViewCellDataSource::SubviewType type);
+  static bool ViewsCanBeSingleLine(KDCoordinate inputViewWidth, KDCoordinate outputViewWidth);
+  void cellDidSelectSubview(HistoryViewCellDataSource::SubviewType type, HistoryViewCellDataSource::SubviewType previousType = HistoryViewCellDataSource::SubviewType::None);
   void setEven(bool even) override;
   void setHighlighted(bool highlight) override;
+  void reloadSubviewHighlight();
   void setDataSource(HistoryViewCellDataSource * dataSource) { m_dataSource = dataSource; }
+  bool displaysSingleLine() const {
+    return m_calculationSingleLine;
+  }
   Responder * responder() override {
     return this;
   }
   Poincare::Layout layout() const override;
-  KDColor backgroundColor() const override;
-  void setCalculation(Calculation * calculation, bool expanded = false);
-  int numberOfSubviews() const override;
+  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(); }
   View * subviewAtIndex(int index) override;
-  void layoutSubviews() override;
+  void layoutSubviews(bool force = false) override;
   void didBecomeFirstResponder() override;
   bool handleEvent(Ion::Events::Event event) override;
-  Shared::ScrollableExactApproximateExpressionsView * outputView();
+  Shared::ScrollableTwoExpressionsView * outputView() { return &m_scrollableOutputView; }
+  ScrollableExpressionView * inputView() { return &m_inputView; }
+  Calculation::AdditionalInformationType additionalInformationType() const { return m_calculationAdditionInformation; }
 private:
   constexpr static KDCoordinate k_resultWidth = 80;
+  void computeSubviewFrames(KDCoordinate frameWidth, KDCoordinate frameHeight, KDRect * ellipsisFrame, KDRect * inputFrame, KDRect * outputFrame);
   void reloadScroll();
-  void reloadOutputSelection();
-  bool displayLeftLayout() const;
+  void reloadOutputSelection(HistoryViewCellDataSource::SubviewType previousType);
+  bool displayedEllipsis() const {
+    return m_highlighted && m_calculationAdditionInformation != Calculation::AdditionalInformationType::None;
+  }
   uint32_t m_calculationCRC32;
   Calculation::DisplayOutput m_calculationDisplayOutput;
-  bool m_calculationExpanded;
+  Calculation::AdditionalInformationType m_calculationAdditionInformation;
   ScrollableExpressionView m_inputView;
-  Shared::ScrollableExactApproximateExpressionsView m_scrollableOutputView;
+  Shared::ScrollableTwoExpressionsView m_scrollableOutputView;
+  EvenOddCellWithEllipsis m_ellipsis;
   HistoryViewCellDataSource * m_dataSource;
+  bool m_calculationExpanded;
+  bool m_calculationSingleLine;
 };
 
 }

apps/calculation/scrollable_expression_view.h

@@ -1,21 +0,0 @@
-#ifndef CALCULATION_SCROLLABLE_EXPRESSION_VIEW_H
-#define CALCULATION_SCROLLABLE_EXPRESSION_VIEW_H
-
-#include <escher.h>
-
-namespace Calculation {
-
-class ScrollableExpressionView : public ScrollableView, public ScrollViewDataSource {
-public:
-  ScrollableExpressionView(Responder * parentResponder);
-  Poincare::Layout layout() const;
-  void setLayout(Poincare::Layout layout);
-  void setBackgroundColor(KDColor backgroundColor) override;
-  void setExpressionBackgroundColor(KDColor backgroundColor);
-private:
-  ExpressionView m_expressionView;
-};
-
-}
-
-#endif

apps/calculation/selectable_table_view.cpp

@@ -1,4 +1,5 @@
 #include "selectable_table_view.h"
+#include <algorithm>
 
 namespace Calculation {
 
@@ -11,30 +12,23 @@ CalculationSelectableTableView::CalculationSelectableTableView(Responder * paren
   setDecoratorType(ScrollView::Decorator::Type::None);
 }
 
+void CalculationSelectableTableView::scrollToBottom() {
+  KDCoordinate contentOffsetX = contentOffset().x();
+  KDCoordinate contentOffsetY = dataSource()->cumulatedHeightFromIndex(dataSource()->numberOfRows()) - maxContentHeightDisplayableWithoutScrolling();
+  setContentOffset(KDPoint(contentOffsetX, contentOffsetY));
+}
+
 void CalculationSelectableTableView::scrollToCell(int i, int j) {
-  ::SelectableTableView::scrollToCell(i, j);
   if (m_contentView.bounds().height() < bounds().height()) {
     setTopMargin(bounds().height() - m_contentView.bounds().height());
   } else {
     setTopMargin(0);
   }
+  ::SelectableTableView::scrollToCell(i, j);
   ScrollView::layoutSubviews();
   if (m_contentView.bounds().height() - contentOffset().y() < bounds().height()) {
-    KDCoordinate contentOffsetX = contentOffset().x();
-    KDCoordinate contentOffsetY = dataSource()->cumulatedHeightFromIndex(dataSource()->numberOfRows()) - maxContentHeightDisplayableWithoutScrolling();
-    setContentOffset(KDPoint(contentOffsetX, contentOffsetY));
-  }
-  if (dataSource()->numberOfRows() > j && dataSource()->numberOfColumns() > i && dataSource()->rowHeight(j) > bounds().height()) {
-    KDCoordinate contentOffsetX = contentOffset().x();
-    KDCoordinate contentOffsetY = contentOffset().y();
-    if (contentOffsetY > dataSource()->cumulatedHeightFromIndex(j) && contentOffsetY > dataSource()->cumulatedHeightFromIndex(j+1)) {
-      // Let's scroll the tableView to align the top of the cell to the top
-      contentOffsetY = dataSource()->cumulatedHeightFromIndex(j);
-    } else {
-      // Let's scroll the tableView to align the bottom of the cell to the bottom
-      contentOffsetY = dataSource()->cumulatedHeightFromIndex(j+1) - maxContentHeightDisplayableWithoutScrolling();
-    }
-    setContentOffset(KDPoint(contentOffsetX, contentOffsetY));
+    // Avoid empty space at the end of the table
+    scrollToBottom();
   }
 }
 
@@ -43,31 +37,66 @@ void CalculationSelectableTableView::scrollToSubviewOfTypeOfCellAtLocation(Histo
     return;
   }
   /* As we scroll, the selected calculation does not use the same history view
-   * cell, thus, we want to deselect the previous used history view cell. */
-  if (selectedRow() >= 0) {
-    HighlightCell * previousCell = selectedCell();
-    previousCell->setHighlighted(false);
-  }
+   * cell, thus, we want to deselect the previous used history view cell. (*) */
+  unhighlightSelectedCell();
+
   /* Main part of the scroll */
+  HistoryViewCell * cell = static_cast<HistoryViewCell *>(selectedCell());
+  assert(cell);
   KDCoordinate contentOffsetX = contentOffset().x();
-  KDCoordinate contentOffsetY = dataSource()->cumulatedHeightFromIndex(j+1) - maxContentHeightDisplayableWithoutScrolling();
-  if (subviewType == HistoryViewCellDataSource::SubviewType::Input) {
-    if (j == 0) {
-      contentOffsetY = 0;
-    } else {
-      contentOffsetY = dataSource()->cumulatedHeightFromIndex(j);
-    }
+
+  KDCoordinate contentOffsetY = dataSource()->cumulatedHeightFromIndex(j);
+  if (cell->displaysSingleLine() && dataSource()->rowHeight(j) > maxContentHeightDisplayableWithoutScrolling()) {
+    /* If we cannot display the full calculation, we display the selected
+     * layout as close as possible to the top of the screen without drawing
+     * empty space between the history and the input field.
+     *
+     * Below are some values we can assign to contentOffsetY, and the kinds of
+     * display they entail :
+     * (the selected cell is at index j)
+     *
+     * 1 - cumulatedHeightFromIndex(j)
+     *   Aligns the top of the cell with the top of the zone in which the
+     *   history can be drawn.
+     *
+     * 2 - (cumulatedHeightFromIndex(j+1)
+     *      - maxContentHeightDisplayableWithoutScrolling())
+     *   Aligns the bottom of the cell with the top of the input field.
+     *
+     * 3 - cumulatedHeightFromIndex(j) + baseline1 - baseline2
+     *   Aligns the top of the selected layout with the top of the screen (only
+     *   used when the selected layout is the smallest).
+     *
+     * The following drawing shows where the calculation would be aligned with
+     * each value of contentOffsetY, for the calculation (1/3)/(4/2) = 1/6.
+     *
+     *        (1)                 (2)                 (3)
+     *  +--------------+    +--------------+    +--------------+
+     *  |  1           |    | ---        - |    |  3         1 |
+     *  |  -           |    |  4         6 |    | ---        - |
+     *  |  3         1 |    |  -           |    |  4         6 |
+     *  | ---        - |    |  2           |    |  -           |
+     *  +--------------+    +--------------+    +--------------+
+     *  | (1/3)/(4/2)  |    | (1/3)/(4/2)  |    | (1/3)/(4/2)  |
+     *  +--------------+    +--------------+    +--------------+
+     *
+     * */
+    contentOffsetY += std::min(
+        dataSource()->rowHeight(j) - maxContentHeightDisplayableWithoutScrolling(),
+        std::max(0, (cell->inputView()->layout().baseline() - cell->outputView()->baseline()) * (subviewType == HistoryViewCellDataSource::SubviewType::Input ? -1 : 1)));
+  } else if (subviewType != HistoryViewCellDataSource::SubviewType::Input) {
+    contentOffsetY += dataSource()->rowHeight(j) - maxContentHeightDisplayableWithoutScrolling();
   }
-  /* For the same reason, we have to rehighlight the new history view cell and
-   * inform the delegate which history view cell is highlighted even if the
-   * selected calculation has not changed. */
+
   setContentOffset(KDPoint(contentOffsetX, contentOffsetY));
-  HighlightCell * cell = cellAtLocation(i, j);
+  /* For the same reason as (*), we have to rehighlight the new history view
+   * cell and reselect the first responder.
+   * We have to recall "selectedCell" because when the table might have been
+   * relayouted in "setContentOffset".*/
+  cell = static_cast<HistoryViewCell *>(selectedCell());
   assert(cell);
   cell->setHighlighted(true);
-  if (m_delegate) {
-    m_delegate->tableViewDidChangeSelection(this, selectedColumn(), selectedRow());
-  }
+  Container::activeApp()->setFirstResponder(cell);
 }
 
 

apps/calculation/selectable_table_view.h

@@ -9,6 +9,7 @@ class CalculationSelectableTableView : public ::SelectableTableView {
 public:
   CalculationSelectableTableView(Responder * parentResponder, TableViewDataSource * dataSource,
     SelectableTableViewDataSource * selectionDataSource, SelectableTableViewDelegate * delegate = nullptr);
+  void scrollToBottom();
   void scrollToCell(int i, int j) override;
   void scrollToSubviewOfTypeOfCellAtLocation(HistoryViewCellDataSource::SubviewType subviewType, int i, int j);
 };

apps/calculation/test.py

@@ -0,0 +1,11 @@
+import sys, tty
+def command_line():
+    tty.setraw(sys.stdin)
+    while True:
+        char = sys.stdin.read(1)
+        if ord(char) == 3: # CTRL-C
+            break;
+        print(ord(char))
+        sys.stdout.write(u"\u001b[1000D") # Move all the way left
+
+command_line();

apps/calculation/test/calculation_store.cpp

@@ -5,112 +5,149 @@
 #include <assert.h>
 #include "../calculation_store.h"
 
+typedef ::Calculation::Calculation::DisplayOutput DisplayOutput;
+typedef ::Calculation::Calculation::EqualSign EqualSign ;
+typedef ::Calculation::Calculation::NumberOfSignificantDigits NumberOfSignificantDigits;
+
 using namespace Poincare;
 using namespace Calculation;
 
+static constexpr int calculationBufferSize = 10 * (sizeof(::Calculation::Calculation) + ::Calculation::Calculation::k_numberOfExpressions * ::Constant::MaxSerializedExpressionSize + sizeof(::Calculation::Calculation *));
+char calculationBuffer[calculationBufferSize];
+
+
 void assert_store_is(CalculationStore * store, const char * * result) {
   for (int i = 0; i < store->numberOfCalculations(); i++) {
     quiz_assert(strcmp(store->calculationAtIndex(i)->inputText(), result[i]) == 0);
   }
 }
 
+KDCoordinate dummyHeight(::Calculation::Calculation * c, bool expanded) { return 0; }
 
 QUIZ_CASE(calculation_store) {
   Shared::GlobalContext globalContext;
-  CalculationStore store;
+  CalculationStore store(calculationBuffer,calculationBufferSize);
   // Store is now {9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
   const char * result[] = {"9", "8", "7", "6", "5", "4", "3", "2", "1", "0"};
   for (int i = 0; i < 10; i++) {
     char text[2] = {(char)(i+'0'), 0};
-    store.push(text, &globalContext);
+    store.push(text, &globalContext, dummyHeight);
     quiz_assert(store.numberOfCalculations() == i+1);
   }
   assert_store_is(&store, result);
 
   for (int i = 9; i > 0; i = i-2) {
-   store.deleteCalculationAtIndex(i);
+    store.deleteCalculationAtIndex(i);
   }
   // Store is now {9, 7, 5, 3, 1}
   const char * result2[] = {"9", "7", "5", "3", "1"};
   assert_store_is(&store, result2);
 
   store.deleteAll();
+
+  // Checking if the store handles correctly the delete of the oldest calculation when full
+  static int minSize = ::Calculation::Calculation::MinimalSize();
+  char text[2] = {'0', 0};
+  while (store.remainingBufferSize() > minSize) {
+    store.push(text, &globalContext, dummyHeight);
+  }
+  int numberOfCalculations1 = store.numberOfCalculations();
+  /* The buffer is now to  full to push a new calculation.
+   * Trying to push a new one should delete the oldest one*/
+  store.push(text, &globalContext, dummyHeight);
+  int numberOfCalculations2 = store.numberOfCalculations();
+  // The numberOfCalculations should be the same
+  quiz_assert(numberOfCalculations1 == numberOfCalculations2);
+  store.deleteAll();
+  quiz_assert(store.remainingBufferSize() == store.bufferSize());
 }
 
 QUIZ_CASE(calculation_ans) {
   Shared::GlobalContext globalContext;
-  CalculationStore store;
+  CalculationStore store(calculationBuffer,calculationBufferSize);
 
-  store.push("1+3/4", &globalContext);
-  store.push("ans+2/3", &globalContext);
+  store.push("1+3/4", &globalContext, dummyHeight);
+  store.push("ans+2/3", &globalContext, dummyHeight);
   Shared::ExpiringPointer<::Calculation::Calculation> lastCalculation = store.calculationAtIndex(0);
-  quiz_assert(lastCalculation->displayOutput(&globalContext) == ::Calculation::Calculation::DisplayOutput::ExactAndApproximate);
+  quiz_assert(lastCalculation->displayOutput(&globalContext) == DisplayOutput::ExactAndApproximate);
   quiz_assert(strcmp(lastCalculation->exactOutputText(),"29/12") == 0);
 
-  store.push("ans+0.22", &globalContext);
+  store.push("ans+0.22", &globalContext, dummyHeight);
   lastCalculation = store.calculationAtIndex(0);
-  quiz_assert(lastCalculation->displayOutput(&globalContext) == ::Calculation::Calculation::DisplayOutput::ExactAndApproximateToggle);
-  quiz_assert(strcmp(lastCalculation->approximateOutputText(),"2.6366666666667") == 0);
+  quiz_assert(lastCalculation->displayOutput(&globalContext) == DisplayOutput::ExactAndApproximateToggle);
+  quiz_assert(strcmp(lastCalculation->approximateOutputText(NumberOfSignificantDigits::Maximal),"2.6366666666667") == 0);
 
   store.deleteAll();
 }
 
-void assertCalculationDisplay(const char * input, ::Calculation::Calculation::DisplayOutput display, ::Calculation::Calculation::EqualSign sign, const char * exactOutput, const char * approximateOutput, Context * context, CalculationStore * store) {
-  store->push(input, context);
+void assertCalculationIs(const char * input, DisplayOutput display, EqualSign sign, const char * exactOutput, const char * displayedApproximateOutput, const char * storedApproximateOutput, Context * context, CalculationStore * store) {
+  store->push(input, context, dummyHeight);
   Shared::ExpiringPointer<::Calculation::Calculation> lastCalculation = store->calculationAtIndex(0);
   quiz_assert(lastCalculation->displayOutput(context) == display);
-  if (sign != ::Calculation::Calculation::EqualSign::Unknown) {
+  if (sign != EqualSign::Unknown) {
     quiz_assert(lastCalculation->exactAndApproximateDisplayedOutputsAreEqual(context) == sign);
   }
   if (exactOutput) {
     quiz_assert_print_if_failure(strcmp(lastCalculation->exactOutputText(), exactOutput) == 0, input);
   }
-  if (approximateOutput) {
-    quiz_assert_print_if_failure(strcmp(lastCalculation->approximateOutputText(), approximateOutput) == 0, input);
+  if (displayedApproximateOutput) {
+    quiz_assert_print_if_failure(strcmp(lastCalculation->approximateOutputText(NumberOfSignificantDigits::UserDefined), displayedApproximateOutput) == 0, input);
+  }
+  if (storedApproximateOutput) {
+    quiz_assert_print_if_failure(strcmp(lastCalculation->approximateOutputText(NumberOfSignificantDigits::Maximal), storedApproximateOutput) == 0, input);
   }
   store->deleteAll();
 }
 
+QUIZ_CASE(calculation_significant_digits) {
+  Shared::GlobalContext globalContext;
+  CalculationStore store(calculationBuffer,calculationBufferSize);
+
+  assertCalculationIs("123456789", DisplayOutput::ExactAndApproximate, EqualSign::Approximation, "123456789", "1.234568ᴇ8", "123456789", &globalContext, &store);
+  assertCalculationIs("1234567", DisplayOutput::ApproximateOnly, EqualSign::Equal, "1234567", "1234567", "1234567", &globalContext, &store);
+
+}
+
 QUIZ_CASE(calculation_display_exact_approximate) {
   Shared::GlobalContext globalContext;
-  CalculationStore store;
+  CalculationStore store(calculationBuffer,calculationBufferSize);
 
-  assertCalculationDisplay("1/2", ::Calculation::Calculation::DisplayOutput::ExactAndApproximate, ::Calculation::Calculation::EqualSign::Equal, nullptr, nullptr, &globalContext, &store);
-  assertCalculationDisplay("1/3", ::Calculation::Calculation::DisplayOutput::ExactAndApproximate, ::Calculation::Calculation::EqualSign::Approximation, nullptr, nullptr, &globalContext, &store);
-  assertCalculationDisplay("1/0", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Unknown, "undef", "undef", &globalContext, &store);
-  assertCalculationDisplay("2x-x", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Unknown, "undef", "undef", &globalContext, &store);
-  assertCalculationDisplay("[[1,2,3]]", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Unknown, nullptr, nullptr, &globalContext, &store);
-  assertCalculationDisplay("[[1,x,3]]", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "undef", &globalContext, &store);
-  assertCalculationDisplay("28^7", ::Calculation::Calculation::DisplayOutput::ExactAndApproximate, ::Calculation::Calculation::EqualSign::Unknown, nullptr, nullptr, &globalContext, &store);
-  assertCalculationDisplay("3+√(2)→a", ::Calculation::Calculation::DisplayOutput::ExactAndApproximate, ::Calculation::Calculation::EqualSign::Approximation, "√(2)+3", nullptr, &globalContext, &store);
+  assertCalculationIs("1/2", DisplayOutput::ExactAndApproximate, EqualSign::Equal, nullptr, nullptr, nullptr, &globalContext, &store);
+  assertCalculationIs("1/3", DisplayOutput::ExactAndApproximate, EqualSign::Approximation, nullptr, nullptr, nullptr, &globalContext, &store);
+  assertCalculationIs("1/0", DisplayOutput::ExactOnly, EqualSign::Unknown, "undef", "undef", "undef", &globalContext, &store);
+  assertCalculationIs("2x-x", DisplayOutput::ExactOnly, EqualSign::Unknown, "x", "undef", "undef", &globalContext, &store);
+  assertCalculationIs("[[1,2,3]]", DisplayOutput::ApproximateOnly, EqualSign::Unknown, nullptr, nullptr, nullptr, &globalContext, &store);
+  assertCalculationIs("[[1,x,3]]", DisplayOutput::ExactAndApproximate, EqualSign::Unknown, nullptr, "[[1,undef,3]]", "[[1,undef,3]]", &globalContext, &store);
+  assertCalculationIs("28^7", DisplayOutput::ExactAndApproximate, EqualSign::Unknown, nullptr, nullptr, nullptr, &globalContext, &store);
+  assertCalculationIs("3+√(2)→a", DisplayOutput::ExactAndApproximate, EqualSign::Approximation, "√(2)+3", nullptr, nullptr, &globalContext, &store);
   Ion::Storage::sharedStorage()->recordNamed("a.exp").destroy();
-  assertCalculationDisplay("3+2→a", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Equal, "5", "5", &globalContext, &store);
+  assertCalculationIs("3+2→a", DisplayOutput::ApproximateOnly, EqualSign::Equal, "5", "5", "5", &globalContext, &store);
   Ion::Storage::sharedStorage()->recordNamed("a.exp").destroy();
-  assertCalculationDisplay("3→a", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Equal, "3", "3", &globalContext, &store);
+  assertCalculationIs("3→a", DisplayOutput::ApproximateOnly, EqualSign::Equal, "3", "3", "3", &globalContext, &store);
   Ion::Storage::sharedStorage()->recordNamed("a.exp").destroy();
-  assertCalculationDisplay("3+x→f(x)", ::Calculation::Calculation::DisplayOutput::ExactOnly, ::Calculation::Calculation::EqualSign::Unknown, "x+3", nullptr, &globalContext, &store);
+  assertCalculationIs("3+x→f(x)", DisplayOutput::ExactOnly, EqualSign::Unknown, "x+3", nullptr, nullptr, &globalContext, &store);
   Ion::Storage::sharedStorage()->recordNamed("f.func").destroy();
-  assertCalculationDisplay("1+1+random()", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Unknown, nullptr, nullptr, &globalContext, &store);
-  assertCalculationDisplay("1+1+round(1.343,2)", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "3.34", &globalContext, &store);
-  assertCalculationDisplay("randint(2,2)+3", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Unknown, "5", "5", &globalContext, &store);
-  assertCalculationDisplay("confidence(0.5,2)+3", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Unknown, nullptr, nullptr, &globalContext, &store);
-  assertCalculationDisplay("prediction(0.5,2)+3", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Unknown, nullptr, nullptr, &globalContext, &store);
-  assertCalculationDisplay("prediction95(0.5,2)+3", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Unknown, nullptr, nullptr, &globalContext, &store);
+  assertCalculationIs("1+1+random()", DisplayOutput::ApproximateOnly, EqualSign::Unknown, nullptr, nullptr, nullptr, &globalContext, &store);
+  assertCalculationIs("1+1+round(1.343,2)", DisplayOutput::ApproximateOnly, EqualSign::Unknown, nullptr, "3.34", "3.34", &globalContext, &store);
+  assertCalculationIs("randint(2,2)+3", DisplayOutput::ApproximateOnly, EqualSign::Unknown, "5", "5", "5", &globalContext, &store);
+  assertCalculationIs("confidence(0.5,2)+3", DisplayOutput::ExactOnly, EqualSign::Unknown, nullptr, nullptr, nullptr, &globalContext, &store);
+  assertCalculationIs("prediction(0.5,2)+3", DisplayOutput::ExactOnly, EqualSign::Unknown, nullptr, nullptr, nullptr, &globalContext, &store);
+  assertCalculationIs("prediction95(0.5,2)+3", DisplayOutput::ExactOnly, EqualSign::Unknown, nullptr, nullptr, nullptr, &globalContext, &store);
 
 }
 
 QUIZ_CASE(calculation_symbolic_computation) {
   Shared::GlobalContext globalContext;
-  CalculationStore store;
+  CalculationStore store(calculationBuffer,calculationBufferSize);
 
-  assertCalculationDisplay("x+x+1+3+√(π)", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Unknown, "undef", "undef", &globalContext, &store);
-  assertCalculationDisplay("f(x)", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Unknown, "undef", "undef", &globalContext, &store);
-  assertCalculationDisplay("1+x→f(x)", ::Calculation::Calculation::DisplayOutput::ExactOnly, ::Calculation::Calculation::EqualSign::Unknown, "x+1", nullptr, &globalContext, &store);
-  assertCalculationDisplay("f(x)", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Unknown, "undef", "undef", &globalContext, &store);
-  assertCalculationDisplay("f(2)", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Equal, "3", "3", &globalContext, &store);
-  assertCalculationDisplay("2→x", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Equal, "2", nullptr, &globalContext, &store);
-  assertCalculationDisplay("f(x)", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Equal, "3", nullptr, &globalContext, &store);
-  assertCalculationDisplay("x+x+1+3+√(π)", ::Calculation::Calculation::DisplayOutput::ExactAndApproximate, ::Calculation::Calculation::EqualSign::Approximation, "√(π)+8", nullptr, &globalContext, &store);
+  assertCalculationIs("x+x+1+3+√(π)", DisplayOutput::ExactOnly, EqualSign::Unknown, "2×x+√(π)+4", "undef", "undef", &globalContext, &store);
+  assertCalculationIs("f(x)", DisplayOutput::ExactOnly, EqualSign::Unknown, "f×x", "undef", "undef", &globalContext, &store);
+  assertCalculationIs("1+x→f(x)", DisplayOutput::ExactOnly, EqualSign::Unknown, "x+1", nullptr, nullptr, &globalContext, &store);
+  assertCalculationIs("f(x)", DisplayOutput::ExactOnly, EqualSign::Unknown, "x+1", "undef", "undef", &globalContext, &store);
+  assertCalculationIs("f(2)", DisplayOutput::ApproximateOnly, EqualSign::Equal, "3", "3", "3", &globalContext, &store);
+  assertCalculationIs("2→x", DisplayOutput::ApproximateOnly, EqualSign::Equal, "2", nullptr, nullptr, &globalContext, &store);
+  assertCalculationIs("f(x)", DisplayOutput::ApproximateOnly, EqualSign::Equal, "3", nullptr, nullptr, &globalContext, &store);
+  assertCalculationIs("x+x+1+3+√(π)", DisplayOutput::ExactAndApproximate, EqualSign::Approximation, "√(π)+8", nullptr, nullptr, &globalContext, &store);
 
   Ion::Storage::sharedStorage()->recordNamed("f.func").destroy();
   Ion::Storage::sharedStorage()->recordNamed("x.exp").destroy();
@@ -118,18 +155,18 @@ QUIZ_CASE(calculation_symbolic_computation) {
 
 QUIZ_CASE(calculation_symbolic_computation_and_parametered_expressions) {
   Shared::GlobalContext globalContext;
-  CalculationStore store;
+  CalculationStore store(calculationBuffer,calculationBufferSize);
 
-  assertCalculationDisplay("int((ℯ^(-x))-x^(0.5), x, 0, 3)", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Unknown, nullptr, nullptr, &globalContext, &store); // Tests a bug with symbolic computation
-  assertCalculationDisplay("int(x,x,0,2)", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "2", &globalContext, &store);
-  assertCalculationDisplay("sum(x,x,0,2)", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "3", &globalContext, &store);
-  assertCalculationDisplay("product(x,x,1,2)", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "2", &globalContext, &store);
-  assertCalculationDisplay("diff(x^2,x,3)", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "6", &globalContext, &store);
-  assertCalculationDisplay("2→x", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Unknown, nullptr, nullptr, &globalContext, &store);
-  assertCalculationDisplay("int(x,x,0,2)", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "2", &globalContext, &store);
-  assertCalculationDisplay("sum(x,x,0,2)", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "3", &globalContext, &store);
-  assertCalculationDisplay("product(x,x,1,2)", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "2", &globalContext, &store);
-  assertCalculationDisplay("diff(x^2,x,3)", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "6", &globalContext, &store);
+  assertCalculationIs("int((ℯ^(-x))-x^(0.5), x, 0, 3)", DisplayOutput::ApproximateOnly, EqualSign::Unknown, nullptr, nullptr, nullptr, &globalContext, &store); // Tests a bug with symbolic computation
+  assertCalculationIs("int(x,x,0,2)", DisplayOutput::ApproximateOnly, EqualSign::Unknown, nullptr, "2", "2", &globalContext, &store);
+  assertCalculationIs("sum(x,x,0,2)", DisplayOutput::ApproximateOnly, EqualSign::Unknown, nullptr, "3", "3", &globalContext, &store);
+  assertCalculationIs("product(x,x,1,2)", DisplayOutput::ApproximateOnly, EqualSign::Unknown, nullptr, "2", "2", &globalContext, &store);
+  assertCalculationIs("diff(x^2,x,3)", DisplayOutput::ApproximateOnly, EqualSign::Unknown, nullptr, "6", "6", &globalContext, &store);
+  assertCalculationIs("2→x", DisplayOutput::ApproximateOnly, EqualSign::Unknown, nullptr, nullptr, nullptr, &globalContext, &store);
+  assertCalculationIs("int(x,x,0,2)", DisplayOutput::ApproximateOnly, EqualSign::Unknown, nullptr, "2", "2", &globalContext, &store);
+  assertCalculationIs("sum(x,x,0,2)", DisplayOutput::ApproximateOnly, EqualSign::Unknown, nullptr, "3", "3", &globalContext, &store);
+  assertCalculationIs("product(x,x,1,2)", DisplayOutput::ApproximateOnly, EqualSign::Unknown, nullptr, "2", "2", &globalContext, &store);
+  assertCalculationIs("diff(x^2,x,3)", DisplayOutput::ApproximateOnly, EqualSign::Unknown, nullptr, "6", "6", &globalContext, &store);
 
   Ion::Storage::sharedStorage()->recordNamed("x.exp").destroy();
 }
@@ -137,34 +174,34 @@ QUIZ_CASE(calculation_symbolic_computation_and_parametered_expressions) {
 
 QUIZ_CASE(calculation_complex_format) {
   Shared::GlobalContext globalContext;
-  CalculationStore store;
+  CalculationStore store(calculationBuffer,calculationBufferSize);
 
   Poincare::Preferences::sharedPreferences()->setComplexFormat(Poincare::Preferences::ComplexFormat::Real);
-  assertCalculationDisplay("1+𝐢", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "1+𝐢", &globalContext, &store);
-  assertCalculationDisplay("√(-1)", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Unknown, "unreal", nullptr, &globalContext, &store);
-  assertCalculationDisplay("ln(-2)", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "unreal", &globalContext, &store);
-  assertCalculationDisplay("√(-1)×√(-1)", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "unreal", &globalContext, &store);
-  assertCalculationDisplay("(-8)^(1/3)", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "-2", &globalContext, &store);
-  assertCalculationDisplay("(-8)^(2/3)", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "4", &globalContext, &store);
-  assertCalculationDisplay("(-2)^(1/4)", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "unreal", &globalContext, &store);
+  assertCalculationIs("1+𝐢", DisplayOutput::ApproximateOnly, EqualSign::Unknown, nullptr, "1+𝐢", "1+𝐢", &globalContext, &store);
+  assertCalculationIs("√(-1)", DisplayOutput::ApproximateOnly, EqualSign::Unknown, "unreal", nullptr, nullptr, &globalContext, &store);
+  assertCalculationIs("ln(-2)", DisplayOutput::ApproximateOnly, EqualSign::Unknown, nullptr, "unreal", "unreal", &globalContext, &store);
+  assertCalculationIs("√(-1)×√(-1)", DisplayOutput::ApproximateOnly, EqualSign::Unknown, nullptr, "unreal", "unreal", &globalContext, &store);
+  assertCalculationIs("(-8)^(1/3)", DisplayOutput::ApproximateOnly, EqualSign::Unknown, nullptr, "-2", "-2", &globalContext, &store);
+  assertCalculationIs("(-8)^(2/3)", DisplayOutput::ApproximateOnly, EqualSign::Unknown, nullptr, "4", "4", &globalContext, &store);
+  assertCalculationIs("(-2)^(1/4)", DisplayOutput::ApproximateOnly, EqualSign::Unknown, nullptr, "unreal", "unreal", &globalContext, &store);
 
   Poincare::Preferences::sharedPreferences()->setComplexFormat(Poincare::Preferences::ComplexFormat::Cartesian);
-  assertCalculationDisplay("1+𝐢", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "1+𝐢", &globalContext, &store);
-  assertCalculationDisplay("√(-1)", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "𝐢", &globalContext, &store);
-  assertCalculationDisplay("ln(-2)", ::Calculation::Calculation::DisplayOutput::ExactAndApproximate, ::Calculation::Calculation::EqualSign::Approximation, "ln(-2)", nullptr, &globalContext, &store);
-  assertCalculationDisplay("√(-1)×√(-1)", ::Calculation::Calculation::DisplayOutput::ApproximateOnly, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "-1", &globalContext, &store);
-  assertCalculationDisplay("(-8)^(1/3)", ::Calculation::Calculation::DisplayOutput::ExactAndApproximate, ::Calculation::Calculation::EqualSign::Approximation, "1+√(3)×𝐢", nullptr, &globalContext, &store);
-  assertCalculationDisplay("(-8)^(2/3)", ::Calculation::Calculation::DisplayOutput::ExactAndApproximate, ::Calculation::Calculation::EqualSign::Approximation, "-2+2×√(3)×𝐢", nullptr, &globalContext, &store);
-  assertCalculationDisplay("(-2)^(1/4)", ::Calculation::Calculation::DisplayOutput::ExactAndApproximate, ::Calculation::Calculation::EqualSign::Approximation, "root(8,4)/2+root(8,4)/2×𝐢", nullptr, &globalContext, &store);
+  assertCalculationIs("1+𝐢", DisplayOutput::ApproximateOnly, EqualSign::Unknown, nullptr, "1+𝐢", "1+𝐢", &globalContext, &store);
+  assertCalculationIs("√(-1)", DisplayOutput::ApproximateOnly, EqualSign::Unknown, nullptr, "𝐢", "𝐢", &globalContext, &store);
+  assertCalculationIs("ln(-2)", DisplayOutput::ExactAndApproximate, EqualSign::Approximation, "ln(-2)", nullptr, nullptr, &globalContext, &store);
+  assertCalculationIs("√(-1)×√(-1)", DisplayOutput::ApproximateOnly, EqualSign::Unknown, nullptr, "-1", "-1", &globalContext, &store);
+  assertCalculationIs("(-8)^(1/3)", DisplayOutput::ExactAndApproximate, EqualSign::Approximation, "1+√(3)×𝐢", nullptr, nullptr, &globalContext, &store);
+  assertCalculationIs("(-8)^(2/3)", DisplayOutput::ExactAndApproximate, EqualSign::Approximation, "-2+2×√(3)×𝐢", nullptr, nullptr, &globalContext, &store);
+  assertCalculationIs("(-2)^(1/4)", DisplayOutput::ExactAndApproximate, EqualSign::Approximation, "root(8,4)/2+root(8,4)/2×𝐢", nullptr, nullptr, &globalContext, &store);
 
   Poincare::Preferences::sharedPreferences()->setComplexFormat(Poincare::Preferences::ComplexFormat::Polar);
-  assertCalculationDisplay("1+𝐢", ::Calculation::Calculation::DisplayOutput::ExactAndApproximate, ::Calculation::Calculation::EqualSign::Approximation, "√(2)×ℯ^\u0012π/4×𝐢\u0013", nullptr, &globalContext, &store);
-  assertCalculationDisplay("√(-1)", ::Calculation::Calculation::DisplayOutput::ExactAndApproximate, ::Calculation::Calculation::EqualSign::Approximation, "ℯ^\u0012π/2×𝐢\u0013", nullptr, &globalContext, &store);
-  assertCalculationDisplay("ln(-2)", ::Calculation::Calculation::DisplayOutput::ExactAndApproximate, ::Calculation::Calculation::EqualSign::Approximation, "ln(-2)", nullptr, &globalContext, &store);
-  assertCalculationDisplay("√(-1)×√(-1)", ::Calculation::Calculation::DisplayOutput::ExactAndApproximate, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "ℯ^\u00123.1415926535898×𝐢\u0013", &globalContext, &store);
-  assertCalculationDisplay("(-8)^(1/3)", ::Calculation::Calculation::DisplayOutput::ExactAndApproximate, ::Calculation::Calculation::EqualSign::Approximation, "2×ℯ^\u0012π/3×𝐢\u0013", nullptr, &globalContext, &store);
-  assertCalculationDisplay("(-8)^(2/3)", ::Calculation::Calculation::DisplayOutput::ExactAndApproximate, ::Calculation::Calculation::EqualSign::Approximation, "4×ℯ^\u0012\u00122×π\u0013/3×𝐢\u0013", nullptr, &globalContext, &store);
-  assertCalculationDisplay("(-2)^(1/4)", ::Calculation::Calculation::DisplayOutput::ExactAndApproximate, ::Calculation::Calculation::EqualSign::Approximation, "root(2,4)×ℯ^\u0012π/4×𝐢\u0013", nullptr, &globalContext, &store);
+  assertCalculationIs("1+𝐢", DisplayOutput::ExactAndApproximate, EqualSign::Approximation, "√(2)×ℯ^\u0012π/4×𝐢\u0013", nullptr, nullptr, &globalContext, &store);
+  assertCalculationIs("√(-1)", DisplayOutput::ExactAndApproximate, EqualSign::Approximation, "ℯ^\u0012π/2×𝐢\u0013", nullptr, nullptr, &globalContext, &store);
+  assertCalculationIs("ln(-2)", DisplayOutput::ExactAndApproximate, EqualSign::Approximation, "ln(-2)", nullptr, nullptr, &globalContext, &store);
+  assertCalculationIs("√(-1)×√(-1)", DisplayOutput::ExactAndApproximate, EqualSign::Unknown, nullptr, "ℯ^\u00123.141593×𝐢\u0013", "ℯ^\u00123.1415926535898×𝐢\u0013", &globalContext, &store);
+  assertCalculationIs("(-8)^(1/3)", DisplayOutput::ExactAndApproximate, EqualSign::Approximation, "2×ℯ^\u0012π/3×𝐢\u0013", nullptr, nullptr, &globalContext, &store);
+  assertCalculationIs("(-8)^(2/3)", DisplayOutput::ExactAndApproximate, EqualSign::Approximation, "4×ℯ^\u0012\u00122×π\u0013/3×𝐢\u0013", nullptr, nullptr, &globalContext, &store);
+  assertCalculationIs("(-2)^(1/4)", DisplayOutput::ExactAndApproximate, EqualSign::Approximation, "root(2,4)×ℯ^\u0012π/4×𝐢\u0013", nullptr, nullptr, &globalContext, &store);
 
   Poincare::Preferences::sharedPreferences()->setComplexFormat(Poincare::Preferences::ComplexFormat::Cartesian);
 }

apps/clock_timer.cpp

@@ -0,0 +1,12 @@
+#include "clock_timer.h"
+#include "apps_container.h"
+
+ClockTimer::ClockTimer(AppsContainer * container) :
+  Timer(1),
+  m_container(container)
+{
+}
+
+bool ClockTimer::fire() {
+  return m_container->updateClock();
+}

apps/clock_timer.h

@@ -0,0 +1,16 @@
+#ifndef APPS_CLOCK_TIMER_H
+#define APPS_CLOCK_TIMER_H
+
+#include <escher.h>
+
+class AppsContainer;
+
+class ClockTimer : public Timer {
+public:
+  ClockTimer(AppsContainer * container);
+private:
+  bool fire() override;
+  AppsContainer * m_container;
+};
+
+#endif

apps/code/Makefile

@@ -1,6 +1,8 @@
 apps += Code::App
 app_headers += apps/code/app.h
 
+SFLAGS += -DHAS_CODE
+
 app_code_src = $(addprefix apps/code/,\
   app.cpp \
   console_controller.cpp \
@@ -11,39 +13,33 @@ app_code_src = $(addprefix apps/code/,\
   editor_view.cpp \
   helpers.cpp \
   menu_controller.cpp \
-  python_toolbox.cpp \
   python_text_area.cpp \
   sandbox_controller.cpp \
-  script.cpp \
   script_name_cell.cpp \
-  script_node_cell.cpp \
   script_parameter_controller.cpp \
+  toolbox_ion_keys.cpp \
+)
+
+app_code_test_src = $(addprefix apps/code/,\
+  python_toolbox.cpp \
+  script.cpp \
+  script_node_cell.cpp \
   script_store.cpp \
   script_template.cpp \
+  variable_box_empty_controller.cpp \
   variable_box_controller.cpp \
 )
 
-app_src += $(app_code_src)
-
-i18n_files += $(addprefix apps/code/,\
-  base.de.i18n\
-  base.en.i18n\
-  base.es.i18n\
-  base.fr.i18n\
-  base.pt.i18n\
-  base.universal.i18n\
-  catalog.de.i18n\
-  catalog.en.i18n\
-  catalog.es.i18n\
-  catalog.fr.i18n\
-  catalog.pt.i18n\
-  catalog.universal.i18n\
-  toolbox.de.i18n\
-  toolbox.en.i18n\
-  toolbox.es.i18n\
-  toolbox.fr.i18n\
-  toolbox.pt.i18n\
-  toolbox.universal.i18n\
+tests_src += $(addprefix apps/code/test/,\
+  variable_box_controller.cpp\
+  toolbox_ion_keys_dummy.cpp \
 )
 
+app_code_src += $(app_code_test_src)
+apps_src += $(app_code_src)
+
+i18n_files += $(call i18n_with_universal_for,code/base)
+i18n_files += $(call i18n_with_universal_for,code/catalog)
+i18n_files += $(call i18n_with_universal_for,code/toolbox)
+
 $(eval $(call depends_on_image,apps/code/app.cpp,apps/code/code_icon.png))

apps/code/app.cpp

@@ -14,6 +14,10 @@ I18n::Message App::Descriptor::upperName() {
   return I18n::Message::CodeAppCapital;
 }
 
+App::Descriptor::ExaminationLevel App::Descriptor::examinationLevel() {
+  return App::Descriptor::ExaminationLevel::Basic;
+}
+
 const Image * App::Descriptor::icon() {
   return ImageStore::CodeIcon;
 }
@@ -21,6 +25,7 @@ const Image * App::Descriptor::icon() {
 App::Snapshot::Snapshot() :
 #if EPSILON_GETOPT
   m_lockOnConsole(false),
+  m_hasBeenWiped(false),
 #endif
   m_scriptStore()
 {
@@ -46,7 +51,11 @@ bool App::Snapshot::lockOnConsole() const {
 
 void App::Snapshot::setOpt(const char * name, const char * value) {
   if (strcmp(name, "script") == 0) {
-    m_scriptStore.deleteAllScripts();
+    if (!m_hasBeenWiped) {
+      m_hasBeenWiped = true;
+      m_scriptStore.deleteAllScripts();
+    }
+  
     char * separator = const_cast<char *>(UTF8Helper::CodePointSearch(value, ':'));
     if (*separator == 0) {
       return;
@@ -61,7 +70,7 @@ void App::Snapshot::setOpt(const char * name, const char * value) {
     const char * scriptContent = separator;
     Code::ScriptTemplate script(scriptName, scriptContent);
     m_scriptStore.addScriptFromTemplate(&script);
-    m_scriptStore.scriptNamed(scriptName).toggleImportationStatus(); // set Importation Status to 1
+    ScriptStore::ScriptNamed(scriptName).toggleAutoimportationStatus(); // set Importation Status to 1
     return;
   }
   if (strcmp(name, "lock-on-console") == 0) {
@@ -80,16 +89,18 @@ App::App(Snapshot * snapshot) :
       , snapshot->lockOnConsole()
 #endif
       ),
-  m_listFooter(&m_codeStackViewController, &m_menuController, &m_menuController, ButtonRowController::Position::Bottom, ButtonRowController::Style::EmbossedGrey, ButtonRowController::Size::Large),
+  m_listFooter(&m_codeStackViewController, &m_menuController, &m_menuController, ButtonRowController::Position::Bottom, ButtonRowController::Style::EmbossedGray, ButtonRowController::Size::Large),
   m_menuController(&m_listFooter, this, snapshot->scriptStore(), &m_listFooter),
   m_codeStackViewController(&m_modalViewController, &m_listFooter),
   m_variableBoxController(snapshot->scriptStore())
 {
+  Clipboard::sharedClipboard()->enterPython();
 }
 
 App::~App() {
   assert(!m_consoleController.inputRunLoopActive());
   deinitPython();
+  Clipboard::sharedClipboard()->exitPython();
 }
 
 bool App::handleEvent(Ion::Events::Event event) {
@@ -105,6 +116,10 @@ bool App::handleEvent(Ion::Events::Event event) {
   return false;
 }
 
+void App::willExitResponderChain(Responder * nextFirstResponder) {
+  m_menuController.willExitApp();
+}
+
 Toolbox * App::toolboxForInputEventHandler(InputEventHandler * textInput) {
   return &m_toolbox;
 }

apps/code/app.h

@@ -9,6 +9,7 @@
 #include "script_store.h"
 #include "python_toolbox.h"
 #include "variable_box_controller.h"
+#include "../shared/shared_app.h"
 
 namespace Code {
 
@@ -18,9 +19,10 @@ public:
   public:
     I18n::Message name() override;
     I18n::Message upperName() override;
+    App::Descriptor::ExaminationLevel examinationLevel() override;
     const Image * icon() override;
   };
-  class Snapshot : public ::App::Snapshot {
+  class Snapshot : public SharedApp::Snapshot {
   public:
     Snapshot();
     App * unpack(Container * container) override;
@@ -33,6 +35,7 @@ public:
   private:
 #if EPSILON_GETOPT
     bool m_lockOnConsole;
+    bool m_hasBeenWiped;
 #endif
     ScriptStore m_scriptStore;
   };
@@ -40,6 +43,7 @@ public:
     return static_cast<App *>(Container::activeApp());
   }
   ~App();
+  TELEMETRY_ID("Code");
   bool prepareForExit() override {
     if (m_consoleController.inputRunLoopActive()) {
       m_consoleController.terminateInputLoop();
@@ -49,9 +53,11 @@ public:
   }
   StackViewController * stackViewController() { return &m_codeStackViewController; }
   ConsoleController * consoleController() { return &m_consoleController; }
+  MenuController * menuController() { return &m_menuController; }
 
   /* Responder */
   bool handleEvent(Ion::Events::Event event) override;
+  void willExitResponderChain(Responder * nextFirstResponder) override;
 
   /* InputEventHandlerDelegate */
   Toolbox * toolboxForInputEventHandler(InputEventHandler * textInput) override;
@@ -68,13 +74,15 @@ public:
   void deinitPython();
 
   VariableBoxController * variableBoxController() { return &m_variableBoxController; }
+
+  static constexpr int k_pythonHeapSize = 67000;
+
 private:
   /* Python delegate:
    * MicroPython requires a heap. To avoid dynamic allocation, we keep a working
    * buffer here and we give to controllers that load Python environment. We
    * also memoize the last Python user to avoid re-initiating MicroPython when
    * unneeded. */
-  static constexpr int k_pythonHeapSize = 32768; // Default value: 16384
   char m_pythonHeap[k_pythonHeapSize];
   const void * m_pythonUser;
 

apps/code/base.de.i18n

@@ -1,8 +1,15 @@
-Console = "Interaktive Konsole"
 AddScript = "Skript hinzufügen"
-ScriptOptions = "Skriptoptionen"
-ExecuteScript = "Skript ausführen"
-AutoImportScript = "Automatischer Import in Konsole"
-DeleteScript = "Skript löschen"
-FunctionsAndVariables = "Funktionen und Variablen"
 AllowedCharactersaz09 = "Erlaubte Zeichen: a-z, 0-9, _"
+Autocomplete = "Autovervollständigung"
+AutoImportScript = "Automatischer Import in die Konsole"
+BuiltinsAndKeywords = "Native Funktionen & Schlüsselwörter"
+Console = "Interaktive Konsole"
+DeleteScript = "Skript löschen"
+DuplicateScript = "Skript duplizieren"
+ExecuteScript = "Skript ausführen"
+FunctionsAndVariables = "Funktionen und Variablen"
+ImportedModulesAndScripts = "Importierte Module und Skripte"
+NoWordAvailableHere = "Hier ist kein Wort verfügbar."
+ScriptInProgress = "Aktuelles Skript"
+ScriptOptions = "Skriptoptionen"
+ScriptSize = "Skriptgröße"

apps/code/base.en.i18n

@@ -1,8 +1,15 @@
-Console = "Python shell"
 AddScript = "Add a script"
-ScriptOptions = "Script options"
-ExecuteScript = "Execute script"
-AutoImportScript = "Auto import in shell"
-DeleteScript = "Delete script"
-FunctionsAndVariables = "Functions and variables"
 AllowedCharactersaz09 = "Allowed characters: a-z, 0-9, _"
+Autocomplete = "Autocomplete"
+AutoImportScript = "Auto import in shell"
+BuiltinsAndKeywords = "Builtins and keywords"
+Console = "Python shell"
+DeleteScript = "Delete script"
+DuplicateScript = "Duplicate script"
+ExecuteScript = "Execute script"
+FunctionsAndVariables = "Functions and variables"
+ImportedModulesAndScripts = "Imported modules and scripts"
+NoWordAvailableHere = "No word available here."
+ScriptInProgress = "Script in progress"
+ScriptOptions = "Script options"
+ScriptSize = "Script size"

apps/code/base.es.i18n

@@ -1,8 +1,15 @@
-Console = "Interprete de comandos"
 AddScript = "Agregar un archivo"
-ScriptOptions = "Opciones del archivo"
-ExecuteScript = "Ejecutar el archivo"
-AutoImportScript = "Importación auto en intérprete"
-DeleteScript = "Eliminar el archivo"
-FunctionsAndVariables = "Funciones y variables"
 AllowedCharactersaz09 = "Caracteres permitidos : a-z, 0-9, _"
+Autocomplete = "Autocompleción"
+AutoImportScript = "Importación auto en intérprete"
+BuiltinsAndKeywords = "Funciones nativas y palabras clave"
+Console = "Interprete de comandos"
+DeleteScript = "Eliminar el archivo"
+DuplicateScript = "Duplicar el guión"
+ExecuteScript = "Ejecutar el archivo"
+FunctionsAndVariables = "Funciones y variables"
+ImportedModulesAndScripts = "Módulos y archivos importados"
+NoWordAvailableHere = "No hay ninguna palabra disponible aquí."
+ScriptInProgress = "Archivo en curso"
+ScriptOptions = "Opciones del archivo"
+ScriptSize = "Tamaño del script"

apps/code/base.fr.i18n

@@ -1,8 +1,15 @@
-Console = "Console d'exécution"
 AddScript = "Ajouter un script"
-ScriptOptions = "Options de script"
-ExecuteScript = "Exécuter le script"
-AutoImportScript = "Importation auto dans la console"
-DeleteScript = "Supprimer le script"
-FunctionsAndVariables = "Fonctions et variables"
 AllowedCharactersaz09 = "Caractères autorisés : a-z, 0-9, _"
+Autocomplete = "Auto-complétion"
+AutoImportScript = "Importation auto dans la console"
+BuiltinsAndKeywords = "Fonctions natives et mots-clés"
+Console = "Console d'exécution"
+DeleteScript = "Supprimer le script"
+DuplicateScript = "Dupliquer le script"
+ExecuteScript = "Exécuter le script"
+FunctionsAndVariables = "Fonctions et variables"
+ImportedModulesAndScripts = "Modules et scripts importés"
+NoWordAvailableHere = "Aucun mot disponible à cet endroit."
+ScriptInProgress = "Script en cours"
+ScriptOptions = "Options de script"
+ScriptSize = "Taille du script"

apps/code/base.hu.i18n

@@ -0,0 +1,15 @@
+AddScript = "Script hozzáadása"
+AllowedCharactersaz09 = "Engedélyezett karakterek: a-z, 0-9, _"
+Autocomplete = "Önkiegészítés"
+AutoImportScript = "Script automata importálása"
+BuiltinsAndKeywords = "Beépített fonkciók és szókincs"
+Console = "Konzol"
+DeleteScript = "Script törlése"
+DuplicateScript = "Script másolása"
+ExecuteScript = "Script indítása"
+FunctionsAndVariables = "Fonktiók és változók"
+ImportedModulesAndScripts = "Importált scriptek és modulok"
+NoWordAvailableHere = "Nincs rendelkezésre álló szó."
+ScriptInProgress = "Script müködésben"
+ScriptOptions = "Script beállítások"
+ScriptSize = "Script mérete"