penwing/calcifer
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

fixed path

Browse source
This commit is contained in:
Penwing 2024-01-27 23:14:39 +01:00
parent 16650a2ca1
commit 0f7a95bff3
3 changed files with 636 additions and 635 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

524
src/calcifer.rs
View file

@ -1,11 +1,10 @@
use eframe::egui; use eframe::egui;
use egui::{text::CCursor, text_edit::CCursorRange, Rangef}; use egui::{text::CCursor, text_edit::CCursorRange, Rangef};
use std::{cmp::max, env, path::Path, path::PathBuf}; use std::{cmp::max, env, path::PathBuf};// path::Path,
use crate::tools; use crate::tools;
use crate::Calcifer; use crate::Calcifer;
use crate::MAX_TABS; use crate::MAX_TABS;
use crate::PATH_ROOT;
use crate::PROJECT_EXTENSION; use crate::PROJECT_EXTENSION;
use tools::hex_str_to_color; use tools::hex_str_to_color;
@ -15,277 +14,288 @@ use code_editor::CodeEditor;
mod app_base; mod app_base;
impl Calcifer { impl Calcifer {
pub fn draw_settings(&mut self, ctx: &egui::Context) { pub fn draw_settings(&mut self, ctx: &egui::Context) {
egui::SidePanel::left("settings") egui::SidePanel::left("settings")
.resizable(false) .resizable(false)
.exact_width(self.font_size * 1.8) .exact_width(self.font_size * 1.8)
.show(ctx, |ui| { .show(ctx, |ui| {
ui.vertical(|ui| { ui.vertical(|ui| {
if ui.add(egui::Button::new("📁")).clicked() { if ui.add(egui::Button::new("📁")).clicked() {
if let Some(path) = rfd::FileDialog::new() if let Some(path) = rfd::FileDialog::new()
.set_directory(Path::new(&PATH_ROOT)) .set_directory(self.home.as_path())
.pick_file() .pick_file()
{ {
self.open_file(Some(&path)); self.open_file(Some(&path));
} }
} }
ui.separator(); ui.separator();
self.tree_visible = self.toggle(ui, self.tree_visible, "🗐"); self.tree_visible = self.toggle(ui, self.tree_visible, "🗐");
ui.separator(); ui.separator();
self.terminal_visible = self.toggle(ui, self.terminal_visible, "🖵"); self.terminal_visible = self.toggle(ui, self.terminal_visible, "🖵");
ui.separator(); ui.separator();
self.search_menu.visible = self.toggle(ui, self.search_menu.visible, "🔍"); self.search_menu.visible = self.toggle(ui, self.search_menu.visible, "🔍");
ui.separator(); ui.separator();
self.settings_menu.visible = self.toggle(ui, self.settings_menu.visible, "⚙"); self.settings_menu.visible = self.toggle(ui, self.settings_menu.visible, "⚙");
ui.separator(); ui.separator();
self.shortcuts_menu.visible = self.toggle(ui, self.shortcuts_menu.visible, "⌨"); self.shortcuts_menu.visible = self.toggle(ui, self.shortcuts_menu.visible, "⌨");
ui.separator(); ui.separator();
self.profiler_visible = self.toggle(ui, self.profiler_visible, "⚡"); self.profiler_visible = self.toggle(ui, self.profiler_visible, "⚡");
if self.tabs[self.selected_tab.to_index()].language == PROJECT_EXTENSION { if self.tabs[self.selected_tab.to_index()].language == PROJECT_EXTENSION {
ui.separator(); ui.separator();
self.project_mode = self.toggle(ui, self.project_mode, "🛠"); self.project_mode = self.toggle(ui, self.project_mode, "🛠");
} }
}); });
}); });
} }
pub fn draw_tree_panel(&mut self, ctx: &egui::Context) { pub fn draw_tree_panel(&mut self, ctx: &egui::Context) {
if !self.tree_visible { if !self.tree_visible {
return; return;
} }
egui::SidePanel::left("file_tree_panel").show(ctx, |ui| { egui::SidePanel::left("file_tree_panel").show(ctx, |ui| {
ui.heading("Bookshelf"); ui.horizontal(|ui| {
ui.separator(); ui.label("Bookshelf ");
let _ = self.list_files(ui, Path::new(&PATH_ROOT)); if ui.add(egui::Button::new("📖")).clicked() {
ui.separator(); self.file_tree = tools::file_tree::generate_file_tree(self.home.as_path(), 7);
}); }
} });
ui.separator();
let mut n_files : usize = 0;
if let Some(file_tree) = self.file_tree.clone() {
self.list_files(ui, &file_tree, 1, &mut n_files);
} else {
ui.label("No book on the Bookshelf");
}
ui.separator();
ui.label(format!("{} files displayed", n_files));
});
}
pub fn draw_bottom_tray(&mut self, ctx: &egui::Context) { pub fn draw_bottom_tray(&mut self, ctx: &egui::Context) {
egui::TopBottomPanel::bottom("tray") egui::TopBottomPanel::bottom("tray")
.default_height(self.font_size * 1.2) .default_height(self.font_size * 1.2)
.resizable(false) .resizable(false)
.show(ctx, |ui| { .show(ctx, |ui| {
ui.label(self.profiler()); ui.label(self.profiler());
}); });
} }
pub fn draw_terminal_panel(&mut self, ctx: &egui::Context) { pub fn draw_terminal_panel(&mut self, ctx: &egui::Context) {
if !self.terminal_visible { if !self.terminal_visible {
return; return;
} }
egui::TopBottomPanel::bottom("terminal") egui::TopBottomPanel::bottom("terminal")
.default_height(super::TERMINAL_HEIGHT) .default_height(super::TERMINAL_HEIGHT)
.height_range(Rangef::new( .height_range(Rangef::new(
super::TERMINAL_RANGE.start, super::TERMINAL_RANGE.start,
super::TERMINAL_RANGE.end, super::TERMINAL_RANGE.end,
)) ))
.resizable(true) .resizable(true)
.show(ctx, |ui| { .show(ctx, |ui| {
ui.with_layout(egui::Layout::bottom_up(egui::Align::LEFT), |ui| { ui.with_layout(egui::Layout::bottom_up(egui::Align::LEFT), |ui| {
let command_color = hex_str_to_color(self.theme.functions); let command_color = hex_str_to_color(self.theme.functions);
let entry_color = hex_str_to_color(self.theme.literals); let entry_color = hex_str_to_color(self.theme.literals);
let bg_color = hex_str_to_color(self.theme.bg); let bg_color = hex_str_to_color(self.theme.bg);
ui.label("");
ui.label(""); ui.horizontal(|ui| {
if ui.add(egui::Button::new("⟳")).clicked() {
self.command_history = vec![];
}
ui.style_mut().visuals.extreme_bg_color = bg_color;
let Self { command, .. } = self;
ui.colored_label(
command_color,
tools::format_path(
&env::current_dir().unwrap_or_else(|_| PathBuf::from("/")),
),
);
let response = ui.add(
egui::TextEdit::singleline(command)
.desired_width(f32::INFINITY)
.lock_focus(true),
);
ui.horizontal(|ui| { if response.lost_focus() && ctx.input(|i| i.key_pressed(egui::Key::Enter)) {
if ui.add(egui::Button::new("⟳")).clicked() { self.command_history
self.command_history = vec![]; .push(tools::send_command(self.command.clone()));
} self.command = "".into();
ui.style_mut().visuals.extreme_bg_color = bg_color; response.request_focus();
let Self { command, .. } = self; }
ui.colored_label( });
command_color, ui.separator();
tools::format_path( egui::ScrollArea::vertical()
&env::current_dir().unwrap_or_else(|_| PathBuf::from("/")), .stick_to_bottom(true)
), .show(ui, |ui| {
); ui.with_layout(egui::Layout::top_down(egui::Align::LEFT), |ui| {
let response = ui.add( ui.separator();
egui::TextEdit::singleline(command) ui.horizontal_wrapped(|ui| {
.desired_width(f32::INFINITY) ui.spacing_mut().item_spacing.y = 0.0;
.lock_focus(true), for entry in &mut self.command_history {
); entry.update();
ui.colored_label(
command_color,
format!("\n{} {}", entry.env, entry.command),
);
ui.end_row();
for line in &entry.result {
let color =
if line.error { super::RED } else { entry_color };
ui.colored_label(color, &line.text);
ui.end_row();
}
}
});
});
});
});
});
}
if response.lost_focus() && ctx.input(|i| i.key_pressed(egui::Key::Enter)) { pub fn draw_tab_panel(&mut self, ctx: &egui::Context) {
self.command_history egui::TopBottomPanel::top("tabs")
.push(tools::send_command(self.command.clone())); .resizable(false)
self.command = "".into(); .show(ctx, |ui| {
response.request_focus(); ui.horizontal(|ui| {
} ui.style_mut().visuals.selection.bg_fill =
}); hex_str_to_color(self.theme.functions);
ui.separator(); ui.style_mut().visuals.hyperlink_color = hex_str_to_color(self.theme.functions);
egui::ScrollArea::vertical() for (index, tab) in self.tabs.clone().iter().enumerate() {
.stick_to_bottom(true) let mut title = tab.get_name();
.show(ui, |ui| { if !tab.saved {
ui.with_layout(egui::Layout::top_down(egui::Align::LEFT), |ui| { title += " ~";
ui.separator(); }
ui.horizontal_wrapped(|ui| { if self.selected_tab == tools::TabNumber::from_index(index) {
ui.spacing_mut().item_spacing.y = 0.0; ui.style_mut().visuals.override_text_color =
for entry in &mut self.command_history { Some(hex_str_to_color(self.theme.bg));
entry.update(); }
ui.colored_label( ui.selectable_value(
command_color, &mut self.selected_tab,
format!("\n{} {}", entry.env, entry.command), tools::TabNumber::from_index(index),
); title,
ui.end_row(); );
for line in &entry.result {
let color =
if line.error { super::RED } else { entry_color };
ui.colored_label(color, &line.text);
ui.end_row();
}
}
});
});
});
});
});
}
pub fn draw_tab_panel(&mut self, ctx: &egui::Context) { ui.style_mut().visuals.override_text_color = None;
egui::TopBottomPanel::top("tabs")
.resizable(false)
.show(ctx, |ui| {
ui.horizontal(|ui| {
ui.style_mut().visuals.selection.bg_fill =
hex_str_to_color(self.theme.functions);
ui.style_mut().visuals.hyperlink_color = hex_str_to_color(self.theme.functions);
for (index, tab) in self.tabs.clone().iter().enumerate() {
let mut title = tab.get_name();
if !tab.saved {
title += " ~";
}
if self.selected_tab == tools::TabNumber::from_index(index) {
ui.style_mut().visuals.override_text_color =
Some(hex_str_to_color(self.theme.bg));
}
ui.selectable_value(
&mut self.selected_tab,
tools::TabNumber::from_index(index),
title,
);
ui.style_mut().visuals.override_text_color = None; if ui.link("X").clicked() && !self.close_tab_confirm.visible {
if self.tabs.len() > 1 {
if tab.saved {
self.delete_tab(index);
} else {
self.close_tab_confirm.ask();
self.tab_to_close = index;
}
} else {
egui::Context::send_viewport_cmd(ctx, egui::ViewportCommand::Close);
}
}
ui.separator();
}
if self.tabs.len() < MAX_TABS {
ui.selectable_value(&mut self.selected_tab, tools::TabNumber::Open, "+");
}
if self.selected_tab == tools::TabNumber::Open {
self.open_file(None);
}
});
});
}
if ui.link("X").clicked() && !self.close_tab_confirm.visible { pub fn draw_content_panel(&mut self, ctx: &egui::Context) {
if self.tabs.len() > 1 { egui::CentralPanel::default().show(ctx, |ui| {
if tab.saved { ui.horizontal(|ui| {
self.delete_tab(index); if ui.add(egui::Button::new("open directory in terminal")).clicked() {
} else { let mut path = self.tabs[self.selected_tab.to_index()].path.clone();
self.close_tab_confirm.ask(); path.pop();
self.tab_to_close = index; tools::send_command(format!("cd {}", path.display()));
} }
} else {
egui::Context::send_viewport_cmd(ctx, egui::ViewportCommand::Close);
}
}
ui.separator();
}
if self.tabs.len() < MAX_TABS {
ui.selectable_value(&mut self.selected_tab, tools::TabNumber::Open, "+");
}
if self.selected_tab == tools::TabNumber::Open {
self.open_file(None);
}
});
});
}
pub fn draw_content_panel(&mut self, ctx: &egui::Context) { ui.label("Picked file:");
egui::CentralPanel::default().show(ctx, |ui| { ui.monospace(
ui.horizontal(|ui| { self.tabs[self.selected_tab.to_index()]
if ui.add(egui::Button::new("open in terminal")).clicked() { .path
let mut path = self.tabs[self.selected_tab.to_index()].path.clone(); .to_string_lossy()
path.pop(); .to_string(),
tools::send_command(format!("cd {}", path.display())); );
} });
ui.label("Picked file:"); ui.separator();
ui.monospace( if self.project_mode
self.tabs[self.selected_tab.to_index()] && self.tabs[self.selected_tab.to_index()].language == PROJECT_EXTENSION
.path {
.to_string_lossy() self.draw_project_file(ui);
.to_string(), } else {
); self.draw_code_file(ui);
}); }
});
}
ui.separator(); fn draw_code_file(&mut self, ui: &mut egui::Ui) {
if self.project_mode let current_tab = &mut self.tabs[self.selected_tab.to_index()];
&& self.tabs[self.selected_tab.to_index()].language == PROJECT_EXTENSION let lines = current_tab.code.chars().filter(|&c| c == '\n').count() + 1;
{ let mut override_cursor: Option<CCursorRange> = None;
self.draw_project_file(ui);
} else {
self.draw_code_file(ui);
}
});
}
fn draw_code_file(&mut self, ui: &mut egui::Ui) { if !self.search_menu.result_selected {
let current_tab = &mut self.tabs[self.selected_tab.to_index()]; override_cursor = Some(CCursorRange::two(
let lines = current_tab.code.chars().filter(|&c| c == '\n').count() + 1; CCursor::new(self.search_menu.get_cursor_start()),
let mut override_cursor: Option<CCursorRange> = None; CCursor::new(self.search_menu.get_cursor_end()),
));
self.search_menu.result_selected = true;
}
if !self.search_menu.result_selected { CodeEditor::default()
override_cursor = Some(CCursorRange::two( .id_source("code editor")
CCursor::new(self.search_menu.get_cursor_start()), .with_rows(max(45, lines))
CCursor::new(self.search_menu.get_cursor_end()), .with_fontsize(self.font_size)
)); .with_theme(self.theme)
self.search_menu.result_selected = true; .with_syntax(tools::to_syntax(&current_tab.language))
} .with_numlines(true)
.show(
ui,
&mut current_tab.code,
&mut current_tab.saved,
&mut current_tab.last_cursor,
&mut current_tab.scroll_offset,
override_cursor,
);
}
CodeEditor::default() fn draw_project_file(&mut self, ui: &mut egui::Ui) {
.id_source("code editor") ui.label("project mode");
.with_rows(max(45, lines)) }
.with_fontsize(self.font_size)
.with_theme(self.theme)
.with_syntax(tools::to_syntax(&current_tab.language))
.with_numlines(true)
.show(
ui,
&mut current_tab.code,
&mut current_tab.saved,
&mut current_tab.last_cursor,
&mut current_tab.scroll_offset,
override_cursor,
);
}
fn draw_project_file(&mut self, ui: &mut egui::Ui) { pub fn draw_windows(&mut self, ctx: &egui::Context) {
ui.label("project mode"); if self.search_menu.visible {
} self.search_menu
.show(ctx, &mut self.tabs, &mut self.selected_tab);
}
if self.close_tab_confirm.visible {
self.close_tab_confirm.show(ctx);
}
if self.refresh_confirm.visible {
self.refresh_confirm.show(ctx);
}
if self.exit_confirm.visible {
self.exit_confirm.show(ctx);
}
if self.exit_confirm.proceed {
for tab in self.tabs.iter_mut() {
tab.saved = true;
}
egui::Context::send_viewport_cmd(ctx, egui::ViewportCommand::Close);
}
if self.shortcuts_menu.visible {
self.shortcuts_menu.show(ctx);
}
if self.settings_menu.visible {
self.settings_menu.show(ctx);
}
if self.settings_menu.updated {
self.theme = self.settings_menu.theme;
}
pub fn draw_windows(&mut self, ctx: &egui::Context) { self.handle_confirm();
if self.search_menu.visible { }
self.search_menu
.show(ctx, &mut self.tabs, &mut self.selected_tab);
}
if self.close_tab_confirm.visible {
self.close_tab_confirm.show(ctx);
}
if self.refresh_confirm.visible {
self.refresh_confirm.show(ctx);
}
if self.exit_confirm.visible {
self.exit_confirm.show(ctx);
}
if self.exit_confirm.proceed {
for tab in self.tabs.iter_mut() {
tab.saved = true;
}
egui::Context::send_viewport_cmd(ctx, egui::ViewportCommand::Close);
}
if self.shortcuts_menu.visible {
self.shortcuts_menu.show(ctx);
}
if self.settings_menu.visible {
self.settings_menu.show(ctx);
}
if self.settings_menu.updated {
self.theme = self.settings_menu.theme;
}
self.handle_confirm();
}
} }

385
src/calcifer/app_base.rs
View file

@ -1,237 +1,216 @@
use eframe::egui; use eframe::egui;
use egui::Color32; use egui::Color32;
use std::{cmp::min, ffi::OsStr, fs, io, path::Path, path::PathBuf}; use std::{cmp::min, fs, path::Path, path::PathBuf};
use crate::tools; use crate::tools;
use crate::Calcifer; use crate::Calcifer;
use crate::DEFAULT_THEMES; use crate::DEFAULT_THEMES;
use crate::MAX_TABS; use crate::MAX_TABS;
use crate::PATH_ROOT;
use crate::SAVE_PATH;
use crate::TIME_LABELS; use crate::TIME_LABELS;
use crate::save_path;
use tools::hex_str_to_color; use tools::hex_str_to_color;
use tools::file_tree;
impl Calcifer { impl Calcifer {
pub fn handle_confirm(&mut self) { pub fn handle_confirm(&mut self) {
if self.close_tab_confirm.proceed { if self.close_tab_confirm.proceed {
self.close_tab_confirm.close(); self.close_tab_confirm.close();
self.delete_tab(self.tab_to_close); self.delete_tab(self.tab_to_close);
} }
if self.refresh_confirm.proceed { if self.refresh_confirm.proceed {
self.refresh_confirm.close(); self.refresh_confirm.close();
self.tabs[self.selected_tab.to_index()].refresh(); self.tabs[self.selected_tab.to_index()].refresh();
} }
} }
pub fn save_tab(&self) -> Option<PathBuf> { pub fn save_tab(&self) -> Option<PathBuf> {
if self.tabs[self.selected_tab.to_index()] if self.tabs[self.selected_tab.to_index()]
.path .path
.file_name() .file_name()
.map_or(true, |name| name.to_string_lossy() == "untitled") .map_or(true, |name| name.to_string_lossy() == "untitled")
{ {
self.save_tab_as() self.save_tab_as()
} else { } else {
if let Err(err) = fs::write( if let Err(err) = fs::write(
&self.tabs[self.selected_tab.to_index()].path, &self.tabs[self.selected_tab.to_index()].path,
&self.tabs[self.selected_tab.to_index()].code, &self.tabs[self.selected_tab.to_index()].code,
) { ) {
eprintln!("Error writing file: {}", err); eprintln!("Error writing file: {}", err);
return None; return None;
} }
Some(self.tabs[self.selected_tab.to_index()].path.clone()) Some(self.tabs[self.selected_tab.to_index()].path.clone())
} }
} }
pub fn save_tab_as(&self) -> Option<PathBuf> { pub fn save_tab_as(&self) -> Option<PathBuf> {
if let Some(path) = rfd::FileDialog::new() if let Some(path) = rfd::FileDialog::new()
.set_directory(Path::new(&PATH_ROOT)) .set_directory(self.home.as_path())
.save_file() .save_file()
{ {
if let Err(err) = fs::write(&path, &self.tabs[self.selected_tab.to_index()].code) { if let Err(err) = fs::write(&path, &self.tabs[self.selected_tab.to_index()].code) {
eprintln!("Error writing file: {}", err); eprintln!("Error writing file: {}", err);
return None; return None;
} }
return Some(path); return Some(path);
} }
None None
} }
pub fn handle_save_file(&mut self, path_option: Option<PathBuf>) { pub fn handle_save_file(&mut self, path_option: Option<PathBuf>) {
if let Some(path) = path_option { if let Some(path) = path_option {
println!("File saved successfully at: {:?}", path); println!("File saved successfully at: {:?}", path);
self.tabs[self.selected_tab.to_index()].path = path; self.tabs[self.selected_tab.to_index()].path = path;
self.tabs[self.selected_tab.to_index()].saved = true; self.tabs[self.selected_tab.to_index()].saved = true;
} else { } else {
println!("File save failed."); println!("File save failed.");
} }
} }
pub fn from_app_state(app_state: tools::AppState) -> Self { pub fn from_app_state(app_state: tools::AppState) -> Self {
let mut new = Self { let mut new = Self {
theme: DEFAULT_THEMES[min(app_state.theme, DEFAULT_THEMES.len() - 1)], theme: DEFAULT_THEMES[min(app_state.theme, DEFAULT_THEMES.len() - 1)],
tabs: Vec::new(), tabs: Vec::new(),
settings_menu: tools::settings::SettingsWindow::new(DEFAULT_THEMES[app_state.theme]), settings_menu: tools::settings::SettingsWindow::new(DEFAULT_THEMES[app_state.theme]),
..Default::default() ..Default::default()
}; };
for path in app_state.tabs { for path in app_state.tabs {
if !path if !path
.file_name() .file_name()
.map_or(true, |name| name.to_string_lossy() == "untitled") .map_or(true, |name| name.to_string_lossy() == "untitled")
{ {
new.open_file(Some(&path)); new.open_file(Some(&path));
} }
} }
if new.tabs == vec![] { if new.tabs == vec![] {
new.open_file(None); new.open_file(None);
} }
new new
} }
pub fn save_state(&self) { pub fn save_state(&self) {
let mut state_theme: usize = 0; let mut state_theme: usize = 0;
if let Some(theme) = DEFAULT_THEMES.iter().position(|&r| r == self.theme) { if let Some(theme) = DEFAULT_THEMES.iter().position(|&r| r == self.theme) {
state_theme = theme; state_theme = theme;
} }
let mut state_tabs = vec![]; let mut state_tabs = vec![];
for tab in &self.tabs { for tab in &self.tabs {
state_tabs.push(tab.path.clone()); state_tabs.push(tab.path.clone());
} }
let app_state = tools::AppState { let app_state = tools::AppState {
tabs: state_tabs, tabs: state_tabs,
theme: state_theme, theme: state_theme,
}; };
let _ = tools::save_state(&app_state, SAVE_PATH); let _ = tools::save_state(&app_state, save_path().as_path());
} }
pub fn move_through_tabs(&mut self, forward: bool) { pub fn move_through_tabs(&mut self, forward: bool) {
let new_index = if forward { let new_index = if forward {
(self.selected_tab.to_index() + 1) % self.tabs.len() (self.selected_tab.to_index() + 1) % self.tabs.len()
} else { } else {
self.selected_tab self.selected_tab
.to_index() .to_index()
.checked_sub(1) .checked_sub(1)
.unwrap_or(self.tabs.len() - 1) .unwrap_or(self.tabs.len() - 1)
}; };
self.selected_tab = tools::TabNumber::from_index(new_index); self.selected_tab = tools::TabNumber::from_index(new_index);
} }
pub fn list_files(&mut self, ui: &mut egui::Ui, path: &Path) -> io::Result<()> { pub fn open_file(&mut self, path_option: Option<&Path>) {
if path.file_name().is_none() { if let Some(path) = path_option.clone() {
return Ok(()); for (index, tab) in self.tabs.clone().iter().enumerate() {
} if tab.path == path {
self.selected_tab = tools::TabNumber::from_index(index);
return;
}
}
}
if self.tabs.len() < MAX_TABS {
if let Some(path) = path_option {
self.tabs.push(tools::Tab::new(path.to_path_buf()));
} else {
self.tabs.push(tools::Tab::default());
}
self.selected_tab = tools::TabNumber::from_index(self.tabs.len() - 1);
}
}
let name = path pub fn delete_tab(&mut self, index: usize) {
.file_name() self.tabs.remove(index);
.unwrap_or_else(|| OsStr::new("")) self.selected_tab = tools::TabNumber::from_index(min(index, self.tabs.len() - 1));
.to_string_lossy() }
.into_owned();
if !path.is_dir() { pub fn toggle(&self, ui: &mut egui::Ui, display: bool, title: &str) -> bool {
if ui.button(name).clicked() { let bg_color: Color32;
self.open_file(Some(path)); let text_color: Color32;
}
return Ok(());
}
egui::CollapsingHeader::new(name).show(ui, |ui| match fs::read_dir(path) { if display {
Err(err) => { bg_color = hex_str_to_color(self.theme.functions);
ui.label(format!("Error reading directory: {}", err)); text_color = hex_str_to_color(self.theme.bg);
} } else {
Ok(entries) => { bg_color = hex_str_to_color(self.theme.bg);
let mut paths: Vec<Result<fs::DirEntry, io::Error>> = entries text_color = hex_str_to_color(self.theme.literals);
.map(|r| r.map_err(|e| io::Error::new(io::ErrorKind::Other, e))) };
.collect();
paths.sort_by(|a, b| match (a, b) { ui.style_mut().visuals.override_text_color = Some(text_color);
(Ok(entry_a), Ok(entry_b)) => tools::sort_directories_first(entry_a, entry_b),
(Err(_), Ok(_)) => std::cmp::Ordering::Greater,
(Ok(_), Err(_)) => std::cmp::Ordering::Less,
(Err(_), Err(_)) => std::cmp::Ordering::Equal,
});
for result in paths { if ui.add(egui::Button::new(title).fill(bg_color)).clicked() {
match result { return !display;
Ok(entry) => { }
let _ = self.list_files(ui, &entry.path()); ui.style_mut().visuals.override_text_color = None;
}
Err(err) => {
ui.label(format!("Error processing directory entry: {}", err));
}
}
}
}
});
Ok(())
}
pub fn open_file(&mut self, path_option: Option<&Path>) { display
if let Some(path) = path_option.clone() { }
for (index, tab) in self.tabs.clone().iter().enumerate() {
if tab.path == path {
self.selected_tab = tools::TabNumber::from_index(index);
return;
}
}
}
if self.tabs.len() < MAX_TABS {
if let Some(path) = path_option {
self.tabs.push(tools::Tab::new(path.to_path_buf()));
} else {
self.tabs.push(tools::Tab::default());
}
self.selected_tab = tools::TabNumber::from_index(self.tabs.len() - 1);
}
}
pub fn delete_tab(&mut self, index: usize) { pub fn profiler(&self) -> String {
self.tabs.remove(index); if !self.profiler_visible {
self.selected_tab = tools::TabNumber::from_index(min(index, self.tabs.len() - 1)); return "".to_string();
} }
let combined_string: Vec<String> = TIME_LABELS
.into_iter()
.zip(self.time_watch.clone())
.map(|(s, v)| format!("{} : {:.1} ms", s, v))
.collect();
pub fn toggle(&self, ui: &mut egui::Ui, display: bool, title: &str) -> bool { let mut result = combined_string.join(" ; ");
let bg_color: Color32; result.push_str(&format!(
let text_color: Color32; " total : {:.1} ms",
self.time_watch.clone().iter().sum::<f32>()
if display { ));
bg_color = hex_str_to_color(self.theme.functions); result
text_color = hex_str_to_color(self.theme.bg); }
} else {
bg_color = hex_str_to_color(self.theme.bg); pub fn list_files(&mut self, ui: &mut egui::Ui, file: &file_tree::File, depth: isize, n_files: &mut usize) {
text_color = hex_str_to_color(self.theme.literals); *n_files += 1;
};
if let Some(folder_content) = &file.folder_content {
ui.style_mut().visuals.override_text_color = Some(text_color); let collapsing_response = egui::CollapsingHeader::new(file.name.clone())
.default_open(depth > 0)
if ui.add(egui::Button::new(title).fill(bg_color)).clicked() { .show(ui, |ui| {
return !display; if !self.tree_dir_opened.contains(&file.name) {
} return
ui.style_mut().visuals.override_text_color = None; }
for deeper_file in folder_content {
display self.list_files(ui, &deeper_file, depth - 1, n_files);
} }
});
pub fn profiler(&self) -> String { if collapsing_response.fully_closed() {
if !self.profiler_visible { self.tree_dir_opened.retain(|s| s != &file.name);
return "".to_string(); } else {
} if !self.tree_dir_opened.contains(&file.name) {
let combined_string: Vec<String> = TIME_LABELS self.tree_dir_opened.push(file.name.clone());
.into_iter() }
.zip(self.time_watch.clone()) }
.map(|(s, v)| format!("{} : {:.1} ms", s, v)) } else {
.collect(); if ui.button(&file.name).clicked() {
self.open_file(Some(&file.path));
let mut result = combined_string.join(" ; "); }
result.push_str(&format!( }
" total : {:.1} ms", }
self.time_watch.clone().iter().sum::<f32>()
));
result
}
} }

362
src/main.rs
View file

@ -6,247 +6,259 @@ use eframe::egui;
use egui::FontFamily::Proportional; use egui::FontFamily::Proportional;
use egui::FontId; use egui::FontId;
use egui::TextStyle::{Body, Button, Heading, Monospace, Small}; use egui::TextStyle::{Body, Button, Heading, Monospace, Small};
use std::{ops::Range, path::Path, sync::Arc, thread, time}; use std::{ops::Range, path::PathBuf, sync::Arc, thread, time};
use homedir::get_my_home;
use calcifer::code_editor::themes::DEFAULT_THEMES; use calcifer::code_editor::themes::DEFAULT_THEMES;
#[cfg(debug_assertions)] #[cfg(debug_assertions)]
mod build { const TITLE: &str = " debug";
pub const SAVE_PATH: &str = "/home/penwing/Documents/.save/debug/calcifer_save.json";
pub const TITLE: &str = " debug";
}
#[cfg(not(debug_assertions))] #[cfg(not(debug_assertions))]
mod build { const TITLE: &str = "";
pub const SAVE_PATH: &str = "/home/penwing/Documents/.save/calcifer_save.json";
pub const TITLE: &str = "";
}
use build::SAVE_PATH;
use build::TITLE;
const ALLOWED_FILE_EXTENSIONS: [&str; 6] = [
"", "rs", "toml", "txt", "project", "sh",
];
const PROJECT_EXTENSION: &str = "project"; const PROJECT_EXTENSION: &str = "project";
const TERMINAL_HEIGHT: f32 = 200.0; const TERMINAL_HEIGHT: f32 = 200.0;
const TERMINAL_RANGE: Range<f32> = 100.0..500.0; const TERMINAL_RANGE: Range<f32> = 100.0..500.0;
const RED: egui::Color32 = egui::Color32::from_rgb(235, 108, 99); const RED: egui::Color32 = egui::Color32::from_rgb(235, 108, 99);
const TIME_LABELS: [&str; 7] = [ const TIME_LABELS: [&str; 7] = [
"input", "settings", "tree", "terminal", "tabs", "content", "windows", "input", "settings", "tree", "terminal", "tabs", "content", "windows",
]; ];
const MAX_FPS: f32 = 30.0; const MAX_FPS: f32 = 30.0;
const PATH_ROOT: &str = "/home/penwing/Documents/";
const DISPLAY_PATH_DEPTH: usize = 3; const DISPLAY_PATH_DEPTH: usize = 3;
const MAX_TABS: usize = 20; const MAX_TABS: usize = 20;
fn main() -> Result<(), eframe::Error> { fn main() -> Result<(), eframe::Error> {
let icon_data = tools::load_icon().unwrap_or_default(); let icon_data = tools::load_icon().unwrap_or_default();
let options = eframe::NativeOptions { let options = eframe::NativeOptions {
viewport: egui::ViewportBuilder::default() viewport: egui::ViewportBuilder::default()
.with_inner_size([1200.0, 800.0]) .with_inner_size([1200.0, 800.0])
.with_icon(Arc::new(icon_data)), .with_icon(Arc::new(icon_data)),
..Default::default() ..Default::default()
}; };
// Attempt to load previous state // Attempt to load previous state
let app_state: tools::AppState = if Path::new(SAVE_PATH).exists() { let app_state: tools::AppState = if save_path().exists() {
match tools::load_state(SAVE_PATH) { match tools::load_state(save_path().as_path()) {
Ok(app_state) => app_state, Ok(app_state) => app_state,
Err(_) => tools::AppState::default(), Err(_) => tools::AppState::default(),
} }
} else { } else {
tools::AppState::default() tools::AppState::default()
}; };
eframe::run_native( eframe::run_native(
&format!("Calcifer{}", TITLE), &format!("Calcifer{}", TITLE),
options, options,
Box::new(move |_cc| Box::from(Calcifer::from_app_state(app_state))), Box::new(move |_cc| Box::from(Calcifer::from_app_state(app_state))),
) )
} }
struct Calcifer { struct Calcifer {
selected_tab: tools::TabNumber, selected_tab: tools::TabNumber,
tabs: Vec<tools::Tab>, tabs: Vec<tools::Tab>,
command: String, command: String,
command_history: Vec<tools::CommandEntry>, command_history: Vec<tools::CommandEntry>,
theme: ColorTheme, theme: ColorTheme,
font_size: f32, font_size: f32,
project_mode: bool, project_mode: bool,
home: PathBuf,
tree_dir_opened: Vec<String>,
file_tree: Option<tools::file_tree::File>,
tree_visible: bool,
profiler_visible: bool,
terminal_visible: bool,
tree_visible: bool, close_tab_confirm: tools::confirm::ConfirmWindow,
profiler_visible: bool, tab_to_close: usize,
terminal_visible: bool, refresh_confirm: tools::confirm::ConfirmWindow,
exit_confirm: tools::confirm::ConfirmWindow,
close_tab_confirm: tools::confirm::ConfirmWindow, search_menu: tools::search::SearchWindow,
tab_to_close: usize, settings_menu: tools::settings::SettingsWindow,
refresh_confirm: tools::confirm::ConfirmWindow, shortcuts_menu: tools::shortcuts::ShortcutsWindow,
exit_confirm: tools::confirm::ConfirmWindow,
search_menu: tools::search::SearchWindow, time_watch: Vec<f32>,
settings_menu: tools::settings::SettingsWindow, next_frame: time::Instant,
shortcuts_menu: tools::shortcuts::ShortcutsWindow,
time_watch: Vec<f32>,
next_frame: time::Instant,
} }
impl Default for Calcifer { impl Default for Calcifer {
fn default() -> Self { fn default() -> Self {
Self { Self {
selected_tab: tools::TabNumber::from_index(0), selected_tab: tools::TabNumber::from_index(0),
tabs: vec![tools::Tab::default()], tabs: vec![tools::Tab::default()],
command: String::new(), command: String::new(),
command_history: Vec::new(), command_history: Vec::new(),
theme: DEFAULT_THEMES[0], theme: DEFAULT_THEMES[0],
font_size: 14.0, font_size: 14.0,
project_mode: true, project_mode: true,
home: get_my_home().unwrap().unwrap(),
tree_dir_opened: vec![],
file_tree: None,
tree_visible: false,
profiler_visible: false,
terminal_visible: false,
tree_visible: false, close_tab_confirm: tools::confirm::ConfirmWindow::new(
profiler_visible: false, "You have some unsaved changes, Do you still want to close this document ?",
terminal_visible: false, "Confirm Close",
),
tab_to_close: 0,
refresh_confirm: tools::confirm::ConfirmWindow::new(
"You have some unsaved changes, Do you still want to refresh this document ?",
"Confirm Refresh",
),
exit_confirm: tools::confirm::ConfirmWindow::new("", "Confirm Exit"),
close_tab_confirm: tools::confirm::ConfirmWindow::new( search_menu: tools::search::SearchWindow::default(),
"You have some unsaved changes, Do you still want to close this document ?", settings_menu: tools::settings::SettingsWindow::new(DEFAULT_THEMES[0]),
"Confirm Close", shortcuts_menu: tools::shortcuts::ShortcutsWindow::new(),
),
tab_to_close: 0,
refresh_confirm: tools::confirm::ConfirmWindow::new(
"You have some unsaved changes, Do you still want to refresh this document ?",
"Confirm Refresh",
),
exit_confirm: tools::confirm::ConfirmWindow::new("", "Confirm Exit"),
search_menu: tools::search::SearchWindow::default(), time_watch: vec![0.0; TIME_LABELS.len()],
settings_menu: tools::settings::SettingsWindow::new(DEFAULT_THEMES[0]), next_frame: time::Instant::now(),
shortcuts_menu: tools::shortcuts::ShortcutsWindow::new(), }
}
time_watch: vec![0.0; TIME_LABELS.len()],
next_frame: time::Instant::now(),
}
}
} }
impl eframe::App for Calcifer { impl eframe::App for Calcifer {
fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) { fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
thread::sleep(time::Duration::from_secs_f32( thread::sleep(time::Duration::from_secs_f32(
((1.0 / MAX_FPS) - self.next_frame.elapsed().as_secs_f32()).max(0.0), ((1.0 / MAX_FPS) - self.next_frame.elapsed().as_secs_f32()).max(0.0),
)); ));
self.next_frame = time::Instant::now(); self.next_frame = time::Instant::now();
let mut watch = time::Instant::now(); let mut watch = time::Instant::now();
let mut style = (*ctx.style()).clone(); let mut style = (*ctx.style()).clone();
style.text_styles = [ style.text_styles = [
(Heading, FontId::new(self.font_size * 1.6, Proportional)), (Heading, FontId::new(self.font_size * 1.6, Proportional)),
(Body, FontId::new(self.font_size, Proportional)), (Body, FontId::new(self.font_size, Proportional)),
(Monospace, FontId::new(self.font_size, Proportional)), (Monospace, FontId::new(self.font_size, Proportional)),
(Button, FontId::new(self.font_size, Proportional)), (Button, FontId::new(self.font_size, Proportional)),
(Small, FontId::new(self.font_size, Proportional)), (Small, FontId::new(self.font_size, Proportional)),
] ]
.into(); .into();
ctx.set_style(style); ctx.set_style(style);
if ctx.input(|i| i.key_pressed(egui::Key::R) && i.modifiers.ctrl) if ctx.input(|i| i.key_pressed(egui::Key::R) && i.modifiers.ctrl)
&& !self.refresh_confirm.visible && !self.refresh_confirm.visible
{ {
if self.tabs[self.selected_tab.to_index()].saved { if self.tabs[self.selected_tab.to_index()].saved {
self.tabs[self.selected_tab.to_index()].refresh(); self.tabs[self.selected_tab.to_index()].refresh();
} else { } else {
self.refresh_confirm.ask(); self.refresh_confirm.ask();
} }
} }
if ctx.input(|i| i.key_pressed(egui::Key::S) && i.modifiers.ctrl) { if ctx.input(|i| i.key_pressed(egui::Key::S) && i.modifiers.ctrl) {
self.handle_save_file(self.save_tab()); self.handle_save_file(self.save_tab());
} }
if ctx.input(|i| i.key_pressed(egui::Key::S) && i.modifiers.ctrl && i.modifiers.shift) { if ctx.input(|i| i.key_pressed(egui::Key::S) && i.modifiers.ctrl && i.modifiers.shift) {
self.handle_save_file(self.save_tab_as()); self.handle_save_file(self.save_tab_as());
} }
if ctx.input(|i| i.key_pressed(egui::Key::ArrowLeft) && i.modifiers.alt) { if ctx.input(|i| i.key_pressed(egui::Key::ArrowLeft) && i.modifiers.alt) {
self.move_through_tabs(false); self.move_through_tabs(false);
} }
if ctx.input(|i| i.key_pressed(egui::Key::ArrowRight) && i.modifiers.alt) { if ctx.input(|i| i.key_pressed(egui::Key::ArrowRight) && i.modifiers.alt) {
self.move_through_tabs(true); self.move_through_tabs(true);
} }
if ctx.input(|i| i.zoom_delta() > 1.0) { if ctx.input(|i| i.zoom_delta() > 1.0) {
self.font_size = (self.font_size * 1.1).min(30.0); self.font_size = (self.font_size * 1.1).min(30.0);
} }
if ctx.input(|i| i.zoom_delta() < 1.0) { if ctx.input(|i| i.zoom_delta() < 1.0) {
self.font_size = (self.font_size / 1.1).max(10.0); self.font_size = (self.font_size / 1.1).max(10.0);
} }
if ctx.input(|i| i.key_pressed(egui::Key::F) && i.modifiers.ctrl) { if ctx.input(|i| i.key_pressed(egui::Key::F) && i.modifiers.ctrl) {
self.search_menu.visible = !self.search_menu.visible; self.search_menu.visible = !self.search_menu.visible;
self.search_menu.initialized = !self.search_menu.visible; self.search_menu.initialized = !self.search_menu.visible;
} }
if ctx.input(|i| i.viewport().close_requested()) { if ctx.input(|i| i.viewport().close_requested()) {
let mut unsaved_tabs: Vec<usize> = vec![]; let mut unsaved_tabs: Vec<usize> = vec![];
for (index, tab) in self.tabs.iter().enumerate() { for (index, tab) in self.tabs.iter().enumerate() {
if !tab.saved { if !tab.saved {
unsaved_tabs.push(index); unsaved_tabs.push(index);
} }
} }
if !unsaved_tabs.is_empty() { if !unsaved_tabs.is_empty() {
let mut unsaved_tabs_names: String = "".to_string(); let mut unsaved_tabs_names: String = "".to_string();
for index in unsaved_tabs.iter() { for index in unsaved_tabs.iter() {
unsaved_tabs_names.push_str(&self.tabs[*index].get_name()); unsaved_tabs_names.push_str(&self.tabs[*index].get_name());
} }
egui::Context::send_viewport_cmd(ctx, egui::ViewportCommand::CancelClose); egui::Context::send_viewport_cmd(ctx, egui::ViewportCommand::CancelClose);
self.exit_confirm.prompt = format!( self.exit_confirm.prompt = format!(
"You have some unsaved changes :\n{}\nDo you still want to exit ?", "You have some unsaved changes :\n{}\nDo you still want to exit ?",
unsaved_tabs_names unsaved_tabs_names
); );
self.exit_confirm.ask(); self.exit_confirm.ask();
} }
} }
self.time_watch[0] = watch.elapsed().as_micros() as f32 / 1000.0; self.time_watch[0] = watch.elapsed().as_micros() as f32 / 1000.0;
watch = time::Instant::now(); watch = time::Instant::now();
self.draw_settings(ctx); self.draw_settings(ctx);
self.time_watch[1] = watch.elapsed().as_micros() as f32 / 1000.0; self.time_watch[1] = watch.elapsed().as_micros() as f32 / 1000.0;
watch = time::Instant::now(); watch = time::Instant::now();
self.draw_tree_panel(ctx); self.draw_tree_panel(ctx);
self.time_watch[2] = watch.elapsed().as_micros() as f32 / 1000.0; self.time_watch[2] = watch.elapsed().as_micros() as f32 / 1000.0;
watch = time::Instant::now(); watch = time::Instant::now();
self.draw_bottom_tray(ctx); self.draw_bottom_tray(ctx);
self.draw_terminal_panel(ctx); self.draw_terminal_panel(ctx);
self.time_watch[3] = watch.elapsed().as_micros() as f32 / 1000.0; self.time_watch[3] = watch.elapsed().as_micros() as f32 / 1000.0;
watch = time::Instant::now(); watch = time::Instant::now();
self.draw_tab_panel(ctx); self.draw_tab_panel(ctx);
self.time_watch[4] = watch.elapsed().as_micros() as f32 / 1000.0; self.time_watch[4] = watch.elapsed().as_micros() as f32 / 1000.0;
watch = time::Instant::now(); watch = time::Instant::now();
self.draw_content_panel(ctx); self.draw_content_panel(ctx);
self.time_watch[5] = watch.elapsed().as_micros() as f32 / 1000.0; self.time_watch[5] = watch.elapsed().as_micros() as f32 / 1000.0;
watch = time::Instant::now(); watch = time::Instant::now();
self.draw_windows(ctx); self.draw_windows(ctx);
self.time_watch[6] = watch.elapsed().as_micros() as f32 / 1000.0; self.time_watch[6] = watch.elapsed().as_micros() as f32 / 1000.0;
} }
fn on_exit(&mut self, _gl: std::option::Option<&eframe::glow::Context>) { fn on_exit(&mut self, _gl: std::option::Option<&eframe::glow::Context>) {
self.save_state(); self.save_state();
} }
} }
fn save_path() -> PathBuf {
if TITLE.is_empty() {
get_my_home().unwrap().unwrap().as_path().join(".calcifer").join("save.json").to_path_buf()
} else {
get_my_home().unwrap().unwrap().as_path().join(".calcifer").join("debug").join("save.json").to_path_buf()
}
}