Can't change title at runtime.

[Gingeh]

Bevy version

rev = "d158e0893ea88b6acf523a4264f076d6e0b540c6"

Operating system & version

Linux Mint 20.1 Ulyssa

What you did

I tried to change the window title:

fn update_title(score: Res<Score>, mut window: ResMut<WindowDescriptor>) {
    window.title = format!("Snake: {}", score.0);
}

What you expected to happen

I expected the title to change.

What actually happened

The title stayed the same.

Additional information

I am using a WindowDescriptor to set the title at startup.
Window::set_title works, but is more verbose.

[DJMcNab]

The WindowDescriptor resource is never used to update the primary window, except for when the WindowPlugin (or maybe the WinitPlugin reads it for the first time)

That is, you should use Window::set_title

This is not really a sensible default, but it's the current state of affairs.

[cart]

Yup we already have an example that covers how to do this: https://github.com/bevyengine/bevy/blob/main/examples/window/window_settings.rs#L22

I agree that people are often confused by WindowDescriptor being "initialization settings" and not "runtime settings". If anyone has suggestions on ways to improve this im all ears. Any suggestions need to retain the behavior of the "default window" being created with "reasonable defaults", without any user action. These initial settings must be configurable prior to the window being created.

[mockersf]

If anyone has suggestions on ways to improve this im all ears

I have an idea... why not remove the resource once used for initialisation? #2886

[tigregalis]

I made comments on this topic earlier in the year #1255 (comment)

My view for the specific issue at hand: WindowDescriptor (if that's the resource used) ideally should be an "active" resource, in the same way as ClearColor. A user simply updates a resource, and things just work. This could be as simple as a system added to WindowPlugin that monitors changes to Res<WindowDescriptor>, and automatically applies the appropriate window.set_* methods. WindowDescriptor only applies to a single window, sure, but so does ClearColor.

I made a prototype of this a while ago (just updated to work with latest main)

mod window {
    use bevy::{prelude::*, window::WindowMode};

    #[derive(Default)]
    pub struct PrevWindow(WindowDescriptor);

    #[inline]
    fn compare_f32(a: f32, b: f32) -> bool {
        (a - b).abs() < std::f32::EPSILON
    }

    pub fn update_window(
        mut prev_window: ResMut<PrevWindow>,
        curr: Res<WindowDescriptor>,
        mut windows: ResMut<Windows>,
    ) {
        if curr.is_changed() {
            let window = windows.get_primary_mut().unwrap();
            let prev = &prev_window.0;

            if compare_f32(prev.width, curr.width) || compare_f32(prev.height, curr.height) {
                window.set_resolution(curr.width, curr.height);
            }
            if prev.scale_factor_override != curr.scale_factor_override {
                window.set_scale_factor_override(curr.scale_factor_override);
            }
            if prev.title != curr.title {
                window.set_title(curr.title.clone());
            }
            if prev.vsync != curr.vsync {
                window.set_vsync(curr.vsync);
            }
            if prev.resizable != curr.resizable {
                window.set_resizable(curr.resizable);
            }
            if prev.decorations != curr.decorations {
                window.set_decorations(curr.decorations);
            }
            if prev.cursor_visible != curr.cursor_visible {
                window.set_cursor_visibility(curr.cursor_visible);
            }
            if prev.cursor_locked != curr.cursor_locked {
                window.set_cursor_lock_mode(curr.cursor_locked);
            }
            match (prev.mode, curr.mode) {
                (WindowMode::Windowed, WindowMode::Windowed)
                | (WindowMode::BorderlessFullscreen, WindowMode::BorderlessFullscreen) => {}
                (
                    WindowMode::Fullscreen { use_size: p },
                    WindowMode::Fullscreen { use_size: c },
                ) => {
                    if p != c {
                        window.set_mode(curr.mode);
                    }
                }
                _ => {
                    window.set_mode(curr.mode);
                }
            }
            // there is no set_canvas method
            // #[cfg(target_arch = "wasm32")]
            // if prev.canvas != curr.canvas {
            //     window.set_canvas(curr.canvas);
            // }

            prev_window.0 = curr.clone();
        }
    }
}

use bevy::{prelude::*, window::WindowMode};

fn main() {
    App::new()
        .insert_resource(WindowDescriptor {
            title: "Press Escape to toggle full screen vs windowed. Hit a key to change the title."
                .into(),
            mode: WindowMode::Windowed,
            ..Default::default()
        })
        .add_plugins(DefaultPlugins)
        .init_resource::<window::PrevWindow>()
        .add_system(demo)
        .add_system(window::update_window)
        .run();
}

fn demo(input: Res<Input<KeyCode>>, mut window_descriptor: ResMut<WindowDescriptor>) {
    if input.just_pressed(KeyCode::Escape) {
        window_descriptor.mode = match window_descriptor.mode {
            WindowMode::Windowed => WindowMode::BorderlessFullscreen,
            WindowMode::BorderlessFullscreen => WindowMode::Windowed,
            _ => unreachable!(),
        }
    }
    for key in input.get_just_pressed() {
        window_descriptor.title = format!("Press Escape to toggle full screen vs windowed. Hit a key to change the title. You just pressed {:?}!", key);
    }
}

[DJMcNab]

One challenge I put against that is that it encourages code written with only one window in mind. That might be fine, for your specific game code, for example.

But it might not be fine for a library, as that might make it misbehave e.g. for within the editor, with multiple windows

However on the other hand, a library shouldn't be poking at your window size anyway, so it probably would be fine.

[tigregalis]

By the same token, you aren't creating multiple windows by inserting WindowDescriptor, so we don't have a multiple-windows-first API. I think we should double-down on WindowDescriptor, because it makes it less surprising. Perhaps it could be made more explicit by renaming WindowDescriptor to PrimaryWindowDescriptor.

It turns out that a side-benefit of my approach is that you can insert the WindowDescriptor after the DefaultPlugins, and it just seems to work, which makes WindowDescriptor even less surprising.

Alternatively, you could have an API that assumes multiple windows, i.e. something like

// resource
struct WindowDescriptors(Vec<WindowDescriptor>);

with the default being a vector of one. (Or each window is an entity.) This starts to get less ergonomic in the primary (usual) case of having one window.

[bjorn3]

Alternatively, you could have an API that assumes multiple windows, i.e. something like

We already have Windows for multiple windows.