AIT/src/view/view.rs

use gtk4 as gtk;

use gtk::{*, prelude::*};
use gtk4::StackTransitionType::SlideLeftRight;

use crate::{
    model::model::*,
    view::{
        properties::*,
        components::{
            *,
            tabs::*,
            switch::*,
            wrapper::*,
        }
    },
    controller::{
        controller::*,
        view_utils::input_utils::*,
        event_handlers::{
            button_event_handlers::*,
            switch_event_handlers::*,
        },
    }
};
use crate::view::components::pages::Pages;

pub fn laboratory_work_first_section(wrapper: &Box) -> (){

    // input

    let hamming_text_view_input_label = Label::builder()
        .halign(Align::Start)
        .set_margin(MarginData::MultipleMargin((10, 5, 0, 0)))
        .label(String::from("Поле ввода для кода:"))
        .build();

    let hamming_text_view_input = TextView::builder()
        .monospace(true)
        .set_text_view_margin(MarginData::EqualsMargin(6))
        .wrap_mode(WrapMode::Word)
        .build();

    let hamming_text_view_input_frame = Frame::builder()
        .child(&hamming_text_view_input)
        .height_request(64)
        .set_margin(MarginData::MultipleMargin((0, 5, 0, 5)))
        .build();

    // output

    let hamming_text_view_output_label = Label::builder()
        .halign(Align::Start)
        .set_margin(MarginData::MultipleMargin((10, 5, 0, 0)))
        .label(String::from("Результат:"))
        .build();

    let hamming_text_view_output = TextView::builder()
        .monospace(true)
        .editable(false)
        .set_text_view_margin(MarginData::EqualsMargin(6))
        .wrap_mode(WrapMode::Word)
        .build();

    let hamming_text_view_output_frame = Frame::builder()
        .child(&hamming_text_view_output)
        .height_request(64)
        .set_margin(MarginData::MultipleMargin((0, 5, 0, 5)))
        .build();

    // interactive panel

    let clear_input_button =
        Button::builder()
            .set_align(Alignment::new(Align::Fill, Align::Fill))
            .label("Очистка полей")
            .build();

    let hamming_crypt_button = Button::builder()
        .set_align(Alignment::new(Align::Fill, Align::Fill))
        .label("Выполнить")
        .build();

    let crypt_mode_switch = Switch::new();

    let crypt_mode_label = Label::builder()
        .label("Режим: кодирование")
        .build();

    // references for binding actions

    let clear_input_button_to_handle = clear_input_button.clone();

    let crypt_mode_label_to_handle = crypt_mode_label.clone();
    let crypt_mode_switch_to_handle = crypt_mode_switch.clone();

    let text_view_input_for_parse = hamming_text_view_input.clone();
    let text_view_output_for_output = hamming_text_view_output.clone();

    let text_view_input_for_clearing = hamming_text_view_input.clone();
    let text_view_output_for_clearing = hamming_text_view_input.clone();

    // actions

    EventHandler::new(
        clear_input_button_to_handle,
        move |_| {
            clearing(&text_view_input_for_clearing, &text_view_output_for_clearing);
        }
    ).on_click();

    EventHandler::new(
        hamming_crypt_button.clone(),
        move |button: &Button| {
            parse_input(
                &text_view_input_for_parse,
                &text_view_output_for_output,
                crypt_mode_switch_to_handle.state()
            )
        }).on_click();

    EventHandler::new(
        crypt_mode_switch.clone(),
        move |s : &Switch| {
            state_controller(s, &crypt_mode_label_to_handle);
        }).on_toggle();

    // wrappers

    let crypt_mode_wrapper = Wrapper::col_builder()
        .set_align(Alignment::new(Align::Fill, Align::Center))
        .hexpand(true)
        .spacing(10)
        .build();

    let interactive_components_wrapper = Wrapper::col_builder()
        .set_align(Alignment::new(Align::Fill, Align::Fill))
        .set_margin(MarginData::MultipleMargin((0, 5, 0, 5)))
        .spacing(10)
        .build();

    crypt_mode_wrapper.append(&crypt_mode_switch);
    crypt_mode_wrapper.append(&crypt_mode_label);

    interactive_components_wrapper.append(&clear_input_button);
    interactive_components_wrapper.append(&crypt_mode_wrapper);
    interactive_components_wrapper.append(&hamming_crypt_button);

    wrapper.append(&hamming_text_view_input_label);
    wrapper.append(&hamming_text_view_input_frame);
    wrapper.append(&interactive_components_wrapper);
    wrapper.append(&hamming_text_view_output_label);
    wrapper.append(&hamming_text_view_output_frame);

}

pub fn ui(application: &adw::Application) {

    let mutual_wrapper = Wrapper::row_builder()
        .set_align(Alignment::new(Align::Fill, Align::Fill))
        .set_margin(MarginData::EqualsMargin(15))
        .spacing(10)
        .build();

    laboratory_work_first_section(&mutual_wrapper);

    let second_wrapper = Wrapper::row_builder()
        .set_align(Alignment::new(Align::Fill, Align::Fill))
        .set_margin(MarginData::EqualsMargin(15))
        .spacing(10)
        .build();

    second_wrapper.append(&Label::new(Some("Код Хафмана")));

    let pages = Pages::builder()
        .set_transition(SlideLeftRight, 200)
        .add_pages(vec![
            ("Код Хэмминга", "Код Хэмминга", &mutual_wrapper),
            ("Код Хафмана", "Код Хафмана", &second_wrapper)
        ])
        .build(5)
        .get();

    let window = ApplicationWindow::builder()
        .title("Комплексная программа для лаб. работ")
        .width_request(650)
        .height_request(400)
        .application(application)
        .child(&pages)
        .build();

    window.show();
}