Window

public string AccessibilityDescription { get; set; }

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

public string AccessibilityName { get; set; }

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

public bool AlwaysOnTop { get; set; }

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

public bool AutoTranslate { get; set; }

Toggles if any text should automatically change to its translated version depending on the current locale.

public bool Borderless { get; set; }

If true, the window will have no borders.

public Window.ContentScaleAspectEnum ContentScaleAspect { get; set; }

Aspect policy for content scaling. Keep preserves the base area with bars where necessary; Expand exposes additional logical area; Ignore permits nonuniform stretching. Does not automatically lay out UI controls.

public float ContentScaleFactor { get; set; }

Scale factor for the whole content, not only fonts. In the tested CanvasItems case, increasing 1 to 2 halves the logical visible area on each axis. In Viewport mode it also affects internal render dimensions; validate layout and quality separately.

public Window.ContentScaleModeEnum ContentScaleMode { get; set; }

Window content scaling mode. CanvasItems scales logical 2D while rendering at the fitted window size; Viewport renders at a base-derived resolution and then scales the image. Not the separate 3D resolution scale.

public Vector2I ContentScaleSize { get; set; }

Base design size for window content scaling. Does not switch monitor resolution and is not necessarily the window Size or render-target size. Final logical area depends on mode, aspect policy and ContentScaleFactor.

public Window.ContentScaleStretchEnum ContentScaleStretch { get; set; }

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

public int CurrentScreen { get; set; }

The screen the window is currently on.

public bool ExcludeFromCapture { get; set; }

If true, the Window is excluded from screenshots taken by DisplayServer.ScreenGetImage, DisplayServer.ScreenGetImageRect, and DisplayServer.ScreenGetPixel. Note: This property is implemented on macOS and Windows. Note: Enabling this setting 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.

public bool Exclusive { get; set; }

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 Window.Transient enabled to work.

public bool ExtendToTitle { get; set; }

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.

public bool ForceNative { get; set; }

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

public bool FullscreenShortcutEnabled { get; set; }

If true, allows the user to toggle fullscreen mode by pressing the shortcut defined in ProjectSettings.input/ui_toggle_fullscreen ([kbd]Alt + Enter[/kbd] by default). This is enabled on the main window according to the ProjectSettings.display/window/size/enable_toggle_fullscreen_shortcut project setting.

public bool HdrOutputRequested { get; set; }

If true, requests HDR output for the Window, falling back to SDR if not supported, and automatically switching between HDR and SDR as the window moves between screens, screen capabilities change, or system settings are modified. This will internally force Viewport.UseHdr2D to be enabled on the main Viewport. All other SubViewport of this Window must have their Viewport.UseHdr2D property enabled to produce HDR output.

public Window.WindowInitialPosition InitialPosition { get; set; }

Specifies the initial type of position for the Window.

public bool KeepTitleVisible { get; set; }

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

public Vector2I MaxSize { get; set; }

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 Window.MinSize.

public bool MaximizeDisabled { get; set; }

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 on Linux (X11), macOS, and Windows.

public Vector2I MinSize { get; set; }

If non-zero, the Window can't be resized to be smaller than this size. Note: This property will be ignored in favor of Window.GetContentsMinimumSize if Window.WrapControls is enabled and if its size is bigger.

public bool MinimizeDisabled { get; set; }

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 on Linux (X11), macOS, and Windows.

public Window.ModeEnum Mode { get; set; }

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.GuiEmbedSubwindows is disabled in the main viewport.

public bool MousePassthrough { get; set; }

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

public Vector2[] MousePassthroughPolygon { get; set; }

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.
GetEntity<Window>("Window").MousePassthroughPolygon = GetEntity<Path2D>("Path2D").Curve.GetBakedPoints();

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

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

Note: This property is ignored if Window.MousePassthrough 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.

public Rect2I NonclientArea { get; set; }

If set, defines the window's custom decoration area which will receive mouse input, even if normal input to the window is blocked (such as when it has an exclusive child opened). See also Window.NonclientWindowInput.

public bool PopupWMHint { get; set; }

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).

public bool PopupWindow { get; set; }

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 Window.Exclusive is enabled).

public Vector2I Position { get; set; }

Window position in its mode's coordinate space. An embedded window uses its parent viewport; a native one uses the screen. Validate restored coordinates against the current usable area, including negative monitor coordinates.

public bool SharpCorners { get; set; }

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.

public Vector2I Size { get; set; }

The window's size in pixels. See also Window.ContentScaleSize, which doesn't set the window's physical size but affects how scaling works relative to the current Window.ContentScaleMode.

public Theme Theme { get; set; }

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.

public StringName ThemeTypeVariation { get; set; }

The name of a theme type variation used by this Window to look up its own theme items. See Control.ThemeTypeVariation for more details.

public string Title { get; set; }

The window's title. If the Window is native, title styles set in Theme will have no effect. If empty, some dialogs may use a default title.

public bool Transient { get; set; }

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.

public bool TransientToFocused { get; set; }

If true, and the Window is Window.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.

public bool Transparent { get; set; }

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.

public bool Unfocusable { get; set; }

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

public bool Unresizable { get; set; }

If true, the window can't be resized.

public bool Visible { get; set; }

If true, the window is visible.

public bool WrapControls { get; set; }

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

public void AddThemeColorOverride(StringName name, Color color);

Creates a local override for a theme Color with the specified name. Local overrides always take precedence when fetching theme items for the control. An override can be removed with Window.RemoveThemeColorOverride. See also Window.GetThemeColor and Control.AddThemeColorOverride for more details.

public void AddThemeConstantOverride(StringName name, int constant);

Creates a local override for a theme constant with the specified name. Local overrides always take precedence when fetching theme items for the control. An override can be removed with Window.RemoveThemeConstantOverride. See also Window.GetThemeConstant.

public void AddThemeFontOverride(StringName name, Font font);

Creates a local override for a theme Font with the specified name. Local overrides always take precedence when fetching theme items for the control. An override can be removed with Window.RemoveThemeFontOverride. See also Window.GetThemeFont.

public void AddThemeFontSizeOverride(StringName name, int fontSize);

Creates a local override for a theme font size with the specified name. Local overrides always take precedence when fetching theme items for the control. An override can be removed with Window.RemoveThemeFontSizeOverride. See also Window.GetThemeFontSize.

public void AddThemeIconOverride(StringName name, Texture2D texture);

Creates a local override for a theme icon with the specified name. Local overrides always take precedence when fetching theme items for the control. An override can be removed with Window.RemoveThemeIconOverride. See also Window.GetThemeIcon.

public void AddThemeSoundOverride(StringName name, AudioStream sound);

Creates a local override for a theme sound with the specified name. Local overrides always take precedence when fetching theme items for the control. An override can be removed with Window.RemoveThemeSoundOverride. See also Window.GetThemeSound.

public void AddThemeStyleboxOverride(StringName name, StyleBox stylebox);

Creates a local override for a theme StyleBox with the specified name. Local overrides always take precedence when fetching theme items for the control. An override can be removed with Window.RemoveThemeStyleboxOverride. See also Window.GetThemeStylebox and Control.AddThemeStyleboxOverride for more details.

public void BeginBulkThemeOverride();

Prevents *_theme_*_override methods from emitting Window.NotificationThemeChanged until Window.EndBulkThemeOverride is called.

public bool CanDraw();

Returns whether the window is being drawn to the screen.

public void ChildControlsChanged();

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

public void EndBulkThemeOverride();

Ends a bulk theme override update. See Window.BeginBulkThemeOverride.

public Window.ContentScaleAspectEnum GetContentScaleAspect();

Returns the requested ContentScaleAspect value. Aspect policy for content scaling. Keep preserves the base area with bars where necessary; Expand exposes additional logical area; Ignore permits nonuniform stretching. Does not automatically lay out UI controls.

public float GetContentScaleFactor();

Returns the requested ContentScaleFactor value. Scale factor for the whole content, not only fonts. In the tested CanvasItems case, increasing 1 to 2 halves the logical visible area on each axis. In Viewport mode it also affects internal render dimensions; validate layout and quality separately.

public Window.ContentScaleModeEnum GetContentScaleMode();

Returns the requested ContentScaleMode value. Window content scaling mode. CanvasItems scales logical 2D while rendering at the fitted window size; Viewport renders at a base-derived resolution and then scales the image. Not the separate 3D resolution scale.

public Vector2I GetContentScaleSize();

Returns the requested ContentScaleSize value. Base design size for window content scaling. Does not switch monitor resolution and is not necessarily the window Size or render-target size. Final logical area depends on mode, aspect policy and ContentScaleFactor.

public Vector2 GetContentsMinimumSize();

Virtual method to be implemented by the user. Overrides the value returned by Window.GetContentsMinimumSize.

public bool GetFlag(Window.Flags flag);

Returns true if the flag is set.

public static Window GetFocusedWindow();

Returns the focused window.

public Window.LayoutDirection GetLayoutDirection();

Returns layout direction and text writing direction.

public float GetOutputMaxLinearValue();

Returns the maximum value for linear color components that can be displayed in this window, regardless of SDR or HDR output. Returns 1.0 if HDR is not enabled or not supported. The Window.OutputMaxLinearValueChanged signal will be emitted whenever this value changes. This value is used by tonemapping and other Environment effects to ensure that bright colors are presented in the range that can be displayed by this window. When using this maximum linear value in your project, it should only be used to present colors directly to the screen without tonemapping and without influencing lighting, post-processing effects, or surrounding color. The following is an example that produces the brightest purple color that the screen can produce:

Note: You will need to convert sRGB colors to linear before multiplying by this value to get correct results.

public Vector2I GetPositionWithDecorations();

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

public Vector2I GetSizeWithDecorations();

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

public Color GetThemeColor(StringName name, StringName themeType = null);

Returns a Color from the first matching Theme in the tree if that Theme has a color item with the specified name and theme_type. See Control.GetThemeColor for details.

public int GetThemeConstant(StringName name, StringName themeType = null);

Returns a constant from the first matching Theme in the tree if that Theme has a constant item with the specified name and theme_type. See Control.GetThemeColor for details.

public float GetThemeDefaultBaseScale();

Returns the default base scale value from the first matching Theme in the tree if that Theme has a valid Theme.DefaultBaseScale value. See Control.GetThemeColor for details.

public Font GetThemeDefaultFont();

Returns the default font from the first matching Theme in the tree if that Theme has a valid Theme.DefaultFont value. See Control.GetThemeColor for details.

public int GetThemeDefaultFontSize();

Returns the default font size value from the first matching Theme in the tree if that Theme has a valid Theme.DefaultFontSize value. See Control.GetThemeColor for details.

public Font GetThemeFont(StringName name, StringName themeType = null);

Returns a Font from the first matching Theme in the tree if that Theme has a font item with the specified name and theme_type. See Control.GetThemeColor for details.

public int GetThemeFontSize(StringName name, StringName themeType = null);

Returns a font size from the first matching Theme in the tree if that Theme has a font size item with the specified name and theme_type. See Control.GetThemeColor for details.

public Texture2D GetThemeIcon(StringName name, StringName themeType = null);

Returns an icon from the first matching Theme in the tree if that Theme has an icon item with the specified name and theme_type. See Control.GetThemeColor for details.

public AudioStream GetThemeSound(StringName name, StringName themeType = null);

Returns a sound from the first matching Theme in the tree if that Theme has a sound item with the specified name and theme_type. See Control.GetThemeColor for details.

public StyleBox GetThemeStylebox(StringName name, StringName themeType = null);

Returns a StyleBox from the first matching Theme in the tree if that Theme has a stylebox item with the specified name and theme_type. See Control.GetThemeColor for details.

public int GetWindowId();

Returns the ID of the window.

public void GrabFocus();

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

public bool HasFocus();

Returns true if the window is focused.

public bool HasThemeColor(StringName name, StringName themeType = null);

Returns true if there is a matching Theme in the tree that has a color item with the specified name and theme_type. See Control.GetThemeColor for details.

public bool HasThemeColorOverride(StringName name);

Returns true if there is a local override for a theme Color with the specified name in this Control node. See Window.AddThemeColorOverride.

public bool HasThemeConstant(StringName name, StringName themeType = null);

Returns true if there is a matching Theme in the tree that has a constant item with the specified name and theme_type. See Control.GetThemeColor for details.

public bool HasThemeConstantOverride(StringName name);

Returns true if there is a local override for a theme constant with the specified name in this Control node. See Window.AddThemeConstantOverride.

public bool HasThemeFont(StringName name, StringName themeType = null);

Returns true if there is a matching Theme in the tree that has a font item with the specified name and theme_type. See Control.GetThemeFont for details.

public bool HasThemeFontOverride(StringName name);

Returns true if there is a local override for a theme Font with the specified name in this Control node. See Window.AddThemeFontOverride.

public bool HasThemeFontSize(StringName name, StringName themeType = null);

Returns true if there is a matching Theme in the tree that has a font size item with the specified name and theme_type. See Control.GetThemeFontSize for details.

public bool HasThemeFontSizeOverride(StringName name);

Returns true if there is a local override for a theme font size with the specified name in this Control node. See Window.AddThemeFontSizeOverride.

public bool HasThemeIcon(StringName name, StringName themeType = null);

Returns true if there is a matching Theme in the tree that has an icon item with the specified name and theme_type. See Control.GetThemeIcon for details.

public bool HasThemeIconOverride(StringName name);

Returns true if there is a local override for a theme icon with the specified name in this Control node. See Window.AddThemeIconOverride.

public bool HasThemeSound(StringName name, StringName themeType = null);

Returns true if there is a matching Theme in the tree that has a sound item with the specified name and theme_type. See Control.GetThemeSound for details.

public bool HasThemeSoundOverride(StringName name);

Returns true if there is a local override for a theme sound with the specified name in this Control node. See Window.AddThemeSoundOverride.

public bool HasThemeStylebox(StringName name, StringName themeType = null);

Returns true if there is a matching Theme in the tree that has a stylebox item with the specified name and theme_type. See Control.GetThemeStylebox for details.

public bool HasThemeStyleboxOverride(StringName name);

Returns true if there is a local override for a theme StyleBox with the specified name in this Control node. See Window.AddThemeStyleboxOverride.

public 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 Window.Show.

public bool IsEmbedded();

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

public bool IsLayoutRtl();

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

public bool IsMaximizeAllowed();

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

public bool IsUsingFontOversampling();

Returns true if font oversampling is enabled. See Window.SetUseFontOversampling.

public void MoveToCenter();

Centers the window in the current screen. If the window is embedded, it is centered in the embedder Viewport instead.

public void MoveToForeground();

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

public void Popup(Rect2I? rect = default);

Shows the Window and makes it transient (see Window.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.

public void PopupCentered(Vector2I? minsize = default);

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 Window.Size.

public void PopupCenteredClamped(Vector2I? minsize = default, float fallbackRatio = 0.75f);

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 Window.Size.

public void PopupCenteredRatio(float ratio = 0.8f);

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.

public void PopupExclusive(Entity fromNode, Rect2I? rect = default);

Attempts to parent this dialog to the last exclusive window relative to from_node, and then calls Window.Popup on it. The dialog must have no current parent, otherwise the method fails. See also Window.SetUnparentWhenInvisible and Entity.GetLastExclusiveWindow.

public void PopupExclusiveCentered(Entity fromNode, Vector2I? minsize = default);

Attempts to parent this dialog to the last exclusive window relative to from_node, and then calls Window.PopupCentered on it. The dialog must have no current parent, otherwise the method fails. See also Window.SetUnparentWhenInvisible and Entity.GetLastExclusiveWindow.

public void PopupExclusiveCenteredClamped(Entity fromNode, Vector2I? minsize = default, float fallbackRatio = 0.75f);

Attempts to parent this dialog to the last exclusive window relative to from_node, and then calls Window.PopupCenteredClamped on it. The dialog must have no current parent, otherwise the method fails. See also Window.SetUnparentWhenInvisible and Entity.GetLastExclusiveWindow.

public void PopupExclusiveCenteredRatio(Entity fromNode, float ratio = 0.8f);

Attempts to parent this dialog to the last exclusive window relative to from_node, and then calls Window.PopupCenteredRatio on it. The dialog must have no current parent, otherwise the method fails. See also Window.SetUnparentWhenInvisible and Entity.GetLastExclusiveWindow.

public void PopupExclusiveOnParent(Entity fromNode, Rect2I parentRect);

Attempts to parent this dialog to the last exclusive window relative to from_node, and then calls Window.PopupOnParent on it. The dialog must have no current parent, otherwise the method fails. See also Window.SetUnparentWhenInvisible and Entity.GetLastExclusiveWindow.

public void PopupOnParent(Rect2I parentRect);

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

public void RemoveThemeColorOverride(StringName name);

Removes a local override for a theme Color with the specified name previously added by Window.AddThemeColorOverride or via the Inspector dock.

public void RemoveThemeConstantOverride(StringName name);

Removes a local override for a theme constant with the specified name previously added by Window.AddThemeConstantOverride or via the Inspector dock.

public void RemoveThemeFontOverride(StringName name);

Removes a local override for a theme Font with the specified name previously added by Window.AddThemeFontOverride or via the Inspector dock.

public void RemoveThemeFontSizeOverride(StringName name);

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

public void RemoveThemeIconOverride(StringName name);

Removes a local override for a theme icon with the specified name previously added by Window.AddThemeIconOverride or via the Inspector dock.

public void RemoveThemeSoundOverride(StringName name);

Removes a local override for a theme sound with the specified name previously added by Window.AddThemeSoundOverride or via the Inspector dock.

public void RemoveThemeStyleboxOverride(StringName name);

Removes a local override for a theme StyleBox with the specified name previously added by Window.AddThemeStyleboxOverride or via the Inspector dock.

public void RequestAttention();

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.

public void ResetSize();

Resets the size to the minimum size, which is the max of Window.MinSize and (if Window.WrapControls is enabled) Window.GetContentsMinimumSize. This is equivalent to calling set_size(Vector2i()) (or any size below the minimum).

public void SetContentScaleAspect(Window.ContentScaleAspectEnum aspect);

Sets ContentScaleAspect. Aspect policy for content scaling. Keep preserves the base area with bars where necessary; Expand exposes additional logical area; Ignore permits nonuniform stretching. Does not automatically lay out UI controls.

public void SetContentScaleFactor(float factor);

Sets ContentScaleFactor. Scale factor for the whole content, not only fonts. In the tested CanvasItems case, increasing 1 to 2 halves the logical visible area on each axis. In Viewport mode it also affects internal render dimensions; validate layout and quality separately.

public void SetContentScaleMode(Window.ContentScaleModeEnum mode);

Sets ContentScaleMode. Window content scaling mode. CanvasItems scales logical 2D while rendering at the fitted window size; Viewport renders at a base-derived resolution and then scales the image. Not the separate 3D resolution scale.

public void SetContentScaleSize(Vector2I size);

Sets ContentScaleSize. Base design size for window content scaling. Does not switch monitor resolution and is not necessarily the window Size or render-target size. Final logical area depends on mode, aspect policy and ContentScaleFactor.

public void SetFlag(Window.Flags flag, bool enabled);

Sets a specified window flag.

public void SetImeActive(bool active);

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

public void SetImePosition(Vector2I position);

Moves IME to the given position.

public void SetLayoutDirection(Window.LayoutDirection direction);

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

public void SetTaskbarProgressState(DisplayServer.ProgressState state);

Sets the type and state of the progress bar on the taskbar/dock icon of the Window. See DisplayServer.ProgressState for possible values and how each mode behaves. Note: This method is implemented only on Windows and macOS.

public void SetTaskbarProgressValue(float value);

Creates a progress bar on the taskbar/dock icon of the Window if it does not exist, sets the progress of the icon. value acts as a relative percentage value, ranges from 0.0 (lowest) to 1.0 (highest). Note: This method is implemented only on Windows and macOS.

public void SetUnparentWhenInvisible(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 Entity.QueueFree to free the window if it's not parented.

public void SetUseFontOversampling(bool enable);

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