Revert merging of server and client repository

src/backend/client/ensembles.rs

@@ -0,0 +1,18 @@
+use super::Backend;
+use crate::database::Ensemble;
+use anyhow::Result;
+
+impl Backend {
+    /// Get all available ensembles from the server.
+    pub async fn get_ensembles(&self) -> Result<Vec<Ensemble>> {
+        let body = self.get("ensembles").await?;
+        let ensembles: Vec<Ensemble> = serde_json::from_str(&body)?;
+        Ok(ensembles)
+    }
+
+    /// Post a new ensemble to the server.
+    pub async fn post_ensemble(&self, data: &Ensemble) -> Result<()> {
+        self.post("ensembles", serde_json::to_string(data)?).await?;
+        Ok(())
+    }
+}

src/backend/client/instruments.rs

@@ -0,0 +1,18 @@
+use super::Backend;
+use crate::database::Instrument;
+use anyhow::Result;
+
+impl Backend {
+    /// Get all available instruments from the server.
+    pub async fn get_instruments(&self) -> Result<Vec<Instrument>> {
+        let body = self.get("instruments").await?;
+        let instruments: Vec<Instrument> = serde_json::from_str(&body)?;
+        Ok(instruments)
+    }
+
+    /// Post a new instrument to the server.
+    pub async fn post_instrument(&self, data: &Instrument) -> Result<()> {
+        self.post("instruments", serde_json::to_string(data)?).await?;
+        Ok(())
+    }
+}

src/backend/client/mod.rs

@@ -0,0 +1,170 @@
+use super::secure;
+use super::Backend;
+use anyhow::{anyhow, bail, Result};
+use gio::prelude::*;
+use isahc::http::StatusCode;
+use isahc::prelude::*;
+use serde::Serialize;
+use std::time::Duration;
+
+pub mod ensembles;
+pub use ensembles::*;
+
+pub mod instruments;
+pub use instruments::*;
+
+pub mod persons;
+pub use persons::*;
+
+pub mod recordings;
+pub use recordings::*;
+
+pub mod works;
+pub use works::*;
+
+/// Credentials used for login.
+#[derive(Serialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct LoginData {
+    pub username: String,
+    pub password: String,
+}
+
+impl Backend {
+    /// Initialize the client.
+    pub(super) fn init_client(&self) -> Result<()> {
+        if let Some(data) = secure::load_login_data()? {
+            self.login_data.replace(Some(data));
+        }
+
+        if let Some(url) = self.settings.get_string("server-url") {
+            if !url.is_empty() {
+                self.server_url.replace(Some(url.to_string()));
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Set the URL of the Musicus server to connect to.
+    pub fn set_server_url(&self, url: &str) -> Result<()> {
+        self.settings.set_string("server-url", url)?;
+        self.server_url.replace(Some(url.to_string()));
+        Ok(())
+    }
+
+    /// Get the currently used login token.
+    pub fn get_token(&self) -> Option<String> {
+        self.token.borrow().clone()
+    }
+
+    /// Set the login token to use. This will be done automatically by the login method.
+    pub fn set_token(&self, token: &str) {
+        self.token.replace(Some(token.to_string()));
+    }
+
+    /// Get the currently set server URL.
+    pub fn get_server_url(&self) -> Option<String> {
+        self.server_url.borrow().clone()
+    }
+
+    /// Get the currently stored login credentials.
+    pub fn get_login_data(&self) -> Option<LoginData> {
+        self.login_data.borrow().clone()
+    }
+
+    /// Set the user credentials to use.
+    pub async fn set_login_data(&self, data: LoginData) -> Result<()> {
+        secure::store_login_data(data.clone()).await?;
+        self.login_data.replace(Some(data));
+        self.token.replace(None);
+        Ok(())
+    }
+
+    /// Try to login a user with the provided credentials and return, wether the login suceeded.
+    pub async fn login(&self) -> Result<bool> {
+        let server_url = self.get_server_url().ok_or(anyhow!("No server URL set!"))?;
+        let data = self.get_login_data().ok_or(anyhow!("No login data set!"))?;
+
+        let request = Request::post(format!("{}/login", server_url))
+            .timeout(Duration::from_secs(10))
+            .header("Content-Type", "application/json")
+            .body(serde_json::to_string(&data)?)?;
+
+        let mut response = isahc::send_async(request).await?;
+
+        let success = match response.status() {
+            StatusCode::OK => {
+                let token = response.text_async().await?;
+                self.set_token(&token);
+                true
+            }
+            StatusCode::UNAUTHORIZED => false,
+            _ => bail!("Unexpected response status!"),
+        };
+
+        Ok(success)
+    }
+
+    /// Make an unauthenticated get request to the server.
+    async fn get(&self, url: &str) -> Result<String> {
+        let server_url = self.get_server_url().ok_or(anyhow!("No server URL set!"))?;
+
+        let mut response = Request::get(format!("{}/{}", server_url, url))
+            .timeout(Duration::from_secs(10))
+            .body(())?
+            .send_async()
+            .await?;
+
+        let body = response.text_async().await?;
+
+        Ok(body)
+    }
+
+    /// Make an authenticated post request to the server.
+    async fn post(&self, url: &str, body: String) -> Result<String> {
+        let body = match self.get_token() {
+            Some(_) => {
+                let mut response = self.post_priv(url, body.clone()).await?;
+
+                // Try one more time (maybe the token was expired)
+                if response.status() == StatusCode::UNAUTHORIZED {
+                    if self.login().await? {
+                        response = self.post_priv(url, body).await?;
+                    } else {
+                        bail!("Login failed!");
+                    }
+                }
+
+                response.text_async().await?
+            }
+            None => {
+                let mut response = if self.login().await? {
+                    self.post_priv(url, body).await?
+                } else {
+                    bail!("Login failed!");
+                };
+
+                response.text_async().await?
+            }
+        };
+
+        Ok(body)
+    }
+
+    /// Post something to the server assuming there is a valid login token.
+    async fn post_priv(&self, url: &str, body: String) -> Result<Response<Body>> {
+        let server_url = self.get_server_url().ok_or(anyhow!("No server URL set!"))?;
+        let token = self.get_token().ok_or(anyhow!("No login token!"))?;
+
+        let response = Request::post(format!("{}/{}", server_url, url))
+            .timeout(Duration::from_secs(10))
+            .header("Authorization", format!("Bearer {}", token))
+            .header("Content-Type", "application/json")
+            .body(body)?
+            .send_async()
+            .await?;
+
+        Ok(response)
+    }
+}

src/backend/client/persons.rs

@@ -0,0 +1,18 @@
+use super::Backend;
+use crate::database::Person;
+use anyhow::Result;
+
+impl Backend {
+    /// Get all available persons from the server.
+    pub async fn get_persons(&self) -> Result<Vec<Person>> {
+        let body = self.get("persons").await?;
+        let persons: Vec<Person> = serde_json::from_str(&body)?;
+        Ok(persons)
+    }
+
+    /// Post a new person to the server.
+    pub async fn post_person(&self, data: &Person) -> Result<()> {
+        self.post("persons", serde_json::to_string(data)?).await?;
+        Ok(())
+    }
+}

src/backend/client/recordings.rs

@@ -0,0 +1,18 @@
+use super::Backend;
+use crate::database::Recording;
+use anyhow::Result;
+
+impl Backend {
+    /// Get all available recordings from the server.
+    pub async fn get_recordings_for_work(&self, work_id: &str) -> Result<Vec<Recording>> {
+        let body = self.get(&format!("works/{}/recordings", work_id)).await?;
+        let recordings: Vec<Recording> = serde_json::from_str(&body)?;
+        Ok(recordings)
+    }
+
+    /// Post a new recording to the server.
+    pub async fn post_recording(&self, data: &Recording) -> Result<()> {
+        self.post("recordings", serde_json::to_string(data)?).await?;
+        Ok(())
+    }
+}

src/backend/client/works.rs

@@ -0,0 +1,18 @@
+use super::Backend;
+use crate::database::Work;
+use anyhow::Result;
+
+impl Backend {
+    /// Get all available works from the server.
+    pub async fn get_works(&self, composer_id: &str) -> Result<Vec<Work>> {
+        let body = self.get(&format!("persons/{}/works", composer_id)).await?;
+        let works: Vec<Work> = serde_json::from_str(&body)?;
+        Ok(works)
+    }
+
+    /// Post a new work to the server.
+    pub async fn post_work(&self, data: &Work) -> Result<()> {
+        self.post("works", serde_json::to_string(data)?).await?;
+        Ok(())
+    }
+}

src/backend/library.rs

@@ -0,0 +1,83 @@
+use super::{Backend, BackendState};
+use crate::database::DbThread;
+use crate::player::Player;
+use anyhow::Result;
+use gio::prelude::*;
+use std::path::PathBuf;
+use std::rc::Rc;
+
+impl Backend {
+    /// Initialize the music library if it is set in the settings.
+    pub(super) async fn init_library(&self) -> Result<()> {
+        if let Some(path) = self.settings.get_string("music-library-path") {
+            if !path.is_empty() {
+                self.set_music_library_path_priv(PathBuf::from(path.to_string()))
+                    .await?;
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Set the path to the music library folder and start a database thread in the background.
+    pub async fn set_music_library_path(&self, path: PathBuf) -> Result<()> {
+        self.settings
+            .set_string("music-library-path", path.to_str().unwrap())?;
+        self.set_music_library_path_priv(path).await
+    }
+
+    /// Set the path to the music library folder and start a database thread in the background.
+    pub async fn set_music_library_path_priv(&self, path: PathBuf) -> Result<()> {
+        self.set_state(BackendState::Loading);
+
+        if let Some(db) = &*self.database.borrow() {
+            db.stop().await?;
+        }
+
+        self.music_library_path.replace(Some(path.clone()));
+
+        let mut db_path = path.clone();
+        db_path.push("musicus.db");
+
+        let database = DbThread::new(db_path.to_str().unwrap().to_string()).await?;
+        self.database.replace(Some(Rc::new(database)));
+
+        let player = Player::new(path);
+        self.player.replace(Some(player));
+
+        self.set_state(BackendState::Ready);
+
+        Ok(())
+    }
+
+    /// Get the currently set music library path.
+    pub fn get_music_library_path(&self) -> Option<PathBuf> {
+        self.music_library_path.borrow().clone()
+    }
+
+    /// Get an interface to the current music library database.
+    pub fn get_database(&self) -> Option<Rc<DbThread>> {
+        self.database.borrow().clone()
+    }
+
+    /// Get an interface to the database and panic if there is none.
+    pub fn db(&self) -> Rc<DbThread> {
+        self.get_database().unwrap()
+    }
+
+    /// Get an interface to the playback service.
+    pub fn get_player(&self) -> Option<Rc<Player>> {
+        self.player.borrow().clone()
+    }
+
+    /// Notify the frontend that the library was changed.
+    pub fn library_changed(&self) {
+        self.set_state(BackendState::Loading);
+        self.set_state(BackendState::Ready);
+    }
+
+    /// Get an interface to the player and panic if there is none.
+    pub fn pl(&self) -> Rc<Player> {
+        self.get_player().unwrap()
+    }
+}

src/backend/mod.rs

@@ -0,0 +1,76 @@
+use crate::database::DbThread;
+use crate::player::Player;
+use anyhow::Result;
+use futures_channel::mpsc;
+use std::cell::RefCell;
+use std::path::PathBuf;
+use std::rc::Rc;
+
+pub mod client;
+pub use client::*;
+
+pub mod library;
+pub use library::*;
+
+mod secure;
+
+/// General states the application can be in.
+pub enum BackendState {
+    /// The backend is not set up yet. This means that no backend methods except for setting the
+    /// music library path should be called. The user interface should adapt and only present this
+    /// option.
+    NoMusicLibrary,
+
+    /// The backend is loading the music library. No methods should be called. The user interface
+    /// should represent that state by prohibiting all interaction.
+    Loading,
+
+    /// The backend is ready and all methods may be called.
+    Ready,
+}
+
+/// A collection of all backend state and functionality.
+pub struct Backend {
+    pub state_stream: RefCell<mpsc::Receiver<BackendState>>,
+    state_sender: RefCell<mpsc::Sender<BackendState>>,
+    settings: gio::Settings,
+    music_library_path: RefCell<Option<PathBuf>>,
+    database: RefCell<Option<Rc<DbThread>>>,
+    player: RefCell<Option<Rc<Player>>>,
+    server_url: RefCell<Option<String>>,
+    login_data: RefCell<Option<LoginData>>,
+    token: RefCell<Option<String>>,
+}
+
+impl Backend {
+    /// Create a new backend initerface. The user interface should subscribe to the state stream
+    /// and call init() afterwards.
+    pub fn new() -> Self {
+        let (state_sender, state_stream) = mpsc::channel(1024);
+
+        Backend {
+            state_stream: RefCell::new(state_stream),
+            state_sender: RefCell::new(state_sender),
+            settings: gio::Settings::new("de.johrpan.musicus"),
+            music_library_path: RefCell::new(None),
+            database: RefCell::new(None),
+            player: RefCell::new(None),
+            server_url: RefCell::new(None),
+            login_data: RefCell::new(None),
+            token: RefCell::new(None),
+        }
+    }
+
+    /// Initialize the backend updating the state accordingly.
+    pub async fn init(self: Rc<Backend>) -> Result<()> {
+        self.init_library().await?;
+        self.init_client()?;
+
+        Ok(())
+    }
+
+    /// Set the current state and notify the user interface.
+    fn set_state(&self, state: BackendState) {
+        self.state_sender.borrow_mut().try_send(state).unwrap();
+    }
+}

src/backend/secure.rs

@@ -0,0 +1,108 @@
+use super::LoginData;
+use anyhow::{anyhow, Result};
+use futures_channel::oneshot;
+use secret_service::{Collection, EncryptionType, SecretService};
+
+/// Savely store the user's current login credentials.
+pub async fn store_login_data(data: LoginData) -> Result<()> {
+    let (sender, receiver) = oneshot::channel::<Result<()>>();
+    std::thread::spawn(move || sender.send(store_login_data_priv(data)));
+    receiver.await?
+}
+
+/// Savely store the user's current login credentials.
+fn store_login_data_priv(data: LoginData) -> Result<()> {
+    let ss = get_ss()?;
+    let collection = get_collection(&ss)?;
+
+    let key = "musicus-login-data";
+    delete_secrets(&collection, key)?;
+
+    collection
+        .create_item(
+            key,
+            vec![("username", &data.username)],
+            data.password.as_bytes(),
+            true,
+            "text/plain",
+        )
+        .or(Err(anyhow!(
+            "Failed to save login data using SecretService!"
+        )))?;
+
+    Ok(())
+}
+
+/// Get the login credentials from secret storage.
+pub fn load_login_data() -> Result<Option<LoginData>> {
+    let ss = get_ss()?;
+    let collection = get_collection(&ss)?;
+
+    let items = collection.get_all_items().or(Err(anyhow!(
+        "Failed to get items from SecretService collection!"
+    )))?;
+
+    let key = "musicus-login-data";
+    let item = items
+        .iter()
+        .find(|item| item.get_label().unwrap_or_default() == key);
+
+    Ok(match item {
+        Some(item) => {
+            let attrs = item.get_attributes().or(Err(anyhow!(
+                "Failed to get attributes for ScretService item!"
+            )))?;
+
+            let username = attrs
+                .iter()
+                .find(|attr| attr.0 == "username")
+                .ok_or(anyhow!("No username in login data!"))?
+                .1
+                .clone();
+
+            let password = std::str::from_utf8(
+                &item
+                    .get_secret()
+                    .or(Err(anyhow!("Failed to get secret from SecretService!")))?,
+            )?
+            .to_string();
+
+            Some(LoginData { username, password })
+        }
+        None => None,
+    })
+}
+
+/// Delete all stored secrets for the provided key.
+fn delete_secrets(collection: &Collection, key: &str) -> Result<()> {
+    let items = collection.get_all_items().or(Err(anyhow!(
+        "Failed to get items from SecretService collection!"
+    )))?;
+
+    for item in items {
+        if item.get_label().unwrap_or_default() == key {
+            item.delete()
+                .or(Err(anyhow!("Failed to delete SecretService item!")))?;
+        }
+    }
+
+    Ok(())
+}
+
+/// Get the SecretService interface.
+fn get_ss() -> Result<SecretService> {
+    SecretService::new(EncryptionType::Dh).or(Err(anyhow!("Failed to get SecretService!")))
+}
+
+/// Get the default SecretService collection and unlock it.
+fn get_collection(ss: &SecretService) -> Result<Collection> {
+    let collection = ss
+        .get_default_collection()
+        .or(Err(anyhow!("Failed to get SecretService connection!")))?;
+
+    collection
+        .unlock()
+        .or(Err(anyhow!("Failed to unclock SecretService collection!")))?;
+
+    Ok(collection)
+}

src/config.rs.in

@@ -0,0 +1,2 @@
+pub static VERSION: &str = @VERSION@;
+pub static LOCALEDIR: &str = @LOCALEDIR@;

src/database/ensembles.rs

@@ -0,0 +1,53 @@
+use super::schema::ensembles;
+use super::Database;
+use anyhow::Result;
+use diesel::prelude::*;
+use serde::{Deserialize, Serialize};
+
+/// An ensemble that takes part in recordings.
+#[derive(Serialize, Deserialize, Insertable, Queryable, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct Ensemble {
+    pub id: String,
+    pub name: String,
+}
+
+impl Database {
+    /// Update an existing ensemble or insert a new one.
+    pub fn update_ensemble(&self, ensemble: Ensemble) -> Result<()> {
+        self.defer_foreign_keys()?;
+
+        self.connection.transaction(|| {
+            diesel::replace_into(ensembles::table)
+                .values(ensemble)
+                .execute(&self.connection)
+        })?;
+
+        Ok(())
+    }
+
+    /// Get an existing ensemble.
+    pub fn get_ensemble(&self, id: &str) -> Result<Option<Ensemble>> {
+        let ensemble = ensembles::table
+            .filter(ensembles::id.eq(id))
+            .load::<Ensemble>(&self.connection)?
+            .into_iter()
+            .next();
+
+        Ok(ensemble)
+    }
+
+    /// Delete an existing ensemble.
+    pub fn delete_ensemble(&self, id: &str) -> Result<()> {
+        diesel::delete(ensembles::table.filter(ensembles::id.eq(id))).execute(&self.connection)?;
+
+        Ok(())
+    }
+
+    /// Get all existing ensembles.
+    pub fn get_ensembles(&self) -> Result<Vec<Ensemble>> {
+        let ensembles = ensembles::table.load::<Ensemble>(&self.connection)?;
+
+        Ok(ensembles)
+    }
+}

src/database/instruments.rs

@@ -0,0 +1,54 @@
+use super::schema::instruments;
+use super::Database;
+use anyhow::Result;
+use diesel::prelude::*;
+use serde::{Deserialize, Serialize};
+
+/// An instrument or any other possible role within a recording.
+#[derive(Serialize, Deserialize, Insertable, Queryable, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct Instrument {
+    pub id: String,
+    pub name: String,
+}
+
+impl Database {
+    /// Update an existing instrument or insert a new one.
+    pub fn update_instrument(&self, instrument: Instrument) -> Result<()> {
+        self.defer_foreign_keys()?;
+
+        self.connection.transaction(|| {
+            diesel::replace_into(instruments::table)
+                .values(instrument)
+                .execute(&self.connection)
+        })?;
+
+        Ok(())
+    }
+
+    /// Get an existing instrument.
+    pub fn get_instrument(&self, id: &str) -> Result<Option<Instrument>> {
+        let instrument = instruments::table
+            .filter(instruments::id.eq(id))
+            .load::<Instrument>(&self.connection)?
+            .into_iter()
+            .next();
+
+        Ok(instrument)
+    }
+
+    /// Delete an existing instrument.
+    pub fn delete_instrument(&self, id: &str) -> Result<()> {
+        diesel::delete(instruments::table.filter(instruments::id.eq(id)))
+            .execute(&self.connection)?;
+
+        Ok(())
+    }
+
+    /// Get all existing instruments.
+    pub fn get_instruments(&self) -> Result<Vec<Instrument>> {
+        let instruments = instruments::table.load::<Instrument>(&self.connection)?;
+
+        Ok(instruments)
+    }
+}

src/database/medium.rs

@@ -0,0 +1,254 @@
+use super::generate_id;
+use super::schema::{mediums, recordings, track_sets, tracks};
+use super::{Database, Recording};
+use anyhow::{anyhow, Error, Result};
+use diesel::prelude::*;
+use serde::{Deserialize, Serialize};
+
+/// Representation of someting like a physical audio disc or a folder with
+/// audio files (i.e. a collection of tracks for one or more recordings).
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct Medium {
+    /// An unique ID for the medium.
+    pub id: String,
+
+    /// The human identifier for the medium.
+    pub name: String,
+
+    /// If applicable, the MusicBrainz DiscID.
+    pub discid: Option<String>,
+
+    /// The tracks of the medium, grouped by recording.
+    pub tracks: Vec<TrackSet>,
+}
+
+/// A set of tracks of one recording within a medium.
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct TrackSet {
+    /// The recording to which the tracks belong.
+    pub recording: Recording,
+
+    /// The actual tracks.
+    pub tracks: Vec<Track>,
+}
+
+/// A track within a recording on a medium.
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct Track {
+    /// The work parts that are played on this track. They are indices to the
+    /// work parts of the work that is associated with the recording.
+    pub work_parts: Vec<usize>,
+
+    /// The path to the audio file containing this track. This will not be
+    /// included when communicating with the server.
+    #[serde(skip)]
+    pub path: String,
+}
+
+/// Table data for a [`Medium`].
+#[derive(Insertable, Queryable, Debug, Clone)]
+#[table_name = "mediums"]
+struct MediumRow {
+    pub id: String,
+    pub name: String,
+    pub discid: Option<String>,
+}
+
+/// Table data for a [`TrackSet`].
+#[derive(Insertable, Queryable, Debug, Clone)]
+#[table_name = "track_sets"]
+struct TrackSetRow {
+    pub id: String,
+    pub medium: String,
+    pub index: i32,
+    pub recording: String,
+}
+
+/// Table data for a [`Track`].
+#[derive(Insertable, Queryable, Debug, Clone)]
+#[table_name = "tracks"]
+struct TrackRow {
+    pub id: String,
+    pub track_set: String,
+    pub index: i32,
+    pub work_parts: String,
+    pub path: String,
+}
+
+impl Database {
+    /// Update an existing medium or insert a new one.
+    pub fn update_medium(&self, medium: Medium) -> Result<()> {
+        self.defer_foreign_keys()?;
+
+        self.connection.transaction::<(), Error, _>(|| {
+            let medium_id = &medium.id;
+
+            // This will also delete the track sets and tracks.
+            self.delete_medium(medium_id)?;
+
+            // Add the new medium.
+
+            let medium_row = MediumRow {
+                id: medium_id.to_owned(),
+                name: medium.name.clone(),
+                discid: medium.discid.clone(),
+            };
+
+            diesel::insert_into(mediums::table)
+                .values(medium_row)
+                .execute(&self.connection)?;
+
+            for (index, track_set) in medium.tracks.iter().enumerate() {
+                // Add associated items from the server, if they don't already
+                // exist.
+
+                if self.get_recording(&track_set.recording.id)?.is_none() {
+                    self.update_recording(track_set.recording.clone())?;
+                }
+
+                // Add the actual track set data.
+
+                let track_set_id = generate_id();
+
+                let track_set_row = TrackSetRow {
+                    id: track_set_id.clone(),
+                    medium: medium_id.to_owned(),
+                    index: index as i32,
+                    recording: track_set.recording.id.clone(),
+                };
+
+                diesel::insert_into(track_sets::table)
+                    .values(track_set_row)
+                    .execute(&self.connection)?;
+
+                for (index, track) in track_set.tracks.iter().enumerate() {
+                    let work_parts = track
+                        .work_parts
+                        .iter()
+                        .map(|part_index| part_index.to_string())
+                        .collect::<Vec<String>>()
+                        .join(",");
+
+                    let track_row = TrackRow {
+                        id: generate_id(),
+                        track_set: track_set_id.clone(),
+                        index: index as i32,
+                        work_parts,
+                        path: track.path.clone(),
+                    };
+
+                    diesel::insert_into(tracks::table)
+                        .values(track_row)
+                        .execute(&self.connection)?;
+                }
+            }
+
+            Ok(())
+        })?;
+
+        Ok(())
+    }
+
+    /// Get an existing medium.
+    pub fn get_medium(&self, id: &str) -> Result<Option<Medium>> {
+        let row = mediums::table
+            .filter(mediums::id.eq(id))
+            .load::<MediumRow>(&self.connection)?
+            .into_iter()
+            .next();
+
+        let medium = match row {
+            Some(row) => Some(self.get_medium_data(row)?),
+            None => None,
+        };
+
+        Ok(medium)
+    }
+
+    /// Delete a medium and all of its tracks. This will fail, if the music
+    /// library contains audio files referencing any of those tracks.
+    pub fn delete_medium(&self, id: &str) -> Result<()> {
+        diesel::delete(mediums::table.filter(mediums::id.eq(id))).execute(&self.connection)?;
+        Ok(())
+    }
+
+    /// Get all available track sets for a recording.
+    pub fn get_track_sets(&self, recording_id: &str) -> Result<Vec<TrackSet>> {
+        let mut track_sets: Vec<TrackSet> = Vec::new();
+
+        let rows = track_sets::table
+            .inner_join(recordings::table.on(recordings::id.eq(track_sets::recording)))
+            .filter(recordings::id.eq(recording_id))
+            .select(track_sets::table::all_columns())
+            .load::<TrackSetRow>(&self.connection)?;
+
+        for row in rows {
+            let track_set = self.get_track_set_from_row(row)?;
+            track_sets.push(track_set);
+        }
+
+        Ok(track_sets)
+    }
+
+    /// Retrieve all available information on a medium from related tables.
+    fn get_medium_data(&self, row: MediumRow) -> Result<Medium> {
+        let track_set_rows = track_sets::table
+            .filter(track_sets::medium.eq(&row.id))
+            .order_by(track_sets::index)
+            .load::<TrackSetRow>(&self.connection)?;
+
+        let mut track_sets = Vec::new();
+
+        for track_set_row in track_set_rows {
+            let track_set = self.get_track_set_from_row(track_set_row)?;
+            track_sets.push(track_set);
+        }
+
+        let medium = Medium {
+            id: row.id,
+            name: row.name,
+            discid: row.discid,
+            tracks: track_sets,
+        };
+
+        Ok(medium)
+    }
+
+    /// Convert a track set row from the database to an actual track set.
+    fn get_track_set_from_row(&self, row: TrackSetRow) -> Result<TrackSet> {
+        let recording_id = row.recording;
+
+        let recording = self
+            .get_recording(&recording_id)?
+            .ok_or_else(|| anyhow!("No recording with ID: {}", recording_id))?;
+
+        let track_rows = tracks::table
+            .filter(tracks::track_set.eq(row.id))
+            .order_by(tracks::index)
+            .load::<TrackRow>(&self.connection)?;
+
+        let mut tracks = Vec::new();
+
+        for track_row in track_rows {
+            let work_parts = track_row
+                .work_parts
+                .split(',')
+                .map(|part_index| Ok(str::parse(part_index)?))
+                .collect::<Result<Vec<usize>>>()?;
+
+            let track = Track {
+                work_parts,
+                path: track_row.path,
+            };
+
+            tracks.push(track);
+        }
+
+        let track_set = TrackSet { recording, tracks };
+
+        Ok(track_set)
+    }
+}

src/database/mod.rs

@@ -0,0 +1,59 @@
+use anyhow::Result;
+use diesel::prelude::*;
+
+pub mod ensembles;
+pub use ensembles::*;
+
+pub mod instruments;
+pub use instruments::*;
+
+pub mod medium;
+pub use medium::*;
+
+pub mod persons;
+pub use persons::*;
+
+pub mod recordings;
+pub use recordings::*;
+
+pub mod thread;
+pub use thread::*;
+
+pub mod works;
+pub use works::*;
+
+mod schema;
+
+// This makes the SQL migration scripts accessible from the code.
+embed_migrations!();
+
+/// Generate a random string suitable as an item ID.
+pub fn generate_id() -> String {
+    let mut buffer = uuid::Uuid::encode_buffer();
+    let id = uuid::Uuid::new_v4().to_simple().encode_lower(&mut buffer);
+
+    id.to_string()
+}
+
+/// Interface to a Musicus database.
+pub struct Database {
+    connection: SqliteConnection,
+}
+
+impl Database {
+    /// Create a new database interface and run migrations if necessary.
+    pub fn new(file_name: &str) -> Result<Database> {
+        let connection = SqliteConnection::establish(file_name)?;
+
+        diesel::sql_query("PRAGMA foreign_keys = ON").execute(&connection)?;
+        embedded_migrations::run(&connection)?;
+
+        Ok(Database { connection })
+    }
+
+    /// Defer all foreign keys for the next transaction.
+    fn defer_foreign_keys(&self) -> Result<()> {
+        diesel::sql_query("PRAGMA defer_foreign_keys = ON").execute(&self.connection)?;
+        Ok(())
+    }
+}

src/database/persons.rs

@@ -0,0 +1,66 @@
+use super::schema::persons;
+use super::Database;
+use anyhow::Result;
+use diesel::prelude::*;
+use serde::{Deserialize, Serialize};
+
+/// A person that is a composer, an interpret or both.
+#[derive(Serialize, Deserialize, Insertable, Queryable, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct Person {
+    pub id: String,
+    pub first_name: String,
+    pub last_name: String,
+}
+
+impl Person {
+    /// Get the full name in the form "First Last".
+    pub fn name_fl(&self) -> String {
+        format!("{} {}", self.first_name, self.last_name)
+    }
+
+    /// Get the full name in the form "Last, First".
+    pub fn name_lf(&self) -> String {
+        format!("{}, {}", self.last_name, self.first_name)
+    }
+}
+
+impl Database {
+    /// Update an existing person or insert a new one.
+    pub fn update_person(&self, person: Person) -> Result<()> {
+        self.defer_foreign_keys()?;
+
+        self.connection.transaction(|| {
+            diesel::replace_into(persons::table)
+                .values(person)
+                .execute(&self.connection)
+        })?;
+
+        Ok(())
+    }
+
+    /// Get an existing person.
+    pub fn get_person(&self, id: &str) -> Result<Option<Person>> {
+        let person = persons::table
+            .filter(persons::id.eq(id))
+            .load::<Person>(&self.connection)?
+            .into_iter()
+            .next();
+
+        Ok(person)
+    }
+
+    /// Delete an existing person.
+    pub fn delete_person(&self, id: &str) -> Result<()> {
+        diesel::delete(persons::table.filter(persons::id.eq(id))).execute(&self.connection)?;
+
+        Ok(())
+    }
+
+    /// Get all existing persons.
+    pub fn get_persons(&self) -> Result<Vec<Person>> {
+        let persons = persons::table.load::<Person>(&self.connection)?;
+
+        Ok(persons)
+    }
+}

src/database/recordings.rs

@@ -0,0 +1,316 @@
+use super::generate_id;
+use super::schema::{ensembles, performances, persons, recordings};
+use super::{Database, Ensemble, Instrument, Person, Work};
+use anyhow::{anyhow, Error, Result};
+use diesel::prelude::*;
+use serde::{Deserialize, Serialize};
+
+/// Database table data for a recording.
+#[derive(Insertable, Queryable, Debug, Clone)]
+#[table_name = "recordings"]
+struct RecordingRow {
+    pub id: String,
+    pub work: String,
+    pub comment: String,
+}
+
+impl From<Recording> for RecordingRow {
+    fn from(recording: Recording) -> Self {
+        RecordingRow {
+            id: recording.id,
+            work: recording.work.id,
+            comment: recording.comment,
+        }
+    }
+}
+
+/// Database table data for a performance.
+#[derive(Insertable, Queryable, Debug, Clone)]
+#[table_name = "performances"]
+struct PerformanceRow {
+    pub id: i64,
+    pub recording: String,
+    pub person: Option<String>,
+    pub ensemble: Option<String>,
+    pub role: Option<String>,
+}
+
+/// How a person or ensemble was involved in a recording.
+// TODO: Replace person/ensemble with an enum.
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct Performance {
+    pub person: Option<Person>,
+    pub ensemble: Option<Ensemble>,
+    pub role: Option<Instrument>,
+}
+
+impl Performance {
+    /// Get a string representation of the performance.
+    // TODO: Replace with impl Display.
+    pub fn get_title(&self) -> String {
+        let mut text = String::from(if self.is_person() {
+            self.unwrap_person().name_fl()
+        } else {
+            self.unwrap_ensemble().name
+        });
+
+        if self.has_role() {
+            text = text + " (" + &self.unwrap_role().name + ")";
+        }
+
+        text
+    }
+
+    pub fn is_person(&self) -> bool {
+        self.person.is_some()
+    }
+
+    pub fn unwrap_person(&self) -> Person {
+        self.person.clone().unwrap()
+    }
+
+    pub fn unwrap_ensemble(&self) -> Ensemble {
+        self.ensemble.clone().unwrap()
+    }
+
+    pub fn has_role(&self) -> bool {
+        self.role.clone().is_some()
+    }
+
+    pub fn unwrap_role(&self) -> Instrument {
+        self.role.clone().unwrap()
+    }
+}
+
+/// A specific recording of a work.
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct Recording {
+    pub id: String,
+    pub work: Work,
+    pub comment: String,
+    pub performances: Vec<Performance>,
+}
+
+impl Recording {
+    /// Initialize a new recording with a work.
+    pub fn new(work: Work) -> Self {
+        Self {
+            id: generate_id(),
+            work,
+            comment: String::new(),
+            performances: Vec::new(),
+        }
+    }
+
+    /// Get a string representation of the performances in this recording.
+    // TODO: Maybe replace with impl Display?
+    pub fn get_performers(&self) -> String {
+        let texts: Vec<String> = self
+            .performances
+            .iter()
+            .map(|performance| performance.get_title())
+            .collect();
+
+        texts.join(", ")
+    }
+}
+
+impl Database {
+    /// Update an existing recording or insert a new one.
+    // TODO: Think about whether to also insert the other items.
+    pub fn update_recording(&self, recording: Recording) -> Result<()> {
+        self.defer_foreign_keys()?;
+        self.connection.transaction::<(), Error, _>(|| {
+            let recording_id = &recording.id;
+            self.delete_recording(recording_id)?;
+
+            // Add associated items from the server, if they don't already exist.
+
+            if self.get_work(&recording.work.id)?.is_none() {
+                self.update_work(recording.work.clone())?;
+            }
+
+            for performance in &recording.performances {
+                if let Some(person) = &performance.person {
+                    if self.get_person(&person.id)?.is_none() {
+                        self.update_person(person.clone())?;
+                    }
+                }
+
+                if let Some(ensemble) = &performance.ensemble {
+                    if self.get_ensemble(&ensemble.id)?.is_none() {
+                        self.update_ensemble(ensemble.clone())?;
+                    }
+                }
+
+                if let Some(role) = &performance.role {
+                    if self.get_instrument(&role.id)?.is_none() {
+                        self.update_instrument(role.clone())?;
+                    }
+                }
+            }
+
+            // Add the actual recording.
+
+            let row: RecordingRow = recording.clone().into();
+            diesel::insert_into(recordings::table)
+                .values(row)
+                .execute(&self.connection)?;
+
+            for performance in recording.performances {
+                let row = PerformanceRow {
+                    id: rand::random(),
+                    recording: recording_id.to_string(),
+                    person: performance.person.map(|person| person.id),
+                    ensemble: performance.ensemble.map(|ensemble| ensemble.id),
+                    role: performance.role.map(|role| role.id),
+                };
+
+                diesel::insert_into(performances::table)
+                    .values(row)
+                    .execute(&self.connection)?;
+            }
+
+            Ok(())
+        })?;
+
+        Ok(())
+    }
+
+    /// Check whether the database contains a recording.
+    pub fn recording_exists(&self, id: &str) -> Result<bool> {
+        let exists = recordings::table
+            .filter(recordings::id.eq(id))
+            .load::<RecordingRow>(&self.connection)?
+            .first()
+            .is_some();
+
+        Ok(exists)
+    }
+
+    /// Get an existing recording.
+    pub fn get_recording(&self, id: &str) -> Result<Option<Recording>> {
+        let row = recordings::table
+            .filter(recordings::id.eq(id))
+            .load::<RecordingRow>(&self.connection)?
+            .into_iter()
+            .next();
+
+        let recording = match row {
+            Some(row) => Some(self.get_recording_data(row)?),
+            None => None,
+        };
+
+        Ok(recording)
+    }
+
+    /// Retrieve all available information on a recording from related tables.
+    fn get_recording_data(&self, row: RecordingRow) -> Result<Recording> {
+        let mut performance_descriptions: Vec<Performance> = Vec::new();
+
+        let performance_rows = performances::table
+            .filter(performances::recording.eq(&row.id))
+            .load::<PerformanceRow>(&self.connection)?;
+
+        for row in performance_rows {
+            performance_descriptions.push(Performance {
+                person: match row.person {
+                    Some(id) => Some(
+                        self.get_person(&id)?
+                            .ok_or(anyhow!("No person with ID: {}", id))?,
+                    ),
+                    None => None,
+                },
+                ensemble: match row.ensemble {
+                    Some(id) => Some(
+                        self.get_ensemble(&id)?
+                            .ok_or(anyhow!("No ensemble with ID: {}", id))?,
+                    ),
+                    None => None,
+                },
+                role: match row.role {
+                    Some(id) => Some(
+                        self.get_instrument(&id)?
+                            .ok_or(anyhow!("No instrument with ID: {}", id))?,
+                    ),
+                    None => None,
+                },
+            });
+        }
+
+        let work_id = &row.work;
+        let work = self
+            .get_work(work_id)?
+            .ok_or(anyhow!("Work doesn't exist: {}", work_id))?;
+
+        let recording_description = Recording {
+            id: row.id,
+            work,
+            comment: row.comment.clone(),
+            performances: performance_descriptions,
+        };
+
+        Ok(recording_description)
+    }
+
+    /// Get all available information on all recordings where a person is performing.
+    pub fn get_recordings_for_person(&self, person_id: &str) -> Result<Vec<Recording>> {
+        let mut recordings: Vec<Recording> = Vec::new();
+
+        let rows = recordings::table
+            .inner_join(performances::table.on(performances::recording.eq(recordings::id)))
+            .inner_join(persons::table.on(persons::id.nullable().eq(performances::person)))
+            .filter(persons::id.eq(person_id))
+            .select(recordings::table::all_columns())
+            .load::<RecordingRow>(&self.connection)?;
+
+        for row in rows {
+            recordings.push(self.get_recording_data(row)?);
+        }
+
+        Ok(recordings)
+    }
+
+    /// Get all available information on all recordings where an ensemble is performing.
+    pub fn get_recordings_for_ensemble(&self, ensemble_id: &str) -> Result<Vec<Recording>> {
+        let mut recordings: Vec<Recording> = Vec::new();
+
+        let rows = recordings::table
+            .inner_join(performances::table.on(performances::recording.eq(recordings::id)))
+            .inner_join(ensembles::table.on(ensembles::id.nullable().eq(performances::ensemble)))
+            .filter(ensembles::id.eq(ensemble_id))
+            .select(recordings::table::all_columns())
+            .load::<RecordingRow>(&self.connection)?;
+
+        for row in rows {
+            recordings.push(self.get_recording_data(row)?);
+        }
+
+        Ok(recordings)
+    }
+
+    /// Get allavailable information on all recordings of a work.
+    pub fn get_recordings_for_work(&self, work_id: &str) -> Result<Vec<Recording>> {
+        let mut recordings: Vec<Recording> = Vec::new();
+
+        let rows = recordings::table
+            .filter(recordings::work.eq(work_id))
+            .load::<RecordingRow>(&self.connection)?;
+
+        for row in rows {
+            recordings.push(self.get_recording_data(row)?);
+        }
+
+        Ok(recordings)
+    }
+
+    /// Delete an existing recording. This will fail if there are still references to this
+    /// recording from other tables that are not directly part of the recording data.
+    pub fn delete_recording(&self, id: &str) -> Result<()> {
+        diesel::delete(recordings::table.filter(recordings::id.eq(id)))
+            .execute(&self.connection)?;
+        Ok(())
+    }
+}

src/database/schema.rs

@@ -0,0 +1,131 @@
+table! {
+    ensembles (id) {
+        id -> Text,
+        name -> Text,
+    }
+}
+
+table! {
+    instrumentations (id) {
+        id -> BigInt,
+        work -> Text,
+        instrument -> Text,
+    }
+}
+
+table! {
+    instruments (id) {
+        id -> Text,
+        name -> Text,
+    }
+}
+
+table! {
+    mediums (id) {
+        id -> Text,
+        name -> Text,
+        discid -> Nullable<Text>,
+    }
+}
+
+table! {
+    performances (id) {
+        id -> BigInt,
+        recording -> Text,
+        person -> Nullable<Text>,
+        ensemble -> Nullable<Text>,
+        role -> Nullable<Text>,
+    }
+}
+
+table! {
+    persons (id) {
+        id -> Text,
+        first_name -> Text,
+        last_name -> Text,
+    }
+}
+
+table! {
+    recordings (id) {
+        id -> Text,
+        work -> Text,
+        comment -> Text,
+    }
+}
+
+table! {
+    track_sets (id) {
+        id -> Text,
+        medium -> Text,
+        index -> Integer,
+        recording -> Text,
+    }
+}
+
+table! {
+    tracks (id) {
+        id -> Text,
+        track_set -> Text,
+        index -> Integer,
+        work_parts -> Text,
+        path -> Text,
+    }
+}
+
+table! {
+    work_parts (id) {
+        id -> BigInt,
+        work -> Text,
+        part_index -> BigInt,
+        title -> Text,
+        composer -> Nullable<Text>,
+    }
+}
+
+table! {
+    work_sections (id) {
+        id -> BigInt,
+        work -> Text,
+        title -> Text,
+        before_index -> BigInt,
+    }
+}
+
+table! {
+    works (id) {
+        id -> Text,
+        composer -> Text,
+        title -> Text,
+    }
+}
+
+joinable!(instrumentations -> instruments (instrument));
+joinable!(instrumentations -> works (work));
+joinable!(performances -> ensembles (ensemble));
+joinable!(performances -> instruments (role));
+joinable!(performances -> persons (person));
+joinable!(performances -> recordings (recording));
+joinable!(recordings -> works (work));
+joinable!(track_sets -> mediums (medium));
+joinable!(track_sets -> recordings (recording));
+joinable!(tracks -> track_sets (track_set));
+joinable!(work_parts -> persons (composer));
+joinable!(work_parts -> works (work));
+joinable!(work_sections -> works (work));
+joinable!(works -> persons (composer));
+
+allow_tables_to_appear_in_same_query!(
+    ensembles,
+    instrumentations,
+    instruments,
+    mediums,
+    performances,
+    persons,
+    recordings,
+    track_sets,
+    tracks,
+    work_parts,
+    work_sections,
+    works,
+);

src/database/thread.rs

@@ -0,0 +1,355 @@
+use super::*;
+use anyhow::Result;
+use futures_channel::oneshot;
+use futures_channel::oneshot::Sender;
+use std::sync::mpsc;
+use std::thread;
+
+/// An action the database thread can perform.
+enum Action {
+    UpdatePerson(Person, Sender<Result<()>>),
+    GetPerson(String, Sender<Result<Option<Person>>>),
+    DeletePerson(String, Sender<Result<()>>),
+    GetPersons(Sender<Result<Vec<Person>>>),
+    UpdateInstrument(Instrument, Sender<Result<()>>),
+    GetInstrument(String, Sender<Result<Option<Instrument>>>),
+    DeleteInstrument(String, Sender<Result<()>>),
+    GetInstruments(Sender<Result<Vec<Instrument>>>),
+    UpdateWork(Work, Sender<Result<()>>),
+    DeleteWork(String, Sender<Result<()>>),
+    GetWorks(String, Sender<Result<Vec<Work>>>),
+    UpdateEnsemble(Ensemble, Sender<Result<()>>),
+    GetEnsemble(String, Sender<Result<Option<Ensemble>>>),
+    DeleteEnsemble(String, Sender<Result<()>>),
+    GetEnsembles(Sender<Result<Vec<Ensemble>>>),
+    UpdateRecording(Recording, Sender<Result<()>>),
+    DeleteRecording(String, Sender<Result<()>>),
+    GetRecordingsForPerson(String, Sender<Result<Vec<Recording>>>),
+    GetRecordingsForEnsemble(String, Sender<Result<Vec<Recording>>>),
+    GetRecordingsForWork(String, Sender<Result<Vec<Recording>>>),
+    RecordingExists(String, Sender<Result<bool>>),
+    UpdateMedium(Medium, Sender<Result<()>>),
+    GetMedium(String, Sender<Result<Option<Medium>>>),
+    DeleteMedium(String, Sender<Result<()>>),
+    GetTrackSets(String, Sender<Result<Vec<TrackSet>>>),
+    Stop(Sender<()>),
+}
+
+use Action::*;
+
+/// A database running within a thread.
+pub struct DbThread {
+    action_sender: mpsc::Sender<Action>,
+}
+
+impl DbThread {
+    /// Create a new database connection in a background thread.
+    pub async fn new(path: String) -> Result<Self> {
+        let (action_sender, action_receiver) = mpsc::channel();
+        let (ready_sender, ready_receiver) = oneshot::channel();
+
+        thread::spawn(move || {
+            let db = match Database::new(&path) {
+                Ok(db) => {
+                    ready_sender.send(Ok(())).unwrap();
+                    db
+                }
+                Err(error) => {
+                    ready_sender.send(Err(error)).unwrap();
+                    return;
+                }
+            };
+
+            for action in action_receiver {
+                match action {
+                    UpdatePerson(person, sender) => {
+                        sender.send(db.update_person(person)).unwrap();
+                    }
+                    GetPerson(id, sender) => {
+                        sender.send(db.get_person(&id)).unwrap();
+                    }
+                    DeletePerson(id, sender) => {
+                        sender.send(db.delete_person(&id)).unwrap();
+                    }
+                    GetPersons(sender) => {
+                        sender.send(db.get_persons()).unwrap();
+                    }
+                    UpdateInstrument(instrument, sender) => {
+                        sender.send(db.update_instrument(instrument)).unwrap();
+                    }
+                    GetInstrument(id, sender) => {
+                        sender.send(db.get_instrument(&id)).unwrap();
+                    }
+                    DeleteInstrument(id, sender) => {
+                        sender.send(db.delete_instrument(&id)).unwrap();
+                    }
+                    GetInstruments(sender) => {
+                        sender.send(db.get_instruments()).unwrap();
+                    }
+                    UpdateWork(work, sender) => {
+                        sender.send(db.update_work(work)).unwrap();
+                    }
+                    DeleteWork(id, sender) => {
+                        sender.send(db.delete_work(&id)).unwrap();
+                    }
+                    GetWorks(id, sender) => {
+                        sender.send(db.get_works(&id)).unwrap();
+                    }
+                    UpdateEnsemble(ensemble, sender) => {
+                        sender.send(db.update_ensemble(ensemble)).unwrap();
+                    }
+                    GetEnsemble(id, sender) => {
+                        sender.send(db.get_ensemble(&id)).unwrap();
+                    }
+                    DeleteEnsemble(id, sender) => {
+                        sender.send(db.delete_ensemble(&id)).unwrap();
+                    }
+                    GetEnsembles(sender) => {
+                        sender.send(db.get_ensembles()).unwrap();
+                    }
+                    UpdateRecording(recording, sender) => {
+                        sender.send(db.update_recording(recording)).unwrap();
+                    }
+                    DeleteRecording(id, sender) => {
+                        sender.send(db.delete_recording(&id)).unwrap();
+                    }
+                    GetRecordingsForPerson(id, sender) => {
+                        sender.send(db.get_recordings_for_person(&id)).unwrap();
+                    }
+                    GetRecordingsForEnsemble(id, sender) => {
+                        sender.send(db.get_recordings_for_ensemble(&id)).unwrap();
+                    }
+                    GetRecordingsForWork(id, sender) => {
+                        sender.send(db.get_recordings_for_work(&id)).unwrap();
+                    }
+                    RecordingExists(id, sender) => {
+                        sender.send(db.recording_exists(&id)).unwrap();
+                    }
+                    UpdateMedium(medium, sender) => {
+                        sender.send(db.update_medium(medium)).unwrap();
+                    }
+                    GetMedium(id, sender) => {
+                        sender.send(db.get_medium(&id)).unwrap();
+                    }
+                    DeleteMedium(id, sender) => {
+                        sender.send(db.delete_medium(&id)).unwrap();
+                    }
+                    GetTrackSets(recording_id, sender) => {
+                        sender.send(db.get_track_sets(&recording_id)).unwrap();
+                    }
+                    Stop(sender) => {
+                        sender.send(()).unwrap();
+                        break;
+                    }
+                }
+            }
+        });
+
+        ready_receiver.await??;
+        Ok(Self { action_sender })
+    }
+
+    /// Update an existing person or insert a new one.
+    pub async fn update_person(&self, person: Person) -> Result<()> {
+        let (sender, receiver) = oneshot::channel();
+        self.action_sender.send(UpdatePerson(person, sender))?;
+        receiver.await?
+    }
+
+    /// Get an existing person.
+    pub async fn get_person(&self, id: &str) -> Result<Option<Person>> {
+        let (sender, receiver) = oneshot::channel();
+        self.action_sender.send(GetPerson(id.to_string(), sender))?;
+        receiver.await?
+    }
+
+    /// Delete an existing person. This will fail, if there are still other items referencing
+    /// this person.
+    pub async fn delete_person(&self, id: &str) -> Result<()> {
+        let (sender, receiver) = oneshot::channel();
+        self.action_sender
+            .send(DeletePerson(id.to_string(), sender))?;
+        receiver.await?
+    }
+
+    /// Get all existing persons.
+    pub async fn get_persons(&self) -> Result<Vec<Person>> {
+        let (sender, receiver) = oneshot::channel();
+        self.action_sender.send(GetPersons(sender))?;
+        receiver.await?
+    }
+
+    /// Update an existing instrument or insert a new one.
+    pub async fn update_instrument(&self, instrument: Instrument) -> Result<()> {
+        let (sender, receiver) = oneshot::channel();
+        self.action_sender
+            .send(UpdateInstrument(instrument, sender))?;
+        receiver.await?
+    }
+
+    /// Get an existing instrument.
+    pub async fn get_instrument(&self, id: &str) -> Result<Option<Instrument>> {
+        let (sender, receiver) = oneshot::channel();
+        self.action_sender
+            .send(GetInstrument(id.to_string(), sender))?;
+        receiver.await?
+    }
+
+    /// Delete an existing instrument. This will fail, if there are still other items referencing
+    /// this instrument.
+    pub async fn delete_instrument(&self, id: &str) -> Result<()> {
+        let (sender, receiver) = oneshot::channel();
+        self.action_sender
+            .send(DeleteInstrument(id.to_string(), sender))?;
+        receiver.await?
+    }
+
+    /// Get all existing instruments.
+    pub async fn get_instruments(&self) -> Result<Vec<Instrument>> {
+        let (sender, receiver) = oneshot::channel();
+        self.action_sender.send(GetInstruments(sender))?;
+        receiver.await?
+    }
+
+    /// Update an existing work or insert a new one.
+    pub async fn update_work(&self, work: Work) -> Result<()> {
+        let (sender, receiver) = oneshot::channel();
+        self.action_sender.send(UpdateWork(work, sender))?;
+        receiver.await?
+    }
+
+    /// Delete an existing work. This will fail, if there are still other items referencing
+    /// this work.
+    pub async fn delete_work(&self, id: &str) -> Result<()> {
+        let (sender, receiver) = oneshot::channel();
+        self.action_sender
+            .send(DeleteWork(id.to_string(), sender))?;
+        receiver.await?
+    }
+
+    /// Get information on all existing works by a composer.
+    pub async fn get_works(&self, person_id: &str) -> Result<Vec<Work>> {
+        let (sender, receiver) = oneshot::channel();
+        self.action_sender
+            .send(GetWorks(person_id.to_string(), sender))?;
+        receiver.await?
+    }
+
+    /// Update an existing ensemble or insert a new one.
+    pub async fn update_ensemble(&self, ensemble: Ensemble) -> Result<()> {
+        let (sender, receiver) = oneshot::channel();
+        self.action_sender.send(UpdateEnsemble(ensemble, sender))?;
+        receiver.await?
+    }
+
+    /// Get an existing ensemble.
+    pub async fn get_ensemble(&self, id: &str) -> Result<Option<Ensemble>> {
+        let (sender, receiver) = oneshot::channel();
+        self.action_sender
+            .send(GetEnsemble(id.to_string(), sender))?;
+        receiver.await?
+    }
+
+    /// Delete an existing ensemble. This will fail, if there are still other items referencing
+    /// this ensemble.
+    pub async fn delete_ensemble(&self, id: &str) -> Result<()> {
+        let (sender, receiver) = oneshot::channel();
+        self.action_sender
+            .send(DeleteEnsemble(id.to_string(), sender))?;
+        receiver.await?
+    }
+
+    /// Get all existing ensembles.
+    pub async fn get_ensembles(&self) -> Result<Vec<Ensemble>> {
+        let (sender, receiver) = oneshot::channel();
+        self.action_sender.send(GetEnsembles(sender))?;
+        receiver.await?
+    }
+
+    /// Update an existing recording or insert a new one.
+    pub async fn update_recording(&self, recording: Recording) -> Result<()> {
+        let (sender, receiver) = oneshot::channel();
+        self.action_sender
+            .send(UpdateRecording(recording, sender))?;
+        receiver.await?
+    }
+
+    /// Delete an existing recording.
+    pub async fn delete_recording(&self, id: &str) -> Result<()> {
+        let (sender, receiver) = oneshot::channel();
+        self.action_sender
+            .send(DeleteRecording(id.to_string(), sender))?;
+        receiver.await?
+    }
+
+    /// Get information on all recordings in which a person performs.
+    pub async fn get_recordings_for_person(&self, person_id: &str) -> Result<Vec<Recording>> {
+        let (sender, receiver) = oneshot::channel();
+        self.action_sender
+            .send(GetRecordingsForPerson(person_id.to_string(), sender))?;
+        receiver.await?
+    }
+
+    /// Get information on all recordings in which an ensemble performs.
+    pub async fn get_recordings_for_ensemble(&self, ensemble_id: &str) -> Result<Vec<Recording>> {
+        let (sender, receiver) = oneshot::channel();
+        self.action_sender
+            .send(GetRecordingsForEnsemble(ensemble_id.to_string(), sender))?;
+        receiver.await?
+    }
+
+    /// Get information on all recordings of a work.
+    pub async fn get_recordings_for_work(&self, work_id: &str) -> Result<Vec<Recording>> {
+        let (sender, receiver) = oneshot::channel();
+        self.action_sender
+            .send(GetRecordingsForWork(work_id.to_string(), sender))?;
+        receiver.await?
+    }
+
+    /// Check whether a recording exists within the database.
+    pub async fn recording_exists(&self, id: &str) -> Result<bool> {
+        let (sender, receiver) = oneshot::channel();
+        self.action_sender
+            .send(RecordingExists(id.to_string(), sender))?;
+        receiver.await?
+    }
+
+    /// Update an existing medium or insert a new one.
+    pub async fn update_medium(&self, medium: Medium) -> Result<()> {
+        let (sender, receiver) = oneshot::channel();
+        self.action_sender.send(UpdateMedium(medium, sender))?;
+        receiver.await?
+    }
+
+    /// Delete an existing medium. This will fail, if there are still other
+    /// items referencing this medium.
+    pub async fn delete_medium(&self, id: &str) -> Result<()> {
+        let (sender, receiver) = oneshot::channel();
+
+        self.action_sender
+            .send(DeleteMedium(id.to_owned(), sender))?;
+
+        receiver.await?
+    }
+
+    /// Get an existing medium.
+    pub async fn get_medium(&self, id: &str) -> Result<Option<Medium>> {
+        let (sender, receiver) = oneshot::channel();
+        self.action_sender.send(GetMedium(id.to_owned(), sender))?;
+        receiver.await?
+    }
+
+    /// Get all track sets for a recording.
+    pub async fn get_track_sets(&self, recording_id: &str) -> Result<Vec<TrackSet>> {
+        let (sender, receiver) = oneshot::channel();
+        self.action_sender.send(GetTrackSets(recording_id.to_owned(), sender))?;
+        receiver.await?
+    }
+
+    /// Stop the database thread. Any future access to the database will fail.
+    pub async fn stop(&self) -> Result<()> {
+        let (sender, receiver) = oneshot::channel();
+        self.action_sender.send(Stop(sender))?;
+        Ok(receiver.await?)
+    }
+}

src/database/works.rs

@@ -0,0 +1,297 @@
+use super::generate_id;
+use super::schema::{instrumentations, work_parts, work_sections, works};
+use super::{Database, Instrument, Person};
+use anyhow::{anyhow, Error, Result};
+use diesel::prelude::*;
+use diesel::{Insertable, Queryable};
+use serde::{Deserialize, Serialize};
+use std::convert::TryInto;
+
+/// Table row data for a work.
+#[derive(Insertable, Queryable, Debug, Clone)]
+#[table_name = "works"]
+struct WorkRow {
+    pub id: String,
+    pub composer: String,
+    pub title: String,
+}
+
+impl From<Work> for WorkRow {
+    fn from(work: Work) -> Self {
+        WorkRow {
+            id: work.id,
+            composer: work.composer.id,
+            title: work.title,
+        }
+    }
+}
+
+/// Definition that a work uses an instrument.
+#[derive(Insertable, Queryable, Debug, Clone)]
+#[table_name = "instrumentations"]
+struct InstrumentationRow {
+    pub id: i64,
+    pub work: String,
+    pub instrument: String,
+}
+
+/// Table row data for a work part.
+#[derive(Insertable, Queryable, Debug, Clone)]
+#[table_name = "work_parts"]
+struct WorkPartRow {
+    pub id: i64,
+    pub work: String,
+    pub part_index: i64,
+    pub title: String,
+    pub composer: Option<String>,
+}
+
+/// Table row data for a work section.
+#[derive(Insertable, Queryable, Debug, Clone)]
+#[table_name = "work_sections"]
+struct WorkSectionRow {
+    pub id: i64,
+    pub work: String,
+    pub title: String,
+    pub before_index: i64,
+}
+/// A concrete work part that can be recorded.
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct WorkPart {
+    pub title: String,
+    pub composer: Option<Person>,
+}
+
+/// A heading between work parts.
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct WorkSection {
+    pub title: String,
+    pub before_index: usize,
+}
+
+/// A specific work by a composer.
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct Work {
+    pub id: String,
+    pub title: String,
+    pub composer: Person,
+    pub instruments: Vec<Instrument>,
+    pub parts: Vec<WorkPart>,
+    pub sections: Vec<WorkSection>,
+}
+
+impl Work {
+    /// Initialize a new work with a composer.
+    pub fn new(composer: Person) -> Self {
+        Self {
+            id: generate_id(),
+            title: String::new(),
+            composer,
+            instruments: Vec::new(),
+            parts: Vec::new(),
+            sections: Vec::new(),
+        }
+    }
+
+    /// Get a string including the composer and title of the work.
+    // TODO: Replace with impl Display.
+    pub fn get_title(&self) -> String {
+        format!("{}: {}", self.composer.name_fl(), self.title)
+    }
+}
+
+impl Database {
+    /// Update an existing work or insert a new one.
+    // TODO: Think about also inserting related items.
+    pub fn update_work(&self, work: Work) -> Result<()> {
+        self.defer_foreign_keys()?;
+
+        self.connection.transaction::<(), Error, _>(|| {
+            let work_id = &work.id;
+            self.delete_work(work_id)?;
+
+            // Add associated items from the server, if they don't already exist.
+
+            if self.get_person(&work.composer.id)?.is_none() {
+                self.update_person(work.composer.clone())?;
+            }
+
+            for instrument in &work.instruments {
+                if self.get_instrument(&instrument.id)?.is_none() {
+                    self.update_instrument(instrument.clone())?;
+                }
+            }
+
+            for part in &work.parts {
+                if let Some(person) = &part.composer {
+                    if self.get_person(&person.id)?.is_none() {
+                        self.update_person(person.clone())?;
+                    }
+                }
+            }
+
+            // Add the actual work.
+
+            let row: WorkRow = work.clone().into();
+            diesel::insert_into(works::table)
+                .values(row)
+                .execute(&self.connection)?;
+
+            match work {
+                Work {
+                    instruments,
+                    parts,
+                    sections,
+                    ..
+                } => {
+                    for instrument in instruments {
+                        let row = InstrumentationRow {
+                            id: rand::random(),
+                            work: work_id.to_string(),
+                            instrument: instrument.id,
+                        };
+
+                        diesel::insert_into(instrumentations::table)
+                            .values(row)
+                            .execute(&self.connection)?;
+                    }
+
+                    for (index, part) in parts.into_iter().enumerate() {
+                        let row = WorkPartRow {
+                            id: rand::random(),
+                            work: work_id.to_string(),
+                            part_index: index.try_into()?,
+                            title: part.title,
+                            composer: part.composer.map(|person| person.id),
+                        };
+
+                        diesel::insert_into(work_parts::table)
+                            .values(row)
+                            .execute(&self.connection)?;
+                    }
+
+                    for section in sections {
+                        let row = WorkSectionRow {
+                            id: rand::random(),
+                            work: work_id.to_string(),
+                            title: section.title,
+                            before_index: section.before_index.try_into()?,
+                        };
+
+                        diesel::insert_into(work_sections::table)
+                            .values(row)
+                            .execute(&self.connection)?;
+                    }
+                }
+            }
+
+            Ok(())
+        })?;
+
+        Ok(())
+    }
+
+    /// Get an existing work.
+    pub fn get_work(&self, id: &str) -> Result<Option<Work>> {
+        let row = works::table
+            .filter(works::id.eq(id))
+            .load::<WorkRow>(&self.connection)?
+            .first()
+            .cloned();
+
+        let work = match row {
+            Some(row) => Some(self.get_work_data(row)?),
+            None => None,
+        };
+
+        Ok(work)
+    }
+
+    /// Retrieve all available information on a work from related tables.
+    fn get_work_data(&self, row: WorkRow) -> Result<Work> {
+        let mut instruments: Vec<Instrument> = Vec::new();
+
+        let instrumentations = instrumentations::table
+            .filter(instrumentations::work.eq(&row.id))
+            .load::<InstrumentationRow>(&self.connection)?;
+
+        for instrumentation in instrumentations {
+            let id = &instrumentation.instrument;
+            instruments.push(
+                self.get_instrument(id)?
+                    .ok_or(anyhow!("No instrument with ID: {}", id))?,
+            );
+        }
+
+        let mut parts: Vec<WorkPart> = Vec::new();
+
+        let part_rows = work_parts::table
+            .filter(work_parts::work.eq(&row.id))
+            .load::<WorkPartRow>(&self.connection)?;
+
+        for part_row in part_rows {
+            parts.push(WorkPart {
+                title: part_row.title,
+                composer: match part_row.composer {
+                    Some(composer) => Some(
+                        self.get_person(&composer)?
+                            .ok_or(anyhow!("No person with ID: {}", composer))?,
+                    ),
+                    None => None,
+                },
+            });
+        }
+
+        let mut sections: Vec<WorkSection> = Vec::new();
+
+        let section_rows = work_sections::table
+            .filter(work_sections::work.eq(&row.id))
+            .load::<WorkSectionRow>(&self.connection)?;
+
+        for section_row in section_rows {
+            sections.push(WorkSection {
+                title: section_row.title,
+                before_index: section_row.before_index.try_into()?,
+            });
+        }
+
+        let person_id = &row.composer;
+        let person = self
+            .get_person(person_id)?
+            .ok_or(anyhow!("Person doesn't exist: {}", person_id))?;
+
+        Ok(Work {
+            id: row.id,
+            composer: person,
+            title: row.title,
+            instruments,
+            parts,
+            sections,
+        })
+    }
+
+    /// Delete an existing work. This will fail if there are still other tables that relate to
+    /// this work except for the things that are part of the information on the work it
+    pub fn delete_work(&self, id: &str) -> Result<()> {
+        diesel::delete(works::table.filter(works::id.eq(id))).execute(&self.connection)?;
+        Ok(())
+    }
+
+    /// Get all existing works by a composer and related information from other tables.
+    pub fn get_works(&self, composer_id: &str) -> Result<Vec<Work>> {
+        let mut works: Vec<Work> = Vec::new();
+
+        let rows = works::table
+            .filter(works::composer.eq(composer_id))
+            .load::<WorkRow>(&self.connection)?;
+
+        for row in rows {
+            works.push(self.get_work_data(row)?);
+        }
+
+        Ok(works)
+    }
+}

src/dialogs/about.rs

@@ -0,0 +1,22 @@
+use crate::config;
+use gettextrs::gettext;
+use gtk::prelude::*;
+
+pub fn show_about_dialog<W: IsA<gtk::Window>>(parent: &W) {
+    let dialog = gtk::AboutDialogBuilder::new()
+        .transient_for(parent)
+        .modal(true)
+        .logo_icon_name("de.johrpan.musicus")
+        .program_name(&gettext("Musicus"))
+        .version(config::VERSION)
+        .comments(&gettext("The classical music player and organizer."))
+        .website("https://github.com/johrpan/musicus")
+        .website_label(&gettext("Further information and source code"))
+        .copyright("© 2020 Elias Projahn")
+        .license_type(gtk::License::Agpl30)
+        .authors(vec![String::from("Elias Projahn <johrpan@gmail.com>")])
+        .build();
+
+    dialog.connect_response(|dialog, _| dialog.close());
+    dialog.show();
+}

src/dialogs/login_dialog.rs

@@ -0,0 +1,88 @@
+use crate::backend::{Backend, LoginData};
+use glib::clone;
+use gtk::prelude::*;
+use gtk_macros::get_widget;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+/// A dialog for entering login credentials.
+pub struct LoginDialog {
+    backend: Rc<Backend>,
+    window: libhandy::Window,
+    stack: gtk::Stack,
+    info_bar: gtk::InfoBar,
+    username_entry: gtk::Entry,
+    password_entry: gtk::Entry,
+    selected_cb: RefCell<Option<Box<dyn Fn(LoginData) -> ()>>>,
+}
+
+impl LoginDialog {
+    /// Create a new login dialog.
+    pub fn new<P: IsA<gtk::Window>>(backend: Rc<Backend>, parent: &P) -> Rc<Self> {
+        // Create UI
+        let builder = gtk::Builder::from_resource("/de/johrpan/musicus/ui/login_dialog.ui");
+
+        get_widget!(builder, libhandy::Window, window);
+        get_widget!(builder, gtk::Stack, stack);
+        get_widget!(builder, gtk::InfoBar, info_bar);
+        get_widget!(builder, gtk::Button, cancel_button);
+        get_widget!(builder, gtk::Button, login_button);
+        get_widget!(builder, gtk::Entry, username_entry);
+        get_widget!(builder, gtk::Entry, password_entry);
+
+        window.set_transient_for(Some(parent));
+
+        let this = Rc::new(Self {
+            backend,
+            window,
+            stack,
+            info_bar,
+            username_entry,
+            password_entry,
+            selected_cb: RefCell::new(None),
+        });
+
+        // Connect signals and callbacks
+
+        cancel_button.connect_clicked(clone!(@strong this => move |_| {
+            this.window.close();
+        }));
+
+        login_button.connect_clicked(clone!(@strong this => move |_| {
+            this.stack.set_visible_child_name("loading");
+
+            let data = LoginData {
+                username: this.username_entry.get_text().to_string(),
+                password: this.password_entry.get_text().to_string(),
+            };
+
+            let c = glib::MainContext::default();
+            let clone = this.clone();
+            c.spawn_local(async move {
+                clone.backend.set_login_data(data.clone()).await.unwrap();
+                if clone.backend.login().await.unwrap() {
+                    if let Some(cb) = &*clone.selected_cb.borrow() {
+                        cb(data);
+                    }
+
+                    clone.window.close();
+                } else {
+                    clone.stack.set_visible_child_name("content");
+                    clone.info_bar.set_revealed(true);
+                }
+            });
+        }));
+
+        this
+    }
+
+    /// The closure to call when the login succeded.
+    pub fn set_selected_cb<F: Fn(LoginData) -> () + 'static>(&self, cb: F) {
+        self.selected_cb.replace(Some(Box::new(cb)));
+    }
+
+    /// Show the login dialog.
+    pub fn show(&self) {
+        self.window.show();
+    }
+}

src/dialogs/mod.rs

@@ -0,0 +1,11 @@
+pub mod about;
+pub use about::*;
+
+pub mod login_dialog;
+pub use login_dialog::*;
+
+pub mod preferences;
+pub use preferences::*;
+
+pub mod server_dialog;
+pub use server_dialog::*;

src/dialogs/preferences.rs

@@ -0,0 +1,105 @@
+use super::{LoginDialog, ServerDialog};
+use crate::backend::Backend;
+use gettextrs::gettext;
+use glib::clone;
+use gtk::prelude::*;
+use gtk_macros::get_widget;
+use libhandy::prelude::*;
+use std::rc::Rc;
+
+/// A dialog for configuring the app.
+pub struct Preferences {
+    backend: Rc<Backend>,
+    window: libhandy::Window,
+    music_library_path_row: libhandy::ActionRow,
+    url_row: libhandy::ActionRow,
+    login_row: libhandy::ActionRow,
+}
+
+impl Preferences {
+    /// Create a new preferences dialog.
+    pub fn new<P: IsA<gtk::Window>>(backend: Rc<Backend>, parent: &P) -> Rc<Self> {
+        // Create UI
+        let builder = gtk::Builder::from_resource("/de/johrpan/musicus/ui/preferences.ui");
+
+        get_widget!(builder, libhandy::Window, window);
+        get_widget!(builder, libhandy::ActionRow, music_library_path_row);
+        get_widget!(builder, gtk::Button, select_music_library_path_button);
+        get_widget!(builder, libhandy::ActionRow, url_row);
+        get_widget!(builder, gtk::Button, url_button);
+        get_widget!(builder, libhandy::ActionRow, login_row);
+        get_widget!(builder, gtk::Button, login_button);
+
+        window.set_transient_for(Some(parent));
+
+        let this = Rc::new(Self {
+            backend,
+            window,
+            music_library_path_row,
+            url_row,
+            login_row,
+        });
+
+        // Connect signals and callbacks
+
+        select_music_library_path_button.connect_clicked(clone!(@strong this => move |_| {
+            let dialog = gtk::FileChooserNative::new(
+                Some(&gettext("Select music library folder")),
+                Some(&this.window), gtk::FileChooserAction::SelectFolder,None, None);
+
+            if let gtk::ResponseType::Accept = dialog.run() {
+                if let Some(path) = dialog.get_filename() {
+                    this.music_library_path_row.set_subtitle(Some(path.to_str().unwrap()));
+
+                    let context = glib::MainContext::default();
+                    let backend = this.backend.clone();
+                    context.spawn_local(async move {
+                        backend.set_music_library_path(path).await.unwrap();
+                    });
+                }
+            }
+        }));
+
+        url_button.connect_clicked(clone!(@strong this => move |_| {
+            let dialog = ServerDialog::new(this.backend.clone(), &this.window);
+
+            dialog.set_selected_cb(clone!(@strong this => move |url| {
+                this.url_row.set_subtitle(Some(&url));
+            }));
+
+            dialog.show();
+        }));
+
+        login_button.connect_clicked(clone!(@strong this => move |_| {
+            let dialog = LoginDialog::new(this.backend.clone(), &this.window);
+
+            dialog.set_selected_cb(clone!(@strong this => move |data| {
+                this.login_row.set_subtitle(Some(&data.username));
+            }));
+
+            dialog.show();
+        }));
+
+        // Initialize
+
+        if let Some(path) = this.backend.get_music_library_path() {
+            this.music_library_path_row
+                .set_subtitle(Some(path.to_str().unwrap()));
+        }
+
+        if let Some(url) = this.backend.get_server_url() {
+            this.url_row.set_subtitle(Some(&url));
+        }
+
+        if let Some(data) = this.backend.get_login_data() {
+            this.login_row.set_subtitle(Some(&data.username));
+        }
+
+        this
+    }
+
+    /// Show the preferences dialog.
+    pub fn show(&self) {
+        self.window.show();
+    }
+}

src/dialogs/server_dialog.rs

@@ -0,0 +1,65 @@
+use crate::backend::Backend;
+use glib::clone;
+use gtk::prelude::*;
+use gtk_macros::get_widget;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+/// A dialog for setting up the server.
+pub struct ServerDialog {
+    backend: Rc<Backend>,
+    window: libhandy::Window,
+    url_entry: gtk::Entry,
+    selected_cb: RefCell<Option<Box<dyn Fn(String) -> ()>>>,
+}
+
+impl ServerDialog {
+    /// Create a new server dialog.
+    pub fn new<P: IsA<gtk::Window>>(backend: Rc<Backend>, parent: &P) -> Rc<Self> {
+        // Create UI
+        let builder = gtk::Builder::from_resource("/de/johrpan/musicus/ui/server_dialog.ui");
+
+        get_widget!(builder, libhandy::Window, window);
+        get_widget!(builder, gtk::Button, cancel_button);
+        get_widget!(builder, gtk::Button, set_button);
+        get_widget!(builder, gtk::Entry, url_entry);
+
+        window.set_transient_for(Some(parent));
+
+        let this = Rc::new(Self {
+            backend,
+            window,
+            url_entry,
+            selected_cb: RefCell::new(None),
+        });
+
+        // Connect signals and callbacks
+
+        cancel_button.connect_clicked(clone!(@strong this => move |_| {
+            this.window.close();
+        }));
+
+        set_button.connect_clicked(clone!(@strong this => move |_| {
+            let url = this.url_entry.get_text().to_string();
+            this.backend.set_server_url(&url).unwrap();
+
+            if let Some(cb) = &*this.selected_cb.borrow() {
+                cb(url);
+            }
+
+            this.window.close();
+        }));
+
+        this
+    }
+
+    /// The closure to call when the server was set.
+    pub fn set_selected_cb<F: Fn(String) -> () + 'static>(&self, cb: F) {
+        self.selected_cb.replace(Some(Box::new(cb)));
+    }
+
+    /// Show the server dialog.
+    pub fn show(&self) {
+        self.window.show();
+    }
+}

src/editors/ensemble.rs

@@ -0,0 +1,135 @@
+use crate::backend::Backend;
+use crate::database::*;
+use crate::widgets::{Navigator, NavigatorScreen};
+use anyhow::Result;
+use glib::clone;
+use gtk::prelude::*;
+use gtk_macros::get_widget;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+/// A dialog for creating or editing a ensemble.
+pub struct EnsembleEditor {
+    backend: Rc<Backend>,
+    id: String,
+    widget: gtk::Stack,
+    info_bar: gtk::InfoBar,
+    name_entry: gtk::Entry,
+    upload_switch: gtk::Switch,
+    saved_cb: RefCell<Option<Box<dyn Fn(Ensemble) -> ()>>>,
+    navigator: RefCell<Option<Rc<Navigator>>>,
+}
+
+impl EnsembleEditor {
+    /// Create a new ensemble editor and optionally initialize it.
+    pub fn new(backend: Rc<Backend>, ensemble: Option<Ensemble>) -> Rc<Self> {
+        // Create UI
+
+        let builder = gtk::Builder::from_resource("/de/johrpan/musicus/ui/ensemble_editor.ui");
+
+        get_widget!(builder, gtk::Stack, widget);
+        get_widget!(builder, gtk::Button, back_button);
+        get_widget!(builder, gtk::Button, save_button);
+        get_widget!(builder, gtk::InfoBar, info_bar);
+        get_widget!(builder, gtk::Entry, name_entry);
+        get_widget!(builder, gtk::Switch, upload_switch);
+
+        let id = match ensemble {
+            Some(ensemble) => {
+                name_entry.set_text(&ensemble.name);
+
+                ensemble.id
+            }
+            None => generate_id(),
+        };
+
+        let this = Rc::new(Self {
+            backend,
+            id,
+            widget,
+            info_bar,
+            name_entry,
+            upload_switch,
+            saved_cb: RefCell::new(None),
+            navigator: RefCell::new(None),
+        });
+
+        // Connect signals and callbacks
+
+        back_button.connect_clicked(clone!(@strong this => move |_| {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.pop();
+            }
+        }));
+
+        save_button.connect_clicked(clone!(@strong this => move |_| {
+            let context = glib::MainContext::default();
+            let clone = this.clone();
+            context.spawn_local(async move {
+                clone.widget.set_visible_child_name("loading");
+                match clone.clone().save().await {
+                    Ok(_) => {
+                        let navigator = clone.navigator.borrow().clone();
+                        if let Some(navigator) = navigator {
+                            navigator.pop();
+                        }
+                    }
+                    Err(_) => {
+                        clone.info_bar.set_revealed(true);
+                        clone.widget.set_visible_child_name("content");
+                    }
+                }
+
+            });
+        }));
+
+        this
+    }
+
+    /// Set the closure to be called if the ensemble was saved.
+    pub fn set_saved_cb<F: Fn(Ensemble) -> () + 'static>(&self, cb: F) {
+        self.saved_cb.replace(Some(Box::new(cb)));
+    }
+
+    /// Save the ensemble and possibly upload it to the server.
+    async fn save(self: Rc<Self>) -> Result<()> {
+        let name = self.name_entry.get_text().to_string();
+
+        let ensemble = Ensemble {
+            id: self.id.clone(),
+            name,
+        };
+
+        let upload = self.upload_switch.get_active();
+        if upload {
+            self.backend.post_ensemble(&ensemble).await?;
+        }
+
+        self.backend
+            .db()
+            .update_ensemble(ensemble.clone())
+            .await?;
+        self.backend.library_changed();
+
+        if let Some(cb) = &*self.saved_cb.borrow() {
+            cb(ensemble.clone());
+        }
+
+        Ok(())
+    }
+}
+
+impl NavigatorScreen for EnsembleEditor {
+    fn attach_navigator(&self, navigator: Rc<Navigator>) {
+        self.navigator.replace(Some(navigator));
+    }
+
+    fn get_widget(&self) -> gtk::Widget {
+        self.widget.clone().upcast()
+    }
+
+    fn detach_navigator(&self) {
+        self.navigator.replace(None);
+    }
+}

src/editors/instrument.rs

@@ -0,0 +1,135 @@
+use crate::backend::Backend;
+use crate::database::*;
+use crate::widgets::{Navigator, NavigatorScreen};
+use anyhow::Result;
+use glib::clone;
+use gtk::prelude::*;
+use gtk_macros::get_widget;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+/// A dialog for creating or editing a instrument.
+pub struct InstrumentEditor {
+    backend: Rc<Backend>,
+    id: String,
+    widget: gtk::Stack,
+    info_bar: gtk::InfoBar,
+    name_entry: gtk::Entry,
+    upload_switch: gtk::Switch,
+    saved_cb: RefCell<Option<Box<dyn Fn(Instrument) -> ()>>>,
+    navigator: RefCell<Option<Rc<Navigator>>>,
+}
+
+impl InstrumentEditor {
+    /// Create a new instrument editor and optionally initialize it.
+    pub fn new(backend: Rc<Backend>, instrument: Option<Instrument>) -> Rc<Self> {
+        // Create UI
+
+        let builder = gtk::Builder::from_resource("/de/johrpan/musicus/ui/instrument_editor.ui");
+
+        get_widget!(builder, gtk::Stack, widget);
+        get_widget!(builder, gtk::Button, back_button);
+        get_widget!(builder, gtk::Button, save_button);
+        get_widget!(builder, gtk::InfoBar, info_bar);
+        get_widget!(builder, gtk::Entry, name_entry);
+        get_widget!(builder, gtk::Switch, upload_switch);
+
+        let id = match instrument {
+            Some(instrument) => {
+                name_entry.set_text(&instrument.name);
+
+                instrument.id
+            }
+            None => generate_id(),
+        };
+
+        let this = Rc::new(Self {
+            backend,
+            id,
+            widget,
+            info_bar,
+            name_entry,
+            upload_switch,
+            saved_cb: RefCell::new(None),
+            navigator: RefCell::new(None),
+        });
+
+        // Connect signals and callbacks
+
+        back_button.connect_clicked(clone!(@strong this => move |_| {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.pop();
+            }
+        }));
+
+        save_button.connect_clicked(clone!(@strong this => move |_| {
+            let context = glib::MainContext::default();
+            let clone = this.clone();
+            context.spawn_local(async move {
+                clone.widget.set_visible_child_name("loading");
+                match clone.clone().save().await {
+                    Ok(_) => {
+                        let navigator = clone.navigator.borrow().clone();
+                        if let Some(navigator) = navigator {
+                            navigator.pop();
+                        }
+                    }
+                    Err(_) => {
+                        clone.info_bar.set_revealed(true);
+                        clone.widget.set_visible_child_name("content");
+                    }
+                }
+
+            });
+        }));
+
+        this
+    }
+
+    /// Set the closure to be called if the instrument was saved.
+    pub fn set_saved_cb<F: Fn(Instrument) -> () + 'static>(&self, cb: F) {
+        self.saved_cb.replace(Some(Box::new(cb)));
+    }
+
+    /// Save the instrument and possibly upload it to the server.
+    async fn save(self: Rc<Self>) -> Result<()> {
+        let name = self.name_entry.get_text().to_string();
+
+        let instrument = Instrument {
+            id: self.id.clone(),
+            name,
+        };
+
+        let upload = self.upload_switch.get_active();
+        if upload {
+            self.backend.post_instrument(&instrument).await?;
+        }
+
+        self.backend
+            .db()
+            .update_instrument(instrument.clone())
+            .await?;
+        self.backend.library_changed();
+
+        if let Some(cb) = &*self.saved_cb.borrow() {
+            cb(instrument.clone());
+        }
+
+        Ok(())
+    }
+}
+
+impl NavigatorScreen for InstrumentEditor {
+    fn attach_navigator(&self, navigator: Rc<Navigator>) {
+        self.navigator.replace(Some(navigator));
+    }
+
+    fn get_widget(&self) -> gtk::Widget {
+        self.widget.clone().upcast()
+    }
+
+    fn detach_navigator(&self) {
+        self.navigator.replace(None);
+    }
+}

src/editors/mod.rs

@@ -0,0 +1,18 @@
+pub mod ensemble;
+pub use ensemble::*;
+
+pub mod instrument;
+pub use instrument::*;
+
+pub mod person;
+pub use person::*;
+
+pub mod recording;
+pub use recording::*;
+
+pub mod work;
+pub use work::*;
+
+mod performance;
+mod work_part;
+mod work_section;

src/editors/performance.rs

@@ -0,0 +1,210 @@
+use crate::backend::Backend;
+use crate::database::*;
+use crate::selectors::{EnsembleSelector, InstrumentSelector, PersonSelector};
+use crate::widgets::{Navigator, NavigatorScreen};
+use gettextrs::gettext;
+use glib::clone;
+use gtk::prelude::*;
+use gtk_macros::get_widget;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+/// A dialog for editing a performance within a recording.
+pub struct PerformanceEditor {
+    backend: Rc<Backend>,
+    widget: gtk::Box,
+    save_button: gtk::Button,
+    person_label: gtk::Label,
+    ensemble_label: gtk::Label,
+    role_label: gtk::Label,
+    reset_role_button: gtk::Button,
+    person: RefCell<Option<Person>>,
+    ensemble: RefCell<Option<Ensemble>>,
+    role: RefCell<Option<Instrument>>,
+    selected_cb: RefCell<Option<Box<dyn Fn(Performance) -> ()>>>,
+    navigator: RefCell<Option<Rc<Navigator>>>,
+}
+
+impl PerformanceEditor {
+    /// Create a new performance editor.
+    pub fn new(backend: Rc<Backend>, performance: Option<Performance>) -> Rc<Self> {
+        // Create UI
+
+        let builder = gtk::Builder::from_resource("/de/johrpan/musicus/ui/performance_editor.ui");
+
+        get_widget!(builder, gtk::Box, widget);
+        get_widget!(builder, gtk::Button, back_button);
+        get_widget!(builder, gtk::Button, save_button);
+        get_widget!(builder, gtk::Button, person_button);
+        get_widget!(builder, gtk::Button, ensemble_button);
+        get_widget!(builder, gtk::Button, role_button);
+        get_widget!(builder, gtk::Button, reset_role_button);
+        get_widget!(builder, gtk::Label, person_label);
+        get_widget!(builder, gtk::Label, ensemble_label);
+        get_widget!(builder, gtk::Label, role_label);
+
+        let this = Rc::new(PerformanceEditor {
+            backend,
+            widget,
+            save_button,
+            person_label,
+            ensemble_label,
+            role_label,
+            reset_role_button,
+            person: RefCell::new(None),
+            ensemble: RefCell::new(None),
+            role: RefCell::new(None),
+            selected_cb: RefCell::new(None),
+            navigator: RefCell::new(None),
+        });
+
+        // Connect signals and callbacks
+
+        back_button.connect_clicked(clone!(@strong this => move |_| {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.pop();
+            }
+        }));
+
+        this.save_button
+            .connect_clicked(clone!(@strong this => move |_| {
+                if let Some(cb) = &*this.selected_cb.borrow() {
+                    cb(Performance {
+                        person: this.person.borrow().clone(),
+                        ensemble: this.ensemble.borrow().clone(),
+                        role: this.role.borrow().clone(),
+                    });
+                }
+
+                let navigator = this.navigator.borrow().clone();
+                if let Some(navigator) = navigator {
+                    navigator.pop();
+                }
+            }));
+
+        person_button.connect_clicked(clone!(@strong this => move |_| {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                let selector = PersonSelector::new(this.backend.clone());
+
+                selector.set_selected_cb(clone!(@strong this, @strong navigator => move |person| {
+                    this.show_person(Some(&person));
+                    this.person.replace(Some(person.clone()));
+                    this.show_ensemble(None);
+                    this.ensemble.replace(None);
+                    navigator.clone().pop();
+                }));
+
+                navigator.push(selector);
+            }
+        }));
+
+        ensemble_button.connect_clicked(clone!(@strong this => move |_| {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                let selector = EnsembleSelector::new(this.backend.clone());
+
+                selector.set_selected_cb(clone!(@strong this, @strong navigator => move |ensemble| {
+                    this.show_person(None);
+                    this.person.replace(None);
+                    this.show_ensemble(Some(&ensemble));
+                    this.ensemble.replace(Some(ensemble.clone()));
+                    navigator.clone().pop();
+                }));
+
+                navigator.push(selector);
+            }
+        }));
+
+        role_button.connect_clicked(clone!(@strong this => move |_| {
+            let navigator = this.navigator.borrow().clone();
+                if let Some(navigator) = navigator {
+                let selector = InstrumentSelector::new(this.backend.clone());
+
+                selector.set_selected_cb(clone!(@strong this, @strong navigator => move |role| {
+                    this.show_role(Some(&role));
+                    this.role.replace(Some(role.clone()));
+                    navigator.clone().pop();
+                }));
+
+                navigator.push(selector);
+            }
+        }));
+
+        this.reset_role_button
+            .connect_clicked(clone!(@strong this => move |_| {
+                this.show_role(None);
+                this.role.replace(None);
+            }));
+
+        // Initialize
+
+        if let Some(performance) = performance {
+            if let Some(person) = performance.person {
+                this.show_person(Some(&person));
+                this.person.replace(Some(person));
+            } else if let Some(ensemble) = performance.ensemble {
+                this.show_ensemble(Some(&ensemble));
+                this.ensemble.replace(Some(ensemble));
+            }
+
+            if let Some(role) = performance.role {
+                this.show_role(Some(&role));
+                this.role.replace(Some(role));
+            }
+        }
+
+        this
+    }
+
+    /// Set a closure to be called when the user has chosen to save the performance.
+    pub fn set_selected_cb<F: Fn(Performance) -> () + 'static>(&self, cb: F) {
+        self.selected_cb.replace(Some(Box::new(cb)));
+    }
+
+    /// Update the UI according to person.
+    fn show_person(&self, person: Option<&Person>) {
+        if let Some(person) = person {
+            self.person_label.set_text(&person.name_fl());
+            self.save_button.set_sensitive(true);
+        } else {
+            self.person_label.set_text(&gettext("Select …"));
+        }
+    }
+
+    /// Update the UI according to ensemble.
+    fn show_ensemble(&self, ensemble: Option<&Ensemble>) {
+        if let Some(ensemble) = ensemble {
+            self.ensemble_label.set_text(&ensemble.name);
+            self.save_button.set_sensitive(true);
+        } else {
+            self.ensemble_label.set_text(&gettext("Select …"));
+        }
+    }
+
+    /// Update the UI according to role.
+    fn show_role(&self, role: Option<&Instrument>) {
+        if let Some(role) = role {
+            self.role_label.set_text(&role.name);
+            self.reset_role_button.show();
+        } else {
+            self.role_label.set_text(&gettext("Select …"));
+            self.reset_role_button.hide();
+        }
+    }
+}
+
+impl NavigatorScreen for PerformanceEditor {
+    fn attach_navigator(&self, navigator: Rc<Navigator>) {
+        self.navigator.replace(Some(navigator));
+    }
+
+    fn get_widget(&self) -> gtk::Widget {
+        self.widget.clone().upcast()
+    }
+
+    fn detach_navigator(&self) {
+        self.navigator.replace(None);
+    }
+}

src/editors/person.rs

@@ -0,0 +1,138 @@
+use crate::backend::Backend;
+use crate::database::*;
+use crate::widgets::{Navigator, NavigatorScreen};
+use anyhow::Result;
+use glib::clone;
+use gtk::prelude::*;
+use gtk_macros::get_widget;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+/// A dialog for creating or editing a person.
+pub struct PersonEditor {
+    backend: Rc<Backend>,
+    id: String,
+    widget: gtk::Stack,
+    info_bar: gtk::InfoBar,
+    first_name_entry: gtk::Entry,
+    last_name_entry: gtk::Entry,
+    upload_switch: gtk::Switch,
+    saved_cb: RefCell<Option<Box<dyn Fn(Person) -> ()>>>,
+    navigator: RefCell<Option<Rc<Navigator>>>,
+}
+
+impl PersonEditor {
+    /// Create a new person editor and optionally initialize it.
+    pub fn new(backend: Rc<Backend>, person: Option<Person>) -> Rc<Self> {
+        // Create UI
+
+        let builder = gtk::Builder::from_resource("/de/johrpan/musicus/ui/person_editor.ui");
+
+        get_widget!(builder, gtk::Stack, widget);
+        get_widget!(builder, gtk::Button, back_button);
+        get_widget!(builder, gtk::Button, save_button);
+        get_widget!(builder, gtk::InfoBar, info_bar);
+        get_widget!(builder, gtk::Entry, first_name_entry);
+        get_widget!(builder, gtk::Entry, last_name_entry);
+        get_widget!(builder, gtk::Switch, upload_switch);
+
+        let id = match person {
+            Some(person) => {
+                first_name_entry.set_text(&person.first_name);
+                last_name_entry.set_text(&person.last_name);
+
+                person.id
+            }
+            None => generate_id(),
+        };
+
+        let this = Rc::new(Self {
+            backend,
+            id,
+            widget,
+            info_bar,
+            first_name_entry,
+            last_name_entry,
+            upload_switch,
+            saved_cb: RefCell::new(None),
+            navigator: RefCell::new(None),
+        });
+
+        // Connect signals and callbacks
+
+        back_button.connect_clicked(clone!(@strong this => move |_| {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.pop();
+            }
+        }));
+
+        save_button.connect_clicked(clone!(@strong this => move |_| {
+            let context = glib::MainContext::default();
+            let clone = this.clone();
+            context.spawn_local(async move {
+                clone.widget.set_visible_child_name("loading");
+                match clone.clone().save().await {
+                    Ok(_) => {
+                        let navigator = clone.navigator.borrow().clone();
+                        if let Some(navigator) = navigator {
+                            navigator.pop();
+                        }
+                    }
+                    Err(_) => {
+                        clone.info_bar.set_revealed(true);
+                        clone.widget.set_visible_child_name("content");
+                    }
+                }
+
+            });
+        }));
+
+        this
+    }
+
+    /// Set the closure to be called if the person was saved.
+    pub fn set_saved_cb<F: Fn(Person) -> () + 'static>(&self, cb: F) {
+        self.saved_cb.replace(Some(Box::new(cb)));
+    }
+
+    /// Save the person and possibly upload it to the server.
+    async fn save(self: Rc<Self>) -> Result<()> {
+        let first_name = self.first_name_entry.get_text().to_string();
+        let last_name = self.last_name_entry.get_text().to_string();
+
+        let person = Person {
+            id: self.id.clone(),
+            first_name,
+            last_name,
+        };
+
+        let upload = self.upload_switch.get_active();
+        if upload {
+            self.backend.post_person(&person).await?;
+        }
+
+        self.backend.db().update_person(person.clone()).await?;
+        self.backend.library_changed();
+
+        if let Some(cb) = &*self.saved_cb.borrow() {
+            cb(person.clone());
+        }
+
+        Ok(())
+    }
+}
+
+impl NavigatorScreen for PersonEditor {
+    fn attach_navigator(&self, navigator: Rc<Navigator>) {
+        self.navigator.replace(Some(navigator));
+    }
+
+    fn get_widget(&self) -> gtk::Widget {
+        self.widget.clone().upcast()
+    }
+
+    fn detach_navigator(&self) {
+        self.navigator.replace(None);
+    }
+}

src/editors/recording.rs

@@ -0,0 +1,276 @@
+use super::performance::PerformanceEditor;
+use crate::backend::Backend;
+use crate::database::*;
+use crate::selectors::{PersonSelector, WorkSelector};
+use crate::widgets::{List, Navigator, NavigatorScreen};
+use anyhow::Result;
+use gettextrs::gettext;
+use glib::clone;
+use gtk::prelude::*;
+use gtk_macros::get_widget;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+/// A widget for creating or editing a recording.
+// TODO: Disable buttons if no performance is selected.
+pub struct RecordingEditor {
+    pub widget: gtk::Stack,
+    backend: Rc<Backend>,
+    save_button: gtk::Button,
+    info_bar: gtk::InfoBar,
+    work_label: gtk::Label,
+    comment_entry: gtk::Entry,
+    upload_switch: gtk::Switch,
+    performance_list: Rc<List<Performance>>,
+    id: String,
+    work: RefCell<Option<Work>>,
+    performances: RefCell<Vec<Performance>>,
+    selected_cb: RefCell<Option<Box<dyn Fn(Recording) -> ()>>>,
+    navigator: RefCell<Option<Rc<Navigator>>>,
+}
+
+impl RecordingEditor {
+    /// Create a new recording editor widget and optionally initialize it.
+    pub fn new(backend: Rc<Backend>, recording: Option<Recording>) -> Rc<Self> {
+        // Create UI
+
+        let builder = gtk::Builder::from_resource("/de/johrpan/musicus/ui/recording_editor.ui");
+
+        get_widget!(builder, gtk::Stack, widget);
+        get_widget!(builder, gtk::Button, back_button);
+        get_widget!(builder, gtk::Button, save_button);
+        get_widget!(builder, gtk::InfoBar, info_bar);
+        get_widget!(builder, gtk::Button, work_button);
+        get_widget!(builder, gtk::Label, work_label);
+        get_widget!(builder, gtk::Entry, comment_entry);
+        get_widget!(builder, gtk::Switch, upload_switch);
+        get_widget!(builder, gtk::ScrolledWindow, scroll);
+        get_widget!(builder, gtk::Button, add_performer_button);
+        get_widget!(builder, gtk::Button, edit_performer_button);
+        get_widget!(builder, gtk::Button, remove_performer_button);
+
+        let performance_list = List::new(&gettext("No performers added."));
+        scroll.add(&performance_list.widget);
+
+        let (id, work, performances) = match recording {
+            Some(recording) => {
+                comment_entry.set_text(&recording.comment);
+                (recording.id, Some(recording.work), recording.performances)
+            }
+            None => (generate_id(), None, Vec::new()),
+        };
+
+        let this = Rc::new(RecordingEditor {
+            widget,
+            backend,
+            save_button,
+            info_bar,
+            work_label,
+            comment_entry,
+            upload_switch,
+            performance_list,
+            id,
+            work: RefCell::new(work),
+            performances: RefCell::new(performances),
+            selected_cb: RefCell::new(None),
+            navigator: RefCell::new(None),
+        });
+
+        // Connect signals and callbacks
+
+        back_button.connect_clicked(clone!(@strong this => move |_| {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.clone().pop();
+            }
+        }));
+
+        this.save_button
+            .connect_clicked(clone!(@strong this => move |_| {
+                let context = glib::MainContext::default();
+                let clone = this.clone();
+                context.spawn_local(async move {
+                    clone.widget.set_visible_child_name("loading");
+                    match clone.clone().save().await {
+                        Ok(_) => {
+                            let navigator = clone.navigator.borrow().clone();
+                            if let Some(navigator) = navigator {
+                                navigator.clone().pop();
+                            }
+                        }
+                        Err(_) => {
+                            clone.info_bar.set_revealed(true);
+                            clone.widget.set_visible_child_name("content");
+                        }
+                    }
+
+                });
+            }));
+
+        work_button.connect_clicked(clone!(@strong this => move |_| {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                let person_selector = PersonSelector::new(this.backend.clone());
+
+                person_selector.set_selected_cb(clone!(@strong this, @strong navigator => move |person| {
+                    let work_selector = WorkSelector::new(this.backend.clone(), person.clone());
+                    
+                    work_selector.set_selected_cb(clone!(@strong this, @strong navigator => move |work| {
+                        this.work_selected(&work);
+                        this.work.replace(Some(work.clone()));
+
+                        navigator.clone().pop();
+                        navigator.clone().pop();
+                    }));
+
+                    navigator.clone().push(work_selector);
+                }));
+
+                navigator.push(person_selector);
+            }
+        }));
+
+        this.performance_list.set_make_widget(|performance| {
+            let label = gtk::Label::new(Some(&performance.get_title()));
+            label.set_ellipsize(pango::EllipsizeMode::End);
+            label.set_halign(gtk::Align::Start);
+            label.set_margin_start(6);
+            label.set_margin_end(6);
+            label.set_margin_top(6);
+            label.set_margin_bottom(6);
+            label.upcast()
+        });
+
+        add_performer_button.connect_clicked(clone!(@strong this => move |_| {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                let editor = PerformanceEditor::new(this.backend.clone(), None);
+
+                editor.set_selected_cb(clone!(@strong this, @strong navigator => move |performance| {
+                    let mut performances = this.performances.borrow_mut();
+
+                    let index = match this.performance_list.get_selected_index() {
+                        Some(index) => index + 1,
+                        None => performances.len(),
+                    };
+
+                    performances.insert(index, performance);
+                    this.performance_list.show_items(performances.clone());
+                    this.performance_list.select_index(index);
+
+                    navigator.clone().pop();
+                }));
+
+                navigator.push(editor);
+            }
+        }));
+
+        edit_performer_button.connect_clicked(clone!(@strong this => move |_| {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                if let Some(index) = this.performance_list.get_selected_index() {
+                    let performance = &this.performances.borrow()[index];
+
+                    let editor = PerformanceEditor::new(
+                        this.backend.clone(),
+                        Some(performance.clone()),
+                    );
+
+                    editor.set_selected_cb(clone!(@strong this, @strong navigator => move |performance| {
+                        let mut performances = this.performances.borrow_mut();
+                        performances[index] = performance;
+                        this.performance_list.show_items(performances.clone());
+                        this.performance_list.select_index(index);
+                        navigator.clone().pop();
+                    }));
+
+                    navigator.push(editor);
+                }
+            }
+        }));
+
+        remove_performer_button.connect_clicked(clone!(@strong this => move |_| {
+            if let Some(index) = this.performance_list.get_selected_index() {
+                let mut performances = this.performances.borrow_mut();
+                performances.remove(index);
+                this.performance_list.show_items(performances.clone());
+                this.performance_list.select_index(index);
+            }
+        }));
+
+        // Initialize
+
+        if let Some(work) = &*this.work.borrow() {
+            this.work_selected(work);
+        }
+
+        this.performance_list
+            .show_items(this.performances.borrow().clone());
+
+        this
+    }
+
+    /// Set the closure to be called if the recording was created.
+    pub fn set_selected_cb<F: Fn(Recording) -> () + 'static>(&self, cb: F) {
+        self.selected_cb.replace(Some(Box::new(cb)));
+    }
+
+    /// Update the UI according to work.    
+    fn work_selected(&self, work: &Work) {
+        self.work_label
+            .set_text(&format!("{}: {}", work.composer.name_fl(), work.title));
+        self.save_button.set_sensitive(true);
+    }
+
+    /// Save the recording and possibly upload it to the server.
+    async fn save(self: Rc<Self>) -> Result<()> {
+        let recording = Recording {
+            id: self.id.clone(),
+            work: self
+                .work
+                .borrow()
+                .clone()
+                .expect("Tried to create recording without work!"),
+            comment: self.comment_entry.get_text().to_string(),
+            performances: self.performances.borrow().clone(),
+        };
+
+        let upload = self.upload_switch.get_active();
+        if upload {
+            self.backend.post_recording(&recording).await?;
+        }
+
+        self.backend
+            .db()
+            .update_recording(recording.clone().into())
+            .await
+            .unwrap();
+
+        self.backend.library_changed();
+
+        if let Some(cb) = &*self.selected_cb.borrow() {
+            cb(recording.clone());
+        }
+
+        let navigator = self.navigator.borrow().clone();
+        if let Some(navigator) = navigator {
+            navigator.clone().pop();
+        }
+
+        Ok(())
+    }
+}
+
+impl NavigatorScreen for RecordingEditor {
+    fn attach_navigator(&self, navigator: Rc<Navigator>) {
+        self.navigator.replace(Some(navigator));
+    }
+
+    fn get_widget(&self) -> gtk::Widget {
+        self.widget.clone().upcast()
+    }
+
+    fn detach_navigator(&self) {
+        self.navigator.replace(None);
+    }
+}

src/editors/work.rs

@@ -0,0 +1,432 @@
+use super::work_part::WorkPartEditor;
+use super::work_section::WorkSectionEditor;
+use crate::backend::Backend;
+use crate::database::*;
+use crate::selectors::{InstrumentSelector, PersonSelector};
+use crate::widgets::{List, Navigator, NavigatorScreen};
+use anyhow::Result;
+use gettextrs::gettext;
+use glib::clone;
+use gtk::prelude::*;
+use gtk_macros::get_widget;
+use std::cell::RefCell;
+use std::convert::TryInto;
+use std::rc::Rc;
+
+/// Either a work part or a work section.
+#[derive(Clone)]
+enum PartOrSection {
+    Part(WorkPart),
+    Section(WorkSection),
+}
+
+/// A widget for editing and creating works.
+pub struct WorkEditor {
+    widget: gtk::Stack,
+    backend: Rc<Backend>,
+    save_button: gtk::Button,
+    title_entry: gtk::Entry,
+    info_bar: gtk::InfoBar,
+    composer_label: gtk::Label,
+    upload_switch: gtk::Switch,
+    instrument_list: Rc<List<Instrument>>,
+    part_list: Rc<List<PartOrSection>>,
+    id: String,
+    composer: RefCell<Option<Person>>,
+    instruments: RefCell<Vec<Instrument>>,
+    structure: RefCell<Vec<PartOrSection>>,
+    saved_cb: RefCell<Option<Box<dyn Fn(Work) -> ()>>>,
+    navigator: RefCell<Option<Rc<Navigator>>>,
+}
+
+impl WorkEditor {
+    /// Create a new work editor widget and optionally initialize it.
+    pub fn new(backend: Rc<Backend>, work: Option<Work>) -> Rc<Self> {
+        // Create UI
+
+        let builder = gtk::Builder::from_resource("/de/johrpan/musicus/ui/work_editor.ui");
+
+        get_widget!(builder, gtk::Stack, widget);
+        get_widget!(builder, gtk::Button, back_button);
+        get_widget!(builder, gtk::Button, save_button);
+        get_widget!(builder, gtk::InfoBar, info_bar);
+        get_widget!(builder, gtk::Entry, title_entry);
+        get_widget!(builder, gtk::Button, composer_button);
+        get_widget!(builder, gtk::Label, composer_label);
+        get_widget!(builder, gtk::Switch, upload_switch);
+        get_widget!(builder, gtk::ScrolledWindow, instruments_scroll);
+        get_widget!(builder, gtk::Button, add_instrument_button);
+        get_widget!(builder, gtk::Button, remove_instrument_button);
+        get_widget!(builder, gtk::ScrolledWindow, structure_scroll);
+        get_widget!(builder, gtk::Button, add_part_button);
+        get_widget!(builder, gtk::Button, remove_part_button);
+        get_widget!(builder, gtk::Button, add_section_button);
+        get_widget!(builder, gtk::Button, edit_part_button);
+        get_widget!(builder, gtk::Button, move_part_up_button);
+        get_widget!(builder, gtk::Button, move_part_down_button);
+
+        let instrument_list = List::new(&gettext("No instruments added."));
+        instruments_scroll.add(&instrument_list.widget);
+
+        let part_list = List::new(&gettext("No work parts added."));
+        structure_scroll.add(&part_list.widget);
+
+        let (id, composer, instruments, structure) = match work {
+            Some(work) => {
+                title_entry.set_text(&work.title);
+
+                let mut structure = Vec::new();
+
+                for part in work.parts {
+                    structure.push(PartOrSection::Part(part));
+                }
+
+                for section in work.sections {
+                    structure.insert(
+                        section.before_index.try_into().unwrap(),
+                        PartOrSection::Section(section),
+                    );
+                }
+
+                (work.id, Some(work.composer), work.instruments, structure)
+            }
+            None => (generate_id(), None, Vec::new(), Vec::new()),
+        };
+
+        let this = Rc::new(Self {
+            widget,
+            backend,
+            save_button,
+            id,
+            info_bar,
+            title_entry,
+            composer_label,
+            upload_switch,
+            instrument_list,
+            part_list,
+            composer: RefCell::new(composer),
+            instruments: RefCell::new(instruments),
+            structure: RefCell::new(structure),
+            saved_cb: RefCell::new(None),
+            navigator: RefCell::new(None),
+        });
+
+        // Connect signals and callbacks
+
+        back_button.connect_clicked(clone!(@strong this => move |_| {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.pop();
+            }
+        }));
+
+        this.save_button
+            .connect_clicked(clone!(@strong this => move |_| {
+                let context = glib::MainContext::default();
+                let clone = this.clone();
+                context.spawn_local(async move {
+                    clone.widget.set_visible_child_name("loading");
+                    match clone.clone().save().await {
+                        Ok(_) => {
+                            let navigator = clone.navigator.borrow().clone();
+                            if let Some(navigator) = navigator {
+                                navigator.pop();
+                            }
+                        }
+                        Err(_) => {
+                            clone.info_bar.set_revealed(true);
+                            clone.widget.set_visible_child_name("content");
+                        }
+                    }
+
+                });
+            }));
+
+        composer_button.connect_clicked(clone!(@strong this => move |_| {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                let selector = PersonSelector::new(this.backend.clone());
+
+                selector.set_selected_cb(clone!(@strong this, @strong navigator => move |person| {
+                    this.show_composer(person);
+                    this.composer.replace(Some(person.clone()));
+                    navigator.clone().pop();
+                }));
+
+                navigator.push(selector);
+            }
+        }));
+
+        this.instrument_list.set_make_widget(|instrument| {
+            let label = gtk::Label::new(Some(&instrument.name));
+            label.set_ellipsize(pango::EllipsizeMode::End);
+            label.set_halign(gtk::Align::Start);
+            label.set_margin_start(6);
+            label.set_margin_end(6);
+            label.set_margin_top(6);
+            label.set_margin_bottom(6);
+            label.upcast()
+        });
+
+        add_instrument_button.connect_clicked(clone!(@strong this => move |_| {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                let selector = InstrumentSelector::new(this.backend.clone());
+
+                selector.set_selected_cb(clone!(@strong this, @strong navigator => move |instrument| {
+                    let mut instruments = this.instruments.borrow_mut();
+
+                    let index = match this.instrument_list.get_selected_index() {
+                        Some(index) => index + 1,
+                        None => instruments.len(),
+                    };
+
+                    instruments.insert(index, instrument.clone());
+                    this.instrument_list.show_items(instruments.clone());
+                    this.instrument_list.select_index(index);
+
+                    navigator.clone().pop();
+                }));
+
+                navigator.push(selector);
+            }
+        }));
+
+        remove_instrument_button.connect_clicked(clone!(@strong this => move |_| {
+            if let Some(index) = this.instrument_list.get_selected_index() {
+                let mut instruments = this.instruments.borrow_mut();
+                instruments.remove(index);
+                this.instrument_list.show_items(instruments.clone());
+                this.instrument_list.select_index(index);
+            }
+        }));
+
+        this.part_list.set_make_widget(|pos| {
+            let label = gtk::Label::new(None);
+            label.set_ellipsize(pango::EllipsizeMode::End);
+            label.set_halign(gtk::Align::Start);
+            label.set_margin_end(6);
+            label.set_margin_top(6);
+            label.set_margin_bottom(6);
+
+            match pos {
+                PartOrSection::Part(part) => {
+                    label.set_text(&part.title);
+                    label.set_margin_start(12);
+                }
+                PartOrSection::Section(section) => {
+                    let attrs = pango::AttrList::new();
+                    attrs.insert(pango::Attribute::new_weight(pango::Weight::Bold).unwrap());
+                    label.set_attributes(Some(&attrs));
+                    label.set_text(&section.title);
+                    label.set_margin_start(6);
+                }
+            }
+
+            label.upcast()
+        });
+
+        add_part_button.connect_clicked(clone!(@strong this => move |_| {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                let editor = WorkPartEditor::new(this.backend.clone(), None);
+
+                editor.set_ready_cb(clone!(@strong this, @strong navigator => move |part| {
+                    let mut structure = this.structure.borrow_mut();
+
+                    let index = match this.part_list.get_selected_index() {
+                        Some(index) => index + 1,
+                        None => structure.len(),
+                    };
+
+                    structure.insert(index, PartOrSection::Part(part));
+                    this.part_list.show_items(structure.clone());
+                    this.part_list.select_index(index);
+
+                    navigator.clone().pop();
+                }));
+
+                navigator.push(editor);
+            }
+        }));
+
+        add_section_button.connect_clicked(clone!(@strong this => move |_| {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                let editor = WorkSectionEditor::new(None);
+
+                editor.set_ready_cb(clone!(@strong this, @strong navigator => move |section| {
+                    let mut structure = this.structure.borrow_mut();
+
+                    let index = match this.part_list.get_selected_index() {
+                        Some(index) => index + 1,
+                        None => structure.len(),
+                    };
+
+                    structure.insert(index, PartOrSection::Section(section));
+                    this.part_list.show_items(structure.clone());
+                    this.part_list.select_index(index);
+
+                    navigator.clone().pop();
+                }));
+
+                navigator.push(editor);
+            }
+        }));
+
+        edit_part_button.connect_clicked(clone!(@strong this => move |_| {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                if let Some(index) = this.part_list.get_selected_index() {
+                    match this.structure.borrow()[index].clone() {
+                        PartOrSection::Part(part) => {
+                            let editor = WorkPartEditor::new(this.backend.clone(), Some(part));
+
+                            editor.set_ready_cb(clone!(@strong this, @strong navigator => move |part| {
+                                let mut structure = this.structure.borrow_mut();
+                                structure[index] = PartOrSection::Part(part);
+                                this.part_list.show_items(structure.clone());
+                                this.part_list.select_index(index);
+                                navigator.clone().pop();
+                            }));
+
+                            navigator.push(editor);
+                        }
+                        PartOrSection::Section(section) => {
+                            let editor = WorkSectionEditor::new(Some(section));
+
+                            editor.set_ready_cb(clone!(@strong this, @strong navigator => move |section| {
+                                let mut structure = this.structure.borrow_mut();
+                                structure[index] = PartOrSection::Section(section);
+                                this.part_list.show_items(structure.clone());
+                                this.part_list.select_index(index);
+                                navigator.clone().pop();
+                            }));
+
+                            navigator.push(editor);
+                        }
+                    }
+                }
+            }
+        }));
+
+        remove_part_button.connect_clicked(clone!(@strong this => move |_| {
+            if let Some(index) = this.part_list.get_selected_index() {
+                let mut structure = this.structure.borrow_mut();
+                structure.remove(index);
+                this.part_list.show_items(structure.clone());
+                this.part_list.select_index(index);
+            }
+        }));
+
+        move_part_up_button.connect_clicked(clone!(@strong this => move |_| {
+            if let Some(index) = this.part_list.get_selected_index() {
+                if index > 0 {
+                    let mut structure = this.structure.borrow_mut();
+                    structure.swap(index - 1, index);
+                    this.part_list.show_items(structure.clone());
+                    this.part_list.select_index(index - 1);
+                }
+            }
+        }));
+
+        move_part_down_button.connect_clicked(clone!(@strong this => move |_| {
+            if let Some(index) = this.part_list.get_selected_index() {
+                let mut structure = this.structure.borrow_mut();
+                if index < structure.len() - 1 {
+                    structure.swap(index, index + 1);
+                    this.part_list.show_items(structure.clone());
+                    this.part_list.select_index(index + 1);
+                }
+            }
+        }));
+
+        // Initialization
+
+        if let Some(composer) = &*this.composer.borrow() {
+            this.show_composer(composer);
+        }
+
+        this.instrument_list
+            .show_items(this.instruments.borrow().clone());
+        this.part_list.show_items(this.structure.borrow().clone());
+
+        this
+    }
+
+    /// The closure to call when a work was created.
+    pub fn set_saved_cb<F: Fn(Work) -> () + 'static>(&self, cb: F) {
+        self.saved_cb.replace(Some(Box::new(cb)));
+    }
+
+    /// Update the UI according to person.
+    fn show_composer(&self, person: &Person) {
+        self.composer_label.set_text(&person.name_fl());
+        self.save_button.set_sensitive(true);
+    }
+
+    /// Save the work and possibly upload it to the server.
+    async fn save(self: Rc<Self>) -> Result<()> {
+        let mut section_count: usize = 0;
+        let mut parts = Vec::new();
+        let mut sections = Vec::new();
+
+        for (index, pos) in self.structure.borrow().iter().enumerate() {
+            match pos {
+                PartOrSection::Part(part) => parts.push(part.clone()),
+                PartOrSection::Section(section) => {
+                    let mut section = section.clone();
+                    section.before_index = index - section_count;
+                    sections.push(section);
+                    section_count += 1;
+                }
+            }
+        }
+
+        let work = Work {
+            id: self.id.clone(),
+            title: self.title_entry.get_text().to_string(),
+            composer: self
+                .composer
+                .borrow()
+                .clone()
+                .expect("Tried to create work without composer!"),
+            instruments: self.instruments.borrow().clone(),
+            parts: parts,
+            sections: sections,
+        };
+
+        let upload = self.upload_switch.get_active();
+        if upload {
+            self.backend.post_work(&work).await?;
+        }
+
+        self.backend
+            .db()
+            .update_work(work.clone().into())
+            .await
+            .unwrap();
+
+        self.backend.library_changed();
+
+        if let Some(cb) = &*self.saved_cb.borrow() {
+            cb(work.clone());
+        }
+
+        Ok(())
+    }
+}
+
+impl NavigatorScreen for WorkEditor {
+    fn attach_navigator(&self, navigator: Rc<Navigator>) {
+        self.navigator.replace(Some(navigator));
+    }
+
+    fn get_widget(&self) -> gtk::Widget {
+        self.widget.clone().upcast()
+    }
+
+    fn detach_navigator(&self) {
+        self.navigator.replace(None);
+    }
+}

src/editors/work_part.rs

@@ -0,0 +1,141 @@
+use crate::backend::Backend;
+use crate::database::*;
+use crate::selectors::PersonSelector;
+use crate::widgets::{Navigator, NavigatorScreen};
+use gettextrs::gettext;
+use glib::clone;
+use gtk::prelude::*;
+use gtk_macros::get_widget;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+/// A dialog for creating or editing a work part.
+pub struct WorkPartEditor {
+    backend: Rc<Backend>,
+    widget: gtk::Box,
+    title_entry: gtk::Entry,
+    composer_label: gtk::Label,
+    reset_composer_button: gtk::Button,
+    composer: RefCell<Option<Person>>,
+    ready_cb: RefCell<Option<Box<dyn Fn(WorkPart) -> ()>>>,
+    navigator: RefCell<Option<Rc<Navigator>>>,
+}
+
+impl WorkPartEditor {
+    /// Create a new part editor and optionally initialize it.
+    pub fn new(backend: Rc<Backend>, part: Option<WorkPart>) -> Rc<Self> {
+        // Create UI
+
+        let builder = gtk::Builder::from_resource("/de/johrpan/musicus/ui/work_part_editor.ui");
+
+        get_widget!(builder, gtk::Box, widget);
+        get_widget!(builder, gtk::Button, back_button);
+        get_widget!(builder, gtk::Button, save_button);
+        get_widget!(builder, gtk::Entry, title_entry);
+        get_widget!(builder, gtk::Button, composer_button);
+        get_widget!(builder, gtk::Label, composer_label);
+        get_widget!(builder, gtk::Button, reset_composer_button);
+
+        let composer = match part {
+            Some(part) => {
+                title_entry.set_text(&part.title);
+                part.composer
+            }
+            None => None,
+        };
+
+        let this = Rc::new(Self {
+            backend,
+            widget,
+            title_entry,
+            composer_label,
+            reset_composer_button,
+            composer: RefCell::new(composer),
+            ready_cb: RefCell::new(None),
+            navigator: RefCell::new(None),
+        });
+
+        // Connect signals and callbacks
+
+        back_button.connect_clicked(clone!(@strong this => move |_| {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.pop();
+            }
+        }));
+
+        save_button.connect_clicked(clone!(@strong this => move |_| {
+            if let Some(cb) = &*this.ready_cb.borrow() {
+                cb(WorkPart {
+                    title: this.title_entry.get_text().to_string(),
+                    composer: this.composer.borrow().clone(),
+                });
+            }
+
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.pop();
+            }
+        }));
+
+        composer_button.connect_clicked(clone!(@strong this => move |_| {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                let selector = PersonSelector::new(this.backend.clone());
+
+                selector.set_selected_cb(clone!(@strong this, @strong navigator => move |person| {
+                    this.show_composer(Some(person));
+                    this.composer.replace(Some(person.clone()));
+                    navigator.clone().pop();
+                }));
+
+                navigator.push(selector);
+            }
+
+        }));
+
+        this.reset_composer_button
+            .connect_clicked(clone!(@strong this => move |_| {
+                this.composer.replace(None);
+                this.show_composer(None);
+            }));
+
+        // Initialize
+
+        if let Some(composer) = &*this.composer.borrow() {
+            this.show_composer(Some(composer));
+        }
+
+        this
+    }
+
+    /// Set the closure to be called when the user wants to save the part.
+    pub fn set_ready_cb<F: Fn(WorkPart) -> () + 'static>(&self, cb: F) {
+        self.ready_cb.replace(Some(Box::new(cb)));
+    }
+
+    /// Update the UI according to person.
+    fn show_composer(&self, person: Option<&Person>) {
+        if let Some(person) = person {
+            self.composer_label.set_text(&person.name_fl());
+            self.reset_composer_button.show();
+        } else {
+            self.composer_label.set_text(&gettext("Select …"));
+            self.reset_composer_button.hide();
+        }
+    }
+}
+
+impl NavigatorScreen for WorkPartEditor {
+    fn attach_navigator(&self, navigator: Rc<Navigator>) {
+        self.navigator.replace(Some(navigator));
+    }
+
+    fn get_widget(&self) -> gtk::Widget {
+        self.widget.clone().upcast()
+    }
+
+    fn detach_navigator(&self) {
+        self.navigator.replace(None);
+    }
+}

src/editors/work_section.rs

@@ -0,0 +1,86 @@
+use crate::database::*;
+use crate::widgets::{Navigator, NavigatorScreen};
+use glib::clone;
+use gtk::prelude::*;
+use gtk_macros::get_widget;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+/// A dialog for creating or editing a work section.
+pub struct WorkSectionEditor {
+    widget: gtk::Box,
+    title_entry: gtk::Entry,
+    ready_cb: RefCell<Option<Box<dyn Fn(WorkSection) -> ()>>>,
+    navigator: RefCell<Option<Rc<Navigator>>>,
+}
+
+impl WorkSectionEditor {
+    /// Create a new section editor and optionally initialize it.
+    pub fn new(section: Option<WorkSection>) -> Rc<Self> {
+        // Create UI
+
+        let builder = gtk::Builder::from_resource("/de/johrpan/musicus/ui/work_section_editor.ui");
+
+        get_widget!(builder, gtk::Box, widget);
+        get_widget!(builder, gtk::Button, back_button);
+        get_widget!(builder, gtk::Button, save_button);
+        get_widget!(builder, gtk::Entry, title_entry);
+
+        if let Some(section) = section {
+            title_entry.set_text(&section.title);
+        }
+
+        let this = Rc::new(Self {
+            widget,
+            title_entry,
+            ready_cb: RefCell::new(None),
+            navigator: RefCell::new(None),
+        });
+
+        // Connect signals and callbacks
+
+        back_button.connect_clicked(clone!(@strong this => move |_| {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.pop();
+            }
+        }));
+
+        save_button.connect_clicked(clone!(@strong this => move |_| {
+            if let Some(cb) = &*this.ready_cb.borrow() {
+                cb(WorkSection {
+                    before_index: 0,
+                    title: this.title_entry.get_text().to_string(),
+                });
+            }
+
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.pop();
+            }
+        }));
+
+        this
+    }
+
+    /// Set the closure to be called when the user wants to save the section. Note that the
+    /// resulting object will always have `before_index` set to 0. The caller is expected to
+    /// change that later before adding the section to the database.
+    pub fn set_ready_cb<F: Fn(WorkSection) -> () + 'static>(&self, cb: F) {
+        self.ready_cb.replace(Some(Box::new(cb)));
+    }
+}
+
+impl NavigatorScreen for WorkSectionEditor {
+    fn attach_navigator(&self, navigator: Rc<Navigator>) {
+        self.navigator.replace(Some(navigator));
+    }
+
+    fn get_widget(&self) -> gtk::Widget {
+        self.widget.clone().upcast()
+    }
+
+    fn detach_navigator(&self) {
+        self.navigator.replace(None);
+    }
+}

src/import/disc_source.rs

@@ -0,0 +1,175 @@
+use anyhow::{anyhow, bail, Result};
+use discid::DiscId;
+use futures_channel::oneshot;
+use gstreamer::prelude::*;
+use gstreamer::{Element, ElementFactory, Pipeline};
+use std::cell::RefCell;
+use std::path::{Path, PathBuf};
+use std::thread;
+
+/// Representation of an audio CD being imported as a medium.
+#[derive(Clone, Debug)]
+pub struct DiscSource {
+    /// The MusicBrainz DiscID of the CD.
+    pub discid: String,
+
+    /// The path to the temporary directory where the audio files will be.
+    pub path: PathBuf,
+
+    /// The tracks on this disc.
+    pub tracks: Vec<TrackSource>,
+}
+
+/// Representation of a single track on an audio CD.
+#[derive(Clone, Debug)]
+pub struct TrackSource {
+    /// The track number. This is different from the index in the disc
+    /// source's tracks list, because it is not defined from which number the
+    /// the track numbers start.
+    pub number: u32,
+
+    /// The path to the temporary file to which the track will be ripped. The
+    /// file will not exist until the track is actually ripped.
+    pub path: PathBuf,
+}
+
+impl DiscSource {
+    /// Try to create a new disc source by asynchronously reading the
+    /// information from the default disc drive.
+    pub async fn load() -> Result<Self> {
+        let (sender, receiver) = oneshot::channel();
+
+        thread::spawn(|| {
+            let disc = Self::load_priv();
+            sender.send(disc).unwrap();
+        });
+
+        let disc = receiver.await??;
+
+        Ok(disc)
+    }
+
+    /// Rip the whole disc asynchronously. After this method has finished
+    /// successfully, the audio files will be available in the specified
+    /// location for each track source.
+    pub async fn rip(&self) -> Result<()> {
+        for track in &self.tracks {
+            let (sender, receiver) = oneshot::channel();
+
+            let number = track.number;
+            let path = track.path.clone();
+
+            thread::spawn(move || {
+                let result = Self::rip_track(&path, number);
+                sender.send(result).unwrap();
+            });
+
+            receiver.await??;
+        }
+
+        Ok(())
+    }
+
+    /// Load the disc from the default disc drive.
+    fn load_priv() -> Result<Self> {
+        let discid = DiscId::read(None)?;
+        let id = discid.id();
+
+        let mut tracks = Vec::new();
+
+        let first_track = discid.first_track_num() as u32;
+        let last_track = discid.last_track_num() as u32;
+
+        let tmp_dir = Self::create_tmp_dir()?;
+
+        for number in first_track..=last_track {
+            let file_name = format!("track_{:02}.flac", number);
+
+            let mut path = tmp_dir.clone();
+            path.push(file_name);
+
+            let track = TrackSource {
+                number,
+                path,
+            };
+
+            tracks.push(track);
+        }
+
+        let disc = DiscSource {
+            discid: id,
+            tracks,
+            path: tmp_dir,
+        };
+
+        Ok(disc)
+    }
+
+    /// Create a new temporary directory and return its path.
+    // TODO: Move to a more appropriate place.
+    fn create_tmp_dir() -> Result<PathBuf> {
+        let mut tmp_dir = glib::get_tmp_dir()
+            .ok_or_else(|| {
+                anyhow!("Failed to get temporary directory using glib::get_tmp_dir()!")
+            })?;
+
+        let dir_name = format!("musicus-{}", rand::random::<u64>());
+        tmp_dir.push(dir_name);
+
+        std::fs::create_dir(&tmp_dir)?;
+
+        Ok(tmp_dir)
+    }
+
+    /// Rip one track.
+    fn rip_track(path: &Path, number: u32) -> Result<()> {
+        let pipeline = Self::build_pipeline(path, number)?;
+
+        let bus = pipeline
+            .get_bus()
+            .ok_or_else(|| anyhow!("Failed to get bus from pipeline!"))?;
+
+        pipeline.set_state(gstreamer::State::Playing)?;
+
+        for msg in bus.iter_timed(gstreamer::CLOCK_TIME_NONE) {
+            use gstreamer::MessageView::*;
+
+            match msg.view() {
+                Eos(..) => break,
+                Error(err) => {
+                    pipeline.set_state(gstreamer::State::Null)?;
+                    bail!("GStreamer error: {:?}!", err);
+                }
+                _ => (),
+            }
+        }
+
+        pipeline.set_state(gstreamer::State::Null)?;
+
+        Ok(())
+    }
+
+    /// Build the GStreamer pipeline to rip a track.
+    fn build_pipeline(path: &Path, number: u32) -> Result<Pipeline> {
+        let cdparanoiasrc = ElementFactory::make("cdparanoiasrc", None)?;
+        cdparanoiasrc.set_property("track", &number)?;
+
+        let queue = ElementFactory::make("queue", None)?;
+        let audioconvert = ElementFactory::make("audioconvert", None)?;
+        let flacenc = ElementFactory::make("flacenc", None)?;
+
+        let path_str = path.to_str().ok_or_else(|| {
+            anyhow!("Failed to convert path '{:?}' to string!", path)
+        })?;
+
+        let filesink = gstreamer::ElementFactory::make("filesink", None)?;
+        filesink.set_property("location", &path_str.to_owned())?;
+
+        let pipeline = gstreamer::Pipeline::new(None);
+        pipeline.add_many(&[&cdparanoiasrc, &queue, &audioconvert, &flacenc, &filesink])?;
+
+        Element::link_many(&[&cdparanoiasrc, &queue, &audioconvert, &flacenc, &filesink])?;
+
+        Ok(pipeline)
+    }
+}

src/import/medium_editor.rs

@@ -0,0 +1,241 @@
+use super::disc_source::DiscSource;
+use super::track_set_editor::{TrackSetData, TrackSetEditor};
+use crate::database::{generate_id, Medium, Track, TrackSet};
+use crate::backend::Backend;
+use crate::widgets::{Navigator, NavigatorScreen};
+use crate::widgets::new_list::List;
+use anyhow::Result;
+use glib::clone;
+use glib::prelude::*;
+use gtk::prelude::*;
+use gtk_macros::get_widget;
+use libhandy::prelude::*;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+/// A dialog for editing metadata while importing music into the music library.
+pub struct MediumEditor {
+    backend: Rc<Backend>,
+    source: Rc<DiscSource>,
+    widget: gtk::Stack,
+    done_button: gtk::Button,
+    done_stack: gtk::Stack,
+    done: gtk::Image,
+    name_entry: gtk::Entry,
+    publish_switch: gtk::Switch,
+    track_set_list: List,
+    track_sets: RefCell<Vec<TrackSetData>>,
+    navigator: RefCell<Option<Rc<Navigator>>>,
+}
+
+impl MediumEditor {
+    /// Create a new medium editor.
+    pub fn new(backend: Rc<Backend>, source: DiscSource) -> Rc<Self> {
+        // Create UI
+
+        let builder = gtk::Builder::from_resource("/de/johrpan/musicus/ui/medium_editor.ui");
+
+        get_widget!(builder, gtk::Stack, widget);
+        get_widget!(builder, gtk::Button, back_button);
+        get_widget!(builder, gtk::Button, done_button);
+        get_widget!(builder, gtk::Stack, done_stack);
+        get_widget!(builder, gtk::Image, done);
+        get_widget!(builder, gtk::Entry, name_entry);
+        get_widget!(builder, gtk::Switch, publish_switch);
+        get_widget!(builder, gtk::Button, add_button);
+        get_widget!(builder, gtk::Frame, frame);
+
+        let list = List::new("No recordings added.");
+        frame.add(&list.widget);
+
+        let this = Rc::new(Self {
+            backend,
+            source: Rc::new(source),
+            widget,
+            done_button,
+            done_stack,
+            done,
+            name_entry,
+            publish_switch,
+            track_set_list: list,
+            track_sets: RefCell::new(Vec::new()),
+            navigator: RefCell::new(None),
+        });
+
+        // Connect signals and callbacks
+
+        back_button.connect_clicked(clone!(@strong this => move |_| {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.pop();
+            }
+        }));
+
+        this.done_button.connect_clicked(clone!(@strong this => move |_| {
+            let context = glib::MainContext::default();
+            let clone = this.clone();
+            context.spawn_local(async move {
+                clone.widget.set_visible_child_name("loading");
+                match clone.clone().save().await {
+                    Ok(_) => (),
+                    Err(err) => {
+                        println!("{:?}", err);
+                        // clone.info_bar.set_revealed(true);
+                    }
+                }
+
+            });
+        }));
+
+        add_button.connect_clicked(clone!(@strong this => move |_| {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                let editor = TrackSetEditor::new(this.backend.clone(), Rc::clone(&this.source));
+
+                editor.set_done_cb(clone!(@strong this => move |track_set| {
+                    let length = {
+                        let mut track_sets = this.track_sets.borrow_mut();
+                        track_sets.push(track_set);
+                        track_sets.len()
+                    };
+
+                    this.track_set_list.update(length);
+                }));
+
+                navigator.push(editor);
+            }
+        }));
+
+        this.track_set_list.set_make_widget(clone!(@strong this => move |index| {
+            let track_set = &this.track_sets.borrow()[index];
+
+            let title = track_set.recording.work.get_title();
+            let subtitle = track_set.recording.get_performers();
+
+            let edit_image = gtk::Image::from_icon_name(Some("document-edit-symbolic"), gtk::IconSize::Button);
+            let edit_button = gtk::Button::new();
+            edit_button.set_relief(gtk::ReliefStyle::None);
+            edit_button.set_valign(gtk::Align::Center);
+            edit_button.add(&edit_image);
+
+            let row = libhandy::ActionRow::new();
+            row.set_activatable(true);
+            row.set_title(Some(&title));
+            row.set_subtitle(Some(&subtitle));
+            row.add(&edit_button);
+            row.set_activatable_widget(Some(&edit_button));
+            row.show_all();
+
+            edit_button.connect_clicked(clone!(@strong this => move |_| {
+
+            }));
+
+            row.upcast()
+        }));
+
+        // Start ripping the CD in the background.
+        let context = glib::MainContext::default();
+        let clone = this.clone();
+        context.spawn_local(async move {
+            match clone.source.rip().await {
+                Err(error) => {
+                    // TODO: Present error.
+                    println!("Failed to rip: {}", error);
+                },
+                Ok(_) => {
+                    clone.done_stack.set_visible_child(&clone.done);
+                    clone.done_button.set_sensitive(true);
+                }
+            }
+        });
+
+        this
+    }
+
+    /// Save the medium and possibly upload it to the server.
+    async fn save(self: Rc<Self>) -> Result<()> {
+        let name = self.name_entry.get_text().to_string();
+
+        // Create a new directory in the music library path for the imported medium.
+
+        let mut path = self.backend.get_music_library_path().unwrap().clone();
+        path.push(&name);
+        std::fs::create_dir(&path)?;
+
+        // Convert the track set data to real track sets.
+
+        let mut track_sets = Vec::new();
+
+        for track_set_data in &*self.track_sets.borrow() {
+            let mut tracks = Vec::new();
+
+            for track_data in &track_set_data.tracks {
+                // Copy the corresponding audio file to the music library.
+
+                let track_source = &self.source.tracks[track_data.track_source];
+                let file_name = format!("track_{:02}.flac", track_source.number);
+
+                let mut track_path = path.clone();
+                track_path.push(&file_name);
+
+                std::fs::copy(&track_source.path, &track_path)?;
+
+                // Create the real track.
+
+                let track = Track {
+                    work_parts: track_data.work_parts.clone(),
+                    path: track_path.to_str().unwrap().to_owned(),
+                };
+
+                tracks.push(track);
+            }
+
+            let track_set = TrackSet {
+                recording: track_set_data.recording.clone(),
+                tracks,
+            };
+
+            track_sets.push(track_set);
+        }
+
+        let medium = Medium {
+            id: generate_id(),
+            name: self.name_entry.get_text().to_string(),
+            discid: Some(self.source.discid.clone()),
+            tracks: track_sets,
+        };
+
+        let upload = self.publish_switch.get_active();
+        if upload {
+            // self.backend.post_medium(&medium).await?;
+        }
+
+        self.backend
+            .db()
+            .update_medium(medium.clone())
+            .await?;
+
+        self.backend.library_changed();
+
+        let navigator = self.navigator.borrow().clone();
+        if let Some(navigator) = navigator {
+            navigator.clone().pop();
+        }
+
+        Ok(())
+    }
+}
+
+impl NavigatorScreen for MediumEditor {
+    fn attach_navigator(&self, navigator: Rc<Navigator>) {
+        self.navigator.replace(Some(navigator));
+    }
+
+    fn get_widget(&self) -> gtk::Widget {
+        self.widget.clone().upcast()
+    }
+
+    fn detach_navigator(&self) {
+        self.navigator.replace(None);
+    }
+}

src/import/mod.rs

@@ -0,0 +1,8 @@
+mod disc_source;
+mod medium_editor;
+mod source_selector;
+mod track_editor;
+mod track_selector;
+mod track_set_editor;
+
+pub use source_selector::SourceSelector;

src/import/source_selector.rs

@@ -0,0 +1,92 @@
+use super::medium_editor::MediumEditor;
+use super::disc_source::DiscSource;
+use crate::backend::Backend;
+use crate::widgets::{Navigator, NavigatorScreen};
+use anyhow::Result;
+use glib::clone;
+use gtk::prelude::*;
+use gtk_macros::get_widget;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+/// A dialog for starting to import music.
+pub struct SourceSelector {
+    backend: Rc<Backend>,
+    widget: gtk::Box,
+    stack: gtk::Stack,
+    info_bar: gtk::InfoBar,
+    navigator: RefCell<Option<Rc<Navigator>>>,
+}
+
+impl SourceSelector {
+    /// Create a new source selector.
+    pub fn new(backend: Rc<Backend>) -> Rc<Self> {
+        // Create UI
+
+        let builder = gtk::Builder::from_resource("/de/johrpan/musicus/ui/source_selector.ui");
+
+        get_widget!(builder, gtk::Box, widget);
+        get_widget!(builder, gtk::Button, back_button);
+        get_widget!(builder, gtk::Stack, stack);
+        get_widget!(builder, gtk::InfoBar, info_bar);
+        get_widget!(builder, gtk::Button, import_button);
+
+        let this = Rc::new(Self {
+            backend,
+            widget,
+            stack,
+            info_bar,
+            navigator: RefCell::new(None),
+        });
+
+        // Connect signals and callbacks
+
+        back_button.connect_clicked(clone!(@strong this => move |_| {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.pop();
+            }
+        }));
+
+        import_button.connect_clicked(clone!(@strong this => move |_| {
+            this.stack.set_visible_child_name("loading");
+
+            let context = glib::MainContext::default();
+            let clone = this.clone();
+            context.spawn_local(async move {
+                match DiscSource::load().await {
+                    Ok(disc) => {
+                        let navigator = clone.navigator.borrow().clone();
+                        if let Some(navigator) = navigator {
+                            let editor = MediumEditor::new(clone.backend.clone(), disc);
+                            navigator.push(editor);
+                        }
+
+                        clone.info_bar.set_revealed(false);
+                        clone.stack.set_visible_child_name("start");
+                    }
+                    Err(_) => {
+                        clone.info_bar.set_revealed(true);
+                        clone.stack.set_visible_child_name("start");
+                    }
+                }
+            });
+        }));
+
+        this
+    }
+}
+
+impl NavigatorScreen for SourceSelector {
+    fn attach_navigator(&self, navigator: Rc<Navigator>) {
+        self.navigator.replace(Some(navigator));
+    }
+
+    fn get_widget(&self) -> gtk::Widget {
+        self.widget.clone().upcast()
+    }
+
+    fn detach_navigator(&self) {
+        self.navigator.replace(None);
+    }
+}

src/import/track_editor.rs

@@ -0,0 +1,110 @@
+use crate::database::Recording;
+use crate::widgets::{Navigator, NavigatorScreen};
+use crate::widgets::new_list::List;
+use glib::clone;
+use gtk::prelude::*;
+use gtk_macros::get_widget;
+use libhandy::prelude::*;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+/// A screen for editing a single track.
+pub struct TrackEditor {
+    widget: gtk::Box,
+    selection: RefCell<Vec<usize>>,
+    selected_cb: RefCell<Option<Box<dyn Fn(Vec<usize>)>>>,
+    navigator: RefCell<Option<Rc<Navigator>>>,
+}
+
+impl TrackEditor {
+    /// Create a new track editor.
+    pub fn new(recording: Recording, selection: Vec<usize>) -> Rc<Self> {
+        // Create UI
+
+        let builder = gtk::Builder::from_resource("/de/johrpan/musicus/ui/track_editor.ui");
+
+        get_widget!(builder, gtk::Box, widget);
+        get_widget!(builder, gtk::Button, back_button);
+        get_widget!(builder, gtk::Button, select_button);
+        get_widget!(builder, gtk::Frame, parts_frame);
+
+        let parts_list = gtk::ListBox::new();
+        parts_list.set_selection_mode(gtk::SelectionMode::None);
+        parts_list.set_vexpand(false);
+        parts_list.show();
+        parts_frame.add(&parts_list);
+
+        let this = Rc::new(Self {
+            widget,
+            selection: RefCell::new(selection),
+            selected_cb: RefCell::new(None),
+            navigator: RefCell::new(None),
+        });
+
+        // Connect signals and callbacks
+
+        back_button.connect_clicked(clone!(@strong this => move |_| {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.pop();
+            }
+        }));
+
+        select_button.connect_clicked(clone!(@strong this => move |_| {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.pop();
+            }
+
+            if let Some(cb) = &*this.selected_cb.borrow() {
+                let selection = this.selection.borrow().clone();
+                cb(selection);
+            }
+        }));
+
+        for (index, part) in recording.work.parts.iter().enumerate() {
+            let check = gtk::CheckButton::new();
+            check.set_active(this.selection.borrow().contains(&index));
+
+            check.connect_toggled(clone!(@strong this => move |check| {
+                let mut selection = this.selection.borrow_mut();
+                if check.get_active() {
+                    selection.push(index);
+                } else {
+                    if let Some(pos) = selection.iter().position(|part| *part == index) {
+                        selection.remove(pos);
+                    }
+                }
+            }));
+
+            let row = libhandy::ActionRow::new();
+            row.add_prefix(&check);
+            row.set_activatable_widget(Some(&check));
+            row.set_title(Some(&part.title));
+            row.show_all();
+
+            parts_list.add(&row);
+        }
+
+        this
+    }
+
+    /// Set the closure to be called when the user has edited the track.
+    pub fn set_selected_cb<F: Fn(Vec<usize>) + 'static>(&self, cb: F) {
+        self.selected_cb.replace(Some(Box::new(cb)));
+    }
+}
+
+impl NavigatorScreen for TrackEditor {
+    fn attach_navigator(&self, navigator: Rc<Navigator>) {
+        self.navigator.replace(Some(navigator));
+    }
+
+    fn get_widget(&self) -> gtk::Widget {
+        self.widget.clone().upcast()
+    }
+
+    fn detach_navigator(&self) {
+        self.navigator.replace(None);
+    }
+}

src/import/track_selector.rs

@@ -0,0 +1,122 @@
+use super::disc_source::DiscSource;
+use crate::widgets::{Navigator, NavigatorScreen};
+use glib::clone;
+use gtk::prelude::*;
+use gtk_macros::get_widget;
+use libhandy::prelude::*;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+/// A screen for selecting tracks from a medium.
+pub struct TrackSelector {
+    source: Rc<DiscSource>,
+    widget: gtk::Box,
+    select_button: gtk::Button,
+    selection: RefCell<Vec<usize>>,
+    selected_cb: RefCell<Option<Box<dyn Fn(Vec<usize>)>>>,
+    navigator: RefCell<Option<Rc<Navigator>>>,
+}
+
+impl TrackSelector {
+    /// Create a new track selector.
+    pub fn new(source: Rc<DiscSource>) -> Rc<Self> {
+        // Create UI
+
+        let builder = gtk::Builder::from_resource("/de/johrpan/musicus/ui/track_selector.ui");
+
+        get_widget!(builder, gtk::Box, widget);
+        get_widget!(builder, gtk::Button, back_button);
+        get_widget!(builder, gtk::Button, select_button);
+        get_widget!(builder, gtk::Frame, tracks_frame);
+
+        let track_list = gtk::ListBox::new();
+        track_list.set_selection_mode(gtk::SelectionMode::None);
+        track_list.set_vexpand(false);
+        track_list.show();
+        tracks_frame.add(&track_list);
+
+        let this = Rc::new(Self {
+            source,
+            widget,
+            select_button,
+            selection: RefCell::new(Vec::new()),
+            selected_cb: RefCell::new(None),
+            navigator: RefCell::new(None),
+        });
+
+        // Connect signals and callbacks
+
+        back_button.connect_clicked(clone!(@strong this => move |_| {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.pop();
+            }
+        }));
+
+        this.select_button.connect_clicked(clone!(@strong this => move |_| {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.pop();
+            }
+
+            if let Some(cb) = &*this.selected_cb.borrow() {
+                let selection = this.selection.borrow().clone();
+                cb(selection);
+            }
+        }));
+
+        for (index, track) in this.source.tracks.iter().enumerate() {
+            let check = gtk::CheckButton::new();
+
+            check.connect_toggled(clone!(@strong this => move |check| {
+                let mut selection = this.selection.borrow_mut();
+                if check.get_active() {
+                    selection.push(index);
+                } else {
+                    if let Some(pos) = selection.iter().position(|part| *part == index) {
+                        selection.remove(pos);
+                    }
+                }
+
+                if selection.is_empty() {
+                    this.select_button.set_sensitive(false);
+                } else {
+                    this.select_button.set_sensitive(true);
+                }
+            }));
+
+            let title = format!("Track {}", track.number);
+
+            let row = libhandy::ActionRow::new();
+            row.add_prefix(&check);
+            row.set_activatable_widget(Some(&check));
+            row.set_title(Some(&title));
+            row.show_all();
+
+            track_list.add(&row);
+        }
+
+        this
+    }
+
+    /// Set the closure to be called when the user has selected tracks. The
+    /// closure will be called with the indices of the selected tracks as its
+    /// argument.
+    pub fn set_selected_cb<F: Fn(Vec<usize>) + 'static>(&self, cb: F) {
+        self.selected_cb.replace(Some(Box::new(cb)));
+    }
+}
+
+impl NavigatorScreen for TrackSelector {
+    fn attach_navigator(&self, navigator: Rc<Navigator>) {
+        self.navigator.replace(Some(navigator));
+    }
+
+    fn get_widget(&self) -> gtk::Widget {
+        self.widget.clone().upcast()
+    }
+
+    fn detach_navigator(&self) {
+        self.navigator.replace(None);
+    }
+}

src/import/track_set_editor.rs

@@ -0,0 +1,283 @@
+use super::disc_source::DiscSource;
+use super::track_editor::TrackEditor;
+use super::track_selector::TrackSelector;
+use crate::backend::Backend;
+use crate::database::{Recording, Track, TrackSet};
+use crate::selectors::{PersonSelector, RecordingSelector, WorkSelector};
+use crate::widgets::{Navigator, NavigatorScreen};
+use crate::widgets::new_list::List;
+use gettextrs::gettext;
+use glib::clone;
+use gtk::prelude::*;
+use gtk_macros::get_widget;
+use libhandy::prelude::*;
+use std::cell::{Cell, RefCell};
+use std::collections::HashSet;
+use std::rc::Rc;
+
+/// A track set before being imported.
+#[derive(Clone, Debug)]
+pub struct TrackSetData {
+    pub recording: Recording,
+    pub tracks: Vec<TrackData>,
+}
+
+/// A track before being imported.
+#[derive(Clone, Debug)]
+pub struct TrackData {
+    /// Index of the track source within the medium source's tracks.
+    pub track_source: usize,
+
+    /// Actual track data.
+    pub work_parts: Vec<usize>,
+}
+
+/// A screen for editing a set of tracks for one recording.
+pub struct TrackSetEditor {
+    backend: Rc<Backend>,
+    source: Rc<DiscSource>,
+    widget: gtk::Box,
+    save_button: gtk::Button,
+    recording_row: libhandy::ActionRow,
+    track_list: List,
+    recording: RefCell<Option<Recording>>,
+    tracks: RefCell<Vec<TrackData>>,
+    done_cb: RefCell<Option<Box<dyn Fn(TrackSetData)>>>,
+    navigator: RefCell<Option<Rc<Navigator>>>,
+}
+
+impl TrackSetEditor {
+    /// Create a new track set editor.
+    pub fn new(backend: Rc<Backend>, source: Rc<DiscSource>) -> Rc<Self> {
+        // Create UI
+
+        let builder = gtk::Builder::from_resource("/de/johrpan/musicus/ui/track_set_editor.ui");
+
+        get_widget!(builder, gtk::Box, widget);
+        get_widget!(builder, gtk::Button, back_button);
+        get_widget!(builder, gtk::Button, save_button);
+        get_widget!(builder, libhandy::ActionRow, recording_row);
+        get_widget!(builder, gtk::Button, select_recording_button);
+        get_widget!(builder, gtk::Button, edit_tracks_button);
+        get_widget!(builder, gtk::Frame, tracks_frame);
+
+        let track_list = List::new(&gettext!("No tracks added"));
+        tracks_frame.add(&track_list.widget);
+
+        let this = Rc::new(Self {
+            backend,
+            source,
+            widget,
+            save_button,
+            recording_row,
+            track_list,
+            recording: RefCell::new(None),
+            tracks: RefCell::new(Vec::new()),
+            done_cb: RefCell::new(None),
+            navigator: RefCell::new(None),
+        });
+
+        // Connect signals and callbacks
+
+        back_button.connect_clicked(clone!(@strong this => move |_| {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.pop();
+            }
+        }));
+
+        this.save_button.connect_clicked(clone!(@strong this => move |_| {
+            if let Some(cb) = &*this.done_cb.borrow() {
+                let data = TrackSetData {
+                    recording: this.recording.borrow().clone().unwrap(),
+                    tracks: this.tracks.borrow().clone(),
+                };
+
+                cb(data);
+            }
+
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.pop();
+            }
+        }));
+
+        select_recording_button.connect_clicked(clone!(@strong this => move |_| {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                let person_selector = PersonSelector::new(this.backend.clone());
+
+                person_selector.set_selected_cb(clone!(@strong this, @strong navigator => move |person| {
+                    let work_selector = WorkSelector::new(this.backend.clone(), person.clone());
+
+                    work_selector.set_selected_cb(clone!(@strong this, @strong navigator => move |work| {
+                        let recording_selector = RecordingSelector::new(this.backend.clone(), work.clone());
+
+                        recording_selector.set_selected_cb(clone!(@strong this, @strong navigator => move |recording| {
+                            this.recording.replace(Some(recording.clone()));
+                            this.recording_selected();
+
+                            navigator.clone().pop();
+                            navigator.clone().pop();
+                            navigator.clone().pop();
+                        }));
+
+                        navigator.clone().push(recording_selector);
+                    }));
+
+                    navigator.clone().push(work_selector);
+                }));
+
+                navigator.clone().push(person_selector);
+            }
+        }));
+
+        edit_tracks_button.connect_clicked(clone!(@strong this => move |_| {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                let selector = TrackSelector::new(Rc::clone(&this.source));
+
+                selector.set_selected_cb(clone!(@strong this => move |selection| {
+                    let mut tracks = Vec::new();
+
+                    for index in selection {
+                        let data = TrackData {
+                            track_source: index,
+                            work_parts: Vec::new(),
+                        };
+
+                        tracks.push(data);
+                    }
+
+                    let length = tracks.len();
+                    this.tracks.replace(tracks);
+                    this.track_list.update(length);
+                    this.autofill_parts();
+                }));
+
+                navigator.push(selector);
+            }
+        }));
+
+        this.track_list.set_make_widget(clone!(@strong this => move |index| {
+            let track = &this.tracks.borrow()[index];
+
+            let mut title_parts = Vec::<String>::new();
+
+            if let Some(recording) = &*this.recording.borrow() {
+                for part in &track.work_parts {
+                    title_parts.push(recording.work.parts[*part].title.clone());
+                }
+            }
+
+            let title = if title_parts.is_empty() {
+                gettext("Unknown")
+            } else {
+                title_parts.join(", ")
+            };
+
+            let number = this.source.tracks[track.track_source].number;
+            let subtitle = format!("Track {}", number);
+
+            let edit_image = gtk::Image::from_icon_name(Some("document-edit-symbolic"), gtk::IconSize::Button);
+            let edit_button = gtk::Button::new();
+            edit_button.set_relief(gtk::ReliefStyle::None);
+            edit_button.set_valign(gtk::Align::Center);
+            edit_button.add(&edit_image);
+
+            let row = libhandy::ActionRow::new();
+            row.set_activatable(true);
+            row.set_title(Some(&title));
+            row.set_subtitle(Some(&subtitle));
+            row.add(&edit_button);
+            row.set_activatable_widget(Some(&edit_button));
+            row.show_all();
+
+            edit_button.connect_clicked(clone!(@strong this => move |_| {
+                let recording = this.recording.borrow().clone();
+                let navigator = this.navigator.borrow().clone();
+
+                if let (Some(recording), Some(navigator)) = (recording, navigator) {
+                    let track = &this.tracks.borrow()[index];
+
+                    let editor = TrackEditor::new(recording, track.work_parts.clone());
+
+                    editor.set_selected_cb(clone!(@strong this => move |selection| {
+                        {
+                            let mut tracks = this.tracks.borrow_mut();
+                            let mut track = &mut tracks[index];
+                            track.work_parts = selection;
+                        };
+
+                        this.update_tracks();
+                    }));
+
+                    navigator.push(editor);
+                }
+            }));
+
+            row.upcast()
+        }));
+
+        this
+    }
+
+    /// Set the closure to be called when the user has created the track set.
+    pub fn set_done_cb<F: Fn(TrackSetData) + 'static>(&self, cb: F) {
+        self.done_cb.replace(Some(Box::new(cb)));
+    }
+
+    /// Set everything up after selecting a recording.
+    fn recording_selected(&self) {
+        if let Some(recording) = &*self.recording.borrow() {
+            self.recording_row.set_title(Some(&recording.work.get_title()));
+            self.recording_row.set_subtitle(Some(&recording.get_performers()));
+            self.save_button.set_sensitive(true);
+        }
+
+        self.autofill_parts();
+    }
+
+    /// Automatically try to put work part information from the selected recording into the
+    /// selected tracks.
+    fn autofill_parts(&self) {
+        if let Some(recording) = &*self.recording.borrow() {
+            let mut tracks = self.tracks.borrow_mut();
+
+            for (index, _) in recording.work.parts.iter().enumerate() {
+                if let Some(mut track) = tracks.get_mut(index) {
+                    track.work_parts = vec![index];
+                } else {
+                    break;
+                }
+            }
+        }
+
+        self.update_tracks();
+    }
+
+    /// Update the track list.
+    fn update_tracks(&self) {
+        let length = self.tracks.borrow().len();
+        self.track_list.update(length);
+    }
+}
+
+impl NavigatorScreen for TrackSetEditor {
+    fn attach_navigator(&self, navigator: Rc<Navigator>) {
+        self.navigator.replace(Some(navigator));
+    }
+
+    fn get_widget(&self) -> gtk::Widget {
+        self.widget.clone().upcast()
+    }
+
+    fn detach_navigator(&self) {
+        self.navigator.replace(None);
+    }
+}
+
+
+
+
+

src/main.rs

@@ -0,0 +1,55 @@
+// Required for database/schema.rs
+#[macro_use]
+extern crate diesel;
+
+// Required for embed_migrations macro in database/database.rs
+#[macro_use]
+extern crate diesel_migrations;
+
+use gio::prelude::*;
+use glib::clone;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+mod backend;
+mod config;
+mod database;
+mod dialogs;
+mod editors;
+mod import;
+mod player;
+mod screens;
+mod selectors;
+mod widgets;
+
+mod window;
+use window::Window;
+
+mod resources;
+
+fn main() {
+    gettextrs::setlocale(gettextrs::LocaleCategory::LcAll, "");
+    gettextrs::bindtextdomain("musicus", config::LOCALEDIR);
+    gettextrs::textdomain("musicus");
+
+    gstreamer::init().expect("Failed to initialize GStreamer!");
+    gtk::init().expect("Failed to initialize GTK!");
+    libhandy::init();
+    resources::init().expect("Failed to initialize resources!");
+
+    let app = gtk::Application::new(Some("de.johrpan.musicus"), gio::ApplicationFlags::empty())
+        .expect("Failed to initialize GTK application!");
+
+    let window: RefCell<Option<Rc<Window>>> = RefCell::new(None);
+
+    app.connect_activate(clone!(@strong app => move |_| {
+        let mut window = window.borrow_mut();
+        if window.is_none() {
+            window.replace(Window::new(&app));
+        }
+        window.as_ref().unwrap().present();
+    }));
+
+    let args = std::env::args().collect::<Vec<String>>();
+    app.run(&args);
+}

src/meson.build

@@ -0,0 +1,115 @@
+prefix = get_option('prefix')
+localedir = join_paths(prefix, get_option('localedir'))
+
+global_conf = configuration_data()
+global_conf.set_quoted('LOCALEDIR', localedir)
+global_conf.set_quoted('VERSION', meson.project_version())
+config_rs = configure_file(
+  input: 'config.rs.in',
+  output: 'config.rs',
+  configuration: global_conf
+)
+
+run_command(
+  'cp',
+  config_rs,
+  meson.current_source_dir(),
+  check: true
+)
+
+resource_conf = configuration_data()
+resource_conf.set_quoted('RESOURCEFILE', resources.full_path())
+resource_rs = configure_file(
+  input: 'resources.rs.in',
+  output: 'resources.rs',
+  configuration: resource_conf
+)
+
+run_command(
+  'cp',
+  resource_rs,
+  meson.current_source_dir(),
+  check: true
+)
+
+sources = files(
+  'backend/client/ensembles.rs',
+  'backend/client/instruments.rs',
+  'backend/client/mod.rs',
+  'backend/client/persons.rs',
+  'backend/client/recordings.rs',
+  'backend/client/works.rs',
+  'backend/library.rs',
+  'backend/mod.rs',
+  'backend/secure.rs',
+  'database/ensembles.rs',
+  'database/instruments.rs',
+  'database/medium.rs',
+  'database/mod.rs',
+  'database/persons.rs',
+  'database/recordings.rs',
+  'database/schema.rs',
+  'database/thread.rs',
+  'database/works.rs',
+  'dialogs/about.rs',
+  'dialogs/login_dialog.rs',
+  'dialogs/mod.rs',
+  'dialogs/preferences.rs',
+  'dialogs/server_dialog.rs',
+  'editors/ensemble.rs',
+  'editors/instrument.rs',
+  'editors/mod.rs',
+  'editors/performance.rs',
+  'editors/person.rs',
+  'editors/recording.rs',
+  'editors/work.rs',
+  'editors/work_part.rs',
+  'editors/work_section.rs',
+  'screens/ensemble_screen.rs',
+  'screens/mod.rs',
+  'screens/person_screen.rs',
+  'screens/player_screen.rs',
+  'screens/recording_screen.rs',
+  'screens/work_screen.rs',
+  'selectors/ensemble.rs',
+  'selectors/instrument.rs',
+  'selectors/mod.rs',
+  'selectors/person.rs',
+  'selectors/recording.rs',
+  'selectors/selector.rs',
+  'selectors/work.rs',
+  'widgets/list.rs',
+  'widgets/mod.rs',
+  'widgets/navigator.rs',
+  'widgets/navigator_window.rs',
+  'widgets/player_bar.rs',
+  'widgets/poe_list.rs',
+  'widgets/selector_row.rs',
+  'config.rs',
+  'config.rs.in',
+  'main.rs',
+  'player.rs',
+  'resources.rs',
+  'resources.rs.in',
+  'window.rs',
+)
+
+cargo_script = find_program(join_paths(meson.source_root(), 'build-aux/cargo.sh'))
+cargo_release = custom_target(
+  'cargo-build',
+  build_by_default: true,
+  input: sources,
+  depends: resources,
+  output: meson.project_name(),
+  console: true,
+  install: true,
+  install_dir: get_option('bindir'),
+  command: [
+    cargo_script,
+    meson.build_root(),
+    meson.source_root(),
+    '@OUTPUT@',
+    get_option('buildtype'),
+    meson.project_name(),
+  ]
+)

src/player.rs

@@ -0,0 +1,287 @@
+use crate::database::*;
+use anyhow::anyhow;
+use anyhow::Result;
+use gstreamer_player::prelude::*;
+use std::cell::{Cell, RefCell};
+use std::path::PathBuf;
+use std::rc::Rc;
+
+#[derive(Clone)]
+pub struct PlaylistItem {
+    pub track_set: TrackSet,
+    pub indices: Vec<usize>,
+}
+
+pub struct Player {
+    music_library_path: PathBuf,
+    player: gstreamer_player::Player,
+    playlist: RefCell<Vec<PlaylistItem>>,
+    current_item: Cell<Option<usize>>,
+    current_track: Cell<Option<usize>>,
+    playing: Cell<bool>,
+    playlist_cbs: RefCell<Vec<Box<dyn Fn(Vec<PlaylistItem>)>>>,
+    track_cbs: RefCell<Vec<Box<dyn Fn(usize, usize)>>>,
+    duration_cbs: RefCell<Vec<Box<dyn Fn(u64)>>>,
+    playing_cbs: RefCell<Vec<Box<dyn Fn(bool)>>>,
+    position_cbs: RefCell<Vec<Box<dyn Fn(u64)>>>,
+}
+
+impl Player {
+    pub fn new(music_library_path: PathBuf) -> Rc<Self> {
+        let dispatcher = gstreamer_player::PlayerGMainContextSignalDispatcher::new(None);
+        let player = gstreamer_player::Player::new(None, Some(&dispatcher.upcast()));
+        let mut config = player.get_config();
+        config.set_position_update_interval(250);
+        player.set_config(config).unwrap();
+        player.set_video_track_enabled(false);
+
+        let result = Rc::new(Self {
+            music_library_path,
+            player: player.clone(),
+            playlist: RefCell::new(Vec::new()),
+            current_item: Cell::new(None),
+            current_track: Cell::new(None),
+            playing: Cell::new(false),
+            playlist_cbs: RefCell::new(Vec::new()),
+            track_cbs: RefCell::new(Vec::new()),
+            duration_cbs: RefCell::new(Vec::new()),
+            playing_cbs: RefCell::new(Vec::new()),
+            position_cbs: RefCell::new(Vec::new()),
+        });
+
+        let clone = fragile::Fragile::new(result.clone());
+        player.connect_end_of_stream(move |_| {
+            let clone = clone.get();
+            if clone.has_next() {
+                clone.next().unwrap();
+            } else {
+                clone.player.stop();
+                clone.playing.replace(false);
+                for cb in &*clone.playing_cbs.borrow() {
+                    cb(false);
+                }
+            }
+        });
+
+        let clone = fragile::Fragile::new(result.clone());
+        player.connect_position_updated(move |_, position| {
+            for cb in &*clone.get().position_cbs.borrow() {
+                cb(position.mseconds().unwrap());
+            }
+        });
+
+        let clone = fragile::Fragile::new(result.clone());
+        player.connect_duration_changed(move |_, duration| {
+            for cb in &*clone.get().duration_cbs.borrow() {
+                cb(duration.mseconds().unwrap());
+            }
+        });
+
+        result
+    }
+
+    pub fn add_playlist_cb<F: Fn(Vec<PlaylistItem>) + 'static>(&self, cb: F) {
+        self.playlist_cbs.borrow_mut().push(Box::new(cb));
+    }
+
+    pub fn add_track_cb<F: Fn(usize, usize) + 'static>(&self, cb: F) {
+        self.track_cbs.borrow_mut().push(Box::new(cb));
+    }
+
+    pub fn add_duration_cb<F: Fn(u64) + 'static>(&self, cb: F) {
+        self.duration_cbs.borrow_mut().push(Box::new(cb));
+    }
+
+    pub fn add_playing_cb<F: Fn(bool) + 'static>(&self, cb: F) {
+        self.playing_cbs.borrow_mut().push(Box::new(cb));
+    }
+
+    pub fn add_position_cb<F: Fn(u64) + 'static>(&self, cb: F) {
+        self.position_cbs.borrow_mut().push(Box::new(cb));
+    }
+
+    pub fn get_playlist(&self) -> Vec<PlaylistItem> {
+        self.playlist.borrow().clone()
+    }
+
+    pub fn get_current_item(&self) -> Option<usize> {
+        self.current_item.get()
+    }
+
+    pub fn get_current_track(&self) -> Option<usize> {
+        self.current_track.get()
+    }
+
+    pub fn get_duration(&self) -> gstreamer::ClockTime {
+        self.player.get_duration()
+    }
+
+    pub fn is_playing(&self) -> bool {
+        self.playing.get()
+    }
+
+    pub fn add_item(&self, item: PlaylistItem) -> Result<()> {
+        if item.indices.is_empty() {
+            Err(anyhow!(
+                "Tried to add playlist item without tracks to playlist!"
+            ))
+        } else {
+            let was_empty = {
+                let mut playlist = self.playlist.borrow_mut();
+                let was_empty = playlist.is_empty();
+
+                playlist.push(item);
+
+                was_empty
+            };
+
+            for cb in &*self.playlist_cbs.borrow() {
+                cb(self.playlist.borrow().clone());
+            }
+
+            if was_empty {
+                self.set_track(0, 0)?;
+                self.player.play();
+                self.playing.set(true);
+
+                for cb in &*self.playing_cbs.borrow() {
+                    cb(true);
+                }
+            }
+
+            Ok(())
+        }
+    }
+
+    pub fn play_pause(&self) {
+        if self.is_playing() {
+            self.player.pause();
+            self.playing.set(false);
+
+            for cb in &*self.playing_cbs.borrow() {
+                cb(false);
+            }
+        } else {
+            self.player.play();
+            self.playing.set(true);
+
+            for cb in &*self.playing_cbs.borrow() {
+                cb(true);
+            }
+        }
+    }
+
+    pub fn seek(&self, ms: u64) {
+        self.player.seek(gstreamer::ClockTime::from_mseconds(ms));
+    }
+
+    pub fn has_previous(&self) -> bool {
+        if let Some(current_item) = self.current_item.get() {
+            if let Some(current_track) = self.current_track.get() {
+                current_track > 0 || current_item > 0
+            } else {
+                false
+            }
+        } else {
+            false
+        }
+    }
+
+    pub fn previous(&self) -> Result<()> {
+        let mut current_item = self.current_item.get().ok_or(anyhow!("No current item!"))?;
+        let mut current_track = self
+            .current_track
+            .get()
+            .ok_or(anyhow!("No current track!"))?;
+
+        let playlist = self.playlist.borrow();
+        if current_track > 0 {
+            current_track -= 1;
+        } else if current_item > 0 {
+            current_item -= 1;
+            current_track = playlist[current_item].indices.len() - 1;
+        } else {
+            return Err(anyhow!("No previous track!"));
+        }
+
+        self.set_track(current_item, current_track)
+    }
+
+    pub fn has_next(&self) -> bool {
+        if let Some(current_item) = self.current_item.get() {
+            if let Some(current_track) = self.current_track.get() {
+                let playlist = self.playlist.borrow();
+                let item = &playlist[current_item];
+
+                current_track + 1 < item.indices.len() || current_item + 1 < playlist.len()
+            } else {
+                false
+            }
+        } else {
+            false
+        }
+    }
+
+    pub fn next(&self) -> Result<()> {
+        let mut current_item = self.current_item.get().ok_or(anyhow!("No current item!"))?;
+        let mut current_track = self
+            .current_track
+            .get()
+            .ok_or(anyhow!("No current track!"))?;
+
+        let playlist = self.playlist.borrow();
+        let item = &playlist[current_item];
+        if current_track + 1 < item.indices.len() {
+            current_track += 1;
+        } else if current_item + 1 < playlist.len() {
+            current_item += 1;
+            current_track = 0;
+        } else {
+            return Err(anyhow!("No next track!"));
+        }
+
+        self.set_track(current_item, current_track)
+    }
+
+    pub fn set_track(&self, current_item: usize, current_track: usize) -> Result<()> {
+        let uri = format!(
+            "file://{}",
+            self.music_library_path
+                .join(
+                    self.playlist.borrow()[current_item].track_set.tracks[current_track].path.clone(),
+                )
+                .to_str()
+                .unwrap(),
+        );
+
+        self.player.set_uri(&uri);
+        if self.is_playing() {
+            self.player.play();
+        }
+
+        self.current_item.set(Some(current_item));
+        self.current_track.set(Some(current_track));
+
+        for cb in &*self.track_cbs.borrow() {
+            cb(current_item, current_track);
+        }
+
+        Ok(())
+    }
+
+    pub fn clear(&self) {
+        self.player.stop();
+        self.playing.set(false);
+        self.current_item.set(None);
+        self.current_track.set(None);
+        self.playlist.replace(Vec::new());
+
+        for cb in &*self.playing_cbs.borrow() {
+            cb(false);
+        }
+
+        for cb in &*self.playlist_cbs.borrow() {
+            cb(Vec::new());
+        }
+    }
+}

src/resources.rs.in

@@ -0,0 +1,9 @@
+use anyhow::Result;
+
+pub fn init() -> Result<()> {
+    let bytes = glib::Bytes::from(include_bytes!(@RESOURCEFILE@).as_ref());
+    let resource = gio::Resource::from_data(&bytes)?;
+    gio::resources_register(&resource);
+
+    Ok(())
+}

src/screens/ensemble_screen.rs

@@ -0,0 +1,155 @@
+use super::*;
+use crate::backend::*;
+use crate::database::*;
+use crate::editors::EnsembleEditor;
+use crate::widgets::{List, Navigator, NavigatorScreen, NavigatorWindow};
+use gettextrs::gettext;
+use gio::prelude::*;
+use glib::clone;
+use gtk::prelude::*;
+use gtk_macros::get_widget;
+use libhandy::HeaderBarExt;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+pub struct EnsembleScreen {
+    backend: Rc<Backend>,
+    ensemble: Ensemble,
+    widget: gtk::Box,
+    stack: gtk::Stack,
+    recording_list: Rc<List<Recording>>,
+    navigator: RefCell<Option<Rc<Navigator>>>,
+}
+
+impl EnsembleScreen {
+    pub fn new(backend: Rc<Backend>, ensemble: Ensemble) -> Rc<Self> {
+        let builder = gtk::Builder::from_resource("/de/johrpan/musicus/ui/ensemble_screen.ui");
+
+        get_widget!(builder, gtk::Box, widget);
+        get_widget!(builder, libhandy::HeaderBar, header);
+        get_widget!(builder, gtk::Button, back_button);
+        get_widget!(builder, gtk::SearchEntry, search_entry);
+        get_widget!(builder, gtk::Stack, stack);
+        get_widget!(builder, gtk::Frame, recording_frame);
+
+        header.set_title(Some(&ensemble.name));
+
+        let edit_action = gio::SimpleAction::new("edit", None);
+        let delete_action = gio::SimpleAction::new("delete", None);
+
+        let actions = gio::SimpleActionGroup::new();
+        actions.add_action(&edit_action);
+        actions.add_action(&delete_action);
+
+        widget.insert_action_group("widget", Some(&actions));
+
+        let recording_list = List::new(&gettext("No recordings found."));
+
+        recording_list.set_make_widget(|recording: &Recording| {
+            let work_label = gtk::Label::new(Some(&recording.work.get_title()));
+
+            work_label.set_ellipsize(pango::EllipsizeMode::End);
+            work_label.set_halign(gtk::Align::Start);
+
+            let performers_label = gtk::Label::new(Some(&recording.get_performers()));
+            performers_label.set_ellipsize(pango::EllipsizeMode::End);
+            performers_label.set_opacity(0.5);
+            performers_label.set_halign(gtk::Align::Start);
+
+            let vbox = gtk::Box::new(gtk::Orientation::Vertical, 0);
+            vbox.set_border_width(6);
+            vbox.add(&work_label);
+            vbox.add(&performers_label);
+
+            vbox.upcast()
+        });
+
+        recording_list.set_filter(
+            clone!(@strong search_entry => move |recording: &Recording| {
+                let search = search_entry.get_text().to_string().to_lowercase();
+                let text = recording.work.get_title() + &recording.get_performers();
+                search.is_empty() || text.contains(&search)
+            }),
+        );
+
+        recording_frame.add(&recording_list.widget.clone());
+
+        let result = Rc::new(Self {
+            backend,
+            ensemble,
+            widget,
+            stack,
+            recording_list,
+            navigator: RefCell::new(None),
+        });
+
+        search_entry.connect_search_changed(clone!(@strong result => move |_| {
+            result.recording_list.invalidate_filter();
+        }));
+
+        back_button.connect_clicked(clone!(@strong result => move |_| {
+            let navigator = result.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.pop();
+            }
+        }));
+
+        result
+            .recording_list
+            .set_selected(clone!(@strong result => move |recording| {
+                let navigator = result.navigator.borrow().clone();
+                if let Some(navigator) = navigator {
+                    navigator.push(RecordingScreen::new(result.backend.clone(), recording.clone()));
+                }
+            }));
+
+        edit_action.connect_activate(clone!(@strong result => move |_, _| {
+            let editor = EnsembleEditor::new(result.backend.clone(), Some(result.ensemble.clone()));
+            let window = NavigatorWindow::new(editor);
+            window.show();
+        }));
+
+        delete_action.connect_activate(clone!(@strong result => move |_, _| {
+            let context = glib::MainContext::default();
+            let clone = result.clone();
+            context.spawn_local(async move {
+                clone.backend.db().delete_ensemble(&clone.ensemble.id).await.unwrap();
+                clone.backend.library_changed();
+            });
+        }));
+
+        let context = glib::MainContext::default();
+        let clone = result.clone();
+        context.spawn_local(async move {
+            let recordings = clone
+                .backend
+                .db()
+                .get_recordings_for_ensemble(&clone.ensemble.id)
+                .await
+                .unwrap();
+
+            if recordings.is_empty() {
+                clone.stack.set_visible_child_name("nothing");
+            } else {
+                clone.recording_list.show_items(recordings);
+                clone.stack.set_visible_child_name("content");
+            }
+        });
+
+        result
+    }
+}
+
+impl NavigatorScreen for EnsembleScreen {
+    fn attach_navigator(&self, navigator: Rc<Navigator>) {
+        self.navigator.replace(Some(navigator));
+    }
+
+    fn get_widget(&self) -> gtk::Widget {
+        self.widget.clone().upcast()
+    }
+
+    fn detach_navigator(&self) {
+        self.navigator.replace(None);
+    }
+}

src/screens/mod.rs

@@ -0,0 +1,14 @@
+pub mod ensemble_screen;
+pub use ensemble_screen::*;
+
+pub mod person_screen;
+pub use person_screen::*;
+
+pub mod player_screen;
+pub use player_screen::*;
+
+pub mod work_screen;
+pub use work_screen::*;
+
+pub mod recording_screen;
+pub use recording_screen::*;

src/screens/person_screen.rs

@@ -0,0 +1,208 @@
+use super::*;
+use crate::backend::*;
+use crate::database::*;
+use crate::editors::PersonEditor;
+use crate::widgets::{List, Navigator, NavigatorScreen, NavigatorWindow};
+use gettextrs::gettext;
+use gio::prelude::*;
+use glib::clone;
+use gtk::prelude::*;
+use gtk_macros::get_widget;
+use libhandy::HeaderBarExt;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+pub struct PersonScreen {
+    backend: Rc<Backend>,
+    person: Person,
+    widget: gtk::Box,
+    stack: gtk::Stack,
+    work_list: Rc<List<Work>>,
+    recording_list: Rc<List<Recording>>,
+    navigator: RefCell<Option<Rc<Navigator>>>,
+}
+
+impl PersonScreen {
+    pub fn new(backend: Rc<Backend>, person: Person) -> Rc<Self> {
+        let builder = gtk::Builder::from_resource("/de/johrpan/musicus/ui/person_screen.ui");
+
+        get_widget!(builder, gtk::Box, widget);
+        get_widget!(builder, libhandy::HeaderBar, header);
+        get_widget!(builder, gtk::Button, back_button);
+        get_widget!(builder, gtk::SearchEntry, search_entry);
+        get_widget!(builder, gtk::Stack, stack);
+        get_widget!(builder, gtk::Box, work_box);
+        get_widget!(builder, gtk::Frame, work_frame);
+        get_widget!(builder, gtk::Box, recording_box);
+        get_widget!(builder, gtk::Frame, recording_frame);
+
+        header.set_title(Some(&person.name_fl()));
+
+        let edit_action = gio::SimpleAction::new("edit", None);
+        let delete_action = gio::SimpleAction::new("delete", None);
+
+        let actions = gio::SimpleActionGroup::new();
+        actions.add_action(&edit_action);
+        actions.add_action(&delete_action);
+
+        widget.insert_action_group("widget", Some(&actions));
+
+        let work_list = List::new(&gettext("No works found."));
+
+        work_list.set_make_widget(|work: &Work| {
+            let label = gtk::Label::new(Some(&work.title));
+            label.set_halign(gtk::Align::Start);
+            label.set_margin_start(6);
+            label.set_margin_end(6);
+            label.set_margin_top(6);
+            label.set_margin_bottom(6);
+            label.upcast()
+        });
+
+        work_list.set_filter(clone!(@strong search_entry => move |work: &Work| {
+            let search = search_entry.get_text().to_string().to_lowercase();
+            let title = work.title.to_lowercase();
+            search.is_empty() || title.contains(&search)
+        }));
+
+        let recording_list = List::new(&gettext("No recordings found."));
+
+        recording_list.set_make_widget(|recording: &Recording| {
+            let work_label = gtk::Label::new(Some(&recording.work.get_title()));
+
+            work_label.set_ellipsize(pango::EllipsizeMode::End);
+            work_label.set_halign(gtk::Align::Start);
+
+            let performers_label = gtk::Label::new(Some(&recording.get_performers()));
+            performers_label.set_ellipsize(pango::EllipsizeMode::End);
+            performers_label.set_opacity(0.5);
+            performers_label.set_halign(gtk::Align::Start);
+
+            let vbox = gtk::Box::new(gtk::Orientation::Vertical, 0);
+            vbox.set_border_width(6);
+            vbox.add(&work_label);
+            vbox.add(&performers_label);
+
+            vbox.upcast()
+        });
+
+        recording_list.set_filter(
+            clone!(@strong search_entry => move |recording: &Recording| {
+                let search = search_entry.get_text().to_string().to_lowercase();
+                let text = recording.work.get_title() + &recording.get_performers();
+                search.is_empty() || text.contains(&search)
+            }),
+        );
+
+        work_frame.add(&work_list.widget);
+        recording_frame.add(&recording_list.widget);
+
+        let result = Rc::new(Self {
+            backend,
+            person,
+            widget,
+            stack,
+            work_list,
+            recording_list,
+            navigator: RefCell::new(None),
+        });
+
+        search_entry.connect_search_changed(clone!(@strong result => move |_| {
+            result.work_list.invalidate_filter();
+            result.recording_list.invalidate_filter();
+        }));
+
+        back_button.connect_clicked(clone!(@strong result => move |_| {
+            let navigator = result.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.clone().pop();
+            }
+        }));
+
+        result
+            .work_list
+            .set_selected(clone!(@strong result => move |work| {
+                result.recording_list.clear_selection();
+                let navigator = result.navigator.borrow().clone();
+                if let Some(navigator) = navigator {
+                    navigator.push(WorkScreen::new(result.backend.clone(), work.clone()));
+                }
+            }));
+
+        result
+            .recording_list
+            .set_selected(clone!(@strong result => move |recording| {
+                result.work_list.clear_selection();
+                let navigator = result.navigator.borrow().clone();
+                if let Some(navigator) = navigator {
+                    navigator.push(RecordingScreen::new(result.backend.clone(), recording.clone()));
+                }
+            }));
+
+        edit_action.connect_activate(clone!(@strong result => move |_, _| {
+            let editor = PersonEditor::new(result.backend.clone(), Some(result.person.clone()));
+            let window = NavigatorWindow::new(editor);
+            window.show();
+        }));
+
+        delete_action.connect_activate(clone!(@strong result => move |_, _| {
+            let context = glib::MainContext::default();
+            let clone = result.clone();
+            context.spawn_local(async move {
+                clone.backend.db().delete_person(&clone.person.id).await.unwrap();
+                clone.backend.library_changed();
+            });
+        }));
+
+        let context = glib::MainContext::default();
+        let clone = result.clone();
+        context.spawn_local(async move {
+            let works = clone
+                .backend
+                .db()
+                .get_works(&clone.person.id)
+                .await
+                .unwrap();
+            let recordings = clone
+                .backend
+                .db()
+                .get_recordings_for_person(&clone.person.id)
+                .await
+                .unwrap();
+
+            if works.is_empty() && recordings.is_empty() {
+                clone.stack.set_visible_child_name("nothing");
+            } else {
+                if works.is_empty() {
+                    work_box.hide();
+                } else {
+                    clone.work_list.show_items(works);
+                }
+
+                if recordings.is_empty() {
+                    recording_box.hide();
+                } else {
+                    clone.recording_list.show_items(recordings);
+                }
+
+                clone.stack.set_visible_child_name("content");
+            }
+        });
+
+        result
+    }
+}
+
+impl NavigatorScreen for PersonScreen {
+    fn attach_navigator(&self, navigator: Rc<Navigator>) {
+        self.navigator.replace(Some(navigator));
+    }
+
+    fn get_widget(&self) -> gtk::Widget {
+        self.widget.clone().upcast()
+    }
+
+    fn detach_navigator(&self) {
+        self.navigator.replace(None);
+    }
+}

src/screens/player_screen.rs

@@ -0,0 +1,336 @@
+use crate::player::*;
+use crate::widgets::*;
+use gettextrs::gettext;
+use glib::clone;
+use gtk::prelude::*;
+use gtk_macros::get_widget;
+use std::cell::{Cell, RefCell};
+use std::rc::Rc;
+
+struct PlaylistElement {
+    pub item: usize,
+    pub track: usize,
+    pub title: String,
+    pub subtitle: Option<String>,
+    pub playable: bool,
+}
+
+pub struct PlayerScreen {
+    pub widget: gtk::Box,
+    title_label: gtk::Label,
+    subtitle_label: gtk::Label,
+    previous_button: gtk::Button,
+    play_button: gtk::Button,
+    next_button: gtk::Button,
+    position_label: gtk::Label,
+    position: gtk::Adjustment,
+    duration_label: gtk::Label,
+    play_image: gtk::Image,
+    pause_image: gtk::Image,
+    list: Rc<List<PlaylistElement>>,
+    player: Rc<RefCell<Option<Rc<Player>>>>,
+    seeking: Rc<Cell<bool>>,
+    current_item: Rc<Cell<usize>>,
+    current_track: Rc<Cell<usize>>,
+    back_cb: Rc<RefCell<Option<Box<dyn Fn() -> ()>>>>,
+}
+
+impl PlayerScreen {
+    pub fn new() -> Self {
+        let builder = gtk::Builder::from_resource("/de/johrpan/musicus/ui/player_screen.ui");
+
+        get_widget!(builder, gtk::Box, widget);
+        get_widget!(builder, gtk::Button, back_button);
+        get_widget!(builder, gtk::Label, title_label);
+        get_widget!(builder, gtk::Label, subtitle_label);
+        get_widget!(builder, gtk::Button, previous_button);
+        get_widget!(builder, gtk::Button, play_button);
+        get_widget!(builder, gtk::Button, next_button);
+        get_widget!(builder, gtk::Button, stop_button);
+        get_widget!(builder, gtk::Label, position_label);
+        get_widget!(builder, gtk::Scale, position_scale);
+        get_widget!(builder, gtk::Adjustment, position);
+        get_widget!(builder, gtk::Label, duration_label);
+        get_widget!(builder, gtk::Image, play_image);
+        get_widget!(builder, gtk::Image, pause_image);
+        get_widget!(builder, gtk::Frame, frame);
+
+        let back_cb = Rc::new(RefCell::new(None::<Box<dyn Fn() -> ()>>));
+
+        back_button.connect_clicked(clone!(@strong back_cb => move |_| {
+            if let Some(cb) = &*back_cb.borrow() {
+                cb();
+            }
+        }));
+
+        let player = Rc::new(RefCell::new(None::<Rc<Player>>));
+        let seeking = Rc::new(Cell::new(false));
+
+        previous_button.connect_clicked(clone!(@strong player => move |_| {
+            if let Some(player) = &*player.borrow() {
+                player.previous().unwrap();
+            }
+        }));
+
+        play_button.connect_clicked(clone!(@strong player => move |_| {
+            if let Some(player) = &*player.borrow() {
+                player.play_pause();
+            }
+        }));
+
+        next_button.connect_clicked(clone!(@strong player => move |_| {
+            if let Some(player) = &*player.borrow() {
+                player.next().unwrap();
+            }
+        }));
+
+        stop_button.connect_clicked(clone!(@strong player, @strong back_cb => move |_| {
+            if let Some(player) = &*player.borrow() {
+                if let Some(cb) = &*back_cb.borrow() {
+                    cb();
+                }
+
+                player.clear();
+            }
+        }));
+
+        position_scale.connect_button_press_event(clone!(@strong seeking => move |_, _| {
+            seeking.replace(true);
+            Inhibit(false)
+        }));
+
+        position_scale.connect_button_release_event(
+            clone!(@strong seeking, @strong position, @strong player => move |_, _| {
+                if let Some(player) = &*player.borrow() {
+                    player.seek(position.get_value() as u64);
+                }
+
+                seeking.replace(false);
+                Inhibit(false)
+            }),
+        );
+
+        position_scale.connect_value_changed(
+            clone!(@strong seeking, @strong position, @strong position_label => move |_| {
+                if seeking.get() {
+                    let ms = position.get_value() as u64;
+                    let min = ms / 60000;
+                    let sec = (ms % 60000) / 1000;
+                    position_label.set_text(&format!("{}:{:02}", min, sec));
+                }
+            }),
+        );
+
+        let current_item = Rc::new(Cell::<usize>::new(0));
+        let current_track = Rc::new(Cell::<usize>::new(0));
+        let list = List::new("");
+
+        list.set_make_widget(clone!(
+            @strong current_item,
+            @strong current_track
+            => move |element: &PlaylistElement| {
+                let title_label = gtk::Label::new(Some(&element.title));
+                title_label.set_ellipsize(pango::EllipsizeMode::End);
+                title_label.set_halign(gtk::Align::Start);
+                let vbox = gtk::Box::new(gtk::Orientation::Vertical, 0);
+                vbox.add(&title_label);
+                if let Some(subtitle) = &element.subtitle {
+                    let subtitle_label = gtk::Label::new(Some(&subtitle));
+                    subtitle_label.set_ellipsize(pango::EllipsizeMode::End);
+                    subtitle_label.set_halign(gtk::Align::Start);
+                    subtitle_label.set_opacity(0.5);
+                    vbox.add(&subtitle_label);
+                }
+
+                let hbox = gtk::Box::new(gtk::Orientation::Horizontal, 6);
+                hbox.set_border_width(6);
+
+                if element.playable {
+                    let image = gtk::Image::new();
+
+                    if element.item == current_item.get() && element.track == current_track.get() {
+                        image.set_from_icon_name(
+                            Some("media-playback-start-symbolic"),
+                            gtk::IconSize::Button,
+                        );
+                    }
+
+                    hbox.add(&image);
+                } else if element.item > 0 {
+                    hbox.set_margin_top(18);
+                }
+                hbox.add(&vbox);
+                hbox.upcast()
+            }
+        ));
+
+        list.set_selected(clone!(@strong player => move |element| {
+            if let Some(player) = &*player.borrow() {
+                player.set_track(element.item, element.track).unwrap();
+            }
+        }));
+
+        frame.add(&list.widget);
+
+        Self {
+            widget,
+            title_label,
+            subtitle_label,
+            previous_button,
+            play_button,
+            next_button,
+            position_label,
+            position,
+            duration_label,
+            play_image,
+            pause_image,
+            list,
+            player,
+            seeking,
+            current_item,
+            current_track,
+            back_cb,
+        }
+    }
+
+    pub fn set_player(&self, player: Option<Rc<Player>>) {
+        self.player.replace(player.clone());
+
+        if let Some(player) = player {
+            let playlist = Rc::new(RefCell::new(Vec::<PlaylistItem>::new()));
+
+            player.add_playlist_cb(clone!(
+                @strong player,
+                @strong self.previous_button as previous_button,
+                @strong self.next_button as next_button,
+                @strong self.list as list,
+                @strong playlist
+                => move |new_playlist| {
+                    playlist.replace(new_playlist);
+                    previous_button.set_sensitive(player.has_previous());
+                    next_button.set_sensitive(player.has_next());
+
+                    let mut elements = Vec::new();
+                    for (item_index, item) in playlist.borrow().iter().enumerate() {
+                        elements.push(PlaylistElement {
+                            item: item_index,
+                            track: 0,
+                            title: item.track_set.recording.work.get_title(),
+                            subtitle: Some(item.track_set.recording.get_performers()),
+                            playable: false,
+                        });
+
+                        for track_index in &item.indices {
+                            let track = &item.track_set.tracks[*track_index];
+
+                            let mut parts = Vec::<String>::new();
+                            for part in &track.work_parts {
+                                parts.push(item.track_set.recording.work.parts[*part].title.clone());
+                            }
+
+                            let title = if parts.is_empty() {
+                                gettext("Unknown")
+                            } else {
+                                parts.join(", ")
+                            };
+
+                            elements.push(PlaylistElement {
+                                item: item_index,
+                                track: *track_index,
+                                title: title,
+                                subtitle: None,
+                                playable: true,
+                            });
+                        }
+                    }
+
+                    list.show_items(elements);
+                }
+            ));
+
+            player.add_track_cb(clone!(
+                @strong player,
+                @strong playlist,
+                @strong self.previous_button as previous_button,
+                @strong self.next_button as next_button,
+                @strong self.title_label as title_label,
+                @strong self.subtitle_label as subtitle_label,
+                @strong self.position_label as position_label,
+                @strong self.current_item as self_item,
+                @strong self.current_track as self_track,
+                @strong self.list as list
+                => move |current_item, current_track| {
+                    previous_button.set_sensitive(player.has_previous());
+                    next_button.set_sensitive(player.has_next());
+
+                    let item = &playlist.borrow()[current_item];
+                    let track = &item.track_set.tracks[current_track];
+
+                    let mut parts = Vec::<String>::new();
+                    for part in &track.work_parts {
+                        parts.push(item.track_set.recording.work.parts[*part].title.clone());
+                    }
+
+                    let mut title = item.track_set.recording.work.get_title();
+                    if !parts.is_empty() {
+                        title = format!("{}: {}", title, parts.join(", "));
+                    }
+
+                    title_label.set_text(&title);
+                    subtitle_label.set_text(&item.track_set.recording.get_performers());
+                    position_label.set_text("0:00");
+
+                    self_item.replace(current_item);
+                    self_track.replace(current_track);
+                    list.update();
+                }
+            ));
+
+            player.add_duration_cb(clone!(
+                @strong self.duration_label as duration_label,
+                @strong self.position as position
+                => move |ms| {
+                    let min = ms / 60000;
+                    let sec = (ms % 60000) / 1000;
+                    duration_label.set_text(&format!("{}:{:02}", min, sec));
+                    position.set_upper(ms as f64);
+                }
+            ));
+
+            player.add_playing_cb(clone!(
+                @strong self.play_button as play_button,
+                @strong self.play_image as play_image,
+                @strong self.pause_image as pause_image
+                => move |playing| {
+                    if let Some(child) = play_button.get_child() {
+                        play_button.remove( &child);
+                    }
+
+                    play_button.add(if playing {
+                        &pause_image
+                    } else {
+                        &play_image
+                    });
+                }
+            ));
+
+            player.add_position_cb(clone!(
+                @strong self.position_label as position_label,
+                @strong self.position as position,
+                @strong self.seeking as seeking
+                => move |ms| {
+                    if !seeking.get() {
+                        let min = ms / 60000;
+                        let sec = (ms % 60000) / 1000;
+                        position_label.set_text(&format!("{}:{:02}", min, sec));
+                        position.set_value(ms as f64);
+                    }
+                }
+            ));
+        }
+    }
+
+    pub fn set_back_cb<F: Fn() -> () + 'static>(&self, cb: F) {
+        self.back_cb.replace(Some(Box::new(cb)));
+    }
+}

src/screens/recording_screen.rs

@@ -0,0 +1,177 @@
+use crate::backend::*;
+use crate::database::*;
+use crate::editors::RecordingEditor;
+use crate::player::*;
+use crate::widgets::{List, Navigator, NavigatorScreen, NavigatorWindow};
+use gettextrs::gettext;
+use gio::prelude::*;
+use glib::clone;
+use gtk::prelude::*;
+use gtk_macros::get_widget;
+use libhandy::HeaderBarExt;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+pub struct RecordingScreen {
+    backend: Rc<Backend>,
+    recording: Recording,
+    widget: gtk::Box,
+    stack: gtk::Stack,
+    track_sets: RefCell<Vec<TrackSet>>,
+    navigator: RefCell<Option<Rc<Navigator>>>,
+}
+
+impl RecordingScreen {
+    pub fn new(backend: Rc<Backend>, recording: Recording) -> Rc<Self> {
+        let builder = gtk::Builder::from_resource("/de/johrpan/musicus/ui/recording_screen.ui");
+
+        get_widget!(builder, gtk::Box, widget);
+        get_widget!(builder, libhandy::HeaderBar, header);
+        get_widget!(builder, gtk::Button, back_button);
+        get_widget!(builder, gtk::Stack, stack);
+        get_widget!(builder, gtk::Frame, frame);
+        get_widget!(builder, gtk::Button, add_to_playlist_button);
+
+        header.set_title(Some(&recording.work.get_title()));
+        header.set_subtitle(Some(&recording.get_performers()));
+
+        let edit_action = gio::SimpleAction::new("edit", None);
+        let delete_action = gio::SimpleAction::new("delete", None);
+        let edit_tracks_action = gio::SimpleAction::new("edit-tracks", None);
+        let delete_tracks_action = gio::SimpleAction::new("delete-tracks", None);
+
+        let actions = gio::SimpleActionGroup::new();
+        actions.add_action(&edit_action);
+        actions.add_action(&delete_action);
+        actions.add_action(&edit_tracks_action);
+        actions.add_action(&delete_tracks_action);
+
+        widget.insert_action_group("widget", Some(&actions));
+
+        let list = List::new(&gettext("No tracks found."));
+        frame.add(&list.widget);
+
+        let result = Rc::new(Self {
+            backend,
+            recording,
+            widget,
+            stack,
+            track_sets: RefCell::new(Vec::new()),
+            navigator: RefCell::new(None),
+        });
+
+        list.set_make_widget(clone!(@strong result => move |track_set: &TrackSet| {
+            let vbox = gtk::Box::new(gtk::Orientation::Vertical, 0);
+            vbox.set_border_width(6);
+            vbox.set_spacing(6);
+
+            for track in &track_set.tracks {
+                let track_box = gtk::Box::new(gtk::Orientation::Vertical, 0);
+
+                let mut title_parts = Vec::<String>::new();
+                for part in &track.work_parts {
+                    title_parts.push(result.recording.work.parts[*part].title.clone());
+                }
+
+                let title = if title_parts.is_empty() {
+                    gettext("Unknown")
+                } else {
+                    title_parts.join(", ")
+                };
+
+                let title_label = gtk::Label::new(Some(&title));
+                title_label.set_ellipsize(pango::EllipsizeMode::End);
+                title_label.set_halign(gtk::Align::Start);
+
+                let file_name_label = gtk::Label::new(Some(&track.path));
+                file_name_label.set_ellipsize(pango::EllipsizeMode::End);
+                file_name_label.set_opacity(0.5);
+                file_name_label.set_halign(gtk::Align::Start);
+
+                track_box.add(&title_label);
+                track_box.add(&file_name_label);
+
+                vbox.add(&track_box);
+            }
+
+            vbox.upcast()
+        }));
+
+        back_button.connect_clicked(clone!(@strong result => move |_| {
+            let navigator = result.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.clone().pop();
+            }
+        }));
+
+        add_to_playlist_button.connect_clicked(clone!(@strong result => move |_| {
+            // if let Some(player) = result.backend.get_player() {
+            //     player.add_item(PlaylistItem {
+            //         track_set: result.track_sets.get(0).unwrap().clone(),
+            //         indices: result.tracks.borrow().clone(),
+            //     }).unwrap();
+            // }
+        }));
+
+        edit_action.connect_activate(clone!(@strong result => move |_, _| {
+            let editor = RecordingEditor::new(result.backend.clone(), Some(result.recording.clone()));
+            let window = NavigatorWindow::new(editor);
+            window.show();
+        }));
+
+        delete_action.connect_activate(clone!(@strong result => move |_, _| {
+            let context = glib::MainContext::default();
+            let clone = result.clone();
+            context.spawn_local(async move {
+                clone.backend.db().delete_recording(&clone.recording.id).await.unwrap();
+                clone.backend.library_changed();
+            });
+        }));
+
+        edit_tracks_action.connect_activate(clone!(@strong result => move |_, _| {
+            // let editor = TracksEditor::new(result.backend.clone(), Some(result.recording.clone()), result.tracks.borrow().clone());
+            // let window = NavigatorWindow::new(editor);
+            // window.show();
+        }));
+
+        delete_tracks_action.connect_activate(clone!(@strong result => move |_, _| {
+            let context = glib::MainContext::default();
+            let clone = result.clone();
+            context.spawn_local(async move {
+                // clone.backend.db().delete_tracks(&clone.recording.id).await.unwrap();
+                // clone.backend.library_changed();
+            });
+        }));
+
+        let context = glib::MainContext::default();
+        let clone = result.clone();
+        context.spawn_local(async move {
+            let track_sets = clone
+                .backend
+                .db()
+                .get_track_sets(&clone.recording.id)
+                .await
+                .unwrap();
+
+            list.show_items(track_sets.clone());
+            clone.stack.set_visible_child_name("content");
+            clone.track_sets.replace(track_sets);
+        });
+
+        result
+    }
+}
+
+impl NavigatorScreen for RecordingScreen {
+    fn attach_navigator(&self, navigator: Rc<Navigator>) {
+        self.navigator.replace(Some(navigator));
+    }
+
+    fn get_widget(&self) -> gtk::Widget {
+        self.widget.clone().upcast()
+    }
+
+    fn detach_navigator(&self) {
+        self.navigator.replace(None);
+    }
+}

src/screens/work_screen.rs

@@ -0,0 +1,154 @@
+use super::*;
+use crate::backend::*;
+use crate::database::*;
+use crate::editors::WorkEditor;
+use crate::widgets::{List, Navigator, NavigatorScreen, NavigatorWindow};
+use gettextrs::gettext;
+use gio::prelude::*;
+use glib::clone;
+use gtk::prelude::*;
+use gtk_macros::get_widget;
+use libhandy::HeaderBarExt;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+pub struct WorkScreen {
+    backend: Rc<Backend>,
+    work: Work,
+    widget: gtk::Box,
+    stack: gtk::Stack,
+    recording_list: Rc<List<Recording>>,
+    navigator: RefCell<Option<Rc<Navigator>>>,
+}
+
+impl WorkScreen {
+    pub fn new(backend: Rc<Backend>, work: Work) -> Rc<Self> {
+        let builder = gtk::Builder::from_resource("/de/johrpan/musicus/ui/work_screen.ui");
+
+        get_widget!(builder, gtk::Box, widget);
+        get_widget!(builder, libhandy::HeaderBar, header);
+        get_widget!(builder, gtk::Button, back_button);
+        get_widget!(builder, gtk::SearchEntry, search_entry);
+        get_widget!(builder, gtk::Stack, stack);
+        get_widget!(builder, gtk::Frame, recording_frame);
+
+        header.set_title(Some(&work.title));
+        header.set_subtitle(Some(&work.composer.name_fl()));
+
+        let edit_action = gio::SimpleAction::new("edit", None);
+        let delete_action = gio::SimpleAction::new("delete", None);
+
+        let actions = gio::SimpleActionGroup::new();
+        actions.add_action(&edit_action);
+        actions.add_action(&delete_action);
+
+        widget.insert_action_group("widget", Some(&actions));
+
+        let recording_list = List::new(&gettext("No recordings found."));
+
+        recording_list.set_make_widget(|recording: &Recording| {
+            let work_label = gtk::Label::new(Some(&recording.work.get_title()));
+
+            work_label.set_ellipsize(pango::EllipsizeMode::End);
+            work_label.set_halign(gtk::Align::Start);
+
+            let performers_label = gtk::Label::new(Some(&recording.get_performers()));
+            performers_label.set_ellipsize(pango::EllipsizeMode::End);
+            performers_label.set_opacity(0.5);
+            performers_label.set_halign(gtk::Align::Start);
+
+            let vbox = gtk::Box::new(gtk::Orientation::Vertical, 0);
+            vbox.set_border_width(6);
+            vbox.add(&work_label);
+            vbox.add(&performers_label);
+
+            vbox.upcast()
+        });
+
+        recording_list.set_filter(clone!(@strong search_entry => move |recording: &Recording| {
+            let search = search_entry.get_text().to_string().to_lowercase();
+            let text = recording.work.get_title().to_lowercase() + &recording.get_performers().to_lowercase();
+            search.is_empty() || text.contains(&search)
+        }),);
+
+        recording_frame.add(&recording_list.widget);
+
+        let result = Rc::new(Self {
+            backend,
+            work,
+            widget,
+            stack,
+            recording_list,
+            navigator: RefCell::new(None),
+        });
+
+        search_entry.connect_search_changed(clone!(@strong result => move |_| {
+            result.recording_list.invalidate_filter();
+        }));
+
+        back_button.connect_clicked(clone!(@strong result => move |_| {
+            let navigator = result.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.clone().pop();
+            }
+        }));
+
+        result
+            .recording_list
+            .set_selected(clone!(@strong result => move |recording| {
+                let navigator = result.navigator.borrow().clone();
+                if let Some(navigator) = navigator {
+                    navigator.push(RecordingScreen::new(result.backend.clone(), recording.clone()));
+                }
+            }));
+
+        edit_action.connect_activate(clone!(@strong result => move |_, _| {
+            let editor = WorkEditor::new(result.backend.clone(), Some(result.work.clone()));
+            let window = NavigatorWindow::new(editor);
+            window.show();
+        }));
+
+        delete_action.connect_activate(clone!(@strong result => move |_, _| {
+            let context = glib::MainContext::default();
+            let clone = result.clone();
+            context.spawn_local(async move {
+                clone.backend.db().delete_work(&clone.work.id).await.unwrap();
+                clone.backend.library_changed();
+            });
+        }));
+
+        let context = glib::MainContext::default();
+        let clone = result.clone();
+        context.spawn_local(async move {
+            let recordings = clone
+                .backend
+                .db()
+                .get_recordings_for_work(&clone.work.id)
+                .await
+                .unwrap();
+
+            if recordings.is_empty() {
+                clone.stack.set_visible_child_name("nothing");
+            } else {
+                clone.recording_list.show_items(recordings);
+                clone.stack.set_visible_child_name("content");
+            }
+        });
+
+        result
+    }
+}
+
+impl NavigatorScreen for WorkScreen {
+    fn attach_navigator(&self, navigator: Rc<Navigator>) {
+        self.navigator.replace(Some(navigator));
+    }
+
+    fn get_widget(&self) -> gtk::Widget {
+        self.widget.clone().upcast()
+    }
+
+    fn detach_navigator(&self) {
+        self.navigator.replace(None);
+    }
+}

src/selectors/ensemble.rs

@@ -0,0 +1,111 @@
+use super::selector::Selector;
+use crate::backend::Backend;
+use crate::database::Ensemble;
+use crate::editors::EnsembleEditor;
+use crate::widgets::{Navigator, NavigatorScreen};
+use gettextrs::gettext;
+use glib::clone;
+use gtk::prelude::*;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+/// A screen for selecting a ensemble.
+pub struct EnsembleSelector {
+    backend: Rc<Backend>,
+    selector: Rc<Selector<Ensemble>>,
+    selected_cb: RefCell<Option<Box<dyn Fn(&Ensemble) -> ()>>>,
+    navigator: RefCell<Option<Rc<Navigator>>>,
+}
+
+impl EnsembleSelector {
+    /// Create a new ensemble selector.
+    pub fn new(backend: Rc<Backend>) -> Rc<Self> {
+        // Create UI
+
+        let selector = Selector::<Ensemble>::new();
+        selector.set_title(&gettext("Select ensemble"));
+
+        let this = Rc::new(Self {
+            backend,
+            selector,
+            selected_cb: RefCell::new(None),
+            navigator: RefCell::new(None),
+        });
+
+        // Connect signals and callbacks
+
+        this.selector.set_back_cb(clone!(@strong this => move || {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.pop();
+            }
+        }));
+
+        this.selector.set_add_cb(clone!(@strong this => move || {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                let editor = EnsembleEditor::new(this.backend.clone(), None);
+                editor
+                    .set_saved_cb(clone!(@strong this => move |ensemble| this.select(&ensemble)));
+                navigator.push(editor);
+            }
+        }));
+
+        this.selector
+            .set_load_online(clone!(@strong this => move || {
+                let clone = this.clone();
+                async move { clone.backend.get_ensembles().await }
+            }));
+
+        this.selector
+            .set_load_local(clone!(@strong this => move || {
+                let clone = this.clone();
+                async move { clone.backend.db().get_ensembles().await.unwrap() }
+            }));
+
+        this.selector.set_make_widget(|ensemble| {
+            let label = gtk::Label::new(Some(&ensemble.name));
+            label.set_halign(gtk::Align::Start);
+            label.set_margin_start(6);
+            label.set_margin_end(6);
+            label.set_margin_top(6);
+            label.set_margin_bottom(6);
+            label.upcast()
+        });
+
+        this.selector
+            .set_filter(|search, ensemble| ensemble.name.to_lowercase().contains(search));
+
+        this.selector
+            .set_selected_cb(clone!(@strong this => move |ensemble| this.select(ensemble)));
+
+        this
+    }
+
+    /// Set the closure to be called when an item is selected.
+    pub fn set_selected_cb<F: Fn(&Ensemble) -> () + 'static>(&self, cb: F) {
+        self.selected_cb.replace(Some(Box::new(cb)));
+    }
+
+    /// Select a ensemble.
+    fn select(&self, ensemble: &Ensemble) {        
+        if let Some(cb) = &*self.selected_cb.borrow() {
+            cb(&ensemble);
+        }
+
+    }
+}
+
+impl NavigatorScreen for EnsembleSelector {
+    fn attach_navigator(&self, navigator: Rc<Navigator>) {
+        self.navigator.replace(Some(navigator));
+    }
+
+    fn get_widget(&self) -> gtk::Widget {
+        self.selector.widget.clone().upcast()
+    }
+
+    fn detach_navigator(&self) {
+        self.navigator.replace(None);
+    }
+}

src/selectors/instrument.rs

@@ -0,0 +1,110 @@
+use super::selector::Selector;
+use crate::backend::Backend;
+use crate::database::Instrument;
+use crate::editors::InstrumentEditor;
+use crate::widgets::{Navigator, NavigatorScreen};
+use gettextrs::gettext;
+use glib::clone;
+use gtk::prelude::*;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+/// A screen for selecting a instrument.
+pub struct InstrumentSelector {
+    backend: Rc<Backend>,
+    selector: Rc<Selector<Instrument>>,
+    selected_cb: RefCell<Option<Box<dyn Fn(&Instrument) -> ()>>>,
+    navigator: RefCell<Option<Rc<Navigator>>>,
+}
+
+impl InstrumentSelector {
+    /// Create a new instrument selector.
+    pub fn new(backend: Rc<Backend>) -> Rc<Self> {
+        // Create UI
+
+        let selector = Selector::<Instrument>::new();
+        selector.set_title(&gettext("Select instrument"));
+
+        let this = Rc::new(Self {
+            backend,
+            selector,
+            selected_cb: RefCell::new(None),
+            navigator: RefCell::new(None),
+        });
+
+        // Connect signals and callbacks
+
+        this.selector.set_back_cb(clone!(@strong this => move || {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.pop();
+            }
+        }));
+
+        this.selector.set_add_cb(clone!(@strong this => move || {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                let editor = InstrumentEditor::new(this.backend.clone(), None);
+                editor
+                    .set_saved_cb(clone!(@strong this => move |instrument| this.select(&instrument)));
+                navigator.push(editor);
+            }
+        }));
+
+        this.selector
+            .set_load_online(clone!(@strong this => move || {
+                let clone = this.clone();
+                async move { clone.backend.get_instruments().await }
+            }));
+
+        this.selector
+            .set_load_local(clone!(@strong this => move || {
+                let clone = this.clone();
+                async move { clone.backend.db().get_instruments().await.unwrap() }
+            }));
+
+        this.selector.set_make_widget(|instrument| {
+            let label = gtk::Label::new(Some(&instrument.name));
+            label.set_halign(gtk::Align::Start);
+            label.set_margin_start(6);
+            label.set_margin_end(6);
+            label.set_margin_top(6);
+            label.set_margin_bottom(6);
+            label.upcast()
+        });
+
+        this.selector
+            .set_filter(|search, instrument| instrument.name.to_lowercase().contains(search));
+
+        this.selector
+            .set_selected_cb(clone!(@strong this => move |instrument| this.select(instrument)));
+
+        this
+    }
+
+    /// Set the closure to be called when an item is selected.
+    pub fn set_selected_cb<F: Fn(&Instrument) -> () + 'static>(&self, cb: F) {
+        self.selected_cb.replace(Some(Box::new(cb)));
+    }
+
+    /// Select a instrument.
+    fn select(&self, instrument: &Instrument) {
+        if let Some(cb) = &*self.selected_cb.borrow() {
+            cb(&instrument);
+        }
+    }
+}
+
+impl NavigatorScreen for InstrumentSelector {
+    fn attach_navigator(&self, navigator: Rc<Navigator>) {
+        self.navigator.replace(Some(navigator));
+    }
+
+    fn get_widget(&self) -> gtk::Widget {
+        self.selector.widget.clone().upcast()
+    }
+
+    fn detach_navigator(&self) {
+        self.navigator.replace(None);
+    }
+}

src/selectors/mod.rs

@@ -0,0 +1,16 @@
+pub mod ensemble;
+pub use ensemble::*;
+
+pub mod instrument;
+pub use instrument::*;
+
+pub mod person;
+pub use person::*;
+
+pub mod recording;
+pub use recording::*;
+
+pub mod work;
+pub use work::*;
+
+mod selector;

src/selectors/person.rs

@@ -0,0 +1,110 @@
+use super::selector::Selector;
+use crate::backend::Backend;
+use crate::database::Person;
+use crate::editors::PersonEditor;
+use crate::widgets::{Navigator, NavigatorScreen};
+use gettextrs::gettext;
+use glib::clone;
+use gtk::prelude::*;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+/// A screen for selecting a person.
+pub struct PersonSelector {
+    backend: Rc<Backend>,
+    selector: Rc<Selector<Person>>,
+    selected_cb: RefCell<Option<Box<dyn Fn(&Person) -> ()>>>,
+    navigator: RefCell<Option<Rc<Navigator>>>,
+}
+
+impl PersonSelector {
+    /// Create a new person selector.
+    pub fn new(backend: Rc<Backend>) -> Rc<Self> {
+        // Create UI
+
+        let selector = Selector::<Person>::new();
+        selector.set_title(&gettext("Select person"));
+
+        let this = Rc::new(Self {
+            backend,
+            selector,
+            selected_cb: RefCell::new(None),
+            navigator: RefCell::new(None),
+        });
+
+        // Connect signals and callbacks
+
+        this.selector.set_back_cb(clone!(@strong this => move || {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.pop();
+            }
+        }));
+
+        this.selector.set_add_cb(clone!(@strong this => move || {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                let editor = PersonEditor::new(this.backend.clone(), None);
+                editor
+                    .set_saved_cb(clone!(@strong this => move |person| this.select(&person)));
+                navigator.push(editor);
+            }
+        }));
+
+        this.selector
+            .set_load_online(clone!(@strong this => move || {
+                let clone = this.clone();
+                async move { clone.backend.get_persons().await }
+            }));
+
+        this.selector
+            .set_load_local(clone!(@strong this => move || {
+                let clone = this.clone();
+                async move { clone.backend.db().get_persons().await.unwrap() }
+            }));
+
+        this.selector.set_make_widget(|person| {
+            let label = gtk::Label::new(Some(&person.name_lf()));
+            label.set_halign(gtk::Align::Start);
+            label.set_margin_start(6);
+            label.set_margin_end(6);
+            label.set_margin_top(6);
+            label.set_margin_bottom(6);
+            label.upcast()
+        });
+
+        this.selector
+            .set_filter(|search, person| person.name_fl().to_lowercase().contains(search));
+
+        this.selector
+            .set_selected_cb(clone!(@strong this => move |person| this.select(person)));
+
+        this
+    }
+
+    /// Set the closure to be called when an item is selected.
+    pub fn set_selected_cb<F: Fn(&Person) -> () + 'static>(&self, cb: F) {
+        self.selected_cb.replace(Some(Box::new(cb)));
+    }
+
+    /// Select a person.
+    fn select(&self, person: &Person) {
+        if let Some(cb) = &*self.selected_cb.borrow() {
+            cb(&person);
+        }
+    }
+}
+
+impl NavigatorScreen for PersonSelector {
+    fn attach_navigator(&self, navigator: Rc<Navigator>) {
+        self.navigator.replace(Some(navigator));
+    }
+
+    fn get_widget(&self) -> gtk::Widget {
+        self.selector.widget.clone().upcast()
+    }
+
+    fn detach_navigator(&self) {
+        self.navigator.replace(None);
+    }
+}

src/selectors/recording.rs

@@ -0,0 +1,121 @@
+use super::selector::Selector;
+use crate::backend::Backend;
+use crate::database::{Recording, Work};
+use crate::editors::RecordingEditor;
+use crate::widgets::{Navigator, NavigatorScreen};
+use gettextrs::gettext;
+use glib::clone;
+use gtk::prelude::*;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+/// A screen for selecting a recording.
+pub struct RecordingSelector {
+    backend: Rc<Backend>,
+    work: Work,
+    selector: Rc<Selector<Recording>>,
+    selected_cb: RefCell<Option<Box<dyn Fn(&Recording) -> ()>>>,
+    navigator: RefCell<Option<Rc<Navigator>>>,
+}
+
+impl RecordingSelector {
+    /// Create a new recording selector for recordings of a specific work.
+    pub fn new(backend: Rc<Backend>, work: Work) -> Rc<Self> {
+        // Create UI
+
+        let selector = Selector::<Recording>::new();
+        selector.set_title(&gettext("Select recording"));
+        selector.set_subtitle(&work.get_title());
+
+        let this = Rc::new(Self {
+            backend,
+            work,
+            selector,
+            selected_cb: RefCell::new(None),
+            navigator: RefCell::new(None),
+        });
+
+        // Connect signals and callbacks
+
+        this.selector.set_back_cb(clone!(@strong this => move || {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.pop();
+            }
+        }));
+
+        this.selector.set_add_cb(clone!(@strong this => move || {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                let recording = Recording::new(this.work.clone());
+
+                let editor = RecordingEditor::new(this.backend.clone(), Some(recording));
+                
+                editor
+                    .set_selected_cb(clone!(@strong this, @strong navigator => move |recording| {
+                        navigator.clone().pop();
+                        this.select(&recording);
+                    }));
+                
+                navigator.push(editor);
+            }
+        }));
+
+        this.selector
+            .set_load_online(clone!(@strong this => move || {
+                let clone = this.clone();
+                async move { clone.backend.get_recordings_for_work(&clone.work.id).await }
+            }));
+
+        this.selector
+            .set_load_local(clone!(@strong this => move || {
+                let clone = this.clone();
+                async move { clone.backend.db().get_recordings_for_work(&clone.work.id).await.unwrap() }
+            }));
+
+        this.selector.set_make_widget(|recording| {
+            let label = gtk::Label::new(Some(&recording.get_performers()));
+            label.set_halign(gtk::Align::Start);
+            label.set_margin_start(6);
+            label.set_margin_end(6);
+            label.set_margin_top(6);
+            label.set_margin_bottom(6);
+            label.upcast()
+        });
+
+        this.selector.set_filter(|search, recording| {
+            recording.get_performers().to_lowercase().contains(search)
+        });
+
+        this.selector
+            .set_selected_cb(clone!(@strong this => move |recording| this.select(recording)));
+
+        this
+    }
+
+    /// Set the closure to be called when an item is selected.
+    pub fn set_selected_cb<F: Fn(&Recording) -> () + 'static>(&self, cb: F) {
+        self.selected_cb.replace(Some(Box::new(cb)));
+    }
+
+    /// Select a recording.
+    fn select(&self, recording: &Recording) {
+        if let Some(cb) = &*self.selected_cb.borrow() {
+            cb(&recording);
+        }
+    }
+}
+
+impl NavigatorScreen for RecordingSelector {
+    fn attach_navigator(&self, navigator: Rc<Navigator>) {
+        self.navigator.replace(Some(navigator));
+    }
+
+    fn get_widget(&self) -> gtk::Widget {
+        self.selector.widget.clone().upcast()
+    }
+
+    fn detach_navigator(&self) {
+        self.navigator.replace(None);
+    }
+}

src/selectors/selector.rs

@@ -0,0 +1,201 @@
+use crate::widgets::List;
+use anyhow::Result;
+use gettextrs::gettext;
+use glib::clone;
+use gtk::prelude::*;
+use gtk_macros::get_widget;
+use libhandy::HeaderBarExt;
+use std::cell::RefCell;
+use std::future::Future;
+use std::pin::Pin;
+use std::rc::Rc;
+
+/// A screen that presents a list of items. It allows to switch between the server and the local
+/// database and to search within the list.
+pub struct Selector<T: 'static> {
+    pub widget: gtk::Box,
+    header: libhandy::HeaderBar,
+    server_check_button: gtk::CheckButton,
+    stack: gtk::Stack,
+    list: Rc<List<T>>,
+    back_cb: RefCell<Option<Box<dyn Fn() -> ()>>>,
+    add_cb: RefCell<Option<Box<dyn Fn() -> ()>>>,
+    load_online: RefCell<Option<Box<dyn Fn() -> Box<dyn Future<Output = Result<Vec<T>>>>>>>,
+    load_local: RefCell<Option<Box<dyn Fn() -> Box<dyn Future<Output = Vec<T>>>>>>,
+    filter: RefCell<Option<Box<dyn Fn(&str, &T) -> bool>>>,
+}
+
+impl<T> Selector<T> {
+    /// Create a new selector.
+    pub fn new() -> Rc<Self> {
+        // Create UI
+
+        let builder = gtk::Builder::from_resource("/de/johrpan/musicus/ui/selector.ui");
+
+        get_widget!(builder, gtk::Box, widget);
+        get_widget!(builder, libhandy::HeaderBar, header);
+        get_widget!(builder, gtk::Button, back_button);
+        get_widget!(builder, gtk::Button, add_button);
+        get_widget!(builder, gtk::SearchEntry, search_entry);
+        get_widget!(builder, gtk::CheckButton, server_check_button);
+        get_widget!(builder, gtk::Stack, stack);
+        get_widget!(builder, gtk::Frame, frame);
+        get_widget!(builder, gtk::Button, try_again_button);
+
+        let list = List::<T>::new(&gettext("Nothing found."));
+        frame.add(&list.widget);
+
+        let this = Rc::new(Self {
+            widget,
+            header,
+            server_check_button,
+            stack,
+            list,
+            back_cb: RefCell::new(None),
+            add_cb: RefCell::new(None),
+            load_online: RefCell::new(None),
+            load_local: RefCell::new(None),
+            filter: RefCell::new(None),
+        });
+
+        // Connect signals and callbacks
+
+        back_button.connect_clicked(clone!(@strong this => move |_| {
+            if let Some(cb) = &*this.back_cb.borrow() {
+                cb();
+            }
+        }));
+
+        add_button.connect_clicked(clone!(@strong this => move |_| {
+            if let Some(cb) = &*this.add_cb.borrow() {
+                cb();
+            }
+        }));
+
+        search_entry.connect_search_changed(clone!(@strong this => move |_| {
+            this.list.invalidate_filter();
+        }));
+
+        this.server_check_button
+            .connect_toggled(clone!(@strong this => move |_| {
+                if this.server_check_button.get_active() {
+                    this.clone().load_online();
+                } else {
+                    this.clone().load_local();
+                }
+            }));
+
+        this.list.set_filter(
+            clone!(@strong this, @strong search_entry => move |item: &T| {
+                match &*this.filter.borrow() {
+                    Some(filter) => {
+                        let search = search_entry.get_text().to_string().to_lowercase();
+                        search.is_empty() || filter(&search, item)
+                    }
+                    None => true,
+                }
+            }),
+        );
+
+        try_again_button.connect_clicked(clone!(@strong this => move |_| {
+            this.clone().load_online();
+        }));
+
+        // Initialize
+        this.clone().load_online();
+
+        this
+    }
+
+    /// Set the title to be shown in the header.
+    pub fn set_title(&self, title: &str) {
+        self.header.set_title(Some(title));
+    }
+
+    /// Set the subtitle to be shown in the header.
+    pub fn set_subtitle(&self, subtitle: &str) {
+        self.header.set_subtitle(Some(subtitle));
+    }
+
+    /// Set the closure to be called when the user wants to go back.
+    pub fn set_back_cb<F: Fn() -> () + 'static>(&self, cb: F) {
+        self.back_cb.replace(Some(Box::new(cb)));
+    }
+
+    /// Set the closure to be called when the user wants to add an item.
+    pub fn set_add_cb<F: Fn() -> () + 'static>(&self, cb: F) {
+        self.add_cb.replace(Some(Box::new(cb)));
+    }
+
+    /// Set the async closure to be called to fetch items from the server. If that results in an
+    /// error, an error screen is shown allowing to try again.
+    pub fn set_load_online<F, R>(&self, cb: F)
+    where
+        F: (Fn() -> R) + 'static,
+        R: Future<Output = Result<Vec<T>>> + 'static,
+    {
+        self.load_online
+            .replace(Some(Box::new(move || Box::new(cb()))));
+    }
+
+    /// Set the async closure to be called to get local items.
+    pub fn set_load_local<F, R>(&self, cb: F)
+    where
+        F: (Fn() -> R) + 'static,
+        R: Future<Output = Vec<T>> + 'static,
+    {
+        self.load_local
+            .replace(Some(Box::new(move || Box::new(cb()))));
+    }
+
+    /// Set the closure to be called for creating a new list row.
+    pub fn set_make_widget<F: Fn(&T) -> gtk::Widget + 'static>(&self, make_widget: F) {
+        self.list.set_make_widget(make_widget);
+    }
+
+    /// Set a closure to call when deciding whether to show an item based on a search string. The
+    /// search string will be converted to lowercase.
+    pub fn set_filter<F: Fn(&str, &T) -> bool + 'static>(&self, filter: F) {
+        self.filter.replace(Some(Box::new(filter)));
+    }
+
+    /// Set the closure to be called when an item is selected.
+    pub fn set_selected_cb<F: Fn(&T) -> () + 'static>(&self, cb: F) {
+        self.list.set_selected(cb);
+    }
+
+    fn load_online(self: Rc<Self>) {
+        let context = glib::MainContext::default();
+        let clone = self.clone();
+        context.spawn_local(async move {
+            if let Some(cb) = &*self.load_online.borrow() {
+                self.stack.set_visible_child_name("loading");
+
+                match Pin::from(cb()).await {
+                    Ok(items) => {
+                        clone.list.show_items(items);
+                        clone.stack.set_visible_child_name("content");
+                    }
+                    Err(_) => {
+                        clone.list.show_items(Vec::new());
+                        clone.stack.set_visible_child_name("error");
+                    }
+                }
+            }
+        });
+    }
+
+    fn load_local(self: Rc<Self>) {
+        let context = glib::MainContext::default();
+        let clone = self.clone();
+        context.spawn_local(async move {
+            if let Some(cb) = &*self.load_local.borrow() {
+                self.stack.set_visible_child_name("loading");
+
+                let items = Pin::from(cb()).await;
+                clone.list.show_items(items);
+                clone.stack.set_visible_child_name("content");
+            }
+        });
+    }
+}

src/selectors/work.rs

@@ -0,0 +1,120 @@
+use super::selector::Selector;
+use crate::backend::Backend;
+use crate::database::{Person, Work};
+use crate::editors::WorkEditor;
+use crate::widgets::{Navigator, NavigatorScreen};
+use gettextrs::gettext;
+use glib::clone;
+use gtk::prelude::*;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+/// A screen for selecting a work.
+pub struct WorkSelector {
+    backend: Rc<Backend>,
+    person: Person,
+    selector: Rc<Selector<Work>>,
+    selected_cb: RefCell<Option<Box<dyn Fn(&Work) -> ()>>>,
+    navigator: RefCell<Option<Rc<Navigator>>>,
+}
+
+impl WorkSelector {
+    /// Create a new work selector for works by a specific composer.
+    pub fn new(backend: Rc<Backend>, person: Person) -> Rc<Self> {
+        // Create UI
+
+        let selector = Selector::<Work>::new();
+        selector.set_title(&gettext("Select work"));
+        selector.set_subtitle(&person.name_fl());
+
+        let this = Rc::new(Self {
+            backend,
+            person,
+            selector,
+            selected_cb: RefCell::new(None),
+            navigator: RefCell::new(None),
+        });
+
+        // Connect signals and callbacks
+
+        this.selector.set_back_cb(clone!(@strong this => move || {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                navigator.pop();
+            }
+        }));
+
+        this.selector.set_add_cb(clone!(@strong this => move || {
+            let navigator = this.navigator.borrow().clone();
+            if let Some(navigator) = navigator {
+                let work = Work::new(this.person.clone());
+
+                let editor = WorkEditor::new(this.backend.clone(), Some(work));
+
+                editor
+                    .set_saved_cb(clone!(@strong this, @strong navigator => move |work| {
+                        navigator.clone().pop();
+                        this.select(&work);
+                    }));
+
+                navigator.push(editor);
+            }
+        }));
+
+        this.selector
+            .set_load_online(clone!(@strong this => move || {
+                let clone = this.clone();
+                async move { clone.backend.get_works(&clone.person.id).await }
+            }));
+
+        this.selector
+            .set_load_local(clone!(@strong this => move || {
+                let clone = this.clone();
+                async move { clone.backend.db().get_works(&clone.person.id).await.unwrap() }
+            }));
+
+        this.selector.set_make_widget(|work| {
+            let label = gtk::Label::new(Some(&work.title));
+            label.set_halign(gtk::Align::Start);
+            label.set_margin_start(6);
+            label.set_margin_end(6);
+            label.set_margin_top(6);
+            label.set_margin_bottom(6);
+            label.upcast()
+        });
+
+        this.selector
+            .set_filter(|search, work| work.title.to_lowercase().contains(search));
+
+        this.selector
+            .set_selected_cb(clone!(@strong this => move |work| this.select(work)));
+
+        this
+    }
+
+    /// Set the closure to be called when an item is selected.
+    pub fn set_selected_cb<F: Fn(&Work) -> () + 'static>(&self, cb: F) {
+        self.selected_cb.replace(Some(Box::new(cb)));
+    }
+
+    /// Select a work.
+    fn select(&self, work: &Work) {
+        if let Some(cb) = &*self.selected_cb.borrow() {
+            cb(&work);
+        }
+    }
+}
+
+impl NavigatorScreen for WorkSelector {
+    fn attach_navigator(&self, navigator: Rc<Navigator>) {
+        self.navigator.replace(Some(navigator));
+    }
+
+    fn get_widget(&self) -> gtk::Widget {
+        self.selector.widget.clone().upcast()
+    }
+
+    fn detach_navigator(&self) {
+        self.navigator.replace(None);
+    }
+}

src/widgets/list.rs

@@ -0,0 +1,139 @@
+use super::*;
+use glib::clone;
+use gtk::prelude::*;
+use std::cell::RefCell;
+use std::convert::TryInto;
+use std::rc::Rc;
+
+pub struct List<T>
+where
+    T: 'static,
+{
+    pub widget: gtk::ListBox,
+    items: RefCell<Vec<T>>,
+    make_widget: RefCell<Option<Box<dyn Fn(&T) -> gtk::Widget>>>,
+    filter: RefCell<Option<Box<dyn Fn(&T) -> bool>>>,
+    selected: RefCell<Option<Box<dyn Fn(&T) -> ()>>>,
+}
+
+impl<T> List<T>
+where
+    T: 'static,
+{
+    pub fn new(placeholder_text: &str) -> Rc<Self> {
+        let placeholder_label = gtk::Label::new(Some(placeholder_text));
+        placeholder_label.set_margin_top(6);
+        placeholder_label.set_margin_bottom(6);
+        placeholder_label.set_margin_start(6);
+        placeholder_label.set_margin_end(6);
+        placeholder_label.show();
+
+        let widget = gtk::ListBox::new();
+        widget.set_placeholder(Some(&placeholder_label));
+        widget.show();
+
+        let this = Rc::new(Self {
+            widget,
+            items: RefCell::new(Vec::new()),
+            make_widget: RefCell::new(None),
+            filter: RefCell::new(None),
+            selected: RefCell::new(None),
+        });
+
+        this.widget
+            .connect_row_activated(clone!(@strong this => move |_, row| {
+                if let Some(selected) = &*this.selected.borrow() {
+                    let row = row.get_child().unwrap().downcast::<SelectorRow>().unwrap();
+                    let index: usize = row.get_index().try_into().unwrap();
+                    selected(&this.items.borrow()[index]);
+                }
+            }));
+
+        this.widget
+            .set_filter_func(Some(Box::new(clone!(@strong this => move |row| {
+                if let Some(filter) = &*this.filter.borrow() {
+                    let row = row.get_child().unwrap().downcast::<SelectorRow>().unwrap();
+                    let index: usize = row.get_index().try_into().unwrap();
+                    filter(&this.items.borrow()[index])
+                } else {
+                    true
+                }
+            }))));
+
+        this
+    }
+
+    pub fn set_selectable(&self, selectable: bool) {
+        let mode = if selectable {
+            gtk::SelectionMode::Single
+        } else {
+            gtk::SelectionMode::None
+        };
+    
+        self.widget.set_selection_mode(mode);
+    }
+
+    pub fn set_make_widget<F: Fn(&T) -> gtk::Widget + 'static>(&self, make_widget: F) {
+        self.make_widget.replace(Some(Box::new(make_widget)));
+    }
+
+    pub fn set_filter<F: Fn(&T) -> bool + 'static>(&self, filter: F) {
+        self.filter.replace(Some(Box::new(filter)));
+    }
+
+    pub fn set_selected<S: Fn(&T) -> () + 'static>(&self, selected: S) {
+        self.selected.replace(Some(Box::new(selected)));
+    }
+
+    pub fn get_selected_index(&self) -> Option<usize> {
+        match self.widget.get_selected_rows().first() {
+            Some(row) => match row.get_child() {
+                Some(child) => Some(
+                    child
+                        .downcast::<SelectorRow>()
+                        .unwrap()
+                        .get_index()
+                        .try_into()
+                        .unwrap(),
+                ),
+                None => None,
+            },
+            None => None,
+        }
+    }
+
+    pub fn select_index(&self, index: usize) {
+        self.widget.select_row(
+            self.widget
+                .get_row_at_index(index.try_into().unwrap())
+                .as_ref(),
+        );
+    }
+
+    pub fn show_items(&self, items: Vec<T>) {
+        self.items.replace(items);
+        self.update();
+    }
+
+    pub fn invalidate_filter(&self) {
+        self.widget.invalidate_filter();
+    }
+
+    pub fn update(&self) {
+        for child in self.widget.get_children() {
+            self.widget.remove(&child);
+        }
+
+        if let Some(make_widget) = &*self.make_widget.borrow() {
+            for (index, item) in self.items.borrow().iter().enumerate() {
+                let row = SelectorRow::new(index.try_into().unwrap(), &make_widget(item));
+                row.show_all();
+                self.widget.insert(&row, -1);
+            }
+        }
+    }
+
+    pub fn clear_selection(&self) {
+        self.widget.unselect_all();
+    }
+}

src/widgets/mod.rs

@@ -0,0 +1,19 @@
+pub mod list;
+pub use list::*;
+
+pub mod navigator;
+pub use navigator::*;
+
+pub mod navigator_window;
+pub use navigator_window::*;
+
+pub mod new_list;
+
+pub mod player_bar;
+pub use player_bar::*;
+
+pub mod poe_list;
+pub use poe_list::*;
+
+pub mod selector_row;
+pub use selector_row::*;

src/widgets/navigator.rs

@@ -0,0 +1,148 @@
+use glib::clone;
+use gtk::prelude::*;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+pub trait NavigatorScreen {
+    fn attach_navigator(&self, navigator: Rc<Navigator>);
+    fn get_widget(&self) -> gtk::Widget;
+    fn detach_navigator(&self);
+}
+
+pub struct Navigator {
+    pub window: gtk::Window,
+    pub widget: gtk::Stack,
+    screens: RefCell<Vec<Rc<dyn NavigatorScreen>>>,
+    old_screens: RefCell<Vec<Rc<dyn NavigatorScreen>>>,
+    back_cb: RefCell<Option<Box<dyn Fn() -> ()>>>,
+}
+
+impl Navigator {
+    pub fn new<W, S>(window: &W, empty_screen: &S) -> Rc<Self>
+    where
+        W: IsA<gtk::Window>,
+        S: IsA<gtk::Widget>,
+    {
+        let widget = gtk::Stack::new();
+        widget.set_hhomogeneous(false);
+        widget.set_vhomogeneous(false);
+        widget.set_interpolate_size(true);
+        widget.set_transition_type(gtk::StackTransitionType::Crossfade);
+        widget.set_hexpand(true);
+        widget.add_named(empty_screen, "empty_screen");
+        widget.show();
+
+        let result = Rc::new(Self {
+            window: window.clone().upcast(),
+            widget,
+            screens: RefCell::new(Vec::new()),
+            old_screens: RefCell::new(Vec::new()),
+            back_cb: RefCell::new(None),
+        });
+
+        unsafe {
+            result.widget.connect_notify_unsafe(
+                Some("transition-running"),
+                clone!(@strong result => move |_, _| {
+                    if !result.widget.get_transition_running() {
+                        result.clear_old_screens();
+                    }
+                }),
+            );
+        }
+
+        result
+    }
+
+    pub fn set_back_cb<F>(&self, cb: F)
+    where
+        F: Fn() -> () + 'static,
+    {
+        self.back_cb.replace(Some(Box::new(cb)));
+    }
+
+    pub fn push<S>(self: Rc<Self>, screen: Rc<S>)
+    where
+        S: NavigatorScreen + 'static,
+    {
+        if let Some(screen) = self.screens.borrow().last() {
+            screen.detach_navigator();
+        }
+
+        let widget = screen.get_widget();
+        self.widget.add(&widget);
+        self.widget.set_visible_child(&widget);
+
+        screen.attach_navigator(self.clone());
+        self.screens.borrow_mut().push(screen);
+    }
+
+    pub fn pop(self: Rc<Self>) {
+        let popped = if let Some(screen) = self.screens.borrow_mut().pop() {
+            screen.detach_navigator();
+            self.old_screens.borrow_mut().push(screen);
+
+            true
+        } else {
+            false
+        };
+
+        if popped {
+            if let Some(screen) = self.screens.borrow().last() {
+                let widget = screen.get_widget();
+                self.widget.set_visible_child(&widget);
+
+                screen.attach_navigator(self.clone());
+            } else {
+                self.widget.set_visible_child_name("empty_screen");
+                if let Some(cb) = &*self.back_cb.borrow() {
+                    cb()
+                }
+            }
+
+            if !self.widget.get_transition_running() {
+                self.clear_old_screens();
+            }
+        }
+    }
+
+    pub fn replace<S>(self: Rc<Self>, screen: Rc<S>)
+    where
+        S: NavigatorScreen + 'static,
+    {
+        for screen in self.screens.replace(Vec::new()) {
+            screen.detach_navigator();
+            self.old_screens.borrow_mut().push(screen);
+        }
+
+        let widget = screen.get_widget();
+        self.widget.add(&widget);
+        self.widget.set_visible_child(&widget);
+
+        screen.attach_navigator(self.clone());
+        self.screens.borrow_mut().push(screen);
+
+        if !self.widget.get_transition_running() {
+            self.clear_old_screens();
+        }
+    }
+
+    pub fn reset(&self) {
+        for screen in self.screens.replace(Vec::new()) {
+            screen.detach_navigator();
+            self.old_screens.borrow_mut().push(screen);
+        }
+
+        if !self.widget.get_transition_running() {
+            self.clear_old_screens();
+        }
+    }
+
+    fn clear_old_screens(&self) {
+        for screen in self.old_screens.borrow().iter() {
+            self.widget.remove(&screen.get_widget());
+        }
+
+        self.old_screens.borrow_mut().clear();
+    }
+}

src/widgets/navigator_window.rs

@@ -0,0 +1,42 @@
+use crate::widgets::{Navigator, NavigatorScreen};
+use glib::clone;
+use gtk::prelude::*;
+use std::rc::Rc;
+
+/// A window hosting a navigator.
+pub struct NavigatorWindow {
+    window: libhandy::Window,
+    navigator: Rc<Navigator>,
+}
+
+impl NavigatorWindow {
+    /// Create a new navigator window showing an initial screen.
+    pub fn new<S: NavigatorScreen + 'static>(initial_screen: Rc<S>) -> Rc<Self> {
+        // Create UI
+
+        let window = libhandy::Window::new();
+        window.set_default_size(600, 424);
+        let placeholder = gtk::Label::new(None);
+        let navigator = Navigator::new(&window, &placeholder);
+        window.add(&navigator.widget);
+
+        let this = Rc::new(Self { window, navigator });
+
+        // Connect signals and callbacks
+
+        this.navigator.set_back_cb(clone!(@strong this => move || {
+            this.window.close();
+        }));
+
+        // Initialize
+
+        this.navigator.clone().replace(initial_screen);
+
+        this
+    }
+
+    /// Show the navigator window.
+    pub fn show(&self) {
+        self.window.show();
+    }
+}

src/widgets/new_list.rs

@@ -0,0 +1,50 @@
+use gtk::prelude::*;
+use std::cell::RefCell;
+
+/// A simple list of widgets.
+pub struct List {
+    pub widget: gtk::ListBox,
+    make_widget: RefCell<Option<Box<dyn Fn(usize) -> gtk::Widget>>>,
+}
+
+impl List {
+    /// Create a new list. The list will be empty.
+    pub fn new(placeholder_text: &str) -> Self {
+        let placeholder_label = gtk::Label::new(Some(placeholder_text));
+        placeholder_label.set_margin_top(6);
+        placeholder_label.set_margin_bottom(6);
+        placeholder_label.set_margin_start(6);
+        placeholder_label.set_margin_end(6);
+        placeholder_label.show();
+
+        let widget = gtk::ListBox::new();
+        widget.set_selection_mode(gtk::SelectionMode::None);
+        widget.set_placeholder(Some(&placeholder_label));
+        widget.show();
+
+        Self {
+            widget,
+            make_widget: RefCell::new(None),
+        }
+    }
+
+    /// Set the closure to be called to construct widgets for the items.
+    pub fn set_make_widget<F: Fn(usize) -> gtk::Widget + 'static>(&self, make_widget: F) {
+        self.make_widget.replace(Some(Box::new(make_widget)));
+    }
+
+    /// Call the make_widget function for each item. This will automatically
+    /// show all children by indices 0..length.
+    pub fn update(&self, length: usize) {
+        for child in self.widget.get_children() {
+            self.widget.remove(&child);
+        }
+
+        if let Some(make_widget) = &*self.make_widget.borrow() {
+            for index in 0..length {
+                let row = make_widget(index);
+                self.widget.insert(&row, -1);
+            }
+        }
+    }
+}

src/widgets/player_bar.rs

@@ -0,0 +1,175 @@
+use crate::player::*;
+use glib::clone;
+use gtk::prelude::*;
+use gtk_macros::get_widget;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+pub struct PlayerBar {
+    pub widget: gtk::Revealer,
+    title_label: gtk::Label,
+    subtitle_label: gtk::Label,
+    previous_button: gtk::Button,
+    play_button: gtk::Button,
+    next_button: gtk::Button,
+    position_label: gtk::Label,
+    duration_label: gtk::Label,
+    play_image: gtk::Image,
+    pause_image: gtk::Image,
+    player: Rc<RefCell<Option<Rc<Player>>>>,
+    playlist_cb: Rc<RefCell<Option<Box<dyn Fn() -> ()>>>>,
+}
+
+impl PlayerBar {
+    pub fn new() -> Self {
+        let builder = gtk::Builder::from_resource("/de/johrpan/musicus/ui/player_bar.ui");
+
+        get_widget!(builder, gtk::Revealer, widget);
+        get_widget!(builder, gtk::Label, title_label);
+        get_widget!(builder, gtk::Label, subtitle_label);
+        get_widget!(builder, gtk::Button, previous_button);
+        get_widget!(builder, gtk::Button, play_button);
+        get_widget!(builder, gtk::Button, next_button);
+        get_widget!(builder, gtk::Label, position_label);
+        get_widget!(builder, gtk::Label, duration_label);
+        get_widget!(builder, gtk::Button, playlist_button);
+        get_widget!(builder, gtk::Image, play_image);
+        get_widget!(builder, gtk::Image, pause_image);
+
+        let player = Rc::new(RefCell::new(None::<Rc<Player>>));
+        let playlist_cb = Rc::new(RefCell::new(None::<Box<dyn Fn() -> ()>>));
+
+        previous_button.connect_clicked(clone!(@strong player => move |_| {
+            if let Some(player) = &*player.borrow() {
+                player.previous().unwrap();
+            }
+        }));
+
+        play_button.connect_clicked(clone!(@strong player => move |_| {
+            if let Some(player) = &*player.borrow() {
+                player.play_pause();
+            }
+        }));
+
+        next_button.connect_clicked(clone!(@strong player => move |_| {
+            if let Some(player) = &*player.borrow() {
+                player.next().unwrap();
+            }
+        }));
+
+        playlist_button.connect_clicked(clone!(@strong playlist_cb => move |_| {
+            if let Some(cb) = &*playlist_cb.borrow() {
+                cb();
+            }
+        }));
+
+        Self {
+            widget,
+            title_label,
+            subtitle_label,
+            previous_button,
+            play_button,
+            next_button,
+            position_label,
+            duration_label,
+            play_image,
+            pause_image,
+            player: player,
+            playlist_cb: playlist_cb,
+        }
+    }
+
+    pub fn set_player(&self, player: Option<Rc<Player>>) {
+        self.player.replace(player.clone());
+
+        if let Some(player) = player {
+            let playlist = Rc::new(RefCell::new(Vec::<PlaylistItem>::new()));
+
+            player.add_playlist_cb(clone!(
+                @strong player,
+                @strong self.widget as widget,
+                @strong self.previous_button as previous_button,
+                @strong self.next_button as next_button,
+                @strong playlist
+                => move |new_playlist| {
+                    widget.set_reveal_child(!new_playlist.is_empty());
+                    playlist.replace(new_playlist);
+                    previous_button.set_sensitive(player.has_previous());
+                    next_button.set_sensitive(player.has_next());
+                }
+            ));
+
+            player.add_track_cb(clone!(
+                @strong player,
+                @strong playlist,
+                @strong self.previous_button as previous_button,
+                @strong self.next_button as next_button,
+                @strong self.title_label as title_label,
+                @strong self.subtitle_label as subtitle_label,
+                @strong self.position_label as position_label
+                => move |current_item, current_track| {
+                    previous_button.set_sensitive(player.has_previous());
+                    next_button.set_sensitive(player.has_next());
+
+                    let item = &playlist.borrow()[current_item];
+                    let track = &item.track_set.tracks[current_track];
+
+                    let mut parts = Vec::<String>::new();
+                    for part in &track.work_parts {
+                        parts.push(item.track_set.recording.work.parts[*part].title.clone());
+                    }
+
+                    let mut title = item.track_set.recording.work.get_title();
+                    if !parts.is_empty() {
+                        title = format!("{}: {}", title, parts.join(", "));
+                    }
+
+                    title_label.set_text(&title);
+                    subtitle_label.set_text(&item.track_set.recording.get_performers());
+                    position_label.set_text("0:00");
+                }
+            ));
+
+            player.add_duration_cb(clone!(
+                @strong self.duration_label as duration_label
+                => move |ms| {
+                    let min = ms / 60000;
+                    let sec = (ms % 60000) / 1000;
+                    duration_label.set_text(&format!("{}:{:02}", min, sec));
+                }
+            ));
+
+            player.add_playing_cb(clone!(
+                @strong self.play_button as play_button,
+                @strong self.play_image as play_image,
+                @strong self.pause_image as pause_image
+                => move |playing| {
+                    if let Some(child) = play_button.get_child() {
+                        play_button.remove( &child);
+                    }
+
+                    play_button.add(if playing {
+                        &pause_image
+                    } else {
+                        &play_image
+                    });
+                }
+            ));
+
+            player.add_position_cb(clone!(
+                @strong self.position_label as position_label
+                => move |ms| {
+                    let min = ms / 60000;
+                    let sec = (ms % 60000) / 1000;
+                    position_label.set_text(&format!("{}:{:02}", min, sec));
+                }
+            ));
+        } else {
+            self.widget.set_reveal_child(false);
+        }
+    }
+
+    pub fn set_playlist_cb<F: Fn() -> () + 'static>(&self, cb: F) {
+        self.playlist_cb.replace(Some(Box::new(cb)));
+    }
+}

src/widgets/poe_list.rs

@@ -0,0 +1,109 @@
+use super::*;
+use crate::backend::Backend;
+use crate::database::*;
+use gettextrs::gettext;
+use glib::clone;
+use gtk::prelude::*;
+use gtk_macros::get_widget;
+use std::rc::Rc;
+
+#[derive(Clone)]
+pub enum PersonOrEnsemble {
+    Person(Person),
+    Ensemble(Ensemble),
+}
+
+impl PersonOrEnsemble {
+    pub fn get_title(&self) -> String {
+        match self {
+            PersonOrEnsemble::Person(person) => person.name_lf(),
+            PersonOrEnsemble::Ensemble(ensemble) => ensemble.name.clone(),
+        }
+    }
+}
+
+pub struct PoeList {
+    pub widget: gtk::Box,
+    list: Rc<List<PersonOrEnsemble>>,
+    backend: Rc<Backend>,
+    stack: gtk::Stack,
+}
+
+impl PoeList {
+    pub fn new(backend: Rc<Backend>) -> Rc<Self> {
+        let builder = gtk::Builder::from_resource("/de/johrpan/musicus/ui/poe_list.ui");
+
+        get_widget!(builder, gtk::Box, widget);
+        get_widget!(builder, gtk::SearchEntry, search_entry);
+        get_widget!(builder, gtk::Stack, stack);
+        get_widget!(builder, gtk::ScrolledWindow, scrolled_window);
+
+        let list = List::new(&gettext("No persons or ensembles found."));
+
+        list.set_make_widget(|poe: &PersonOrEnsemble| {
+            let label = gtk::Label::new(Some(&poe.get_title()));
+            label.set_halign(gtk::Align::Start);
+            label.set_margin_start(6);
+            label.set_margin_end(6);
+            label.set_margin_top(6);
+            label.set_margin_bottom(6);
+            label.upcast()
+        });
+
+        list.set_filter(
+            clone!(@strong search_entry => move |poe: &PersonOrEnsemble| {
+                let search = search_entry.get_text().to_string().to_lowercase();
+                let title = poe.get_title().to_lowercase();
+                search.is_empty() || title.contains(&search)
+            }),
+        );
+
+        scrolled_window.add(&list.widget);
+
+        let result = Rc::new(Self {
+            widget,
+            list,
+            backend,
+            stack,
+        });
+
+        search_entry.connect_search_changed(clone!(@strong result => move |_| {
+            result.list.invalidate_filter();
+        }));
+
+        result
+    }
+
+    pub fn set_selected<S>(&self, selected: S)
+    where
+        S: Fn(&PersonOrEnsemble) -> () + 'static,
+    {
+        self.list.set_selected(selected);
+    }
+
+    pub fn reload(self: Rc<Self>) {
+        self.stack.set_visible_child_name("loading");
+
+        let context = glib::MainContext::default();
+        let backend = self.backend.clone();
+        let list = self.list.clone();
+
+        context.spawn_local(async move {
+            let persons = backend.db().get_persons().await.unwrap();
+            let ensembles = backend.db().get_ensembles().await.unwrap();
+            let mut poes: Vec<PersonOrEnsemble> = Vec::new();
+
+            for person in persons {
+                poes.push(PersonOrEnsemble::Person(person));
+            }
+
+            for ensemble in ensembles {
+                poes.push(PersonOrEnsemble::Ensemble(ensemble));
+            }
+
+            list.show_items(poes);
+
+            self.stack.set_visible_child_name("content");
+        });
+    }
+}

src/widgets/selector_row.rs

@@ -0,0 +1,149 @@
+use glib::prelude::*;
+use glib::subclass;
+use glib::subclass::prelude::*;
+use glib::translate::*;
+use glib::{glib_object_impl, glib_object_subclass, glib_wrapper};
+use gtk::prelude::*;
+use gtk::subclass::prelude::*;
+use std::cell::{Cell, RefCell};
+
+glib_wrapper! {
+    pub struct SelectorRow(
+        Object<subclass::simple::InstanceStruct<SelectorRowPriv>,
+            subclass::simple::ClassStruct<SelectorRowPriv>,
+            SelectorRowClass>
+    ) @extends gtk::Bin, gtk::Container, gtk::Widget;
+
+    match fn {
+        get_type => || SelectorRowPriv::get_type().to_glib(),
+    }
+}
+
+impl SelectorRow {
+    pub fn new<T: IsA<gtk::Widget>>(index: u64, child: &T) -> Self {
+        glib::Object::new(
+            Self::static_type(),
+            &[("index", &index), ("child", child.upcast_ref())],
+        )
+        .expect("Failed to create SelectorRow GObject!")
+        .downcast()
+        .expect("SelectorRow GObject is of the wrong type!")
+    }
+
+    pub fn get_index(&self) -> u64 {
+        self.get_property("index").unwrap().get().unwrap().unwrap()
+    }
+}
+
+pub struct SelectorRowPriv {
+    index: Cell<u64>,
+    child: RefCell<Option<gtk::Widget>>,
+}
+
+static PROPERTIES: [subclass::Property; 2] = [
+    subclass::Property("index", |name| {
+        glib::ParamSpec::uint64(
+            name,
+            "Index",
+            "Index",
+            0,
+            u64::MAX,
+            0,
+            glib::ParamFlags::READWRITE,
+        )
+    }),
+    subclass::Property("child", |name| {
+        glib::ParamSpec::object(
+            name,
+            "Child",
+            "Child",
+            gtk::Widget::static_type(),
+            glib::ParamFlags::READWRITE,
+        )
+    }),
+];
+
+impl ObjectSubclass for SelectorRowPriv {
+    const NAME: &'static str = "SelectorRow";
+    type ParentType = gtk::Bin;
+    type Instance = subclass::simple::InstanceStruct<Self>;
+    type Class = subclass::simple::ClassStruct<Self>;
+
+    glib_object_subclass!();
+
+    fn class_init(klass: &mut Self::Class) {
+        klass.install_properties(&PROPERTIES);
+    }
+
+    fn new() -> Self {
+        Self {
+            index: Cell::new(0),
+            child: RefCell::new(None),
+        }
+    }
+}
+
+impl ObjectImpl for SelectorRowPriv {
+    glib_object_impl!();
+
+    fn constructed(&self, object: &glib::Object) {
+        self.parent_constructed(object);
+
+        let row = object.downcast_ref::<SelectorRow>().unwrap();
+
+        let child = self.child.borrow();
+        match child.as_ref() {
+            Some(child) => row.add(child),
+            None => (),
+        }
+    }
+
+    fn set_property(&self, object: &glib::Object, id: usize, value: &glib::Value) {
+        let prop = &PROPERTIES[id];
+
+        match *prop {
+            subclass::Property("index", ..) => {
+                let index = value
+                    .get_some()
+                    .expect("Wrong type for SelectorRow GObject index property!");
+                self.index.set(index);
+            }
+            subclass::Property("child", ..) => {
+                let child = value
+                    .get()
+                    .expect("Wrong type for SelectorRow GObject child property!");
+
+                let row = object.downcast_ref::<SelectorRow>().unwrap();
+
+                {
+                    let old = self.child.borrow();
+                    match old.as_ref() {
+                        Some(old) => row.remove(old),
+                        None => (),
+                    }
+                }
+
+                self.child.replace(child.clone());
+                match child {
+                    Some(child) => row.add(&child),
+                    None => (),
+                }
+            }
+            _ => unimplemented!(),
+        }
+    }
+
+    fn get_property(&self, _obj: &glib::Object, id: usize) -> Result<glib::Value, ()> {
+        let prop = &PROPERTIES[id];
+
+        match *prop {
+            subclass::Property("index", ..) => Ok(self.index.get().to_value()),
+            subclass::Property("child", ..) => Ok(self.child.borrow().to_value()),
+            _ => unimplemented!(),
+        }
+    }
+}
+
+impl WidgetImpl for SelectorRowPriv {}
+impl ContainerImpl for SelectorRowPriv {}
+impl BinImpl for SelectorRowPriv {}

src/window.rs

@@ -0,0 +1,204 @@
+use crate::backend::*;
+use crate::dialogs::*;
+use crate::import::SourceSelector;
+use crate::screens::*;
+use crate::widgets::*;
+use futures::prelude::*;
+use gettextrs::gettext;
+use gio::prelude::*;
+use glib::clone;
+use gtk::prelude::*;
+use gtk_macros::{action, get_widget};
+use libhandy::prelude::*;
+use std::rc::Rc;
+
+pub struct Window {
+    backend: Rc<Backend>,
+    window: libhandy::ApplicationWindow,
+    stack: gtk::Stack,
+    leaflet: libhandy::Leaflet,
+    sidebar_box: gtk::Box,
+    poe_list: Rc<PoeList>,
+    navigator: Rc<Navigator>,
+    player_bar: PlayerBar,
+    player_screen: PlayerScreen,
+}
+
+impl Window {
+    pub fn new(app: &gtk::Application) -> Rc<Self> {
+        let builder = gtk::Builder::from_resource("/de/johrpan/musicus/ui/window.ui");
+
+        get_widget!(builder, libhandy::ApplicationWindow, window);
+        get_widget!(builder, gtk::Stack, stack);
+        get_widget!(builder, gtk::Button, select_music_library_path_button);
+        get_widget!(builder, gtk::Box, content_box);
+        get_widget!(builder, libhandy::Leaflet, leaflet);
+        get_widget!(builder, gtk::Button, add_button);
+        get_widget!(builder, gtk::Box, sidebar_box);
+        get_widget!(builder, gtk::Box, empty_screen);
+
+        let backend = Rc::new(Backend::new());
+
+        let player_screen = PlayerScreen::new();
+        stack.add_named(&player_screen.widget, "player_screen");
+
+        let poe_list = PoeList::new(backend.clone());
+        let navigator = Navigator::new(&window, &empty_screen);
+        navigator.set_back_cb(clone!(@strong leaflet, @strong sidebar_box => move || {
+            leaflet.set_visible_child(&sidebar_box);
+        }));
+
+        let player_bar = PlayerBar::new();
+        content_box.add(&player_bar.widget);
+
+        let result = Rc::new(Self {
+            backend,
+            window,
+            stack,
+            leaflet,
+            sidebar_box,
+            poe_list,
+            navigator,
+            player_bar,
+            player_screen,
+        });
+
+        result.window.set_application(Some(app));
+
+        select_music_library_path_button.connect_clicked(clone!(@strong result => move |_| {
+            let dialog = gtk::FileChooserNative::new(
+                Some(&gettext("Select music library folder")),
+                Some(&result.window),
+                gtk::FileChooserAction::SelectFolder,
+                None,
+                None);
+
+            if let gtk::ResponseType::Accept = dialog.run() {
+                if let Some(path) = dialog.get_filename() {
+                    let context = glib::MainContext::default();
+                    let backend = result.backend.clone();
+                    context.spawn_local(async move {
+                        backend.set_music_library_path(path).await.unwrap();
+                    });
+                }
+            }
+        }));
+
+        add_button.connect_clicked(clone!(@strong result => move |_| {
+            // let editor = TracksEditor::new(result.backend.clone(), None, Vec::new());
+
+            // editor.set_callback(clone!(@strong result => move || {
+            //     result.reload();
+            // }));
+
+            // let window = NavigatorWindow::new(editor);
+            // window.show();
+
+            let dialog = SourceSelector::new(result.backend.clone());
+            let window = NavigatorWindow::new(dialog);
+            window.show();
+        }));
+
+        result
+            .player_bar
+            .set_playlist_cb(clone!(@strong result => move || {
+                result.stack.set_visible_child_name("player_screen");
+            }));
+
+        result
+            .player_screen
+            .set_back_cb(clone!(@strong result => move || {
+                result.stack.set_visible_child_name("content");
+            }));
+
+        // action!(
+        //     result.window,
+        //     "import-disc",
+        //     clone!(@strong result => move |_, _| {
+        //         let dialog = ImportDiscDialog::new(result.backend.clone());
+        //         let window = NavigatorWindow::new(dialog);
+        //         window.show();
+        //     })
+        // );
+
+        action!(
+            result.window,
+            "preferences",
+            clone!(@strong result => move |_, _| {
+                Preferences::new(result.backend.clone(), &result.window).show();
+            })
+        );
+
+        action!(
+            result.window,
+            "about",
+            clone!(@strong result => move |_, _| {
+                show_about_dialog(&result.window);
+            })
+        );
+
+        let context = glib::MainContext::default();
+        let clone = result.clone();
+        context.spawn_local(async move {
+            let mut state_stream = clone.backend.state_stream.borrow_mut();
+            while let Some(state) = state_stream.next().await {
+                match state {
+                    BackendState::NoMusicLibrary => {
+                        clone.stack.set_visible_child_name("empty");
+                    }
+                    BackendState::Loading => {
+                        clone.stack.set_visible_child_name("loading");
+                    }
+                    BackendState::Ready => {
+                        clone.stack.set_visible_child_name("content");
+                        clone.poe_list.clone().reload();
+                        clone.navigator.reset();
+
+                        let player = clone.backend.get_player().unwrap();
+                        clone.player_bar.set_player(Some(player.clone()));
+                        clone.player_screen.set_player(Some(player));
+                    }
+                }
+            }
+        });
+
+        let clone = result.clone();
+        context.spawn_local(async move {
+            // This is not done in the async block below, because backend state changes may happen
+            // while this method is running.
+            clone.backend.clone().init().await.unwrap();
+        });
+
+        result.leaflet.add(&result.navigator.widget);
+
+        result
+            .poe_list
+            .set_selected(clone!(@strong result => move |poe| {
+                result.leaflet.set_visible_child(&result.navigator.widget);
+                match poe {
+                    PersonOrEnsemble::Person(person) => {
+                        result.navigator.clone().replace(PersonScreen::new(result.backend.clone(), person.clone()));
+                    }
+                    PersonOrEnsemble::Ensemble(ensemble) => {
+                        result.navigator.clone().replace(EnsembleScreen::new(result.backend.clone(), ensemble.clone()));
+                    }
+                }
+            }));
+
+        result
+            .sidebar_box
+            .pack_start(&result.poe_list.widget, true, true, 0);
+
+        result
+    }
+
+    pub fn present(&self) {
+        self.window.present();
+    }
+
+    fn reload(&self) {
+        self.poe_list.clone().reload();
+        self.navigator.reset();
+        self.leaflet.set_visible_child(&self.sidebar_box);
+    }
+}