1use fs::OpenOptions;
  2use gpui::{
  3    executor,
  4    geometry::{rect::RectF, vector::vec2f},
  5    platform::{current as platform, App as _, Runner as _, WindowOptions},
  6    FontCache,
  7};
  8use log::LevelFilter;
  9use simplelog::SimpleLogger;
 10use std::{fs, mem, rc::Rc, sync::Arc};
 11use zed::{
 12    editor, settings,
 13    workspace::{self, OpenParams},
 14};
 15
 16fn main() {
 17    init_logger();
 18
 19    let platform = Arc::new(platform::app());
 20
 21    let foreground = Rc::new(
 22        executor::Foreground::platform(platform.dispatcher())
 23            .expect("could not foreground create executor"),
 24    );
 25
 26    let font_cache = FontCache::new();
 27
 28    let (settings_tx, settings_rx) = settings::channel(&font_cache).unwrap();
 29
 30    let mut app = gpui::App::new(As).unwrap();
 31
 32    platform::runner()
 33        .on_finish_launching(move || {
 34            log::info!("finish launching");
 35
 36            workspace::init(&mut app);
 37            editor::init(&mut app);
 38
 39            if stdout_is_a_pty() {
 40                platform.activate(true);
 41            }
 42
 43            let paths = std::env::args()
 44                .skip(1)
 45                .filter_map(|arg| match fs::canonicalize(arg) {
 46                    Ok(path) => Some(path),
 47                    Err(error) => {
 48                        log::error!("error parsing path argument: {}", error);
 49                        None
 50                    }
 51                })
 52                .collect::<Vec<_>>();
 53
 54            if !paths.is_empty() {
 55                app.dispatch_global_action(
 56                    "workspace:open_paths",
 57                    OpenParams {
 58                        paths,
 59                        settings: settings_rx,
 60                    },
 61                );
 62                mem::forget(app); // This is here until we hold on to the app for some reason
 63            }
 64
 65            // let window = platform
 66            //     .open_window(
 67            //         WindowOptions {
 68            //             bounds: RectF::new(vec2f(0., 0.), vec2f(1024., 768.)),
 69            //             title: Some("Zed"),
 70            //         },
 71            //         foreground,
 72            //     )
 73            //     .expect("error opening window");
 74
 75            // mem::forget(window); // Leak window for now so it doesn't close
 76        })
 77        .run();
 78}
 79
 80fn init_logger() {
 81    let level = LevelFilter::Info;
 82
 83    if stdout_is_a_pty() {
 84        SimpleLogger::init(level, Default::default()).expect("could not initialize logger");
 85    } else {
 86        let log_dir_path = dirs::home_dir()
 87            .expect("could not locate home directory for logging")
 88            .join("Library/Logs/");
 89        let log_file_path = log_dir_path.join("Zed.log");
 90        fs::create_dir_all(&log_dir_path).expect("could not create log directory");
 91        let log_file = OpenOptions::new()
 92            .create(true)
 93            .append(true)
 94            .open(log_file_path)
 95            .expect("could not open logfile");
 96        simplelog::WriteLogger::init(level, simplelog::Config::default(), log_file)
 97            .expect("could not initialize logger");
 98    }
 99}
100
101fn stdout_is_a_pty() -> bool {
102    unsafe { libc::isatty(libc::STDOUT_FILENO as i32) != 0 }
103}