Class reference

Window

Inherits Viewport

Base class for all windows, dialogs, and popups.

Description

A node that creates a window. The window can either be a native system window or embedded inside another Window (see Viewport.gui_embed_subwindows). At runtime, Windows will not close automatically when requested. You need to handle it manually using the close_requested signal (this applies both to pressing the close button and clicking outside of a popup).

Properties

String accessibility_description = ""

The human-readable node description that is reported to assistive apps.

String accessibility_name = ""

The human-readable node name that is reported to assistive apps.

bool always_on_top = false

If true, the window will be on top of all other windows. Does not work if transient is enabled.

bool borderless = false

If true, the window will have no borders.

int content_scale_aspect = 0

Specifies how the content's aspect behaves when the Window is resized. The base aspect is determined by content_scale_size.

int content_scale_mode = 0

Specifies how the content is scaled when the Window is resized.

Vector2i content_scale_size = Vector2i(0, 0)

Base size of the content (i.e. nodes that are drawn inside the window). If non-zero, Window's content will be scaled when the window is resized to a different size.

int content_scale_stretch = 0

The policy to use to determine the final scale factor for 2D elements. This affects how content_scale_factor is applied, in addition to the automatic scale factor determined by content_scale_size.

int current_screen

The screen the window is currently on.

bool exclusive = false

If true, the Window will be in exclusive mode. Exclusive windows are always on top of their parent and will block all input going to the parent Window. Needs transient enabled to work.

bool extend_to_title = false

If true, the Window contents is expanded to the full size of the window, window title bar is transparent. Note: This property is implemented only on macOS. Note: This property only works with native windows.

bool force_native = false

If true, native window will be used regardless of parent viewport and project settings.

int initial_position = 0

Specifies the initial type of position for the Window.

bool keep_title_visible = false

If true, the Window width is expanded to keep the title bar text fully visible.

Vector2i max_size = Vector2i(0, 0)

If non-zero, the Window can't be resized to be bigger than this size. Note: This property will be ignored if the value is lower than min_size.

bool maximize_disabled = false

If true, the Window's maximize button is disabled. Note: If both minimize and maximize buttons are disabled, buttons are fully hidden, and only close button is visible. Note: This property is implemented only on macOS and Windows.

bool minimize_disabled = false

If true, the Window's minimize button is disabled. Note: If both minimize and maximize buttons are disabled, buttons are fully hidden, and only close button is visible. Note: This property is implemented only on macOS and Windows.

int mode = 0

Set's the window's current mode. Note: Fullscreen mode is not exclusive full screen on Windows and Linux. Note: This method only works with native windows, i.e. the main window and Window-derived nodes when Viewport.gui_embed_subwindows is disabled in the main viewport.

bool mouse_passthrough = false

If true, all mouse events will be passed to the underlying window of the same application. See also mouse_passthrough_polygon. Note: This property is implemented on Linux (X11), macOS and Windows. Note: This property only works with native windows.

PackedVector2Array mouse_passthrough_polygon = PackedVector2Array()

Sets a polygonal region of the window which accepts mouse events. Mouse events outside the region will be passed through. Passing an empty array will disable passthrough support (all mouse events will be intercepted by the window, which is the default behavior).

			# Set region, using Path2D node.
			$Window.mouse_passthrough_polygon = $Path2D.curve.get_baked_points()

			# Set region, using Polygon2D node.
			$Window.mouse_passthrough_polygon = $Polygon2D.polygon

			# Reset region to default.
			$Window.mouse_passthrough_polygon = []
			
			// Set region, using Path2D node.
			GetNode<Window>("Window").MousePassthroughPolygon = GetNode<Path2D>("Path2D").Curve.GetBakedPoints();

			// Set region, using Polygon2D node.
			GetNode<Window>("Window").MousePassthroughPolygon = GetNode<Polygon2D>("Polygon2D").Polygon;

			// Reset region to default.
			GetNode<Window>("Window").MousePassthroughPolygon = [];

Note: This property is ignored if mouse_passthrough is set to true. Note: On Windows, the portion of a window that lies outside the region is not drawn, while on Linux (X11) and macOS it is. Note: This property is implemented on Linux (X11), macOS and Windows.

bool popup_window = false

If true, the Window will be considered a popup. Popups are sub-windows that don't show as separate windows in system's window manager's window list and will send close request when anything is clicked outside of them (unless exclusive is enabled).

bool popup_wm_hint = false

If true, the Window will signal to the window manager that it is supposed to be an implementation-defined "popup" (usually a floating, borderless, untileable and immovable child window).

bool sharp_corners = false

If true, the Window will override the OS window style to display sharp corners. Note: This property is implemented only on Windows (11). Note: This property only works with native windows.

Vector2i size = Vector2i(100, 100)

The window's size in pixels.

Theme theme

The Theme resource this node and all its Control and Window children use. If a child node has its own Theme resource set, theme items are merged with child's definitions having higher priority. Note: Window styles will have no effect unless the window is embedded.

String title = ""

The window's title. If the Window is native, title styles set in Theme will have no effect.

bool transient = false

If true, the Window is transient, i.e. it's considered a child of another Window. The transient window will be destroyed with its transient parent and will return focus to their parent when closed. The transient window is displayed on top of a non-exclusive full-screen parent window. Transient windows can't enter full-screen mode. Note that behavior might be different depending on the platform.

bool transient_to_focused = false

If true, and the Window is transient, this window will (at the time of becoming visible) become transient to the currently focused window instead of the immediate parent window in the hierarchy. Note that the transient parent is assigned at the time this window becomes visible, so changing it afterwards has no effect until re-shown.

bool transparent = false

If true, the Window's background can be transparent. This is best used with embedded windows. Note: Transparency support is implemented on Linux, macOS and Windows, but availability might vary depending on GPU driver, display manager, and compositor capabilities. Note: This property has no effect if ProjectSettings.display/window/per_pixel_transparency/allowed is set to false.

bool unfocusable = false

If true, the Window can't be focused nor interacted with. It can still be visible.

bool unresizable = false

If true, the window can't be resized.

bool visible = true

If true, the window is visible.

bool wrap_controls = false

If true, the window's size will automatically update when a child node is added or removed, ignoring min_size if the new size is bigger. If false, you need to call child_controls_changed() manually.

Methods

bool can_draw() const

Returns whether the window is being drawn to the screen.

void child_controls_changed()

Requests an update of the Window size to fit underlying Control nodes.

bool get_flag(int flag) const

Returns true if the flag is set.

Window get_focused_window() static

Returns the focused window.

int get_layout_direction() const

Returns layout direction and text writing direction.

Vector2i get_position_with_decorations() const

Returns the window's position including its border. Note: If visible is false, this method returns the same value as position.

Vector2i get_size_with_decorations() const

Returns the window's size including its border. Note: If visible is false, this method returns the same value as size.

int get_window_id() const

Returns the ID of the window.

void grab_focus()

Causes the window to grab focus, allowing it to receive user input.

bool has_focus() const

Returns true if the window is focused.

void hide()

Hides the window. This is not the same as minimized state. Hidden window can't be interacted with and needs to be made visible with show().

bool is_embedded() const

Returns true if the window is currently embedded in another window.

bool is_layout_rtl() const

Returns true if the layout is right-to-left.

bool is_maximize_allowed() const

Returns true if the window can be maximized (the maximize button is enabled).

void move_to_center()

Centers a native window on the current screen and an embedded window on its embedder Viewport.

void move_to_foreground()

Deprecated.

Use Window.grab_focus() instead.

Causes the window to grab focus, allowing it to receive user input.

void popup(Rect2i rect = Rect2i(0, 0, 0, 0))

Shows the Window and makes it transient (see transient). If rect is provided, it will be set as the Window's size. Fails if called on the main window. If ProjectSettings.display/window/subwindows/embed_subwindows is true (single-window mode), rect's coordinates are global and relative to the main window's top-left corner (excluding window decorations). If rect's position coordinates are negative, the window will be located outside the main window and may not be visible as a result. If ProjectSettings.display/window/subwindows/embed_subwindows is false (multi-window mode), rect's coordinates are global and relative to the top-left corner of the leftmost screen. If rect's position coordinates are negative, the window will be placed at the top-left corner of the screen. Note: rect must be in global coordinates if specified.

void popup_centered(Vector2i minsize = Vector2i(0, 0))

Popups the Window at the center of the current screen, with optionally given minimum size. If the Window is embedded, it will be centered in the parent Viewport instead. Note: Calling it with the default value of minsize is equivalent to calling it with size.

void popup_centered_clamped(Vector2i minsize = Vector2i(0, 0), float fallback_ratio = 0.75)

Popups the Window centered inside its parent Window. fallback_ratio determines the maximum size of the Window, in relation to its parent. Note: Calling it with the default value of minsize is equivalent to calling it with size.

void popup_centered_ratio(float ratio = 0.8)

If Window is embedded, popups the Window centered inside its embedder and sets its size as a ratio of embedder's size. If Window is a native window, popups the Window centered inside the screen of its parent Window and sets its size as a ratio of the screen size.

void popup_on_parent(Rect2i parent_rect)

Popups the Window with a position shifted by parent Window's position. If the Window is embedded, has the same effect as popup().

void remove_theme_constant_override(StringName name)

Removes a local override for a theme constant with the specified name previously added by add_theme_constant_override() or via the Inspector dock.

void remove_theme_font_size_override(StringName name)

Removes a local override for a theme font size with the specified name previously added by add_theme_font_size_override() or via the Inspector dock.

void remove_theme_icon_override(StringName name)

Removes a local override for a theme icon with the specified name previously added by add_theme_icon_override() or via the Inspector dock.

void request_attention()

Tells the OS that the Window needs an attention. This makes the window stand out in some way depending on the system, e.g. it might blink on the task bar.

void set_flag(int flag, bool enabled)

Sets a specified window flag.

void set_ime_active(bool active)

If active is true, enables system's native IME (Input Method Editor).

void set_ime_position(Vector2i position)

Moves IME to the given position.

void set_layout_direction(int direction)

Sets layout direction and text writing direction. Right-to-left layouts are necessary for certain languages (e.g. Arabic and Hebrew).

void set_unparent_when_invisible(bool unparent)

If unparent is true, the window is automatically unparented when going invisible. Note: Make sure to keep a reference to the node, otherwise it will be orphaned. You also need to manually call Node.queue_free() to free the window if it's not parented.

void set_use_font_oversampling(bool enable)

Enables font oversampling. This makes fonts look better when they are scaled up.

void show()

Makes the Window appear. This enables interactions with the Window and doesn't change any of its property other than visibility (unlike e.g. popup()).

void start_drag()

Starts an interactive drag operation on the window, using the current mouse position. Call this method when handling a mouse button being pressed to simulate a pressed event on the window's title bar. Using this method allows the window to participate in space switching, tiling, and other system features.

void start_resize(int edge)

Starts an interactive resize operation on the window, using the current mouse position. Call this method when handling a mouse button being pressed to simulate a pressed event on the window's edge.

Signals

about_to_popup()

Emitted right after popup() call, before the Window appears or does anything.

close_requested()

Emitted when the Window's close button is pressed or when popup_window is enabled and user clicks outside the window. This signal can be used to handle window closing, e.g. by connecting it to hide().

dpi_changed()

Emitted when the Window's DPI changes as a result of OS-level changes (e.g. moving the window from a Retina display to a lower resolution one). Note: Only implemented on macOS and Linux (Wayland).

files_dropped(PackedStringArray files)

Emitted when files are dragged from the OS file manager and dropped in the game window. The argument is a list of file paths.

				func _ready():
					get_window().files_dropped.connect(on_files_dropped)

				func on_files_dropped(files):
					print(files)

Note: This signal only works with native windows, i.e. the main window and Window-derived nodes when Viewport.gui_embed_subwindows is disabled in the main viewport.

focus_entered()

Emitted when the Window gains focus.

focus_exited()

Emitted when the Window loses its focus.

mouse_entered()

Emitted when the mouse cursor enters the Window's visible area, that is not occluded behind other Controls or windows, provided its Viewport.gui_disable_input is false and regardless if it's currently focused or not.

mouse_exited()

Emitted when the mouse cursor leaves the Window's visible area, that is not occluded behind other Controls or windows, provided its Viewport.gui_disable_input is false and regardless if it's currently focused or not.

title_changed()

Emitted when window title bar text is changed.

titlebar_changed()

Emitted when window title bar decorations are changed, e.g. macOS window enter/exit full screen mode, or extend-to-title flag is changed.

visibility_changed()

Emitted when Window is made visible or disappears.

window_input(InputEvent event)

Emitted when the Window is currently focused and receives any input, passing the received event as an argument. The event's position, if present, is in the embedder's coordinate system.

Constants

NOTIFICATION_THEME_CHANGED = 32

Sent when the node needs to refresh its theme items. This happens in one of the following cases: - The theme property is changed on this node or any of its ancestors. - The theme_type_variation property is changed on this node. - The node enters the scene tree. Note: As an optimization, this notification won't be sent from changes that occur while this node is outside of the scene tree. Instead, all of the theme item updates can be applied at once when the node enters the scene tree.

MODE_WINDOWED = 0

Enum: Mode

Windowed mode, i.e. Window doesn't occupy the whole screen (unless set to the size of the screen).

MODE_MINIMIZED = 1

Enum: Mode

Minimized window mode, i.e. Window is not visible and available on window manager's window list. Normally happens when the minimize button is pressed.

MODE_MAXIMIZED = 2

Enum: Mode

Maximized window mode, i.e. Window will occupy whole screen area except task bar and still display its borders. Normally happens when the maximize button is pressed.

MODE_FULLSCREEN = 3

Enum: Mode

Full screen mode with full multi-window support. Full screen window covers the entire display area of a screen and has no decorations. The display's video mode is not changed. On Android: This enables immersive mode. On macOS: A new desktop is used to display the running project. Note: Regardless of the platform, enabling full screen will change the window size to match the monitor's size. Therefore, make sure your project supports multiple resolutions when enabling full screen mode.

MODE_EXCLUSIVE_FULLSCREEN = 4

Enum: Mode

A single window full screen mode. This mode has less overhead, but only one window can be open on a given screen at a time (opening a child window or application switching will trigger a full screen transition). Full screen window covers the entire display area of a screen and has no border or decorations. The display's video mode is not changed. Note: This mode might not work with screen recording software. On Android: This enables immersive mode. On Windows: Depending on video driver, full screen transition might cause screens to go black for a moment. On macOS: A new desktop is used to display the running project. Exclusive full screen mode prevents Dock and Menu from showing up when the mouse pointer is hovering the edge of the screen. On Linux (X11): Exclusive full screen mode bypasses compositor. On Linux (Wayland): Equivalent to MODE_FULLSCREEN. Note: Regardless of the platform, enabling full screen will change the window size to match the monitor's size. Therefore, make sure your project supports multiple resolutions when enabling full screen mode.

FLAG_RESIZE_DISABLED = 0

Enum: Flags

The window can't be resized by dragging its resize grip. It's still possible to resize the window using size. This flag is ignored for full screen windows. Set with unresizable.

FLAG_BORDERLESS = 1

Enum: Flags

The window do not have native title bar and other decorations. This flag is ignored for full-screen windows. Set with borderless.

FLAG_ALWAYS_ON_TOP = 2

Enum: Flags

The window is floating on top of all other windows. This flag is ignored for full-screen windows. Set with always_on_top.

FLAG_NO_FOCUS = 4

Enum: Flags

The window can't be focused. No-focus window will ignore all input, except mouse clicks. Set with unfocusable.

FLAG_POPUP = 5

Enum: Flags

Window is part of menu or OptionButton dropdown. This flag can't be changed when the window is visible. An active popup window will exclusively receive all input, without stealing focus from its parent. Popup windows are automatically closed when uses click outside it, or when an application is switched. Popup window must have transient parent set (see transient). Note: This flag has no effect in embedded windows (unless said window is a Popup).

FLAG_EXTEND_TO_TITLE = 6

Enum: Flags

Window content is expanded to the full size of the window. Unlike borderless window, the frame is left intact and can be used to resize the window, title bar is transparent, but have minimize/maximize/close buttons. Set with extend_to_title. Note: This flag is implemented only on macOS. Note: This flag has no effect in embedded windows.

FLAG_MOUSE_PASSTHROUGH = 7

Enum: Flags

All mouse events are passed to the underlying window of the same application. Note: This flag has no effect in embedded windows.

FLAG_SHARP_CORNERS = 8

Enum: Flags

Window style is overridden, forcing sharp corners. Note: This flag has no effect in embedded windows. Note: This flag is implemented only on Windows (11).

FLAG_EXCLUDE_FROM_CAPTURE = 9

Enum: Flags

Windows is excluded from screenshots taken by DisplayServer.screen_get_image(), DisplayServer.screen_get_image_rect(), and DisplayServer.screen_get_pixel(). Note: This flag has no effect in embedded windows. Note: This flag is implemented on macOS and Windows (10, 20H1). Note: Setting this flag will prevent standard screenshot methods from capturing a window image, but does NOT guarantee that other apps won't be able to capture an image. It should not be used as a DRM or security measure.

FLAG_POPUP_WM_HINT = 10

Enum: Flags

Signals the window manager that this window is supposed to be an implementation-defined "popup" (usually a floating, borderless, untileable and immovable child window).

FLAG_MINIMIZE_DISABLED = 11

Enum: Flags

Window minimize button is disabled. Note: This flag is implemented on macOS and Windows.

FLAG_MAXIMIZE_DISABLED = 12

Enum: Flags

Window maximize button is disabled. Note: This flag is implemented on macOS and Windows.

FLAG_MAX = 13

Enum: Flags

Max value of the Flags.

CONTENT_SCALE_MODE_DISABLED = 0

Enum: ContentScaleMode

The content will not be scaled to match the Window's size.

CONTENT_SCALE_MODE_CANVAS_ITEMS = 1

Enum: ContentScaleMode

The content will be rendered at the target size. This is more performance-expensive than CONTENT_SCALE_MODE_VIEWPORT, but provides better results.

CONTENT_SCALE_MODE_VIEWPORT = 2

Enum: ContentScaleMode

The content will be rendered at the base size and then scaled to the target size. More performant than CONTENT_SCALE_MODE_CANVAS_ITEMS, but results in pixelated image.

CONTENT_SCALE_ASPECT_IGNORE = 0

Enum: ContentScaleAspect

The aspect will be ignored. Scaling will simply stretch the content to fit the target size.

CONTENT_SCALE_ASPECT_KEEP = 1

Enum: ContentScaleAspect

The content's aspect will be preserved. If the target size has different aspect from the base one, the image will be centered and black bars will appear on left and right sides.

CONTENT_SCALE_ASPECT_KEEP_WIDTH = 2

Enum: ContentScaleAspect

The content can be expanded vertically. Scaling horizontally will result in keeping the width ratio and then black bars on left and right sides.

CONTENT_SCALE_ASPECT_KEEP_HEIGHT = 3

Enum: ContentScaleAspect

The content can be expanded horizontally. Scaling vertically will result in keeping the height ratio and then black bars on top and bottom sides.

CONTENT_SCALE_ASPECT_EXPAND = 4

Enum: ContentScaleAspect

The content's aspect will be preserved. If the target size has different aspect from the base one, the content will stay in the top-left corner and add an extra visible area in the stretched space.

CONTENT_SCALE_STRETCH_FRACTIONAL = 0

Enum: ContentScaleStretch

The content will be stretched according to a fractional factor. This fills all the space available in the window, but allows "pixel wobble" to occur due to uneven pixel scaling.

CONTENT_SCALE_STRETCH_INTEGER = 1

Enum: ContentScaleStretch

The content will be stretched only according to an integer factor, preserving sharp pixels. This may leave a black background visible on the window's edges depending on the window size.

LAYOUT_DIRECTION_INHERITED = 0

Enum: LayoutDirection

Automatic layout direction, determined from the parent window layout direction.

LAYOUT_DIRECTION_APPLICATION_LOCALE = 1

Enum: LayoutDirection

Automatic layout direction, determined from the current locale.

LAYOUT_DIRECTION_LTR = 2

Enum: LayoutDirection

Left-to-right layout direction.

LAYOUT_DIRECTION_RTL = 3

Enum: LayoutDirection

Right-to-left layout direction.

LAYOUT_DIRECTION_SYSTEM_LOCALE = 4

Enum: LayoutDirection

Automatic layout direction, determined from the system locale.

LAYOUT_DIRECTION_MAX = 5

Enum: LayoutDirection

Represents the size of the LayoutDirection enum.

WINDOW_INITIAL_POSITION_ABSOLUTE = 0

Enum: WindowInitialPosition

Initial window position is determined by position.

WINDOW_INITIAL_POSITION_CENTER_PRIMARY_SCREEN = 1

Enum: WindowInitialPosition

Initial window position is the center of the primary screen.

WINDOW_INITIAL_POSITION_CENTER_MAIN_WINDOW_SCREEN = 2

Enum: WindowInitialPosition

Initial window position is the center of the main window screen.

WINDOW_INITIAL_POSITION_CENTER_OTHER_SCREEN = 3

Enum: WindowInitialPosition

Initial window position is the center of current_screen screen.

WINDOW_INITIAL_POSITION_CENTER_SCREEN_WITH_MOUSE_FOCUS = 4

Enum: WindowInitialPosition

Initial window position is the center of the screen containing the mouse pointer.

WINDOW_INITIAL_POSITION_CENTER_SCREEN_WITH_KEYBOARD_FOCUS = 5

Enum: WindowInitialPosition

Initial window position is the center of the screen containing the window with the keyboard focus.

Theme properties

Color title_color = Color(0.875, 0.875, 0.875, 1)

The color of the title's text.

Color title_outline_modulate = Color(0, 0, 0, 1)

The color of the title's text outline.

int close_h_offset = 18

Horizontal position offset of the close button, relative to the end of the title bar, towards the beginning of the title bar.

int close_v_offset = 24

Vertical position offset of the close button, relative to the bottom of the title bar, towards the top of the title bar.

int resize_margin = 4

Defines the outside margin at which the window border can be grabbed with mouse and resized.

int title_height = 36

Height of the title bar.

int title_outline_size = 0

The size of the title outline.

Font title_font

The font used to draw the title.

int title_font_size

The size of the title font.

Texture2D close

The icon for the close button.

Texture2D close_pressed

The icon for the close button when it's being pressed.

StyleBox embedded_border

The background style used when the Window is embedded. Note that this is drawn only under the window's content, excluding the title. For proper borders and title bar style, you can use expand_margin_* properties of StyleBoxFlat. Note: The content background will not be visible unless transparent is enabled.

StyleBox embedded_unfocused_border

The background style used when the Window is embedded and unfocused.

Source revision 5592dc3a7a61
Connection interrupted. Reload×

Rejoining the server...

Rejoin failed... trying again in seconds.

Failed to rejoin.
Please retry or reload the page.

The session has been paused by the server.

Failed to resume the session.
Please retry or reload the page.