Struct GridLayoutItem

Source

pub struct GridLayoutItem {
    pub col: u32,
    pub row: u32,
    pub col_span: u32,
    pub row_span: u32,
    /* private fields */
}

Expand description

A control item in a GridLayout

Fields§

§col: u32

The column position of the control in the layout

§row: u32

The row position of the control in the layout

§col_span: u32

The number column this item should span. Should be 1 for single column item.

§row_span: u32

The number row this item should span. Should be 1 for single row item.

Implementations§

Source §

impl GridLayoutItem

Source

pub fn new<W: Into<ControlHandle>>( c: W, col: u32, row: u32, col_span: u32, row_span: u32, ) -> GridLayoutItem

Initialize a new grid layout item

Examples found in repository ?

examples/basic_barebone.rs (line 45)

12fn main() {
13    nwg::init().expect("Failed to init Native Windows GUI");
14    nwg::Font::set_global_family("Segoe UI").expect("Failed to set default font");
15
16    let mut window = Default::default();
17    let mut name_edit = Default::default();
18    let mut hello_button = Default::default();
19    let layout = Default::default();
20
21    nwg::Window::builder()
22        .size((300, 115))
23        .position((300, 300))
24        .title("Basic example")
25        .build(&mut window)
26        .unwrap();
27
28    nwg::TextInput::builder()
29        .text("Heisenberg")
30        .focus(true)
31        .parent(&window)
32        .build(&mut name_edit)
33        .unwrap();
34
35    nwg::Button::builder()
36        .text("Say my name")
37        .parent(&window)
38        .build(&mut hello_button)
39        .unwrap();
40
41    nwg::GridLayout::builder()
42        .parent(&window)
43        .spacing(1)
44        .child(0, 0, &name_edit)
45        .child_item(nwg::GridLayoutItem::new(&hello_button, 0, 1, 1, 2))
46        .build(&layout)
47        .unwrap();
48
49    let window = Rc::new(window);
50    let events_window = window.clone();
51
52    let handler = nwg::full_bind_event_handler(&window.handle, move |evt, _evt_data, handle| {
53        use nwg::Event as E;
54
55        match evt {
56            E::OnWindowClose => {
57                if &handle == &events_window as &nwg::Window {
58                    nwg::modal_info_message(
59                        &events_window.handle,
60                        "Goodbye",
61                        &format!("Goodbye {}", name_edit.text()),
62                    );
63                    nwg::stop_thread_dispatch();
64                }
65            }
66            E::OnButtonClick => {
67                if &handle == &hello_button {
68                    nwg::modal_info_message(
69                        &events_window.handle,
70                        "Hello",
71                        &format!("Hello {}", name_edit.text()),
72                    );
73                }
74            }
75            _ => {}
76        }
77    });
78
79    nwg::dispatch_thread_events();
80    nwg::unbind_event_handler(&handler);
81}

More examples

Hide additional examples

examples/basic_layout.rs (line 110)

52        fn build_ui(mut data: BasicApp) -> Result<BasicAppUi, nwg::NwgError> {
53            use nwg::Event as E;
54
55            // Controls
56            nwg::Window::builder()
57                .flags(nwg::WindowFlags::WINDOW | nwg::WindowFlags::VISIBLE)
58                .size((300, 115))
59                .position((300, 300))
60                .title("Basic example")
61                .build(&mut data.window)?;
62
63            nwg::TextInput::builder()
64                .text("Heisenberg")
65                .parent(&data.window)
66                .focus(true)
67                .build(&mut data.name_edit)?;
68
69            nwg::Button::builder()
70                .text("Say my name")
71                .parent(&data.window)
72                .build(&mut data.hello_button)?;
73
74            // Wrap-up
75            let ui = BasicAppUi {
76                inner: Rc::new(data),
77                default_handler: Default::default(),
78            };
79
80            // Events
81            let evt_ui = Rc::downgrade(&ui.inner);
82            let handle_events = move |evt, _evt_data, handle| {
83                if let Some(evt_ui) = evt_ui.upgrade() {
84                    match evt {
85                        E::OnButtonClick => {
86                            if &handle == &evt_ui.hello_button {
87                                BasicApp::say_hello(&evt_ui);
88                            }
89                        }
90                        E::OnWindowClose => {
91                            if &handle == &evt_ui.window {
92                                BasicApp::say_goodbye(&evt_ui);
93                            }
94                        }
95                        _ => {}
96                    }
97                }
98            };
99
100            *ui.default_handler.borrow_mut() = Some(nwg::full_bind_event_handler(
101                &ui.window.handle,
102                handle_events,
103            ));
104
105            // Layouts
106            nwg::GridLayout::builder()
107                .parent(&ui.window)
108                .spacing(1)
109                .child(0, 0, &ui.name_edit)
110                .child_item(nwg::GridLayoutItem::new(&ui.hello_button, 0, 1, 1, 2))
111                .build(&ui.layout)?;
112
113            return Ok(ui);
114        }

examples/message_bank.rs (line 153)

87        fn build_ui(mut data: MessageBank) -> Result<MessageBankUi, nwg::NwgError> {
88            use nwg::Event as E;
89
90            // Controls
91            nwg::Window::builder()
92                .flags(nwg::WindowFlags::MAIN_WINDOW | nwg::WindowFlags::VISIBLE)
93                .size((400, 300))
94                .position((800, 300))
95                .title("My message bank")
96                .build(&mut data.window)?;
97
98            nwg::TextInput::builder()
99                .text("Hello World!")
100                .focus(true)
101                .parent(&data.window)
102                .build(&mut data.message_content)?;
103
104            nwg::Button::builder()
105                .text("Save")
106                .parent(&data.window)
107                .build(&mut data.add_message_btn)?;
108
109            nwg::TextInput::builder()
110                .text("Title")
111                .parent(&data.window)
112                .build(&mut data.message_title)?;
113
114            // Wrap-up
115            let ui = MessageBankUi {
116                inner: Rc::new(data),
117                default_handler: Default::default(),
118            };
119
120            // Events
121            let window_handles = [&ui.window.handle];
122
123            for handle in window_handles.iter() {
124                let evt_ui = Rc::downgrade(&ui.inner);
125                let handle_events = move |evt, _evt_data, handle| {
126                    if let Some(evt_ui) = evt_ui.upgrade() {
127                        match evt {
128                            E::OnButtonClick => {
129                                if &handle == &evt_ui.add_message_btn {
130                                    MessageBank::add_message(&evt_ui);
131                                }
132                            }
133                            E::OnWindowClose => {
134                                if &handle == &evt_ui.window {
135                                    MessageBank::exit(&evt_ui);
136                                }
137                            }
138                            _ => {}
139                        }
140                    }
141                };
142
143                ui.default_handler
144                    .borrow_mut()
145                    .push(nwg::full_bind_event_handler(handle, handle_events));
146            }
147
148            // Layout
149            nwg::GridLayout::builder()
150                .parent(&ui.window)
151                .max_row(Some(6))
152                .child(0, 0, &ui.add_message_btn)
153                .child_item(nwg::GridLayoutItem::new(&ui.message_title, 1, 0, 2, 1))
154                .child_item(nwg::GridLayoutItem::new(&ui.message_content, 3, 0, 3, 1))
155                .build(&ui.layout)?;
156
157            return Ok(ui);
158        }

examples/calculator.rs (line 303)

150        fn build_ui(mut data: Calculator) -> Result<CalculatorUi, nwg::NwgError> {
151            use nwg::Event as E;
152
153            // Controls
154            nwg::Window::builder()
155                .size((300, 150))
156                .position((300, 300))
157                .title("Calculator")
158                .build(&mut data.window)?;
159
160            nwg::TextInput::builder()
161                .text("")
162                .align(nwg::HTextAlign::Right)
163                .readonly(true)
164                .parent(&data.window)
165                .build(&mut data.input)?;
166
167            nwg::Button::builder()
168                .text("1")
169                .parent(&data.window)
170                .focus(true)
171                .build(&mut data.btn1)?;
172
173            nwg::Button::builder()
174                .text("2")
175                .parent(&data.window)
176                .build(&mut data.btn2)?;
177            nwg::Button::builder()
178                .text("3")
179                .parent(&data.window)
180                .build(&mut data.btn3)?;
181            nwg::Button::builder()
182                .text("4")
183                .parent(&data.window)
184                .build(&mut data.btn4)?;
185            nwg::Button::builder()
186                .text("5")
187                .parent(&data.window)
188                .build(&mut data.btn5)?;
189            nwg::Button::builder()
190                .text("6")
191                .parent(&data.window)
192                .build(&mut data.btn6)?;
193            nwg::Button::builder()
194                .text("7")
195                .parent(&data.window)
196                .build(&mut data.btn7)?;
197            nwg::Button::builder()
198                .text("8")
199                .parent(&data.window)
200                .build(&mut data.btn8)?;
201            nwg::Button::builder()
202                .text("9")
203                .parent(&data.window)
204                .build(&mut data.btn9)?;
205            nwg::Button::builder()
206                .text("0")
207                .parent(&data.window)
208                .build(&mut data.btn0)?;
209
210            nwg::Button::builder()
211                .text("+")
212                .parent(&data.window)
213                .build(&mut data.btn_plus)?;
214            nwg::Button::builder()
215                .text("-")
216                .parent(&data.window)
217                .build(&mut data.btn_minus)?;
218            nwg::Button::builder()
219                .text("*")
220                .parent(&data.window)
221                .build(&mut data.btn_mult)?;
222            nwg::Button::builder()
223                .text("/")
224                .parent(&data.window)
225                .build(&mut data.btn_divide)?;
226            nwg::Button::builder()
227                .text("Clear")
228                .parent(&data.window)
229                .build(&mut data.btn_clear)?;
230            nwg::Button::builder()
231                .text("=")
232                .parent(&data.window)
233                .build(&mut data.btn_process)?;
234
235            // Wrap-up
236            let ui = CalculatorUi {
237                inner: Rc::new(data),
238                default_handler: Default::default(),
239            };
240
241            // Events
242            let window_handles = [&ui.window.handle];
243            for handle in window_handles.iter() {
244                let evt_ui = Rc::downgrade(&ui.inner);
245                let handle_events = move |evt, _evt_data, handle| {
246                    if let Some(evt_ui) = evt_ui.upgrade() {
247                        match evt {
248                            E::OnButtonClick => {
249                                if &handle == &evt_ui.btn0 {
250                                    Calculator::number(&evt_ui, &evt_ui.btn0);
251                                } else if &handle == &evt_ui.btn1 {
252                                    Calculator::number(&evt_ui, &evt_ui.btn1);
253                                } else if &handle == &evt_ui.btn2 {
254                                    Calculator::number(&evt_ui, &evt_ui.btn2);
255                                } else if &handle == &evt_ui.btn3 {
256                                    Calculator::number(&evt_ui, &evt_ui.btn3);
257                                } else if &handle == &evt_ui.btn4 {
258                                    Calculator::number(&evt_ui, &evt_ui.btn4);
259                                } else if &handle == &evt_ui.btn5 {
260                                    Calculator::number(&evt_ui, &evt_ui.btn5);
261                                } else if &handle == &evt_ui.btn6 {
262                                    Calculator::number(&evt_ui, &evt_ui.btn6);
263                                } else if &handle == &evt_ui.btn7 {
264                                    Calculator::number(&evt_ui, &evt_ui.btn7);
265                                } else if &handle == &evt_ui.btn8 {
266                                    Calculator::number(&evt_ui, &evt_ui.btn8);
267                                } else if &handle == &evt_ui.btn9 {
268                                    Calculator::number(&evt_ui, &evt_ui.btn9);
269                                } else if &handle == &evt_ui.btn_plus {
270                                    Calculator::number(&evt_ui, &evt_ui.btn_plus);
271                                } else if &handle == &evt_ui.btn_minus {
272                                    Calculator::number(&evt_ui, &evt_ui.btn_minus);
273                                } else if &handle == &evt_ui.btn_mult {
274                                    Calculator::number(&evt_ui, &evt_ui.btn_mult);
275                                } else if &handle == &evt_ui.btn_divide {
276                                    Calculator::number(&evt_ui, &evt_ui.btn_divide);
277                                } else if &handle == &evt_ui.btn_clear {
278                                    Calculator::clear(&evt_ui);
279                                } else if &handle == &evt_ui.btn_process {
280                                    Calculator::compute(&evt_ui);
281                                }
282                            }
283                            E::OnWindowClose => {
284                                if &handle == &evt_ui.window {
285                                    Calculator::exit(&evt_ui);
286                                }
287                            }
288                            _ => {}
289                        }
290                    }
291                };
292
293                ui.default_handler
294                    .borrow_mut()
295                    .push(nwg::full_bind_event_handler(handle, handle_events));
296            }
297
298            // Layouts
299            nwg::GridLayout::builder()
300                .parent(&ui.window)
301                .spacing(2)
302                .min_size([150, 140])
303                .child_item(nwg::GridLayoutItem::new(&ui.input, 0, 0, 5, 1))
304                .child(0, 1, &ui.btn1)
305                .child(1, 1, &ui.btn2)
306                .child(2, 1, &ui.btn3)
307                .child(0, 2, &ui.btn4)
308                .child(1, 2, &ui.btn5)
309                .child(2, 2, &ui.btn6)
310                .child(0, 3, &ui.btn7)
311                .child(1, 3, &ui.btn8)
312                .child(2, 3, &ui.btn9)
313                .child(3, 1, &ui.btn_plus)
314                .child(4, 1, &ui.btn_minus)
315                .child(3, 2, &ui.btn_mult)
316                .child(4, 2, &ui.btn_divide)
317                .child_item(nwg::GridLayoutItem::new(&ui.btn_clear, 3, 3, 2, 1))
318                .child_item(nwg::GridLayoutItem::new(&ui.btn_process, 3, 4, 2, 1))
319                .child_item(nwg::GridLayoutItem::new(&ui.btn0, 0, 4, 3, 1))
320                .build(&ui.layout)?;
321
322            return Ok(ui);
323        }