use std::cell::RefCell;
use std::cmp::Ordering;
use std::io;
use std::fs;
use std::fs::DirEntry;
use std::path::{Component, Path, PathBuf};
use std::rc::Rc;
use std::ops::Deref;
use gio;
use gio::prelude::*;
use gtk;
use gtk::prelude::*;
use neovim_lib::{NeovimApi, NeovimApiAsync};
use crate::misc::escape_filename;
use crate::nvim::{ErrorReport, NeovimClient, NeovimRef};
use crate::shell;
use crate::subscriptions::SubscriptionKey;
const ICON_FOLDER_CLOSED: &str = "folder-symbolic";
const ICON_FOLDER_OPEN: &str = "folder-open-symbolic";
const ICON_FILE: &str = "text-x-generic-symbolic";
struct Components {
dir_list_model: gtk::TreeStore,
dir_list: gtk::ComboBox,
context_menu: gtk::Menu,
show_hidden_checkbox: gtk::CheckMenuItem,
cd_action: gio::SimpleAction,
}
struct State {
current_dir: String,
show_hidden: bool,
selected_path: Option<String>,
}
pub struct FileBrowserWidget {
store: gtk::TreeStore,
tree: gtk::TreeView,
widget: gtk::Box,
nvim: Option<Rc<NeovimClient>>,
comps: Components,
state: Rc<RefCell<State>>,
}
impl Deref for FileBrowserWidget {
type Target = gtk::Box;
fn deref(&self) -> >k::Box {
&self.widget
}
}
#[derive(Copy, Clone, Debug)]
enum FileType {
File,
Dir,
}
#[allow(dead_code)]
enum Column {
Filename,
Path,
FileType,
IconName,
}
impl FileBrowserWidget {
pub fn new() -> Self {
let builder = gtk::Builder::new_from_string(include_str!("../resources/side-panel.ui"));
let widget: gtk::Box = builder.get_object("file_browser").unwrap();
let tree: gtk::TreeView = builder.get_object("file_browser_tree_view").unwrap();
let store: gtk::TreeStore = builder.get_object("file_browser_tree_store").unwrap();
let dir_list_model: gtk::TreeStore = builder.get_object("dir_list_model").unwrap();
let dir_list: gtk::ComboBox = builder.get_object("dir_list").unwrap();
let context_menu: gtk::Menu = builder.get_object("file_browser_context_menu").unwrap();
let show_hidden_checkbox: gtk::CheckMenuItem = builder
.get_object("file_browser_show_hidden_checkbox")
.unwrap();
let file_browser = FileBrowserWidget {
store,
tree,
widget,
nvim: None,
comps: Components {
dir_list_model,
dir_list,
context_menu,
show_hidden_checkbox,
cd_action: gio::SimpleAction::new("cd", None),
},
state: Rc::new(RefCell::new(State {
current_dir: "".to_owned(),
show_hidden: false,
selected_path: None,
})),
};
file_browser
}
fn nvim(&self) -> Option<NeovimRef> {
self.nvim.as_ref().unwrap().nvim()
}
pub fn init(&mut self, shell_state: &shell::State) {
let nvim = shell_state.nvim_clone();
self.nvim = Some(nvim);
if let Some(dir) = get_current_dir(&mut self.nvim().unwrap()) {
update_dir_list(&dir, &self.comps.dir_list_model, &self.comps.dir_list);
self.state.borrow_mut().current_dir = dir;
}
tree_reload(&self.store, &self.state.borrow());
let store = &self.store;
let state_ref = &self.state;
self.tree.connect_test_expand_row(clone!(store, state_ref => move |_, iter, _| {
store.set(&iter, &[Column::IconName as u32], &[&ICON_FOLDER_OPEN]);
let state = state_ref.borrow();
if let Some(child) = store.iter_children(iter) {
let filename = store.get_value(&child, Column::Filename as i32);
if filename.get::<&str>().is_none() {
store.remove(&child);
let dir_value = store.get_value(&iter, Column::Path as i32);
if let Some(dir) = dir_value.get() {
populate_tree_nodes(&store, &state, dir, Some(iter));
}
} else {
let mut tree_path = store.get_path(&child).unwrap();
while let Some(iter) = store.get_iter(&tree_path) {
tree_path.next();
let file_type = store
.get_value(&iter, Column::FileType as i32)
.get::<u8>();
if file_type == Some(FileType::Dir as u8) {
store.set(&iter, &[Column::IconName as u32], &[&ICON_FOLDER_CLOSED]);
}
}
}
}
Inhibit(false)
}));
self.tree.connect_row_collapsed(clone!(store => move |_, iter, _| {
store.set(&iter, &[Column::IconName as u32], &[&ICON_FOLDER_CLOSED]);
}));
self.init_actions();
self.init_subscriptions(shell_state);
self.connect_events();
}
fn init_actions(&self) {
let actions = gio::SimpleActionGroup::new();
let store = &self.store;
let state_ref = &self.state;
let nvim_ref = self.nvim.as_ref().unwrap();
let reload_action = gio::SimpleAction::new("reload", None);
reload_action.connect_activate(clone!(store, state_ref => move |_, _| {
tree_reload(&store, &state_ref.borrow());
}));
actions.add_action(&reload_action);
let cd_action = &self.comps.cd_action;
cd_action.connect_activate(clone!(state_ref, nvim_ref => move |_, _| {
let mut nvim = nvim_ref.nvim().unwrap();
if let Some(ref path) = state_ref.borrow().selected_path {
nvim.set_current_dir_async(&path)
.cb(|r| r.report_err())
.call();
}
}));
actions.add_action(cd_action);
self.comps
.context_menu
.insert_action_group("filebrowser", &actions);
}
fn init_subscriptions(&self, shell_state: &shell::State) {
let store = &self.store;
let state_ref = &self.state;
let dir_list_model = &self.comps.dir_list_model;
let dir_list = &self.comps.dir_list;
shell_state.subscribe(
SubscriptionKey::from("DirChanged"),
&["getcwd()"],
clone!(store, state_ref, dir_list_model, dir_list => move |args| {
let dir = args.into_iter().next().unwrap();
if dir != state_ref.borrow().current_dir {
state_ref.borrow_mut().current_dir = dir.to_owned();
update_dir_list(&dir, &dir_list_model, &dir_list);
tree_reload(&store, &state_ref.borrow());
}
}),
);
let tree = &self.tree;
let subscription = shell_state.subscribe(
SubscriptionKey::from("BufEnter"),
&["getcwd()", "expand('%:p')"],
clone!(tree, store => move |args| {
let mut args_iter = args.into_iter();
let dir = args_iter.next().unwrap();
let file_path = args_iter.next().unwrap();
let could_reveal =
if let Ok(rel_path) = Path::new(&file_path).strip_prefix(&Path::new(&dir)) {
reveal_path_in_tree(&store, &tree, &rel_path)
} else {
false
};
if !could_reveal {
tree.get_selection().unselect_all();
}
}),
);
shell_state.run_now(&subscription);
}
fn connect_events(&self) {
let store = &self.store;
let state_ref = &self.state;
let nvim_ref = self.nvim.as_ref().unwrap();
self.tree.connect_row_activated(clone!(store, state_ref, nvim_ref => move |tree, path, _| {
let iter = store.get_iter(path).unwrap();
let file_type = store
.get_value(&iter, Column::FileType as i32)
.get::<u8>()
.unwrap();
let file_path = store
.get_value(&iter, Column::Path as i32)
.get::<String>()
.unwrap();
if file_type == FileType::Dir as u8 {
let expanded = tree.row_expanded(path);
if expanded {
tree.collapse_row(path);
} else {
tree.expand_row(path, false);
}
} else {
let cwd = &state_ref.borrow().current_dir;
let cwd = Path::new(cwd);
let file_path = if let Some(rel_path) = Path::new(&file_path)
.strip_prefix(&cwd)
.ok()
.and_then(|p| p.to_str())
{
rel_path
} else {
&file_path
};
let file_path = escape_filename(file_path);
nvim_ref.nvim().unwrap().command_async(&format!(":e {}", file_path))
.cb(|r| r.report_err())
.call();
}
}));
let nvim_ref = self.nvim.as_ref().unwrap();
self.comps.dir_list.connect_changed(clone!(nvim_ref, state_ref => move |dir_list| {
if let Some(iter) = dir_list.get_active_iter() {
let model = dir_list.get_model().unwrap();
if let Some(dir) = model.get_value(&iter, 2).get::<&str>() {
if dir != state_ref.borrow().current_dir {
let mut nvim = nvim_ref.nvim().unwrap();
nvim.set_current_dir_async(dir)
.cb(|r| r.report_err())
.call();
}
}
}
}));
let context_menu = &self.comps.context_menu;
let cd_action = &self.comps.cd_action;
self.tree.connect_button_press_event(
clone!(store, state_ref, context_menu, cd_action => move |tree, ev_btn| {
if ev_btn.get_button() == 3 {
context_menu.popup_at_pointer(&**ev_btn);
let (pos_x, pos_y) = ev_btn.get_position();
let iter = tree
.get_path_at_pos(pos_x as i32, pos_y as i32)
.and_then(|(path, _, _, _)| path)
.and_then(|path| store.get_iter(&path));
let file_type = iter
.as_ref()
.and_then(|iter| {
store
.get_value(&iter, Column::FileType as i32)
.get::<u8>()
});
cd_action.set_enabled(file_type == Some(FileType::Dir as u8));
let path = iter
.and_then(|iter| {
store
.get_value(&iter, Column::Path as i32)
.get::<String>()
});
state_ref.borrow_mut().selected_path = path;
}
Inhibit(false)
}),
);
self.comps.show_hidden_checkbox.connect_toggled(clone!(state_ref, store => move |ev| {
let mut state = state_ref.borrow_mut();
state.show_hidden = ev.get_active();
tree_reload(&store, &state);
}));
}
}
fn cmp_dirs_first(lhs: &DirEntry, rhs: &DirEntry) -> io::Result<Ordering> {
let lhs_metadata = fs::metadata(lhs.path())?;
let rhs_metadata = fs::metadata(rhs.path())?;
if lhs_metadata.is_dir() == rhs_metadata.is_dir() {
Ok(lhs.path()
.to_string_lossy()
.to_lowercase()
.cmp(&rhs.path().to_string_lossy().to_lowercase()))
} else {
if lhs_metadata.is_dir() {
Ok(Ordering::Less)
} else {
Ok(Ordering::Greater)
}
}
}
fn tree_reload(store: >k::TreeStore, state: &State) {
let dir = &state.current_dir;
store.clear();
populate_tree_nodes(store, state, dir, None);
}
fn update_dir_list(dir: &str, dir_list_model: >k::TreeStore, dir_list: >k::ComboBox) {
let complete_path = Path::new(dir);
let mut path = PathBuf::new();
let mut components = complete_path.components();
let mut next = components.next();
let mut dir_list_iter = dir_list_model.get_iter_first();
let mut is_prefix = true;
while let Some(dir) = next {
next = components.next();
let dir_name = &*dir.as_os_str().to_string_lossy();
path.push(Path::new(&dir));
let path_str = path.to_str().unwrap_or_else(|| {
error!(
"Could not convert path to string: {}\n
Directory chooser will not work for that entry.",
path.to_string_lossy()
);
""
});
let current_iter = dir_list_iter.unwrap_or_else(|| dir_list_model.append(None));
if is_prefix && dir_list_model.get_value(¤t_iter, 0).get::<&str>() != Some(&dir_name)
{
is_prefix = false;
}
if next.is_some() {
dir_list_model.set(
¤t_iter,
&[0, 1, 2],
&[&dir_name, &ICON_FOLDER_CLOSED, &path_str],
);
} else {
dir_list_model.set(
¤t_iter,
&[0, 1, 2],
&[&dir_name, &ICON_FOLDER_OPEN, &path_str],
);
dir_list.set_active_iter(¤t_iter);
};
dir_list_iter = if dir_list_model.iter_next(¤t_iter) {
Some(current_iter)
} else {
None
}
}
if let Some(iter) = dir_list_iter {
if is_prefix {
loop {
dir_list_model.set(&iter, &[1], &[&ICON_FOLDER_CLOSED]);
if !dir_list_model.iter_next(&iter) {
break;
}
}
} else {
while dir_list_model.remove(&iter) {}
}
}
}
fn populate_tree_nodes(
store: >k::TreeStore,
state: &State,
dir: &str,
parent: Option<>k::TreeIter>,
) {
let path = Path::new(dir);
let read_dir = match path.read_dir() {
Ok(read_dir) => read_dir,
Err(err) => {
error!("Couldn't populate tree: {}", err);
return;
}
};
let iter = read_dir.filter_map(Result::ok);
let mut entries: Vec<DirEntry> = if state.show_hidden {
iter.collect()
} else {
iter.filter(|entry| !entry.file_name().to_string_lossy().starts_with("."))
.filter(|entry| !entry.file_name().to_string_lossy().ends_with("~"))
.collect()
};
entries.sort_unstable_by(|lhs, rhs| cmp_dirs_first(lhs, rhs).unwrap_or(Ordering::Equal));
for entry in entries {
let path = if let Some(path) = entry.path().to_str() {
path.to_owned()
} else {
continue;
};
let filename = entry.file_name().to_str().unwrap().to_owned();
let file_type = if let Ok(metadata) = fs::metadata(entry.path()) {
let file_type = metadata.file_type();
if file_type.is_dir() {
FileType::Dir
} else if file_type.is_file() {
FileType::File
} else {
continue;
}
} else {
continue;
};
let icon = match file_type {
FileType::Dir => ICON_FOLDER_CLOSED,
FileType::File => ICON_FILE,
};
let iter = store.append(parent);
store.set(
&iter,
&[0, 1, 2, 3],
&[&filename, &path, &(file_type as u8), &icon],
);
if let FileType::Dir = file_type {
let not_empty = if let Ok(mut dir) = entry.path().read_dir() {
dir.next().is_some()
} else {
false
};
if not_empty {
let iter = store.append(&iter);
store.set(&iter, &[], &[]);
}
}
}
}
fn get_current_dir(nvim: &mut NeovimRef) -> Option<String> {
match nvim.eval("getcwd()") {
Ok(cwd) => cwd.as_str().map(|s| s.to_owned()),
Err(err) => {
error!("Couldn't get cwd: {}", err);
None
}
}
}
fn reveal_path_in_tree(store: >k::TreeStore, tree: >k::TreeView, rel_file_path: &Path) -> bool {
let mut tree_path = gtk::TreePath::new();
'components: for component in rel_file_path.components() {
if let Component::Normal(component) = component {
tree_path.down();
while let Some(iter) = store.get_iter(&tree_path) {
let entry_value = store.get_value(&iter, Column::Filename as i32);
let entry = entry_value.get::<&str>().unwrap();
if component == entry {
tree.expand_row(&tree_path, false);
continue 'components;
}
tree_path.next();
}
return false;
} else {
return false;
}
}
if tree_path.get_depth() == 0 {
return false;
}
tree.set_cursor(&tree_path, Option::<>k::TreeViewColumn>::None, false);
true
}