Quick demo of using the Relm framework to create a very basic file explorer.

treeview.rs

#![feature(proc_macro)]

extern crate gtk;
#[macro_use]
extern crate relm;
#[macro_use]
extern crate relm_derive;
extern crate relm_attributes;

use std::io;
use std::fs;
use std::path::PathBuf;

use relm::{Widget, RemoteRelm};

use gtk::prelude::*;


const VALUE_COL: i32 = 0;
const IS_DIR_COL: i32 = 1;
// Model
#[derive(Clone)]
pub struct Directory {
    current_dir: PathBuf,
}

// Message types
#[derive(Msg)]
enum Msg {
    ItemSelect,
    Quit,
}

// Top level structure
#[derive(Clone)]
struct Win {
    window: gtk::Window,
    tree_view: gtk::TreeView,
}

impl Widget for Win {
    type Model = Directory;
    type Msg = Msg;
    type Root = gtk::Window;

    fn model() -> Directory {
        let working_directory = fs::canonicalize(".").expect("Failed to open directory");

        Directory { current_dir: working_directory }
    }

    fn root(&self) -> &Self::Root {
        &self.window
    }

    fn update(&mut self, event: Msg, model: &mut Self::Model) {
        match event {
            Msg::ItemSelect => {
                let selection = self.tree_view.get_selection();
                if let Some((list_model, iter)) = selection.get_selected() {
                    let is_dir: bool = list_model
                        .get_value(&iter, IS_DIR_COL)
                        .get::<bool>()
                        .unwrap();

                    if is_dir {
                        let dir_name = list_model
                            .get_value(&iter, VALUE_COL)
                            .get::<String>()
                            .unwrap();
                        println!("{:?} selected", dir_name);
                        let new_dir = if dir_name == ".." {
                            // Go up parent directory if it exists
                            model
                                .current_dir
                                .parent()
                                .unwrap_or(&model.current_dir)
                                .to_owned()
                        } else {
                            model.current_dir.join(dir_name)
                        };

                        model.current_dir = new_dir;
                        let new_model = create_and_fill_model(&model.current_dir).unwrap();

                        self.tree_view.set_model(Some(&new_model));
                    }
                }
            }
            Msg::Quit => gtk::main_quit(),
        }
    }

    fn view(relm: RemoteRelm<Msg>, _model: &Self::Model) -> Win {
        let window = create_window("Treeview");

        let tree = gtk::TreeView::new();


        let column = gtk::TreeViewColumn::new();
        let cell = gtk::CellRendererText::new();

        column.pack_start(&cell, true);
        // Association of the view's column with the model's 'id' column.
        let id = 0;
        column.add_attribute(&cell, "text", id);
        tree.append_column(&column);


        let model = create_and_fill_model(&_model.current_dir).unwrap();

        tree.set_model(Some(&model));

        // tree.connect_cursor_changed(change_dir);
        connect!(relm, tree, connect_cursor_changed(_), Msg::ItemSelect);
        connect!(relm, window, connect_delete_event(_, _) (Some(Msg::Quit), Inhibit(false)));

        window.add(&tree);

        window.show_all();

        Win {
            window: window,
            tree_view: tree,
        }
    }
}

fn create_window(title: &'static str) -> gtk::Window {
    let window = gtk::Window::new(gtk::WindowType::Toplevel);

    window.set_title(title);
    window.set_border_width(10);
    window.set_position(gtk::WindowPosition::Center);
    window.set_default_size(350, 70);

    window.connect_delete_event(|_, _| {
                                    gtk::main_quit();
                                    Inhibit(false)
                                });

    window
}

fn create_and_fill_model(dir_str: &PathBuf) -> io::Result<gtk::ListStore> {
    // Single row model
    let model = gtk::ListStore::new(&[String::static_type(), bool::static_type()]);

    // Add the parent directory
    model.insert_with_values(None,
                             &[VALUE_COL as u32, IS_DIR_COL as u32],
                             &[&"..", &true]);

    let entry_iter = fs::read_dir(dir_str)?.filter_map(|x| x.ok());
    for entry in entry_iter {
        if let Ok(metadata) = entry.metadata() {

            if let Ok(file_name) = entry.file_name().into_string() {
                let (final_name, is_dir) = if metadata.is_dir() {
                    (format!("{}/", file_name), true)
                } else {
                    (file_name, false)
                };
                model.insert_with_values(None,
                                         &[VALUE_COL as u32, IS_DIR_COL as u32],
                                         &[&final_name, &is_dir]);
            }
        }
    }
    Ok(model)
}

fn main() {
    relm::run::<Win>().unwrap();
}

Hey @maccoda,

This was a very nice example. I've created an relm example from it antoyo/relm#79.

I hope this is Ok for you. Please let me know if you have any objections.