blue-recorder/gui/src/ui.rs

use adw::{Application, Window};
use adw::gio::File;
use adw::gtk::{AboutDialog, Builder, Button, CheckButton, ComboBoxText, CssProvider, Entry, Expander, FileChooserNative,
               FileChooserAction, Image, Label, MessageDialog, SpinButton, TextBuffer, TextView, ToggleButton};
use adw::prelude::*;
use anyhow::Result;
#[cfg(any(target_os = "freebsd", target_os = "linux"))]
use blue_recorder_core::ffmpeg_linux::Ffmpeg;
#[cfg(target_os = "windows")]
use blue_recorder_core::ffmpeg_windows::Ffmpeg;
use blue_recorder_core::utils::{is_overwrite, is_wayland, play_record, RecordMode};
use cpal::traits::{DeviceTrait, HostTrait};
use std::cell::RefCell;
use std::ops::Add;
use std::path::Path;
use std::rc::Rc;

use crate::{area_capture, config_management, fluent::get_bundle};
use crate::timer::{RecordClick, recording_delay, start_timer, stop_timer};

pub fn run_ui(application: &Application) {
    // Error dialog
    let error_dialog_ui_src = include_str!("../interfaces/error_dialog.ui").to_string();
    let builder: Builder = Builder::from_string(error_dialog_ui_src.as_str());
    let error_dialog: MessageDialog = builder.object("error_dialog").unwrap();
    let error_dialog_button: Button = builder.object("error_button").unwrap();
    let error_dialog_label: Label = builder.object("error_text").unwrap();
    let error_expander: Expander = builder.object("error_expander").unwrap();
    let error_expander_label: Label = builder.object("expander_label").unwrap();
    let error_message: TextView = builder.object("error_details").unwrap();
    error_dialog_button.set_label(&get_bundle("close", None));
    error_expander_label.set_label(&get_bundle("details-button", None));
    error_dialog_label.set_label(&get_bundle("some-error", None));
    error_dialog.set_title(Some(&get_bundle("error-title", None)));
    let _error_dialog = error_dialog.clone();
    let _error_expander = error_expander.clone();
    error_dialog_button.connect_clicked(move |_| {
        _error_expander.set_expanded(false);
        _error_dialog.set_hide_on_close(true);
        _error_dialog.close();
    });

    match build_ui(application, error_dialog.clone(), error_message.clone()) {
        Ok(_) => {
            // Continue
        },
        Err(error) => {
            let text_buffer = TextBuffer::new(None);
            text_buffer.set_text(&error.to_string());
            error_message.set_buffer(Some(&text_buffer));
            error_dialog.show();
            error_dialog.set_hide_on_close(true);
        }
    }
}

fn build_ui(application: &Application, error_dialog: MessageDialog, error_message: TextView) -> Result<()> {
    // Init audio source
    let host_audio_device = cpal::default_host();

    // Config initialize
    config_management::initialize();

    // UI source
    let about_dialog_ui_src = include_str!("../interfaces/about_dialog.ui").to_string();
    let area_selection_ui_src = include_str!("../interfaces/area_selection.ui").to_string();
    let delay_ui_src = include_str!("../interfaces/delay.ui").to_string();
    let main_ui_src = include_str!("../interfaces/main.ui").to_string();
    let select_window_ui_src = include_str!("../interfaces/select_window.ui").to_string();

    let builder: Builder = Builder::from_string(main_ui_src.as_str());
    builder.add_from_string(about_dialog_ui_src.as_str()).unwrap();
    builder.add_from_string(area_selection_ui_src.as_str()).unwrap();
    builder.add_from_string(delay_ui_src.as_str()).unwrap();
    builder.add_from_string(select_window_ui_src.as_str()).unwrap();

    // Get Objects from UI
    let area_apply_label: Label = builder.object("area_apply").unwrap();
    let area_chooser_window: Window = builder.object("area_chooser_window").unwrap();
    let area_grab_button: ToggleButton = builder.object("area_grab_button").unwrap();
    let area_grab_icon: Image = builder.object("area_grab_icon").unwrap();
    let area_grab_label: Label = builder.object("area_grab_label").unwrap();
    let area_set_button: Button = builder.object("area_set_button").unwrap();
    let area_size_bottom_label: Label = builder.object("area_size_bottom").unwrap();
    let area_size_top_label: Label = builder.object("area_size_top").unwrap();
    let area_switch: CheckButton = builder.object("areaswitch").unwrap();
    let about_button: Button = builder.object("aboutbutton").unwrap();
    let about_dialog: AboutDialog = builder.object("about_dialog").unwrap();
    let audio_bitrate_label: Label = builder.object("audio_bitrate_label").unwrap();
    let audio_bitrate_spin: SpinButton = builder.object("audio_bitrate").unwrap();
    let audio_source_combobox: ComboBoxText = builder.object("audiosource").unwrap();
    let audio_source_label: Label = builder.object("audio_source_label").unwrap();
    let audio_input_switch: CheckButton = builder.object("audio_input_switch").unwrap();
    let command_entry: Entry = builder.object("command").unwrap();
    let command_label: Label = builder.object("command_label").unwrap();
    let delay_label: Label = builder.object("delay_label").unwrap();
    let delay_spin: SpinButton = builder.object("delay").unwrap();
    let delay_window: Window = builder.object("delay_window").unwrap();
    let delay_window_button: ToggleButton = builder.object("delay_window_stopbutton").unwrap();
    let delay_window_label: Label = builder.object("delay_window_label").unwrap();
    let delay_window_title: Label = builder.object("delay_window_title").unwrap();
    let filename_entry: Entry = builder.object("filename").unwrap();
    let folder_chooser_button: Button = builder.object("folder_chooser").unwrap();
    let folder_chooser_image: Image = builder.object("folder_chooser_image").unwrap();
    let folder_chooser_label: Label = builder.object("folder_chooser_label").unwrap();
    let follow_mouse_switch: CheckButton = builder.object("followmouseswitch").unwrap();
    let format_chooser_combobox: ComboBoxText = builder.object("comboboxtext1").unwrap();
    let frames_label: Label = builder.object("frames_label").unwrap();
    let frames_spin: SpinButton = builder.object("frames").unwrap();
    let hide_switch: CheckButton = builder.object("hideswitch").unwrap();
    let main_window: Window = builder.object("main_window").unwrap();
    let mouse_switch: CheckButton = builder.object("mouseswitch").unwrap();
    let play_button: Button = builder.object("playbutton").unwrap();
    let record_button: Button = builder.object("recordbutton").unwrap();
    let record_label: Label = builder.object("record_label").unwrap();
    let record_time_label: Label = builder.object("record_time_label").unwrap();
    let tray_switch: CheckButton = builder.object("trayswitch").unwrap();
    let screen_grab_button: ToggleButton = builder.object("screen_grab_button").unwrap();
    let screen_grab_icon: Image = builder.object("screen_grab_icon").unwrap();
    let screen_grab_label: Label = builder.object("screen_grab_label").unwrap();
    let select_window: Window = builder.object("select_window").unwrap();
    #[cfg(target_os = "windows")]
    let select_window_label: Label = builder.object("select_window_label").unwrap();
    let audio_output_switch: CheckButton = builder.object("speakerswitch").unwrap();
    let stop_button: Button = builder.object("stopbutton").unwrap();
    let stop_label: Label = builder.object("stop_label").unwrap();
    let video_bitrate_label: Label = builder.object("video_bitrate_label").unwrap();
    let video_bitrate_spin: SpinButton = builder.object("video_bitrate").unwrap();
    let video_switch: CheckButton = builder.object("videoswitch").unwrap();
    let window_grab_button: ToggleButton = builder.object("window_grab_button").unwrap();
    let window_grab_icon: Image = builder.object("window_grab_icon").unwrap();
    let window_grab_label: Label = builder.object("window_grab_label").unwrap();

    // --- default properties
    // Windows
    area_chooser_window.set_title(Some(&get_bundle("area-chooser", None))); // Title is hidden
    error_dialog.set_transient_for(Some(&main_window));
    select_window.set_transient_for(Some(&main_window));
    main_window.set_application(Some(application));
    main_window.set_title(Some(&get_bundle("blue-recorder", None)));

    // Hide stop & play buttons
    play_button.hide();
    stop_button.hide();

    // Disable show area check button
    if !area_grab_button.is_active() {
        area_switch.set_active(false);
        area_switch.set_sensitive(false);
    }

    // Toggle button
    config_management::set("default", "mode", "screen");
    screen_grab_button.set_active(true);

    // Comboboxs tooltip
    area_grab_button.set_tooltip_text(Some(&get_bundle("area-tooltip", None)));
    audio_source_combobox.set_tooltip_text(Some(&get_bundle("audio-source-tooltip", None)));
    format_chooser_combobox.set_tooltip_text(Some(&get_bundle("format-tooltip", None)));

    // Temporary solution
    if is_wayland() {
        // Hide window grab button in Wayland
        area_grab_button.set_sensitive(false);
        area_grab_button.set_tooltip_text(Some(&get_bundle("wayland-tooltip", None)));
    }
    // Disable follow mouse option
    #[cfg(target_os = "windows")]
    {
        follow_mouse_switch.set_active(false);
        follow_mouse_switch.set_sensitive(false);
    }

    // Entries
    filename_entry.set_placeholder_text(Some(&get_bundle("file-name", None)));
    command_entry.set_placeholder_text(Some(&get_bundle("default-command", None)));
    filename_entry.set_text(&config_management::get("default", "filename"));
    command_entry.set_text(&config_management::get("default", "command"));

    // Format combobox
    format_chooser_combobox.append(Some("mp4"), &get_bundle("mp4-format", None));
    format_chooser_combobox.append(
        Some("mkv"),
        &get_bundle("mkv-format", None),
    );
    format_chooser_combobox.append(Some("webm"), &get_bundle("webm-format", None));
    format_chooser_combobox.append(Some("gif"), &get_bundle("gif-format", None));
    format_chooser_combobox.append(Some("avi"), &get_bundle("avi-format", None));
    format_chooser_combobox.append(Some("wmv"), &get_bundle("wmv-format", None));
    format_chooser_combobox.append(Some("nut"), &get_bundle("nut-format", None));
    format_chooser_combobox.set_active(Some(config_management::get("default", "format").parse::<u32>().unwrap_or(0u32)));

    // Get audio sources
    let input_device = host_audio_device.input_devices()?;
    let sources_descriptions: Vec<String> = input_device
        .filter_map(|device| device.name().ok())
        .collect();
    let host_output_device = host_audio_device.default_output_device();
    let output_device = if host_output_device.is_some() {
        host_output_device.unwrap().name()?
    } else {
      String::new()
    };

    audio_source_combobox.append(Some("default"), &get_bundle("audio-input", None));
    for (id, audio_source) in sources_descriptions.iter().enumerate() {
        audio_source_combobox.append(Some(id.to_string().as_str()), audio_source);
    }
    audio_source_combobox.set_active(Some(0));

    // Switchs
    audio_input_switch.set_active(config_management::get_bool("default", "audio_input_check"));
    follow_mouse_switch.set_active(config_management::get_bool("default", "followmousecheck"));
    hide_switch.set_active(config_management::get_bool("default", "hidecheck"));
    mouse_switch.set_active(config_management::get_bool("default", "mousecheck"));
    audio_output_switch.set_active(config_management::get_bool("default", "speakercheck"));
    tray_switch.set_active(config_management::get_bool("default", "traycheck"));
    video_switch.set_active(config_management::get_bool("default", "videocheck"));
    area_switch.set_label(Some(&get_bundle("show-area", None)));
    audio_input_switch.set_label(Some(&get_bundle("record-audio", None)));
    follow_mouse_switch.set_label(Some(&get_bundle("follow-mouse", None)));
    hide_switch.set_label(Some(&get_bundle("auto-hide", None)));
    mouse_switch.set_label(Some(&get_bundle("show-mouse", None)));
    audio_output_switch.set_label(Some(&get_bundle("record-speaker", None)));
    tray_switch.set_label(Some(&get_bundle("tray-minimize", None)));
    video_switch.set_label(Some(&get_bundle("record-video", None)));
    area_switch.set_tooltip_text(Some(&get_bundle("show-area-tooltip", None)));
    audio_input_switch.set_tooltip_text(Some(&get_bundle("audio-input-tooltip", None)));
    #[cfg(target_os = "windows")]
    follow_mouse_switch.set_tooltip_text(Some(&get_bundle("windows-unsupported-tooltip", None)));
    #[cfg(any(target_os = "freebsd", target_os = "linux"))]
    follow_mouse_switch.set_tooltip_text(Some(&get_bundle("follow-mouse-tooltip", None)));
    hide_switch.set_tooltip_text(Some(&get_bundle("hide-tooltip", None)));
    mouse_switch.set_tooltip_text(Some(&get_bundle("mouse-tooltip", None)));
    audio_output_switch.set_tooltip_text(Some(&get_bundle("speaker-tooltip", None)));
    tray_switch.set_tooltip_text(Some(&get_bundle("tray-minimize-tooltip", None)));
    video_switch.set_tooltip_text(Some(&get_bundle("video-tooltip", None)));

    let _mouse_switch = mouse_switch.clone();
    let _video_switch = video_switch.clone();
    audio_input_switch.connect_toggled(move |switch: &CheckButton| {
        config_management::set_bool("default", "audio_input_check", switch.is_active());
        if !switch.is_active() && !_video_switch.is_active() {
            _mouse_switch.set_sensitive(true);
        }
    });
    follow_mouse_switch.connect_toggled(|switch: &CheckButton| {
        config_management::set_bool("default", "followmousecheck", switch.is_active());
    });
    hide_switch.connect_toggled(|switch: &CheckButton| {
        config_management::set_bool("default", "hidecheck", switch.is_active());
    });
    mouse_switch.connect_toggled(move |switch: &CheckButton| {
        config_management::set_bool("default", "mousecheck", switch.is_active());
    });
    audio_output_switch.connect_toggled(|switch: &CheckButton| {
        config_management::set_bool("default", "speakercheck", switch.is_active());
    });
    let _audio_input_switch = audio_input_switch.clone();
    let _follow_mouse_switch = follow_mouse_switch.clone();
    let _mouse_switch = mouse_switch.clone();
    video_switch.connect_toggled(move |switch: &CheckButton| {
        config_management::set_bool("default", "videocheck", switch.is_active());
        if switch.is_active() {
            _follow_mouse_switch.set_sensitive(true);
            _mouse_switch.set_sensitive(true);
        } else {
            _mouse_switch.set_active(false);
            _mouse_switch.set_sensitive(false);
            _follow_mouse_switch.set_active(false);
            _follow_mouse_switch.set_sensitive(false);
        }
    });

    match dark_light::detect() {
        // Dark mode
        dark_light::Mode::Dark => {
            // Buttons
            let mut area_icon_path = {
                let mut current_exec_dir = std::env::current_exe().unwrap();
                current_exec_dir.pop();
                current_exec_dir
            }
            .join(Path::new("data/screenshot-ui-area-symbolic-white.svg"));

            if !area_icon_path.exists() {
                area_icon_path = std::fs::canonicalize(Path::new(
                    &std::env::var("DATA_DIR")
                        .unwrap_or_else(|_| String::from("data/"))
                        .add("screenshot-ui-area-symbolic-white.svg"),
                ))
                .unwrap();
            }

            let mut screen_icon_path = {
                let mut current_exec_dir = std::env::current_exe().unwrap();
                current_exec_dir.pop();
                current_exec_dir
            }
            .join(Path::new("data/screenshot-ui-display-symbolic-white.svg"));

            if !screen_icon_path.exists() {
                screen_icon_path = std::fs::canonicalize(Path::new(
                    &std::env::var("DATA_DIR")
                        .unwrap_or_else(|_| String::from("data/"))
                        .add("screenshot-ui-display-symbolic-white.svg"),
                ))
                .unwrap();
            }

            let mut window_icon_path = {
                let mut current_exec_dir = std::env::current_exe().unwrap();
                current_exec_dir.pop();
                current_exec_dir
            }
            .join(Path::new("data/screenshot-ui-window-symbolic-white.svg"));

            if !window_icon_path.exists() {
                window_icon_path = std::fs::canonicalize(Path::new(
                    &std::env::var("DATA_DIR")
                        .unwrap_or_else(|_| String::from("data/"))
                        .add("screenshot-ui-window-symbolic-white.svg"),
                ))
                .unwrap();
            }

            area_grab_icon.set_from_file(Some(area_icon_path));
            screen_grab_icon.set_from_file(Some(screen_icon_path));
            window_grab_icon.set_from_file(Some(&window_icon_path));
        }
        // any theme
        _ => {
            // Buttons
            let mut area_icon_path = {
                let mut current_exec_dir = std::env::current_exe().unwrap();
                current_exec_dir.pop();
                current_exec_dir
            }
            .join(Path::new("data/screenshot-ui-area-symbolic.svg"));

            if !area_icon_path.exists() {
                area_icon_path = std::fs::canonicalize(Path::new(
                    &std::env::var("DATA_DIR")
                        .unwrap_or_else(|_| String::from("data/"))
                        .add("screenshot-ui-area-symbolic.svg"),
                ))
                .unwrap();
            }

            let mut screen_icon_path = {
                let mut current_exec_dir = std::env::current_exe().unwrap();
                current_exec_dir.pop();
                current_exec_dir
            }
            .join(Path::new("data/screenshot-ui-display-symbolic.svg"));

            if !screen_icon_path.exists() {
                screen_icon_path = std::fs::canonicalize(Path::new(
                    &std::env::var("DATA_DIR")
                        .unwrap_or_else(|_| String::from("data/"))
                        .add("screenshot-ui-display-symbolic.svg"),
                ))
                .unwrap();
            }

            let mut window_icon_path = {
                let mut current_exec_dir = std::env::current_exe().unwrap();
                current_exec_dir.pop();
                current_exec_dir
            }
            .join(Path::new("data/screenshot-ui-window-symbolic.svg"));

            if !window_icon_path.exists() {
                window_icon_path = std::fs::canonicalize(Path::new(
                    &std::env::var("DATA_DIR")
                        .unwrap_or_else(|_| String::from("data/"))
                        .add("screenshot-ui-window-symbolic.svg"),
                ))
                .unwrap();
            }

            area_grab_icon.set_from_file(Some(area_icon_path));
            screen_grab_icon.set_from_file(Some(screen_icon_path));
            window_grab_icon.set_from_file(Some(&window_icon_path));
        }
    }

    // Spin
    audio_bitrate_spin.set_tooltip_text(Some(&get_bundle("audio-bitrate-tooltip", None)));
    delay_spin.set_tooltip_text(Some(&get_bundle("delay-tooltip", None)));
    frames_spin.set_tooltip_text(Some(&get_bundle("frames-tooltip", None)));
    video_bitrate_spin.set_tooltip_text(Some(&get_bundle("video-bitrate-tooltip", None)));
    frames_spin.set_value(
        config_management::get("default",
                               &format!
                               ("frame-{}",
                                &format_chooser_combobox.active().unwrap().to_string()))
            .parse::<f64>()
            .unwrap_or(0f64),
    );
    audio_bitrate_spin.set_value(
        config_management::get("default", "audiobitrate")
            .parse::<f64>()
            .unwrap_or(0f64),
    );
    delay_spin.set_value(
        config_management::get("default", "delay")
            .parse::<f64>()
            .unwrap_or(0f64),
    );
    video_bitrate_spin.set_value(
        config_management::get("default",
                               &format!
                               ("videobitrate-{}",
                                &format_chooser_combobox.active().unwrap().to_string()))
            .parse::<f64>()
            .unwrap_or(0f64),
    );

    let _format_chooser_combobox = format_chooser_combobox.clone();
    let _frames_spin = frames_spin.clone();
    let _video_bitrate_spin = video_bitrate_spin.clone();
    format_chooser_combobox.connect_changed(move |_| {
        let format_chooser_combobox = _format_chooser_combobox.clone();
        if _format_chooser_combobox.active_text().is_some() {
            config_management::set(
                "default",
                "format",
                &_format_chooser_combobox.active().unwrap().to_string(),
            );
            _frames_spin.set_value(
                config_management::get("default",
                                       &format!
                                       ("frame-{}",
                                        &format_chooser_combobox.active().unwrap().to_string()))
                    .parse::<f64>()
                    .unwrap_or(0f64),
            );
            _video_bitrate_spin.set_value(
                config_management::get("default",
                                       &format!
                                       ("videobitrate-{}",
                                        &format_chooser_combobox.active().unwrap().to_string()))
                    .parse::<f64>()
                    .unwrap_or(0f64),
            );
        }
    });

    let _audio_bitrate_spin = audio_bitrate_spin.to_owned();
    audio_bitrate_spin.connect_value_changed(move |_| {
        config_management::set("default",
                               "audio_bitrate",
                               _audio_bitrate_spin.value().to_string().as_str());
    });
    let _delay_spin = delay_spin.to_owned();
    delay_spin.connect_value_changed(move |_| {
        config_management::set("default",
                               "delay",
                               _delay_spin.value().to_string().as_str());
    });
    let _frames_spin = frames_spin.to_owned();
    let _format_chooser_combobox = format_chooser_combobox.clone();
    frames_spin.connect_value_changed(move |_| {
        config_management::set("default",
                               &format!
                               ("frame-{}",
                                &_format_chooser_combobox.active().unwrap().to_string()),
                               _frames_spin.value().to_string().as_str());
    });
    let _format_chooser_combobox = format_chooser_combobox.clone();
    let _video_bitrate_spin = video_bitrate_spin.to_owned();
    video_bitrate_spin.connect_value_changed(move |_| {
        config_management::set("default",
                               &format!
                               ("videobitrate-{}",
                                &_format_chooser_combobox.active().unwrap().to_string()),
                               _video_bitrate_spin.value().to_string().as_str());
     });

    // Labels
    audio_bitrate_label.set_label(&get_bundle("audio-bitrate", None));
    audio_source_label.set_label(&get_bundle("audio-source", None));
    delay_label.set_label(&get_bundle("delay", None));
    command_label.set_label(&get_bundle("run-command", None));
    frames_label.set_label(&get_bundle("frames", None));
    video_bitrate_label.set_label(&get_bundle("video-bitrate", None));

    // FileChooser
    let folder_chooser_native = FileChooserNative::new(
        Some("Select Folder"),
        Some(&main_window),
        FileChooserAction::SelectFolder,
        Some("Select"),
        Some("Cancel"),
    );
    folder_chooser_native.set_transient_for(Some(&main_window));
    folder_chooser_native.set_modal(true);
    folder_chooser_native
        .set_file(&File::for_path(&config_management::get(
            "default", "folder",
        )))
        .unwrap();
    let folder_chooser = Some(File::for_path(&config_management::get(
        "default", "folder",
    )))
    .unwrap();
    let _error_dialog = error_dialog.clone();
    let _error_message = error_message.clone();
    let folder_chooser_name = folder_chooser.basename().unwrap().to_string_lossy().to_string();
    folder_chooser_label.set_label(&folder_chooser_name);
    let folder_chooser_icon = config_management::folder_icon(Some(folder_chooser_name.as_str()));
    folder_chooser_image.set_icon_name(Some(folder_chooser_icon));
    folder_chooser_button.set_tooltip_text(Some(&get_bundle("folder-tooltip", None)));
    // Show file chooser dialog
    folder_chooser_button.connect_clicked(glib::clone!(@strong folder_chooser_native => move |_| {
        let error_dialog = _error_dialog.clone();
        let error_message = _error_message.clone();
        folder_chooser_native.connect_response
                             (glib::clone!(@strong folder_chooser_native, @strong folder_chooser_label,
                                           @strong folder_chooser_image => move |_, response| {
                                               let text_buffer = TextBuffer::new(None);
                                               if response == adw::gtk::ResponseType::Accept {
                                                   if folder_chooser_native.file().is_none() {
                                                       text_buffer.set_text("Failed to get save file path.");
                                                       error_message.set_buffer(Some(&text_buffer));
                                                       error_dialog.show();
                                                   }
                                                   let folder_chooser = folder_chooser_native.file().unwrap_or_else
                                                       (||
                                                        File::for_path(&config_management::get(
                                                            "default", "folder",
                                                        ))); // Default

                                                   let folder_chooser_name = folder_chooser.basename().unwrap();
                                                   folder_chooser_label.set_label(&folder_chooser_name.to_string_lossy());
                                                   let folder_chooser_icon = config_management::folder_icon(folder_chooser_name.to_str());
                                                   folder_chooser_image.set_icon_name(Some(folder_chooser_icon));
                                               };
                                               folder_chooser_native.hide();
                                           }));
        folder_chooser_native.show();
    }));

    // --- connections
    // Show dialog window when about button clicked then hide it after close
    about_button.set_tooltip_text(Some(&get_bundle("about-tooltip", None)));
    let _about_dialog: AboutDialog = about_dialog.to_owned();
    about_button.set_label(&get_bundle("about", None));
    about_button.connect_clicked(move |_| {
        _about_dialog.show();
        _about_dialog.set_hide_on_close(true);
    });

    // Buttons
    let area_capture: Rc<RefCell<area_capture::AreaCapture>> =
        Rc::new(RefCell::new(area_capture::AreaCapture::new()?));
    #[cfg(target_os = "windows")]
    let window_title: Rc<RefCell<area_capture::Title>> =
        Rc::new(RefCell::new(area_capture::Title::new()?));

    area_grab_label.set_label(&get_bundle("select-area", None));
    let _area_chooser_window = area_chooser_window.clone();
    let mut _area_capture = area_capture.clone();
    let _area_switch = area_switch.clone();
    let _error_dialog = error_dialog.clone();
    let _error_message = error_message.clone();
    area_grab_button.connect_clicked(move |_| {
        config_management::set("default", "mode", "area");
        _area_chooser_window.show();
        if area_capture::show_size(
            _area_chooser_window.clone(),
            area_size_bottom_label.clone(),
            area_size_top_label.clone(),
        ).is_err() {
            let text_buffer = TextBuffer::new(None);
            text_buffer.set_text("Failed to get area size value.");
            _error_message.set_buffer(Some(&text_buffer));
            _error_dialog.show();
        }
        _area_switch.set_active(config_management::get_bool("default", "areacheck"));
        _area_switch.set_sensitive(true);
    });

    area_apply_label.set_label(&get_bundle("apply", None));
    let _area_chooser_window = area_chooser_window.clone();
    let mut _area_capture = area_capture.clone();
    let _error_dialog = error_dialog.clone();
    let _error_message = error_message.clone();
    area_set_button.connect_clicked(move |_| {
        let text_buffer = TextBuffer::new(None);
        #[cfg(target_os = "windows")]
        if _area_capture
            .borrow_mut()
            .get_active_window().is_err() {
                text_buffer.set_text("Failed to get area size value.");
                _error_message.set_buffer(Some(&text_buffer));
                _error_dialog.show();
            }
        #[cfg(any(target_os = "freebsd", target_os = "linux"))]
        if _area_capture
            .borrow_mut()
            .get_window_by_name(_area_chooser_window.title().unwrap().as_str()).is_err() {
                text_buffer.set_text("Failed to get area size value.");
                _error_message.set_buffer(Some(&text_buffer));
                _error_dialog.show();
            }
        _area_chooser_window.hide();
    });

    let _area_chooser_window = area_chooser_window.clone();
    let mut _area_capture = area_capture.clone();
    let _area_switch = area_switch.clone();
    let _error_dialog = error_dialog.clone();
    let _error_message = error_message.clone();
    let record_window: Rc<RefCell<bool>> = Rc::new(RefCell::new(false));
    let window_grab_button_record_window: Rc<RefCell<bool>> = record_window.clone();
    let screen_grab_button_record_window: Rc<RefCell<bool>> = record_window.clone();
    screen_grab_button.set_tooltip_text(Some(&get_bundle("screen-tooltip", None)));
    screen_grab_label.set_label(&get_bundle("select-screen", None));
    screen_grab_button.connect_clicked(move |_| {
        let text_buffer = TextBuffer::new(None);
        config_management::set_bool("default", "areacheck", _area_switch.is_active());
        _area_switch.set_active(false);
        _area_switch.set_sensitive(false);
        config_management::set("default", "mode", "screen");
        screen_grab_button_record_window.replace(false);
        _area_chooser_window.hide();
        if _area_capture.borrow_mut().reset().is_err() {
            text_buffer.set_text("Failed to reset area_capture value.");
            _error_message.set_buffer(Some(&text_buffer));
            _error_dialog.show();
        }
    });

    let _area_chooser_window: Window = area_chooser_window.clone();
    let mut _area_capture: Rc<RefCell<area_capture::AreaCapture>> = area_capture.clone();
    let _area_switch = area_switch.clone();
    let _error_dialog = error_dialog.clone();
    let _error_message = error_message.clone();
    window_grab_button.set_tooltip_text(Some(&get_bundle("window-tooltip", None)));
    window_grab_label.set_label(&get_bundle("select-window", None));
    #[cfg(target_os = "windows")]
    let mut _window_title: Rc<RefCell<area_capture::Title>> = window_title.clone();
    window_grab_button.connect_clicked(move |_| {
        let text_buffer = TextBuffer::new(None);
        config_management::set_bool("default", "areacheck", _area_switch.is_active());
        _area_switch.set_active(false);
        _area_switch.set_sensitive(false);
        config_management::set("default", "mode", "window");
        _area_chooser_window.hide();
        if is_wayland() {
            window_grab_button_record_window.replace(true);
        } else {
            #[cfg(target_os = "windows")]
            {
                select_window_label.set_label(&get_bundle("click-window", None));
                select_window.show();

                let area_capture = _area_capture.clone();
                let error_message = _error_message.clone();
                let error_dialog = error_dialog.clone();
                let _select_window = select_window.clone();
                let window_title = _window_title.clone();
                glib::timeout_add_local(1000, move || {
                    let clicked = area_capture::check_input();
                    if clicked {
                        _select_window.hide();
                        if window_title.borrow_mut().get_title().is_err() {
                            text_buffer.set_text("Failed to get window title.");
                            error_message.set_buffer(Some(&text_buffer));
                            error_dialog.show();
                        }
                        return glib::source::Continue(false);
                    } else if !clicked {
                        _select_window.hide();
                        return glib::source::Continue(false);
                    }
                    glib::source::Continue(true)
                });
            }

            #[cfg(any(target_os = "freebsd", target_os = "linux"))]
            {
                if _area_capture.borrow_mut().get_area().is_err() {
                    text_buffer.set_text("Failed to get window info.");
                    _error_message.set_buffer(Some(&text_buffer));
                    _error_dialog.show();
                }
            }}
    });

    // Record struct values
    let audio_output_id = if audio_output_switch.is_active() {
        output_device
    } else {
        String::new()
    };
    let mode = if area_grab_button.is_active() {
        RecordMode::Area
    } else if window_grab_button.is_active() {
        RecordMode::Window
    } else {
        RecordMode::Screen
    };
    #[cfg(target_os = "windows")]
    let window_title = window_title.borrow_mut().title.clone();

    // Init record struct
    #[cfg(target_os = "windows")]
    let ffmpeg_record_interface: Rc<RefCell<Ffmpeg>> = Rc::new(RefCell::new(Ffmpeg {
        audio_input_id: audio_source_combobox.clone(),
        audio_output_id,
        filename: (
            folder_chooser_native,
            filename_entry,
            format_chooser_combobox,
        ),
        output: String::new(),
        temp_input_audio_filename: String::new(),
        temp_output_audio_filename: String::new(),
        temp_video_filename: String::new(),
        window_title,
        saved_filename: String::new(),
        height: None,
        input_audio_process: None,
        output_audio_process: None,
        video_process: None,
        audio_record_bitrate: audio_bitrate_spin,
        record_delay: delay_spin,
        record_frames: frames_spin,
        video_record_bitrate: video_bitrate_spin,
        follow_mouse: follow_mouse_switch,
        record_mouse: mouse_switch,
        show_area: area_switch
    }));
    #[cfg(any(target_os = "freebsd", target_os = "linux"))]
    let ffmpeg_record_interface: Rc<RefCell<Ffmpeg>> = Rc::new(RefCell::new(Ffmpeg {
        audio_input_id: audio_source_combobox.clone(),
        audio_output_id,
        filename: (
            folder_chooser_native,
            filename_entry,
            format_chooser_combobox,
        ),
        output: String::new(),
        temp_input_audio_filename: String::new(),
        temp_output_audio_filename: String::new(),
        temp_video_filename: String::new(),
        saved_filename: String::new(),
        height: None,
        input_audio_process: None,
        output_audio_process: None,
        video_process: None,
        audio_record_bitrate: audio_bitrate_spin,
        record_delay: delay_spin.clone(),
        record_frames: frames_spin,
        video_record_bitrate: video_bitrate_spin,
        follow_mouse: follow_mouse_switch,
        record_mouse: mouse_switch,
        show_area: area_switch
    }));

    // Record button
    delay_window_button.set_label(&get_bundle("delay-window-stop", None));
    delay_window_title.set_label(&get_bundle("delay-title", None));
    record_button.set_tooltip_text(Some(&get_bundle("record-tooltip", None)));
    record_label.set_label(&get_bundle("record", None));
    let _audio_input_switch = audio_input_switch.clone();
    let _audio_output_switch = audio_output_switch.clone();
    //let bundle_msg = get_bundle("already-exist", None);
    let _delay_spin = delay_spin.clone();
    let _delay_window = delay_window.clone();
    let _delay_window_button = delay_window_button.clone();
    let _error_dialog = error_dialog.clone();
    let _error_message = error_message.clone();
    //let main_context = glib::MainContext::default();
    let _main_window = main_window.clone();
    let _play_button = play_button.clone();
    let _record_button = record_button.clone();
    let _record_time_label = record_time_label.clone();
    let _stop_button = stop_button.clone();
    let _video_switch = video_switch.clone();
    //let wayland_record = main_context.block_on(WaylandRecorder::new());
    let mut _ffmpeg_record_interface = ffmpeg_record_interface.clone();
    let second_click: Rc<RefCell<RecordClick>> = Rc::new(RefCell::new(RecordClick {
        is_record_button_clicked: false,
    }));
    record_button.connect_clicked(move |_| {
        match _ffmpeg_record_interface.borrow_mut().get_filename() {
            Err(error) => {
                let text_buffer = TextBuffer::new(None);
                text_buffer.set_text(&format!("{}", error));
                _error_message.set_buffer(Some(&text_buffer));
                _error_dialog.show();
            },
            Ok(_) => {
                if !_audio_input_switch.is_active() &&
                    !_audio_output_switch.is_active() &&
                    !_video_switch.is_active() ||
                    !is_overwrite(&get_bundle("already-exist", None),
                                 &_ffmpeg_record_interface.borrow_mut().saved_filename,
                                 _main_window.clone()
                    ) && !second_click.borrow_mut().is_clicked() && _delay_spin.value() as u16 == 0
                {
                    // Do nothing
                } else {
                    _delay_window_button.set_active(false);
                    if _delay_spin.value() as u16 > 0 {
                        if !is_overwrite(&get_bundle("already-exist", None),
                                         &_ffmpeg_record_interface.borrow_mut().saved_filename,
                                         _main_window.clone())
                        {
                            //Do nothing
                        } else {
                            recording_delay(
                                _delay_spin.clone(),
                                _delay_spin.value() as u16,
                                delay_window.clone(),
                                _delay_window_button.clone(),
                                delay_window_label.clone(),
                                _record_button.clone(),
                                second_click.clone(),
                            );
                        }
                    } else if _delay_spin.value() as u16 == 0 && !is_wayland() {
                        let _area_capture = area_capture.borrow_mut();
                        _audio_input_switch.set_sensitive(false);
                        _audio_output_switch.set_sensitive(false);
                        _video_switch.set_sensitive(false);
                        start_timer(record_time_label.clone());
                        record_time_label.set_visible(true);
                        if hide_switch.is_active() {
                            _main_window.minimize();
                        }
                        _play_button.hide();
                        _record_button.hide();
                        _stop_button.show();
                        if _audio_input_switch.is_active() {
                            match _ffmpeg_record_interface.borrow_mut().start_input_audio() {
                                Ok(_) => {
                                    // Do nothing
                                },
                                Err(error) => {
                                    _audio_input_switch.set_sensitive(true);
                                    _audio_output_switch.set_sensitive(true);
                                    _video_switch.set_sensitive(true);
                                    _record_button.show();
                                    _stop_button.hide();
                                    let text_buffer = TextBuffer::new(None);
                                    text_buffer.set_text(&format!("{}", error));
                                    _error_message.set_buffer(Some(&text_buffer));
                                    _error_dialog.show();
                                },
                            }
                        }
                        if _audio_output_switch.is_active() {
                            match _ffmpeg_record_interface.borrow_mut().start_output_audio() {
                                Ok(_) => {
                                    // Do nothing
                                },
                                Err(error) => {
                                    _audio_input_switch.set_sensitive(true);
                                    _audio_output_switch.set_sensitive(true);
                                    _video_switch.set_sensitive(true);
                                    _record_button.show();
                                    _stop_button.hide();
                                    let text_buffer = TextBuffer::new(None);
                                    text_buffer.set_text(&format!("{}", error));
                                    _error_message.set_buffer(Some(&text_buffer));
                                    _error_dialog.show();
                                },
                            }
                        }
                        if _video_switch.is_active() {
                            match _ffmpeg_record_interface.borrow_mut().start_video(
                                _area_capture.x,
                                _area_capture.y,
                                _area_capture.width,
                                _area_capture.height,
                                mode
                            ) {
                                Ok(_) => {
                                    // Do nothing
                                },
                                Err(error) => {
                                    _audio_input_switch.set_sensitive(true);
                                    _audio_output_switch.set_sensitive(true);
                                    _video_switch.set_sensitive(true);
                                    _record_button.show();
                                    _stop_button.hide();
                                    let text_buffer = TextBuffer::new(None);
                                    text_buffer.set_text(&format!("{}", error));
                                    _error_message.set_buffer(Some(&text_buffer));
                                    _error_dialog.show();
                                },
                            }
                        }
                    }
                }
            },
        }
    });

    // Stop record button
    stop_button.set_tooltip_text(Some(&get_bundle("stop-tooltip", None)));
    stop_label.set_label(&get_bundle("stop-recording", None));
    let _audio_input_switch = audio_input_switch.clone();
    let _error_dialog = error_dialog.clone();
    let _error_message = error_message.clone();
    let _play_button = play_button.clone();
    let _audio_output_switch = audio_output_switch.clone();
    let _stop_button = stop_button.clone();
    let _video_switch = video_switch.clone();
    let mut _ffmpeg_record_interface = ffmpeg_record_interface.clone();
    stop_button.connect_clicked(move |_| {
        _record_time_label.set_visible(false);
        stop_timer(_record_time_label.clone());
        if _audio_input_switch.is_active() {
            match _ffmpeg_record_interface.borrow_mut().stop_input_audio() {
                Ok(_) => {
                    // Do nothing
                    },
                Err(error) => {
                    _audio_input_switch.set_sensitive(true);
                    _audio_output_switch.set_sensitive(true);
                    _video_switch.set_sensitive(true);
                    record_button.show();
                    _stop_button.hide();
                    let text_buffer = TextBuffer::new(None);
                    text_buffer.set_text(&format!("{}", error));
                    _error_message.set_buffer(Some(&text_buffer));
                    _error_dialog.show();
                },
            }
        }
        if _audio_output_switch.is_active() {
            match _ffmpeg_record_interface.borrow_mut().stop_output_audio() {
                Ok(_) => {
                    // Do nothing
                    },
                Err(error) => {
                    _audio_input_switch.set_sensitive(true);
                    _audio_output_switch.set_sensitive(true);
                    _video_switch.set_sensitive(true);
                    record_button.show();
                    _stop_button.hide();
                    let text_buffer = TextBuffer::new(None);
                    text_buffer.set_text(&format!("{}", error));
                    _error_message.set_buffer(Some(&text_buffer));
                    _error_dialog.show();
                },
            }
        }
        if _video_switch.is_active() {
            match _ffmpeg_record_interface.borrow_mut().stop_video() {
                Ok(_) => {
                    // Do nothing
                },
                Err(error) => {
                    _audio_input_switch.set_sensitive(true);
                    _audio_output_switch.set_sensitive(true);
                    _video_switch.set_sensitive(true);
                    record_button.show();
                    _stop_button.hide();
                    let text_buffer = TextBuffer::new(None);
                    text_buffer.set_text(&format!("{}", error));
                    _error_message.set_buffer(Some(&text_buffer));
                    _error_dialog.show();
                },
            }
        }
        _audio_input_switch.set_sensitive(true);
        _audio_output_switch.set_sensitive(true);
        _video_switch.set_sensitive(true);
        record_button.show();
        _stop_button.hide();
        let file_name = _ffmpeg_record_interface.borrow_mut().saved_filename.clone();
        if Path::new(&file_name).try_exists().is_ok() {
            _play_button.show();
            _play_button.set_tooltip_text(Some(&get_bundle("play-tooltip", None)));
        } else  {
            _play_button.show();
            _play_button.set_sensitive(false);
            _play_button.set_tooltip_text(Some(&get_bundle("play-inactive-tooltip", None)));
        }
    });

    // Delay window button
    let _delay_window_button = delay_window_button.clone();
    delay_window_button.connect_clicked(move |_| {});

    // Play button
    let _error_dialog = error_dialog.clone();
    let _error_message = error_message.clone();
    let mut _ffmpeg_record_interface = ffmpeg_record_interface.clone();
    play_button.connect_clicked(move |_| {
        let file_name = _ffmpeg_record_interface.borrow_mut().saved_filename.clone();
        match play_record(&file_name) {
            Ok(_) => {
                // Do nothing
            },
            Err(error) => {
                let text_buffer = TextBuffer::new(None);
                text_buffer.set_text(&format!("{}", error));
                _error_message.set_buffer(Some(&text_buffer));
                _error_dialog.show();
            },
        }
    });

    // About dialog
    let mut about_icon_path = {
        let mut current_exec_dir = std::env::current_exe().unwrap();
        current_exec_dir.pop();
        current_exec_dir
    }
    .join(Path::new("data/blue-recorder.svg"));

    if !about_icon_path.exists() {
        about_icon_path = std::fs::canonicalize(Path::new(
            &std::env::var("DATA_DIR")
                .unwrap_or_else(|_| String::from("data/"))
                .add("blue-recorder.svg"),
        ))
        .unwrap();
    }

    about_dialog.set_comments(Some(&get_bundle("dialog-comment", None)));
    about_dialog.set_copyright(Some(&get_bundle("copy-right", None)));
    about_dialog.set_license(Some(&get_bundle("license", None)));
    let logo = Image::from_file(&about_icon_path.to_str().unwrap());
    about_dialog.set_logo(logo.paintable().as_ref());
    about_dialog.set_modal(true);
    about_dialog.set_program_name(Some(&get_bundle("blue-recorder", None)));
    about_dialog.set_transient_for(Some(&main_window));
    about_dialog.set_version(Some("0.3.0"));
    about_dialog.set_website(Some("https://github.com/xlmnxp/blue-recorder/"));
    about_dialog.set_website_label(&get_bundle("website", None));
    about_dialog.set_wrap_license(true);
    // Authors
    about_dialog.add_credit_section(
        &get_bundle("authors", None),
        &[&get_bundle("address-abdullah-al-baroty", None),
          &get_bundle("address-alessandro-toia", None),
          &get_bundle("address-chibani", None),
          &get_bundle("address-hamir-mahal", None),
          &get_bundle("address-hanny-sabbagh", None),
          &get_bundle("address-salem-yaslem", None),
          &get_bundle("address-suliman-altassan", None),
        ]
    );
    // Patreon suppoters
    about_dialog.add_credit_section(
        &get_bundle("patreon", None),
        &[&get_bundle("address-ahmad-gharib", None),
          &get_bundle("address-medium", None),
          &get_bundle("address-william-grunow", None),
          &get_bundle("address-alex-benishek", None),
        ]
    );
    // Designers
    about_dialog.add_credit_section(
        &get_bundle("design", None),
        &[&get_bundle("address-abdullah-al-baroty", None),
          &get_bundle("address-mustapha-assabar", None),
        ]
    );
    // Translators
    about_dialog.add_credit_section(
        &get_bundle("translate", None),
        &[&get_bundle("address-ake-engelbrektson", None),
          &get_bundle("address-amerey", None),
          &get_bundle("address-gmou3", None),
          &get_bundle("address-larry-wei", None),
          &get_bundle("address-mark-wagie", None),
          &get_bundle("address-albanobattistella", None),
          &get_bundle("address-mr-Narsus", None),
       ]
    );

    // Windows
    // Hide area chooser after it deleted.
    let _area_chooser_window = area_chooser_window.clone();
    area_chooser_window.connect_close_request(move |_| {
        _area_chooser_window.hide();
        adw::gtk::Inhibit(true)
    });

    // Stop recording before close the application
    let mut _ffmpeg_record_interface = ffmpeg_record_interface.clone();
    main_window.connect_close_request(move |main_window| {
        _ffmpeg_record_interface.borrow_mut().kill().unwrap();
        main_window.destroy();
        adw::gtk::Inhibit(true)
    });

    // Apply CSS
    let display = adw::gdk::Display::default().unwrap();
    let provider = CssProvider::new();
    provider.load_from_data(include_str!("styles/global.css").as_bytes());
    adw::gtk::StyleContext::add_provider_for_display(
        &display,
        &provider,
        adw::gtk::STYLE_PROVIDER_PRIORITY_APPLICATION,
    );

    main_window.show();

    Ok(())
}