Ordinary

Ordinary is a compositor and shell written in slint that aims e-paper devices like the remarkable 2 tablet. It is supposed to support more devices but I currently own only the rm2.

I failed to implement wayland myself so I created a custom compositor. If there is someone interested in moving this to wayland please contribute.

Disclaimer

All of this is very much work in progress. Most of the code is in a rough shape and experimental. Make it work, make it right, make it fast... Well I am in the first step.

Any help is very much appreciated.

Motivation

At first I wanted to read an epub with the xochitl and that didn't work. While there are a lot of custom applications for the rm2 I missed having a common desktop, a compositor to properly deal with having multiple apps... and everything feeling like it was meant to exist together.

Installation Instructions

Disclaimer: This will change the launcher application and if something goes wrong you may soft lock your device. You should create an ssh key and copy it to your tablet to be able to revert changes.

You need to install https://github.com/ddvk/remarkable2-framebuffer which means you need toltec. You can start here: https://toltec-dev.org/

Then you can download the latest release of the ordinary store, copy it onto your rm2 and run store init. This will setup ordinary directories and install ordinary and ordinary shell as services that start on boot.

Project Architecture

Ordinary has multiple binaries:

• ordinary: The compositor
• ordinary-shell: The shell UI
• settings: The default settings app
• reader: The default reader app
• writer: The default notes app
• keyboard: The on-screen keyboard
• companion: A companion app that allows file management, screen cast (todo) and remote control
• remote: Use your tablet as remote pen input device for your PC.
• wrapp: A Wrapper that allows to run any app as full screen app.

Ordinary (compositor)

The compositor creats a unix socket. Clients connect to this via the binary protocol specified in ordinary/src/protocol.rs. After connection a client requests a "surface" to draw to. The wording is stolen from wayland but here it is just the rectangle size the client is allowed to draw to.

Each ordinary client (e.g. an app) creates a shared memory frame in the provided surface size to render into. They notify to ordinary when they rendered and ordinary composes the clients frames.

Input events are collected in ordinary and sent to the clients they relate to.

Currently ordinary only supports a single fullscreen app but it will reduce the apps surface size when the keyboard is shown.

All files of ordinary or its apps are located inside the ordinary root folder. The folder is identified by the env var ORDINARY.

Regarding Wayland

I failed to understand how to implement wayland. I wanted to implement ordinary and I got stuck on wayland until I dropped it. If there is anyone who likes to replace my custom protocol with wayland I would be very happy to support and thankfull for that help.

Ordinary Shell

The Ordinary Shell is based on Gnomes design. It features a header bar with basic information and a quick access popup.

The shell includes a dasktop with folders and files. The desktop can have multiple pages.

Ordinary Settings

The settings app allows to control device settings. Its UI is based on gnome-settings: A sidebar with categories and each category contains multiple settings. The settings are not hard coded but provided .toml files located in /settings.

All settings are defined in a toml format like this:

[setting.my-category]
# Categories always need an icon
icon = "settings"
# This is shown as category in the UI
label = "My Category"

[setting.my-category.my-setting]

# Shows the title/name/label of the setting. Can be omitted to create 'hidden' settings.
label = "My Setting"

# Optional: describing text
text = "This text is optionial"

# The current value of the setting
value = true

On screen keyboard

Very basic ATM but it works.

Ordinary Reader

Ebooks and comics in epub (3) format can be viewed in 3 different font sizes. You can click on words to look it up in a dictionary. You must copy a dictionary .index and .dict.dz file into <ORDINARY HOME>/apps/reader. You can find dictionaries here: https://freedict.org/downloads/#gnu/linux.

The latest position of the book is saved in <ORDINARY HOME>/apps/reader/books.toml.

Ordinary Writer

A simple note taking app exists. The notes are written directly into .notes files. These are just 4 byte RGBA binary image files with a 1024 byte header.

Client framework

When building as lib ordinary provides all glue code and framework to create apps for ordinary using slint.

Companion App

There is a basic companion App. It allows to manage files on the desktop: Uploading, (bulk) delete, etc.

More operations are planned. A view to stream the tablet contents is a major one.

Remote control

With the remote app you can control the mouse cursor of your PC. This requires the companion app to be opened.

Wrapp

Using the wrapp utility you can use any app with ordinary. The app will be in fullscreen mode and must provide its own way to exit the process. For example you can add koreader to ordinary by placing this file in ordinary/desktop:

[Desktop Entry]
Name = koreader
Exec = wrapp --command opt/koreader/koreader
Icon=/opt/koreader/resources/koreader.png

UI library

The directory /uilib contains the slint files you can use to create your app.

TODO: Install via cargo

Icons

Ordinary uses the GTK symbolic icon set.

Template project

TODO: Currently there is no template project but by looking at the reader or settings apps you can see how to create your own app