changing_the_window_dynamically.rs change to preset to monitor size.

[jpercyasnet]

I added the following code; so I could preset the window based on monitor size.
enum Message {
UpdateWidth(String),
UpdateHeight(String),
ResizeWindow,
PrintSize(Option),
}

struct MyApp {
width: String,
height: String,
mwidth: f32,
mheight: f32,
}
fn new() -> (Self, Task) {
(
Self {
width: "1024".into(),
height: "768".into(),
mheight: 768.0,
mwidth: 1024.0,
},
window::latest().and_then(window::monitor_size)
.map(Message::PrintSize),
)
Message::PrintSize(sizei) => {
if let Some(sizex) = sizei {
println!(" good size = {:?}", sizex);
self.mwidth = sizex.width;
self.mheight = sizex.height;
if self.mwidth > 1920.0 {
self.mwidth = 1900.0;
}
if self.mheight > 1080.0 {
self.mheight = 1070.0;
}
} else {
println!(" bad size = {:?}", sizei);
self.mwidth = 1024.0;
self.mheight = 768.0;
}
self.width = format!("{}",self.mwidth);
self.height = format!("{}", self.mheight);
return window::latest().and_then(Self::resize_window(self.mwidth, self.mheight));
}
Message::ResizeWindow => {
let width = self.width.parse::().unwrap_or(self.mwidth);
let height = self.height.parse::().unwrap_or(self.mheight);

[fogarecious]

Thanks for sharing this!

I’m not sure I fully understand what problem you’re running into.
Could you clarify what you’re trying to achieve, or what isn’t working as expected?

If this code is meant as an example of how to use iced, would you be interested in adding it to the tutorial?
I think it could be helpful for other learners.

[jpercyasnet]

This works. Just update your changing_the_window_dynamically.rs with the above lines. I am a novice at rust and iced, but a good plagiarizer. I use this code so I can preset my window based on monitor size. I have a cheap 4k monitor. If you see a better way, please implement.

[fogarecious]

Thanks for sharing the example and the explanation.

I’ve created PR #25 that integrates your idea into changing_the_window_dynamically.rs.
I made a few adjustments so it fits better with the existing tutorial structure, but the core idea is the same.

Could you take a look and let me know if everything looks good to you?
If it’s OK on your side, I’ll go ahead and merge it.

[jpercyasnet]

Actually, my example shows how to preset the monitor size before you first display the gui.

fn new() -> (Self, Task) {
(
Self {
width: "1024".into(),
height: "768".into(),
mheight: 768.0,
mwidth: 1024.0,
},
window::latest().and_then(window::monitor_size)
.map(Message::PrintSize),
)

Also, it shows how to get the size and modify it; especially for those of us that have 4k monitors.

full code:
use iced::{
Element, Result, Size, Task,
widget::{button, row, text_input},
window,
};

fn main() -> Result {
iced::application(MyApp::new, MyApp::update, MyApp::view)
.title("My App")
.run()
}

#[derive(Debug, Clone)]
enum Message {
UpdateWidth(String),
UpdateHeight(String),
ResizeWindow,
MonitorSize(Option),
}

struct MyApp {
width: String,
height: String,
mwidth: f32,
mheight: f32,
}

impl MyApp {
fn new() -> (Self, Task) {
(
Self {
width: "1024".into(),
height: "768".into(),
mheight: 768.0,
mwidth: 1024.0,
},
window::latest().and_then(window::monitor_size)
.map(Message::MonitorSize),
)
}
fn resize_window(width: f32, height: f32) -> impl Fn(window::Id) -> Task {
move |window_id: window::Id| {
println!("Calling resize_window");
window::resize::(window_id, Size::new(width, height))
}
}

fn update(&mut self, message: Message) -> Task<Message> {
    match message {
        Message::UpdateWidth(w) => self.width = w,
        Message::UpdateHeight(h) => self.height = h,
        Message::MonitorSize(sizei) => {
           if let Some(sizex) = sizei {
               println!(" good size = {:?}", sizex);
               self.mwidth = sizex.width;
               self.mheight = sizex.height;
               if self.mwidth > 1920.0 {
                   self.mwidth = 1900.0;
               }
               if self.mheight > 1080.0 {
                   self.mheight = 1070.0;
               }
           } else {
               println!(" bad size = {:?}", sizei);
               self.mwidth = 1024.0;
               self.mheight = 768.0;
           }
           self.width = format!("{}",self.mwidth);
           self.height = format!("{}", self.mheight);
           return window::latest().and_then(Self::resize_window(self.mwidth, self.mheight));
        }
        Message::ResizeWindow => {
            let width = self.width.parse::<f32>().unwrap_or(self.mwidth);
            let height = self.height.parse::<f32>().unwrap_or(self.mheight);
            println!("Resizing window to {}x{}", width, height);
            return window::latest().and_then(Self::resize_window(width, height));
        }
    }
    Task::none()
}

fn view(&self) -> Element<'_, Message> {
    row![
        text_input("Width", &self.width).on_input(Message::UpdateWidth),
        text_input("Height", &self.height).on_input(Message::UpdateHeight),
        button("Resize window").on_press(Message::ResizeWindow),
    ]
    .into()
}

}

[fogarecious]

I see that your example resizes the window to match the monitor size (with some adjustments) when the application starts. It’s a nice example and I agree that it can be useful for many learners.

That said, this particular tutorial section is intended to focus on changing the window after it has already been initialized. For that reason, in the PR I focused on the part that adjusts the window size dynamically rather than the initial setup.

My goal is to keep each tutorial section as simple and focused as possible, so that learners can more easily find what they need and combine different parts later to fit their own requirements.

If you feel that this use case deserves its own section, contributions of new tutorial parts are always welcome.