first commit

src/controller.rs

@@ -0,0 +1,47 @@
+use gtk4 as gtk;
+
+use gtk::prelude::*;
+use super::switch::*;
+
+pub struct EventHandler<F, C>{
+    component: C,
+    callback: F,
+}
+
+impl<F, C> EventHandler<F, C>
+where F: Fn(&C) + FnOnce(&C) + FnMut(&C){
+    pub fn new(component: C, callback: F) -> EventHandler<F, C>{
+        Self{
+            component,
+            callback,
+        }
+    }
+}
+
+pub trait BtnEventHandler{
+    fn on_click(self) -> ();
+}
+
+pub trait SwEventHandler{
+    fn on_toggle(self) -> ();
+}
+
+impl<F, C> BtnEventHandler for EventHandler<F, C>
+    where F: Fn(&C) + FnOnce(&C) + FnMut(&C) + 'static, C: ButtonExt + WidgetExt{
+    fn on_click(self) -> () {
+        self.component.connect_clicked(move |button| {
+            (self.callback)(button)
+        });
+    }
+}
+
+impl<F, C> SwEventHandler for EventHandler<F, C>
+    where F: Fn(&C) + FnOnce(&C) + FnMut(&C) + 'static, C: SwitchExt + WidgetExt{
+    fn on_toggle(self) -> () {
+        self.component.connect_state_notify(move |switch| {
+            (self.callback)(switch)
+        });
+    }
+}
+
+

src/main.rs

@@ -1,53 +1,33 @@
-mod graph {
+use gtk4 as gtk;
 
-    use std::collections::{HashMap, HashSet};
-    use std::vec::Vec;
+use gtk::*;
+use view::*;
+use gtk::prelude::*;
 
-    pub struct Graph {
-        frame_graph : HashMap<u32, Vec<u32>>,
-        flags_graph : HashSet<(u32, bool)>
-    }
+#[path="ui_src/components/switch.rs"]
+mod switch;
 
-    impl Graph {
+#[path="ui_src/components/wrapper.rs"]
+mod wrapper;
 
-        pub fn new() -> Graph {
-            Graph{
-                frame_graph : HashMap::new(),
-                flags_graph : HashSet::new(),
-            }
-        }
+#[path="ui_src/properties.rs"]
+mod properties;
 
-        pub fn add(&mut self, parent : u32, children : Vec<u32>){
+#[path="utils/parse_input.rs"]
+mod parse_input;
 
-            self.frame_graph.insert(parent, children);
-            self.flags_graph.insert((parent, false));
-            for &i in self.frame_graph.get(&parent).unwrap() {
-                self.flags_graph.insert((i, false));
-            }
+#[path="utils/state_controller.rs"]
+mod state_controller;
 
-        }
+mod view;
+mod model;
+mod controller;
 
-        pub fn get(&self) -> &Graph {
-            self.clone()
-        }
-
-    }
-}
-
-mod new_class{
-
-    use super::graph;
-
-}
-
-
-fn main(){
-
-    use crate::graph::Graph;
-
-    let mut graph : Graph = Graph::new();
-    graph.add(1, vec![2, 3, 4]);
-    graph.add(2, vec![9, 7, 6, 1]);
-    graph.add(6, vec![12, 11, 19]);
+fn main() {
+    let app = Application::builder()
+        .application_id("com.github.gtk-rs.examples.basic")
+        .build();
 
+    app.connect_activate(ui);
+    app.run();
 }

src/model.rs

@@ -0,0 +1,61 @@
+use std::ops::Deref;
+use bitvec::prelude::{AsBits};
+use crate::model::processing_input::processing_input;
+use crate::model::check_correct_input::check_correct_input;
+use crate::model::from_string_to_vec_bits::from_string_to_vec_bits;
+use crate::model::hamming_code::hamming_code::hamming_decrypt_data;
+use crate::model::hamming_code::hamming_code::hamming_encrypt_data;
+
+#[path="utils/model_utils/processing_input.rs"]
+mod processing_input;
+
+#[path="utils/model_utils/check_correct_input.rs"]
+mod check_correct_input;
+
+#[path="utils/model_utils/from_string_to_vec_bits.rs"]
+mod from_string_to_vec_bits;
+
+#[path="utils/hamming_code_utils/hamming_code_seven_four.rs"]
+mod hamming_code;
+
+pub enum HammingMode{
+    Encrypt,
+    Decrypt
+}
+
+// ошибочная позиция 1 false true true
+// ошибочная позиция 2 false false true
+// ошибочная позиция 3 true false true
+// ошибочная позиция 4 false true false
+// ошибочная позиция 5 true true false
+// ошибочная позиция 6 true false false
+// ошибочная позиция 7 false false false
+
+pub fn hamming(raw_input: String, mode: HammingMode) -> Result<String, String>{
+
+    let length_of_code : usize = if let HammingMode::Encrypt = mode { 4 } else { 7 };
+
+    let prepared_input : String = processing_input(&raw_input);
+
+    let (fc, sc) = check_correct_input(&raw_input, &prepared_input, length_of_code);
+
+    if !fc || !sc {
+
+        Err("Ошибка. Проверьте корректность ввода.".to_string())
+
+    } else {
+
+        let mut data : String = String::new();
+
+        let prepared_data: Vec<u8> = from_string_to_vec_bits(prepared_input);
+
+        match mode {
+            HammingMode::Encrypt => hamming_encrypt_data(&prepared_data, &mut data, length_of_code),
+            HammingMode::Decrypt => hamming_decrypt_data(&prepared_data, &mut data, length_of_code),
+        }
+
+        return Ok(data);
+
+    }
+}
+

src/ui_src/components/switch.rs

@@ -0,0 +1,152 @@
+use gtk4 as gtk;
+
+use gtk::*;
+use gtk::prelude::*;
+
+use glib::{
+    signal::{connect_raw, SignalHandlerId},
+    translate::*,
+};
+use std::boxed::Box as Box_;
+
+mod wrapper;
+
+mod sealed {
+    pub trait Sealed {}
+    impl<T: super::IsA<super::Switch>> Sealed for T {}
+}
+
+pub trait SwitchExt: IsA<Switch> + sealed::Sealed + 'static {
+    #[doc(alias = "gtk_switch_get_active")]
+    #[doc(alias = "get_active")]
+    fn is_active(&self) -> bool {
+        unsafe { from_glib(ffi::gtk_switch_get_active(self.as_ref().to_glib_none().0)) }
+    }
+
+    #[doc(alias = "gtk_switch_get_state")]
+    #[doc(alias = "get_state")]
+    fn state(&self) -> bool {
+        unsafe { from_glib(ffi::gtk_switch_get_state(self.as_ref().to_glib_none().0)) }
+    }
+
+    #[doc(alias = "gtk_switch_set_active")]
+    fn set_active(&self, is_active: bool) {
+        unsafe {
+            ffi::gtk_switch_set_active(self.as_ref().to_glib_none().0, is_active.into_glib());
+        }
+    }
+
+    #[doc(alias = "gtk_switch_set_state")]
+    fn set_state(&self, state: bool) {
+        unsafe {
+            ffi::gtk_switch_set_state(self.as_ref().to_glib_none().0, state.into_glib());
+        }
+    }
+
+    #[doc(alias = "activate")]
+    fn connect_activate<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
+        unsafe extern "C" fn activate_trampoline<P: IsA<Switch>, F: Fn(&P) + 'static>(
+            this: *mut ffi::GtkSwitch,
+            f: glib::ffi::gpointer,
+        ) {
+            let f: &F = &*(f as *const F);
+            f(Switch::from_glib_borrow(this).unsafe_cast_ref())
+        }
+        unsafe {
+            let f: Box_<F> = Box_::new(f);
+            connect_raw(
+                self.as_ptr() as *mut _,
+                b"activate\0".as_ptr() as *const _,
+                Some(std::mem::transmute::<_, unsafe extern "C" fn()>(
+                    activate_trampoline::<Self, F> as *const (),
+                )),
+                Box_::into_raw(f),
+            )
+        }
+    }
+
+    fn emit_activate(&self) {
+        self.emit_by_name::<()>("activate", &[]);
+    }
+
+    #[doc(alias = "state-set")]
+    fn connect_state_set<F: Fn(&Self, bool) -> glib::Propagation + 'static>(
+        &self,
+        f: F,
+    ) -> SignalHandlerId {
+        unsafe extern "C" fn state_set_trampoline<
+            P: IsA<Switch>,
+            F: Fn(&P, bool) -> glib::Propagation + 'static,
+        >(
+            this: *mut ffi::GtkSwitch,
+            state: glib::ffi::gboolean,
+            f: glib::ffi::gpointer,
+        ) -> glib::ffi::gboolean {
+            let f: &F = &*(f as *const F);
+            f(
+                Switch::from_glib_borrow(this).unsafe_cast_ref(),
+                from_glib(state),
+            )
+                .into_glib()
+        }
+        unsafe {
+            let f: Box_<F> = Box_::new(f);
+            connect_raw(
+                self.as_ptr() as *mut _,
+                b"state-set\0".as_ptr() as *const _,
+                Some(std::mem::transmute::<_, unsafe extern "C" fn()>(
+                    state_set_trampoline::<Self, F> as *const (),
+                )),
+                Box_::into_raw(f),
+            )
+        }
+    }
+
+    #[doc(alias = "active")]
+    fn connect_active_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
+        unsafe extern "C" fn notify_active_trampoline<P: IsA<Switch>, F: Fn(&P) + 'static>(
+            this: *mut ffi::GtkSwitch,
+            _param_spec: glib::ffi::gpointer,
+            f: glib::ffi::gpointer,
+        ) {
+            let f: &F = &*(f as *const F);
+            f(Switch::from_glib_borrow(this).unsafe_cast_ref())
+        }
+        unsafe {
+            let f: Box_<F> = Box_::new(f);
+            connect_raw(
+                self.as_ptr() as *mut _,
+                b"notify::active\0".as_ptr() as *const _,
+                Some(std::mem::transmute::<_, unsafe extern "C" fn()>(
+                    notify_active_trampoline::<Self, F> as *const (),
+                )),
+                Box_::into_raw(f),
+            )
+        }
+    }
+
+    #[doc(alias = "state")]
+    fn connect_state_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
+        unsafe extern "C" fn notify_state_trampoline<P: IsA<Switch>, F: Fn(&P) + 'static>(
+            this: *mut ffi::GtkSwitch,
+            _param_spec: glib::ffi::gpointer,
+            f: glib::ffi::gpointer,
+        ) {
+            let f: &F = &*(f as *const F);
+            f(Switch::from_glib_borrow(this).unsafe_cast_ref())
+        }
+        unsafe {
+            let f: Box_<F> = Box_::new(f);
+            connect_raw(
+                self.as_ptr() as *mut _,
+                b"notify::state\0".as_ptr() as *const _,
+                Some(std::mem::transmute::<_, unsafe extern "C" fn()>(
+                    notify_state_trampoline::<Self, F> as *const (),
+                )),
+                Box_::into_raw(f),
+            )
+        }
+    }
+}
+
+impl<O: IsA<Switch>> SwitchExt for O {}

src/ui_src/components/wrapper.rs

@@ -0,0 +1,20 @@
+use gtk4 as gtk;
+
+use gtk::Orientation;
+use gtk::builders::BoxBuilder;
+use gtk::Box;
+
+#[allow(dead_code)]
+pub struct Wrapper;
+
+impl Wrapper{
+
+    pub fn row_builder() -> BoxBuilder {
+        Box::builder().orientation(Orientation::Vertical)
+    }
+
+    pub fn col_builder() -> BoxBuilder {
+        Box::builder().orientation(Orientation::Horizontal)
+    }
+
+}

src/ui_src/properties.rs

@@ -0,0 +1,118 @@
+use gtk4 as gtk;
+
+use gtk::{Align};
+use gtk::builders::*;
+
+/**
+ * Types
+ */
+
+pub type Margin = (i32, i32, i32, i32);
+
+/**
+ * Enums
+ */
+
+pub enum MarginData{
+    EqualsMargin(i32),
+    MultipleMargin(Margin),
+}
+
+/**
+ * Structs
+ */
+
+#[allow(dead_code)]
+
+pub struct Size {
+    pub width: i32,
+    pub height: i32
+}
+
+pub struct Alignment {
+    pub horizontal: Align,
+    pub vertical : Align
+}
+
+/**
+ * Traits
+ */
+
+pub trait Setters{
+    fn set_margin(self, margin: MarginData) -> Self;
+    fn set_align(self, align: Alignment) -> Self;
+}
+
+pub trait TextViewSetters{
+    fn set_text_view_margin(self, margin: MarginData) -> Self;
+}
+
+impl TextViewSetters for TextViewBuilder{
+    fn set_text_view_margin(self, margin: MarginData) -> Self{
+        match margin{
+            MarginData::EqualsMargin(margin) =>
+                self.top_margin(margin)
+                    .left_margin(margin)
+                    .bottom_margin(margin)
+                    .right_margin(margin),
+            MarginData::MultipleMargin(margins) =>
+                self.top_margin(margins.0)
+                    .left_margin(margins.1)
+                    .bottom_margin(margins.2)
+                    .right_margin(margins.3),
+        }
+    }
+}
+
+/**
+ * Macros
+ */
+
+macro_rules! impl_setters {
+    ($($t:ty),+) => {
+        $(
+            impl Setters for $t {
+                fn set_margin(self, margin: MarginData) -> Self{
+                    match margin{
+                        MarginData::EqualsMargin(margin) =>
+                            self.margin_top(margin)
+                                .margin_start(margin)
+                                .margin_bottom(margin)
+                                .margin_end(margin),
+                        MarginData::MultipleMargin(margins) =>
+                            self.margin_top(margins.0)
+                                .margin_start(margins.1)
+                                .margin_bottom(margins.2)
+                                .margin_end(margins.3),
+                    }
+                }
+                fn set_align(self, align: Alignment) -> Self {
+                    self.halign(align.horizontal)
+                        .valign(align.vertical)
+                }
+            }
+        )*
+    }
+}
+
+impl_setters!{ButtonBuilder, EntryBuilder, TextViewBuilder,
+    BoxBuilder, SwitchBuilder, FrameBuilder, LabelBuilder}
+
+#[allow(dead_code)]
+impl Size{
+    pub fn new(w: i32, h: i32) -> Size{
+        Size{
+            width: w,
+            height: h,
+        }
+    }
+}
+
+impl Alignment{
+    pub fn new(horizontal: Align, vertical : Align) -> Alignment{
+        Alignment{
+            horizontal,
+            vertical,
+        }
+    }
+}

src/utils/hamming_code_utils/hamming_code_seven_four.rs

@@ -0,0 +1,106 @@
+// ошибочная позиция 1 false true true
+// ошибочная позиция 2 false false true
+// ошибочная позиция 3 true false true
+// ошибочная позиция 4 false true false
+// ошибочная позиция 5 true true false
+// ошибочная позиция 6 true false false
+// ошибочная позиция 7 false false false
+
+pub mod hamming_code{
+    use std::borrow::Borrow;
+    use std::collections::HashMap;
+
+    pub fn hamming_encrypt_data(data: &Vec<u8>, result_string: &mut String, length_of_code: usize) -> () {
+        let mut i : usize = length_of_code;
+
+        while i <= data.len(){
+
+            let data_bits = &data[i - length_of_code..i];
+            let (check_bit_1, check_bit_2, check_bit_3) = (
+                data_bits[0] ^ data_bits[1] ^ data_bits[3],
+                data_bits[0] ^ data_bits[2] ^ data_bits[3],
+                data_bits[1] ^ data_bits[2] ^ data_bits[3]
+            );
+            result_string.push_str(&*format!("{check_bit_1}{}{check_bit_2}{}{check_bit_3}{}{} ",
+                                             data_bits[0],
+                                             data_bits[1],
+                                             data_bits[2],
+                                             data_bits[3]));
+            i += length_of_code;
+
+        }
+    }
+
+    pub fn hamming_decrypt_data(data: &Vec<u8>, result_string: &mut String, length_of_code: usize) -> () {
+        let mut i : usize = length_of_code;
+
+        let syndromes : HashMap<usize, (bool, bool, bool)> = HashMap::from(
+            [
+                (1, (false, true, true)),
+                (2, (false, false, true)),
+                (3, (true, false, true)),
+                (4, (false, true, false)),
+                (5, (true, true, false)),
+                (6, (true, false, false)),
+                (7, (false, false, false)),
+            ]
+        );
+
+        let mut errors : String = String::new();
+
+        while i <= data.len(){
+
+            let mut data_bits = &data[i - length_of_code..i];
+
+            let checked_bits : (bool, bool, bool) =
+                (
+                    (data_bits[1] ^ data_bits[3] ^ data_bits[6]) == data_bits[0],
+                    (data_bits[1] ^ data_bits[5] ^ data_bits[6]) == data_bits[2],
+                    (data_bits[3] ^ data_bits[5] ^ data_bits[6]) == data_bits[4]
+                );
+
+            match checked_bits {
+                (true, true, true) => {
+                    i += length_of_code;
+                    continue;
+                },
+                _ => {
+
+                    let error_position = syndromes
+                        .iter()
+                        .find(move |&(&error_position, &error)| error == checked_bits).
+                        unwrap().0;
+
+                    let correctly_code : Vec<u8> = data_bits
+                        .iter()
+                        .enumerate()
+                        .map(|(index, bit)| {
+                        if index == error_position - 1 {
+                            if *bit == 1u8 { 0u8 } else { 1u8 }
+                        } else {
+                            *bit
+                        }
+                    }).collect();
+
+                    let error = format!("Ошибка в коде {} {:?}, позиция ошибки {}, корректный код: {:?}; \n",
+                                    i / 7,
+                                    &data_bits,
+                                    error_position,
+                                    correctly_code
+                    );
+
+                    errors.push_str(error.as_str());
+
+                    i += length_of_code;
+
+                }
+            }
+        }
+
+        if errors.len() == 0 {
+            result_string.push_str("Все коды корректны.");
+        } else {
+            result_string.push_str(errors.as_str())
+        }
+    }
+}

src/utils/model_utils/check_correct_input.rs

@@ -0,0 +1,11 @@
+pub fn check_correct_input(input: &String, prepared_input: &String, l: usize) -> (bool, bool){
+
+    let first_condition = input
+        .chars()
+        .all(|c| {c == '1' || c == '0' || c == ' '});
+
+    let second_condition = prepared_input.len() % l == 0;
+
+    (first_condition, second_condition)
+
+}

src/utils/model_utils/from_string_to_vec_bits.rs

@@ -0,0 +1,14 @@
+use std::ops::Deref;
+use bitvec::order::Lsb0;
+use bitvec::prelude::AsBits;
+
+pub fn from_string_to_vec_bits(raw_data: String) -> Vec<u8>{
+
+    raw_data
+        .as_bits::<Lsb0>()
+        .iter()
+        .step_by(8)
+        .map(|x| *x.deref() as u8)
+        .collect()
+
+}

src/utils/model_utils/processing_input.rs

@@ -0,0 +1,10 @@
+pub fn processing_input(input : &String) -> String {
+
+    input
+        .split_ascii_whitespace()
+        .filter(|&x| {
+            x != ""
+        })
+        .fold(String::new(), |c: String, n: &str| { c + n })
+
+}

src/utils/parse_input.rs

@@ -0,0 +1,29 @@
+use gtk4 as gtk;
+
+use gtk::*;
+use gtk::prelude::*;
+use super::model::*;
+
+pub fn parse_input(input : &TextView, output : &TextView, mode: bool) -> (){
+
+    let (iter_start, iter_end) = input.buffer().bounds();
+    let parsed_input : String = input
+        .buffer()
+        .text(&iter_start, &iter_end, false)
+        .to_string()
+        .trim()
+        .parse()
+        .unwrap();
+
+    let operation = if mode == false {
+        HammingMode::Encrypt
+    } else {
+        HammingMode::Decrypt
+    };
+
+    match hamming(parsed_input, operation) {
+        Ok(res) => output.buffer().set_text(res.trim_end()),
+        Err(rej) => output.buffer().set_text(rej.as_str()),
+    }
+
+}

src/utils/state_controller.rs

@@ -0,0 +1,7 @@
+use gtk4 as gtk;
+use gtk::*;
+
+pub fn state_controller(switch: &Switch, label: &Label) -> (){
+    if switch.state() == true { label.set_label("Режим: проверка"); }
+    else { label.set_label("Режим: кодирование"); }
+}

src/view.rs

@@ -0,0 +1,151 @@
+use gtk4 as gtk;
+
+use gtk::*;
+use gtk::prelude::*;
+use super::wrapper::*;
+use super::controller::*;
+use super::parse_input::parse_input;
+use super::state_controller::state_controller;
+use super::properties::{MarginData, Setters, TextViewSetters, Alignment};
+
+fn clearing(output : &TextView, input: &TextView){
+    input.buffer().set_text("");
+    output.buffer().set_text("");
+}
+
+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 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 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();
+
+    // actions
+
+    EventHandler::new(
+        hamming_crypt_button.clone(),
+        move |_| {
+            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| {
+            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();
+
+    // separators
+
+    let separator = Separator::builder()
+        .orientation(Orientation::Horizontal)
+        .build();
+
+    crypt_mode_wrapper.append(&crypt_mode_switch);
+    crypt_mode_wrapper.append(&crypt_mode_label);
+
+    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);
+    wrapper.append(&separator);
+
+}
+
+pub fn ui(application: &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 window = ApplicationWindow::builder()
+        .title("Комплексная программа для лаб. работ")
+        .width_request(650)
+        .height_request(400)
+        .application(application)
+        .child(&mutual_wrapper)
+        .build();
+
+    window.show();
+}