Windows

Windows

Window Manager in SplashKit can be used create, and manipulate graphics windows

Functions

Clear Window  {</>}

clears a window to the specified color given in clr

Parameters:

Name	Type	Description
wind	Window	the Window to clear
clr	Color	the Color to clear the window to.

Signatures:

C++

void clear_window(window wind, color clr)

C#

public void Window.Clear(Color clr);
public static void SplashKit.ClearWindow(Window wind, Color clr);

Python

def clear_window(wind, clr):

Pascal

procedure ClearWindow(wind: Window; clr: Color)

Usage:  {</>}

See Implementations

API Documentation Code Examples:

• Resume Music: Pausing and Resuming Game Music
• Random Window Point: Splashkit Function: RandomWindowPoint
• Fill Rectangle On Window: Filled Rectangles on Separate Windows
• Fill Rectangle On Window: Filled Rectangles on Separate Windows

---

Close All Windows  {</>}

Releases all of the windows which have been loaded.

Signatures:

C++

void close_all_windows()

C#

public static void SplashKit.CloseAllWindows();

Python

def close_all_windows():

Pascal

procedure CloseAllWindows()

Usage:  {</>}

See Implementations

Tutorials and Guides:

• Get Started with SplashKit GPIO
• Reading Button Presses
• Modify PWM through button presses

API Documentation Code Examples:

• Update Animation: Color Cycle Animation
• Resume Music: Pausing and Resuming Game Music
• Camera Position: Display the current camera position.
• Camera X: Read the camera X position while moving horizontally.

---

Close Current Window

Closes and frees the current window.

Signatures:

C++

void close_current_window()

C#

public static void SplashKit.CloseCurrentWindow();

Python

def close_current_window():

Pascal

procedure CloseCurrentWindow()

---

Close Window  {</>}

Note

This function is overloaded. The following versions exist:

• Close Window (name: string)
• Close Window (wind: window)  {</>}

Close Window

Closes and frees the graphics window identified by name.

Parameters:

Name	Type	Description
name	String	The name (caption) of the window to close

Signatures:

C++

void close_window(const string &name)

C#

public static void SplashKit.CloseWindow(string name);

Python

def close_window_named(name):

Pascal

procedure CloseWindow(const name: String)

---

Close Window  {</>}

Closes and frees the graphics window supplied in wind.

Parameters:

Name	Type	Description
wind	Window	The window to close

Signatures:

C++

void close_window(window wind)

C#

public void Window.Close();
public static void SplashKit.CloseWindow(Window wind);

Python

def close_window(wind):

Pascal

procedure CloseWindow(wind: Window)

Usage:  {</>}

See Implementations

API Documentation Code Examples:

• Circle Radius: Using the Circle Radius
• Point In Circle: Splashkit Function: PointInCircle
• Point On Line: Splashkit Function: PointOnLine1
• Random Window Point: Splashkit Function: RandomWindowPoint

See Code Examples

Example 1: Starts a countdown to close the window at the push of a button.

C++

#include "splashkit.h"

int main()
{
    // open a window
    window wind = open_window("DON'T CLICK THE BUTTON!", 400, 200);

    bool countdown_started = false;
    int countdown = 5;
    timer countdown_timer = create_timer("countdown");

    while (!quit_requested())
    {
        // get user events
        process_events();

        // clear screen
        clear_window(wind, COLOR_WHITE);

        if (!countdown_started)
        {
            // Show the button before countdown starts
            if (button("Click Me!", rectangle_from(150, 85, 100, 30)))
            {
                countdown_started = true;
                start_timer(countdown_timer);
            }
        }
        else
        {
            // Display countdown
            draw_text("This window will self destruct in " + std::to_string(countdown), COLOR_BLACK, "arial", 18, 50, 85);

            // Check if 1 second has passed
            if (timer_ticks(countdown_timer) > 1000)
            {
                countdown--;
                reset_timer(countdown_timer);

                if (countdown <= 0)
                {
                    close_window(wind);
                    break;
                }
            }
        }

        draw_interface();
        refresh_window(wind);
    }

    // close all open windows
    close_all_windows();
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

// open a window
Window wind = OpenWindow("DON'T CLICK THE BUTTON!", 400, 200);

bool countdownStarted = false;
int countdown = 5;
// SplashKitSDK.Timer needed to distinguish from System.Threading.Timer
SplashKitSDK.Timer countdownTimer = new SplashKitSDK.Timer("countdown");

// main loop
while (!QuitRequested())
{
    // get user events
    ProcessEvents();

    // clear screen
    ClearWindow(wind, ColorWhite());

    if (!countdownStarted)
    {
        // Show the button before countdown starts
        if (Button("Click Me!", RectangleFrom(150, 85, 100, 30)))
        {
            countdownStarted = true;
            StartTimer(countdownTimer);
        }
    }
    else
    {
        // Display countdown
        DrawText($"This window will self destruct in {countdown}", ColorBlack(), "arial", 18, 50, 85);

        // Check if 1 second has passed
        if (TimerTicks(countdownTimer) > 1000)
        {
            countdown--;
            ResetTimer(countdownTimer);

            if (countdown <= 0)
            {
                CloseWindow(wind);
                break;
            }
        }
    }

    // draw interface and refresh
    DrawInterface();
    RefreshWindow(wind);
}

// close all open windows
CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace CloseWindowExample
{
    public class Program
    {
        public static void Main()
        {
            // open a window
            Window wind = SplashKit.OpenWindow("DON'T CLICK THE BUTTON!", 400, 200);

            bool countdownStarted = false;
            int countdown = 5;
            SplashKitSDK.Timer countdownTimer = new SplashKitSDK.Timer("countdown");

            // main loop
            while (!SplashKit.QuitRequested())
            {
                // get user events
                SplashKit.ProcessEvents();

                // clear screen
                SplashKit.ClearWindow(wind, Color.White);

                if (!countdownStarted)
                {
                    // Show the button before countdown starts
                    if (SplashKit.Button("Click Me!", SplashKit.RectangleFrom(150, 85, 100, 30)))
                    {
                        countdownStarted = true;
                        SplashKit.StartTimer(countdownTimer);
                    }
                }
                else
                {
                    // Display countdown
                    SplashKit.DrawText($"This window will self destruct in {countdown}", Color.Black, "arial", 18, 50, 85);

                    // Check if 1 second has passed
                    if (SplashKit.TimerTicks(countdownTimer) > 1000)
                    {
                        countdown--;
                        SplashKit.ResetTimer(countdownTimer);

                        if (countdown <= 0)
                        {
                            SplashKit.CloseWindow(wind);
                            break;
                        }
                    }
                }

                // draw interface and refresh
                SplashKit.DrawInterface();
                SplashKit.RefreshWindow(wind);
            }

            // close all open windows
            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

# open a window
wind = open_window("DON'T CLICK THE BUTTON!", 400, 200)

countdown_started = False
countdown = 5
countdown_timer = create_timer("countdown")

# main loop
while not quit_requested():
    # get user events
    process_events()

    # clear screen
    clear_window(wind, color_white())

    if not countdown_started:
        # Show the button before countdown starts
        if button_at_position("Click Me!", rectangle_from(150, 85, 100, 30)):
            countdown_started = True
            start_timer(countdown_timer)
    else:
        # Display countdown
        draw_text_font_as_string(f"This window will self destruct in {countdown}", color_black(), "arial", 18, 50, 85)

        # Check if 1 second has passed
        if timer_ticks(countdown_timer) > 1000:
            countdown -= 1
            reset_timer(countdown_timer)

            if countdown <= 0:
                close_window(wind)
                break

    # draw interface and refresh
    draw_interface()
    refresh_window(wind)

# close all open windows
close_all_windows()

Output:

---

Current Window  {</>}

Returns the window that you are currently interacting with. This will be the default window for drawing options, and events.

Return Type: Window

Returns: The current window

Signatures:

C++

window current_window()

C#

public static Window SplashKit.CurrentWindow();

Python

def current_window():

Pascal

function CurrentWindow(): Window

Usage:  {</>}

See Implementations

API Documentation Code Examples:

• Window Has Focus: Show Whether the Window Has Focus

---

Current Window Has Border

Indicate if the current window has a border.

Return Type: Boolean

Returns: True if the window has a border

Signatures:

C++

bool current_window_has_border()

C#

public static bool SplashKit.CurrentWindowHasBorder();

Python

def current_window_has_border():

Pascal

function CurrentWindowHasBorder(): Boolean

---

Current Window Height

Returns the height of the current window.

Return Type: Integer

Returns: The height of the current window

Signatures:

C++

int current_window_height()

C#

public static int SplashKit.CurrentWindowHeight();

Python

def current_window_height():

Pascal

function CurrentWindowHeight(): Integer

---

Current Window Is Fullscreen  {</>}

Is the current window currently fullscreen?

Return Type: Boolean

Returns: True when the window is fullscreen

Signatures:

C++

bool current_window_is_fullscreen()

C#

public static bool SplashKit.CurrentWindowIsFullscreen();

Python

def current_window_is_fullscreen():

Pascal

function CurrentWindowIsFullscreen(): Boolean

Usage:  {</>}

See Implementations

API Documentation Code Examples:

• Current Window Toggle Fullscreen: Presentation Mode

See Code Examples

Example 1: Fullscreen Checker

C++

#include "splashkit.h"

int main()
{
    open_window("Fullscreen Checker", 800, 450);

    while (!quit_requested())
    {
        process_events();

        // Give the player a way to change the state that we are about to check
        if (key_typed(F_KEY))
        {
            current_window_toggle_fullscreen();
        }

        clear_screen(COLOR_WHITE);

        // Check every frame so the text always matches what the window is doing
        bool is_fullscreen = current_window_is_fullscreen();

        if (is_fullscreen)
        {
            draw_text("Fullscreen: true", COLOR_BLACK, "arial", 48, 40, 60);
        }
        else
        {
            draw_text("Fullscreen: false", COLOR_BLACK, "arial", 48, 40, 60);
        }

        draw_text("Press F to switch", COLOR_DARK_GRAY, "arial", 28, 40, 150);

        refresh_screen(60);
    }

    close_all_windows();
    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

OpenWindow("Fullscreen Checker", 800, 450);

while (!QuitRequested())
{
    ProcessEvents();

    // Give the player a way to change the state that we are about to check
    if (KeyTyped(KeyCode.FKey))
    {
        CurrentWindowToggleFullscreen();
    }

    ClearScreen(ColorWhite());

    // Check every frame so the text always matches what the window is doing
    bool isFullscreen = CurrentWindowIsFullscreen();

    if (isFullscreen)
    {
        DrawText("Fullscreen: true", ColorBlack(), "arial", 48, 40, 60);
    }
    else
    {
        DrawText("Fullscreen: false", ColorBlack(), "arial", 48, 40, 60);
    }

    DrawText("Press F to switch", ColorDarkGray(), "arial", 28, 40, 150);

    RefreshScreen(60);
}

CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace CurrentWindowIsFullscreenExample
{
    public class Program
    {
        public static void Main()
        {
            SplashKit.OpenWindow("Fullscreen Checker", 800, 450);

            while (!SplashKit.QuitRequested())
            {
                SplashKit.ProcessEvents();

                // Give the player a way to change the state that we are about to check
                if (SplashKit.KeyTyped(KeyCode.FKey))
                {
                    SplashKit.CurrentWindowToggleFullscreen();
                }

                SplashKit.ClearScreen(Color.White);

                // Check every frame so the text always matches what the window is doing
                bool isFullscreen = SplashKit.CurrentWindowIsFullscreen();

                if (isFullscreen)
                {
                    SplashKit.DrawText("Fullscreen: true", Color.Black, "arial", 48, 40, 60);
                }
                else
                {
                    SplashKit.DrawText("Fullscreen: false", Color.Black, "arial", 48, 40, 60);
                }

                SplashKit.DrawText("Press F to switch", Color.DarkGray, "arial", 28, 40, 150);

                SplashKit.RefreshScreen(60);
            }

            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

open_window("Fullscreen Checker", 800, 450)

while not quit_requested():
    process_events()

    # Give the player a way to change the state that we are about to check
    if key_typed(KeyCode.f_key):
        current_window_toggle_fullscreen()

    clear_screen_to_white()

    # Check every frame so the text always matches what the window is doing
    is_fullscreen = current_window_is_fullscreen()

    if is_fullscreen:
        draw_text_font_as_string("Fullscreen: true", color_black(), "arial", 48, 40, 60)
    else:
        draw_text_font_as_string("Fullscreen: false", color_black(), "arial", 48, 40, 60)

    draw_text_font_as_string("Press F to switch", color_dark_gray(), "arial", 28, 40, 150)

    refresh_screen_with_target_fps(60)

close_all_windows()

Output:

---

Current Window Position

The location of the current window.

Return Type: Point 2d

Returns: Its location on the displays

Signatures:

C++

point_2d current_window_position()

C#

public static Point2D SplashKit.CurrentWindowPosition();

Python

def current_window_position():

Pascal

function CurrentWindowPosition(): Point2D

---

Current Window Toggle Border

Toggle the current window border.

Signatures:

C++

void current_window_toggle_border()

C#

public static void SplashKit.CurrentWindowToggleBorder();

Python

def current_window_toggle_border():

Pascal

procedure CurrentWindowToggleBorder()

---

Current Window Toggle Fullscreen  {</>}

Toggle the fullscreen property of the current window

Signatures:

C++

void current_window_toggle_fullscreen()

C#

public static void SplashKit.CurrentWindowToggleFullscreen();

Python

def current_window_toggle_fullscreen():

Pascal

procedure CurrentWindowToggleFullscreen()

Usage:  {</>}

See Implementations

API Documentation Code Examples:

• Current Window Is Fullscreen: Fullscreen Checker

See Code Examples

Example 1: Presentation Mode

C++

#include "splashkit.h"

int main()
{
    open_window("Presentation Mode", 800, 450);

    while (!quit_requested())
    {
        process_events();

        // Toggling means the same key can both enter and leave fullscreen
        if (key_typed(F_KEY))
        {
            current_window_toggle_fullscreen();
        }

        // Draw for the new state so the screen shows which mode the window is in
        if (current_window_is_fullscreen())
        {
            clear_screen(COLOR_BLACK);
            draw_text("Fullscreen mode", COLOR_WHITE, "arial", 48, 40, 60);
            draw_text("Press F to leave fullscreen", COLOR_LIGHT_GRAY, "arial", 28, 40, 150);
        }
        else
        {
            clear_screen(COLOR_WHITE);
            draw_text("Windowed mode", COLOR_BLACK, "arial", 48, 40, 60);
            draw_text("Press F to enter fullscreen", COLOR_DARK_GRAY, "arial", 28, 40, 150);
        }

        refresh_screen(60);
    }

    close_all_windows();
    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

OpenWindow("Presentation Mode", 800, 450);

while (!QuitRequested())
{
    ProcessEvents();

    // Toggling means the same key can both enter and leave fullscreen
    if (KeyTyped(KeyCode.FKey))
    {
        CurrentWindowToggleFullscreen();
    }

    // Draw for the new state so the screen shows which mode the window is in
    if (CurrentWindowIsFullscreen())
    {
        ClearScreen(ColorBlack());
        DrawText("Fullscreen mode", ColorWhite(), "arial", 48, 40, 60);
        DrawText("Press F to leave fullscreen", ColorLightGray(), "arial", 28, 40, 150);
    }
    else
    {
        ClearScreen(ColorWhite());
        DrawText("Windowed mode", ColorBlack(), "arial", 48, 40, 60);
        DrawText("Press F to enter fullscreen", ColorDarkGray(), "arial", 28, 40, 150);
    }

    RefreshScreen(60);
}

CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace CurrentWindowToggleFullscreenExample
{
    public class Program
    {
        public static void Main()
        {
            SplashKit.OpenWindow("Presentation Mode", 800, 450);

            while (!SplashKit.QuitRequested())
            {
                SplashKit.ProcessEvents();

                // Toggling means the same key can both enter and leave fullscreen
                if (SplashKit.KeyTyped(KeyCode.FKey))
                {
                    SplashKit.CurrentWindowToggleFullscreen();
                }

                // Draw for the new state so the screen shows which mode the window is in
                if (SplashKit.CurrentWindowIsFullscreen())
                {
                    SplashKit.ClearScreen(Color.Black);
                    SplashKit.DrawText("Fullscreen mode", Color.White, "arial", 48, 40, 60);
                    SplashKit.DrawText("Press F to leave fullscreen", Color.LightGray, "arial", 28, 40, 150);
                }
                else
                {
                    SplashKit.ClearScreen(Color.White);
                    SplashKit.DrawText("Windowed mode", Color.Black, "arial", 48, 40, 60);
                    SplashKit.DrawText("Press F to enter fullscreen", Color.DarkGray, "arial", 28, 40, 150);
                }

                SplashKit.RefreshScreen(60);
            }

            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

open_window("Presentation Mode", 800, 450)

while not quit_requested():
    process_events()

    # Toggling means the same key can both enter and leave fullscreen
    if key_typed(KeyCode.f_key):
        current_window_toggle_fullscreen()

    # Draw for the new state so the screen shows which mode the window is in
    if current_window_is_fullscreen():
        clear_screen(color_black())
        draw_text_font_as_string("Fullscreen mode", color_white(), "arial", 48, 40, 60)
        draw_text_font_as_string("Press F to leave fullscreen", color_light_gray(), "arial", 28, 40, 150)
    else:
        clear_screen(color_white())
        draw_text_font_as_string("Windowed mode", color_black(), "arial", 48, 40, 60)
        draw_text_font_as_string("Press F to enter fullscreen", color_dark_gray(), "arial", 28, 40, 150)

    refresh_screen_with_target_fps(60)

close_all_windows()

Output:

---

Current Window Width  {</>}

Returns the width of the current window.

Return Type: Integer

Returns: The width of the current window

Signatures:

C++

int current_window_width()

C#

public static int SplashKit.CurrentWindowWidth();

Python

def current_window_width():

Pascal

function CurrentWindowWidth(): Integer

Usage:  {</>}

See Code Examples

Example 1: Show the Current Window Width

C++

#include "splashkit.h"
#include <string>

int main()
{
    open_window("Current Window Width", 800, 600);

    while (!quit_requested())
    {
        process_events();

        int window_width = current_window_width();

        clear_screen(COLOR_WHITE);

        draw_text("Current window width:", COLOR_BLACK, 220, 220);
        draw_text(std::to_string(window_width) + " pixels", COLOR_BLUE, 260, 270);

        refresh_screen(60);
    }

    close_all_windows();
    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

OpenWindow("Current Window Width", 800, 600);

while (!QuitRequested())
{
    ProcessEvents();

    int windowWidth = CurrentWindowWidth();

    ClearScreen(ColorWhite());

    DrawText("Current window width:", ColorBlack(), 220, 220);
    DrawText(windowWidth.ToString() + " pixels", ColorBlue(), 260, 270);

    RefreshScreen(60);
}

CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace CurrentWindowWidthExample
{
    public class Program
    {
        public static void Main()
        {
            SplashKit.OpenWindow("Current Window Width", 800, 600);

            while (!SplashKit.QuitRequested())
            {
                SplashKit.ProcessEvents();

                int windowWidth = SplashKit.CurrentWindowWidth();

                SplashKit.ClearScreen(Color.White);

                SplashKit.DrawText("Current window width:", Color.Black, 220, 220);
                SplashKit.DrawText(windowWidth.ToString() + " pixels", Color.Blue, 260, 270);

                SplashKit.RefreshScreen(60);
            }

            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

open_window("Current Window Width", 800, 600)

while not quit_requested():
    process_events()

    window_width = current_window_width()

    clear_screen(color_white())

    draw_text_no_font_no_size("Current window width:", color_black(), 220, 220)
    draw_text_no_font_no_size(str(window_width) + " pixels", color_blue(), 260, 270)

    refresh_screen_with_target_fps(60)

close_all_windows()

Output:

---

Current Window X

The x location of the current window on the displays.

Return Type: Integer

Returns: Its location on the displays

Signatures:

C++

int current_window_x()

C#

public static int SplashKit.CurrentWindowX();

Python

def current_window_x():

Pascal

function CurrentWindowX(): Integer

---

Current Window Y

The y location of the current window on the displays.

Return Type: Integer

Returns: Its location on the displays

Signatures:

C++

int current_window_y()

C#

public static int SplashKit.CurrentWindowY();

Python

def current_window_y():

Pascal

function CurrentWindowY(): Integer

---

Has Window

Determines if SplashKit has a window loaded with the supplied name. This checks against all windows loaded, those loaded without a name are assigned the filename as a default. If this returns false, you may want to use load_window to load in a specific window and give it the desired name.

Parameters:

Name	Type	Description
caption	String	The name of the window to check for.

Return Type: Boolean

Returns: Returns true if there is a window with the given caption which has has been loaded.

Signatures:

C++

bool has_window(string caption)

C#

public static bool SplashKit.HasWindow(string caption);

Python

def has_window(caption):

Pascal

function HasWindow(caption: String): Boolean

---

Is Current Window

Check if the requested window is the current window.

Parameters:

Name	Type	Description
wind	Window	The window to check

Return Type: Boolean

Returns: true if the window is the current window

Signatures:

C++

bool is_current_window(window wind)

C#

public bool Window.IsCurrentWindow { get }
public static bool SplashKit.IsCurrentWindow(Window wind);

Python

def is_current_window(wind):

Pascal

function IsCurrentWindow(wind: Window): Boolean

---

Move Current Window To

Move the current window to the new location on the displays.

Parameters:

Name	Type	Description
x	Integer	The new x location
y	Integer	The new y location

Signatures:

C++

void move_current_window_to(int x, int y)

C#

public static void SplashKit.MoveCurrentWindowTo(int x, int y);

Python

def move_current_window_to(x, y):

Pascal

procedure MoveCurrentWindowTo(x: Integer; y: Integer)

---

Move Window To  {</>}

Note

This function is overloaded. The following versions exist:

• Move Window To (name: string, x: int, y: int)
• Move Window To (wind: window, x: int, y: int)  {</>}

Move Window To

Move the window to the new location on the displays.

Parameters:

Name	Type	Description
name	String	The name of the window to move
x	Integer	The new x location
y	Integer	The new y location

Signatures:

C++

void move_window_to(const string &name, int x, int y)

C#

public static void SplashKit.MoveWindowTo(string name, int x, int y);

Python

def move_window_to_named(name, x, y):

Pascal

procedure MoveWindowTo(const name: String; x: Integer; y: Integer)

---

Move Window To  {</>}

Move the window to the new location on the displays.

Parameters:

Name	Type	Description
wind	Window	the window to move.
x	Integer	The new x location
y	Integer	The new y location

Signatures:

C++

void move_window_to(window wind, int x, int y)

C#

public void Window.MoveTo(int x, int y);
public static void SplashKit.MoveWindowTo(Window wind, int x, int y);

Python

def move_window_to(wind, x, y):

Pascal

procedure MoveWindowTo(wind: Window; x: Integer; y: Integer)

Usage:  {</>}

See Implementations

API Documentation Code Examples:

• Draw Quad On Window: Halved Ninja Star
• Fill Quad On Window: Halved Coloured Star
• Fill Rectangle On Window: Filled Rectangles on Separate Windows
• Fill Rectangle On Window: Filled Rectangles on Separate Windows

---

Open Window  {</>}

Opens a new graphics window. The supplied caption is used to name and identify the window. The supplied width and height indicate the size of the window. The window can be retrieved by passing caption to the Window Named function.

Parameters:

Name	Type	Description
caption	String	The title of the window. If a window with this caption already exists, SplashKit will alter the caption to ensure that it is unique.
width	Integer	The width of the window
height	Integer	The height of the window

Return Type: Window

Returns: A new window

Signatures:

C++

window open_window(string caption, int width, int height)

C#

public static Window SplashKit.OpenWindow(string caption, int width, int height);
public Window(string caption, int width, int height);

Python

def open_window(caption, width, height):

Pascal

function OpenWindow(caption: String; width: Integer; height: Integer): Window

Usage:  {</>}

See Implementations

Tutorials and Guides:

• Using Animations in SplashKit
• Drawing using Procedures
• User Inputs in Graphical Applications
• Getting Started Creating User Interfaces
• Get Started with SplashKit GPIO
• Reading Button Presses
• Modify PWM through button presses

API Documentation Code Examples:

• Update Animation: Color Cycle Animation
• Resume Music: Pausing and Resuming Game Music
• Stop Music: Stop/Start Music
• Camera Position: Display the current camera position.

---

Refresh Window  {</>}

Note

This function is overloaded. The following versions exist:

• Refresh Window (wind: window)  {</>}
• Refresh Window (wind: window, target_fps: unsigned int)

Refresh Window  {</>}

Refreshes the window wind.

Parameters:

Name	Type	Description
wind	Window	the Window to refresh.

Signatures:

C++

void refresh_window(window wind)

C#

public void Window.Refresh();
public static void SplashKit.RefreshWindow(Window wind);

Python

def refresh_window(wind):

Pascal

procedure RefreshWindow(wind: Window)

Usage:  {</>}

See Implementations

API Documentation Code Examples:

• Resume Music: Pausing and Resuming Game Music
• Fill Rectangle On Window: Filled Rectangles on Separate Windows
• Fill Rectangle On Window: Filled Rectangles on Separate Windows
• Fill Triangle On Window: Filled Triangles on Separate Windows

---

Refresh Window

Refreshes the window wind.

Parameters:

Name	Type	Description
wind	Window	the Window to refresh.
target_fps	Unsigned Integer	the desired framerate

Signatures:

C++

void refresh_window(window wind, unsigned int target_fps)

C#

public void Window.Refresh(uint targetFps);
public static void SplashKit.RefreshWindow(Window wind, uint targetFps);

Python

def refresh_window_with_target_fps(wind, target_fps):

Pascal

procedure RefreshWindow(wind: Window; targetFps: Cardinal)

---

Resize Current Window

Change the size of the current window.

Parameters:

Name	Type	Description
width	Integer	Its new width
height	Integer	Its new height

Signatures:

C++

void resize_current_window(int width, int height)

C#

public static void SplashKit.ResizeCurrentWindow(int width, int height);

Python

def resize_current_window(width, height):

Pascal

procedure ResizeCurrentWindow(width: Integer; height: Integer)

---

Resize Window

Change the size of the window.

Parameters:

Name	Type	Description
wnd	Window	The window to change.
width	Integer	Its new width
height	Integer	Its new height

Signatures:

C++

void resize_window(window wnd, int width, int height)

C#

public void Window.Resize(int width, int height);
public static void SplashKit.ResizeWindow(Window wnd, int width, int height);

Python

def resize_window(wnd, width, height):

Pascal

procedure ResizeWindow(wnd: Window; width: Integer; height: Integer)

---

Set Current Window

Note

This function is overloaded. The following versions exist:

• Set Current Window (name: string)
• Set Current Window (wind: window)

Set Current Window

Set the current window to the window with the supplied caption.

Parameters:

Name	Type	Description
name	String	The caption of the new current window.

Signatures:

C++

void set_current_window(const string &name)

C#

public static void SplashKit.SetCurrentWindow(string name);

Python

def set_current_window_named(name):

Pascal

procedure SetCurrentWindow(const name: String)

---

Set Current Window

Change the current window. Use this so that you can draw to different windows by default.

Parameters:

Name	Type	Description
wind	Window	The new current window

Signatures:

C++

void set_current_window(window wind)

C#

public void Window.MakeCurrent();
public static void SplashKit.SetCurrentWindow(Window wind);

Python

def set_current_window(wind):

Pascal

procedure SetCurrentWindow(wind: Window)

---

Window Caption

The caption of the window.

Parameters:

Name	Type	Description
wind	Window	The window

Return Type: String

Returns: The window’s caption.

Signatures:

C++

string window_caption(window wind)

C#

public string Window.Caption { get }
public static string SplashKit.WindowCaption(Window wind);

Python

def window_caption(wind):

Pascal

function WindowCaption(wind: Window): String

---

Window Close Requested  {</>}

Note

This function is overloaded. The following versions exist:

• Window Close Requested (name: string)
• Window Close Requested (wind: window)  {</>}

Window Close Requested

Checks all opened windows in the current program to determin if a window with the name name is currently open, and will close a window if one is found.

Parameters:

Name	Type	Description
name	String	The name of the window to close

Return Type: Boolean

Returns: Returns true if the window has been asked to close.

Signatures:

C++

bool window_close_requested(const string &name)

C#

public static bool SplashKit.WindowCloseRequested(string name);

Python

def window_close_requested_named(name):

Pascal

function WindowCloseRequested(const name: String): Boolean

---

Window Close Requested  {</>}

Closes the window given in wind

Parameters:

Name	Type	Description
wind	Window	the Window to be closed

Return Type: Boolean

Returns: Returns true if the window is closed, false if there is an error.

Signatures:

C++

bool window_close_requested(window wind)

C#

public bool Window.CloseRequested { get }
public static bool SplashKit.WindowCloseRequested(Window wind);

Python

def window_close_requested(wind):

Pascal

function WindowCloseRequested(wind: Window): Boolean

Usage:  {</>}

See Implementations

Tutorials and Guides:

• User Inputs in Graphical Applications

API Documentation Code Examples:

• Circle Radius: Using the Circle Radius
• Draw Circle On Bitmap: Creating a Red Planet
• Draw Line On Bitmap: Drawing a Route on a Map
• Draw Quad On Bitmap: 3D Cube

---

Window Has Border

Note

This function is overloaded. The following versions exist:

• Window Has Border (name: string)
• Window Has Border (wnd: window)

Window Has Border

Indicate if the window has a border.

Parameters:

Name	Type	Description
name	String	The name of the window

Return Type: Boolean

Returns: True if the window has a border

Signatures:

C++

bool window_has_border(const string &name)

C#

public static bool SplashKit.WindowHasBorder(string name);

Python

def window_has_border_named(name):

Pascal

function WindowHasBorder(const name: String): Boolean

---

Window Has Border

Indicate if the window has a border.

Parameters:

Name	Type	Description
wnd	Window	The window

Return Type: Boolean

Returns: True if the window has a border

Signatures:

C++

bool window_has_border(window wnd)

C#

public bool Window.HasBorder { get }
public static bool SplashKit.WindowHasBorder(Window wnd);

Python

def window_has_border(wnd):

Pascal

function WindowHasBorder(wnd: Window): Boolean

---

Window Has Focus  {</>}

Indicates if the window has focus.

Parameters:

Name	Type	Description
wind	Window	The window

Return Type: Boolean

Returns: True if the window has the user’s focus

Signatures:

C++

bool window_has_focus(window wind)

C#

public bool Window.HasFocus { get }
public static bool SplashKit.WindowHasFocus(Window wind);

Python

def window_has_focus(wind):

Pascal

function WindowHasFocus(wind: Window): Boolean

Usage:  {</>}

See Code Examples

Example 1: Show Whether the Window Has Focus

C++

#include "splashkit.h"

int main()
{
    open_window("Window Has Focus", 800, 600);

    while (!quit_requested())
    {
        process_events();

        // Check whether the current window has focus
        bool has_focus = window_has_focus(current_window());

        clear_screen(COLOR_WHITE);

        // Show the current focus state on screen
        draw_text("Click on or away from the window to change focus.", COLOR_BLACK, 120, 220);

        if (has_focus)
        {
            draw_text("Window has focus", COLOR_GREEN, 280, 280);
        }
        else
        {
            draw_text("Window does not have focus", COLOR_RED, 240, 280);
        }

        refresh_screen(60);
    }

    close_all_windows();
    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

OpenWindow("Window Has Focus", 800, 600);

while (!QuitRequested())
{
    ProcessEvents();

    // Check whether the current window has focus
    bool hasFocus = WindowHasFocus(CurrentWindow());

    ClearScreen(ColorWhite());

    // Show the current focus state on screen
    DrawText("Click on or away from the window to change focus.", ColorBlack(), 120, 220);

    if (hasFocus)
    {
        DrawText("Window has focus", ColorGreen(), 280, 280);
    }
    else
    {
        DrawText("Window does not have focus", ColorRed(), 240, 280);
    }

    RefreshScreen(60);
}

CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace WindowHasFocusExample
{
    public class Program
    {
        public static void Main()
        {
            SplashKit.OpenWindow("Window Has Focus", 800, 600);

            while (!SplashKit.QuitRequested())
            {
                SplashKit.ProcessEvents();

                // Check whether the current window has focus
                bool hasFocus = SplashKit.WindowHasFocus(SplashKit.CurrentWindow());

                SplashKit.ClearScreen(Color.White);

                // Show the current focus state on screen
                SplashKit.DrawText("Click on or away from the window to change focus.", Color.Black, 120, 220);

                if (hasFocus)
                {
                    SplashKit.DrawText("Window has focus", Color.Green, 280, 280);
                }
                else
                {
                    SplashKit.DrawText("Window does not have focus", Color.Red, 240, 280);
                }

                SplashKit.RefreshScreen(60);
            }

            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

open_window("Window Has Focus", 800, 600)

while not quit_requested():
    process_events()

    # Check whether the current window has focus
    has_focus = window_has_focus(current_window())

    clear_screen(color_white())

    # Show the current focus state on screen
    draw_text_no_font_no_size("Click on or away from the window to change focus.", color_black(), 120, 220)

    if has_focus:
        draw_text_no_font_no_size("Window has focus", color_green(), 280, 280)
    else:
        draw_text_no_font_no_size("Window does not have focus", color_red(), 240, 280)

    refresh_screen_with_target_fps(60)

close_all_windows()

Output:

---

Window Height

Note

This function is overloaded. The following versions exist:

• Window Height (name: string)
• Window Height (wind: window)

Window Height

Returns the height of the window with the indicated name in pixels.

Parameters:

Name	Type	Description
name	String	The name of the window

Return Type: Integer

Returns: The height of the window

Signatures:

C++

int window_height(const string &name)

C#

public static int SplashKit.WindowHeight(string name);

Python

def window_height_named(name):

Pascal

function WindowHeight(const name: String): Integer

---

Window Height

Returns the height of the window in pixels.

Parameters:

Name	Type	Description
wind	Window	The window

Return Type: Integer

Returns: The height of the window

Signatures:

C++

int window_height(window wind)

C#

public int Window.Height { get }
public static int SplashKit.WindowHeight(Window wind);

Python

def window_height(wind):

Pascal

function WindowHeight(wind: Window): Integer

---

Window Is Fullscreen  {</>}

Note

This function is overloaded. The following versions exist:

• Window Is Fullscreen (name: string)  {</>}
• Window Is Fullscreen (wnd: window)  {</>}

Window Is Fullscreen  {</>}

Is the window currently fullscreen?

Parameters:

Name	Type	Description
name	String	The name of the window to check

Return Type: Boolean

Returns: True when the window is fullscreen

Signatures:

C++

bool window_is_fullscreen(const string &name)

C#

public static bool SplashKit.WindowIsFullscreen(string name);

Python

def window_is_fullscreen_named(name):

Pascal

function WindowIsFullscreen(const name: String): Boolean

Usage:  {</>}

See Code Examples

Example 1: Caption Status Light

C++

#include "splashkit.h"

int main()
{
    // Keep the caption in one variable so the window and the lookups can never disagree
    string preview_caption = "Preview";

    window dashboard_window = open_window("Dashboard", 480, 280);
    window preview_window = open_window(preview_caption, 480, 280);

    // Place the windows side by side so both stay visible
    move_window_to(dashboard_window, 60, 100);
    move_window_to(preview_window, 580, 100);

    while (!quit_requested())
    {
        process_events();

        // The F key sends the preview window in and out of fullscreen
        if (key_typed(F_KEY))
        {
            window_toggle_fullscreen(preview_caption);
        }

        // Look the window up by its caption, so no window handle is needed here
        bool preview_is_fullscreen = window_is_fullscreen(preview_caption);

        // The whole dashboard acts as a status light
        if (preview_is_fullscreen)
        {
            clear_window(dashboard_window, COLOR_LIGHT_GREEN);
            draw_text_on_window(dashboard_window, "Preview is fullscreen", COLOR_BLACK, "arial", 30, 20, 60);
        }
        else
        {
            clear_window(dashboard_window, COLOR_LIGHT_GRAY);
            draw_text_on_window(dashboard_window, "Preview is windowed", COLOR_BLACK, "arial", 30, 20, 60);
        }

        draw_text_on_window(dashboard_window, "Press F to toggle the preview", COLOR_DARK_GRAY, "arial", 20, 20, 140);
        refresh_window(dashboard_window);

        clear_window(preview_window, COLOR_LIGHT_BLUE);
        draw_text_on_window(preview_window, "Preview", COLOR_BLACK, "arial", 40, 20, 40);

        // The preview shows the same answer, because the dashboard is hidden while it fills the screen
        if (preview_is_fullscreen)
        {
            draw_text_on_window(preview_window, "Fullscreen: true", COLOR_BLACK, "arial", 30, 20, 120);
        }
        else
        {
            draw_text_on_window(preview_window, "Fullscreen: false", COLOR_BLACK, "arial", 30, 20, 120);
        }

        draw_text_on_window(preview_window, "Press F to toggle", COLOR_DARK_GRAY, "arial", 20, 20, 190);
        refresh_window(preview_window);
    }

    close_all_windows();
    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

// Keep the caption in one variable so the window and the lookups can never disagree
string previewCaption = "Preview";

Window dashboardWindow = OpenWindow("Dashboard", 480, 280);
Window previewWindow = OpenWindow(previewCaption, 480, 280);

// Place the windows side by side so both stay visible
MoveWindowTo(dashboardWindow, 60, 100);
MoveWindowTo(previewWindow, 580, 100);

while (!QuitRequested())
{
    ProcessEvents();

    // The F key sends the preview window in and out of fullscreen
    if (KeyTyped(KeyCode.FKey))
    {
        WindowToggleFullscreen(previewCaption);
    }

    // Look the window up by its caption, so no window handle is needed here
    bool previewIsFullscreen = WindowIsFullscreen(previewCaption);

    // The whole dashboard acts as a status light
    if (previewIsFullscreen)
    {
        ClearWindow(dashboardWindow, ColorLightGreen());
        DrawTextOnWindow(dashboardWindow, "Preview is fullscreen", ColorBlack(), "arial", 30, 20, 60);
    }
    else
    {
        ClearWindow(dashboardWindow, ColorLightGray());
        DrawTextOnWindow(dashboardWindow, "Preview is windowed", ColorBlack(), "arial", 30, 20, 60);
    }

    DrawTextOnWindow(dashboardWindow, "Press F to toggle the preview", ColorDarkGray(), "arial", 20, 20, 140);
    RefreshWindow(dashboardWindow);

    ClearWindow(previewWindow, ColorLightBlue());
    DrawTextOnWindow(previewWindow, "Preview", ColorBlack(), "arial", 40, 20, 40);

    // The preview shows the same answer, because the dashboard is hidden while it fills the screen
    if (previewIsFullscreen)
    {
        DrawTextOnWindow(previewWindow, "Fullscreen: true", ColorBlack(), "arial", 30, 20, 120);
    }
    else
    {
        DrawTextOnWindow(previewWindow, "Fullscreen: false", ColorBlack(), "arial", 30, 20, 120);
    }

    DrawTextOnWindow(previewWindow, "Press F to toggle", ColorDarkGray(), "arial", 20, 20, 190);
    RefreshWindow(previewWindow);
}

CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace WindowIsFullscreenNamedExample
{
    public class Program
    {
        public static void Main()
        {
            // Keep the caption in one variable so the window and the lookups can never disagree
            string previewCaption = "Preview";

            Window dashboardWindow = SplashKit.OpenWindow("Dashboard", 480, 280);
            Window previewWindow = SplashKit.OpenWindow(previewCaption, 480, 280);

            // Place the windows side by side so both stay visible
            dashboardWindow.MoveTo(60, 100);
            previewWindow.MoveTo(580, 100);

            while (!SplashKit.QuitRequested())
            {
                SplashKit.ProcessEvents();

                // The F key sends the preview window in and out of fullscreen
                if (SplashKit.KeyTyped(KeyCode.FKey))
                {
                    SplashKit.WindowToggleFullscreen(previewCaption);
                }

                // Look the window up by its caption, so no window handle is needed here
                bool previewIsFullscreen = SplashKit.WindowIsFullscreen(previewCaption);

                // The whole dashboard acts as a status light
                if (previewIsFullscreen)
                {
                    dashboardWindow.Clear(Color.LightGreen);
                    dashboardWindow.DrawText("Preview is fullscreen", Color.Black, "arial", 30, 20, 60);
                }
                else
                {
                    dashboardWindow.Clear(Color.LightGray);
                    dashboardWindow.DrawText("Preview is windowed", Color.Black, "arial", 30, 20, 60);
                }

                dashboardWindow.DrawText("Press F to toggle the preview", Color.DarkGray, "arial", 20, 20, 140);
                dashboardWindow.Refresh();

                previewWindow.Clear(Color.LightBlue);
                previewWindow.DrawText("Preview", Color.Black, "arial", 40, 20, 40);

                // The preview shows the same answer, because the dashboard is hidden while it fills the screen
                if (previewIsFullscreen)
                {
                    previewWindow.DrawText("Fullscreen: true", Color.Black, "arial", 30, 20, 120);
                }
                else
                {
                    previewWindow.DrawText("Fullscreen: false", Color.Black, "arial", 30, 20, 120);
                }

                previewWindow.DrawText("Press F to toggle", Color.DarkGray, "arial", 20, 20, 190);
                previewWindow.Refresh();
            }

            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

# Keep the caption in one variable so the window and the lookups can never disagree
preview_caption = "Preview"

dashboard_window = open_window("Dashboard", 480, 280)
preview_window = open_window(preview_caption, 480, 280)

# Place the windows side by side so both stay visible
move_window_to(dashboard_window, 60, 100)
move_window_to(preview_window, 580, 100)

while not quit_requested():
    process_events()

    # The F key sends the preview window in and out of fullscreen
    if key_typed(KeyCode.f_key):
        window_toggle_fullscreen_named(preview_caption)

    # Look the window up by its caption, so no window handle is needed here
    preview_is_fullscreen = window_is_fullscreen_named(preview_caption)

    # The whole dashboard acts as a status light
    if preview_is_fullscreen:
        clear_window(dashboard_window, color_light_green())
        draw_text_on_window_font_as_string(dashboard_window, "Preview is fullscreen", color_black(), "arial", 30, 20, 60)
    else:
        clear_window(dashboard_window, color_light_gray())
        draw_text_on_window_font_as_string(dashboard_window, "Preview is windowed", color_black(), "arial", 30, 20, 60)

    draw_text_on_window_font_as_string(dashboard_window, "Press F to toggle the preview", color_dark_gray(), "arial", 20, 20, 140)
    refresh_window(dashboard_window)

    clear_window(preview_window, color_light_blue())
    draw_text_on_window_font_as_string(preview_window, "Preview", color_black(), "arial", 40, 20, 40)

    # The preview shows the same answer, because the dashboard is hidden while it fills the screen
    if preview_is_fullscreen:
        draw_text_on_window_font_as_string(preview_window, "Fullscreen: true", color_black(), "arial", 30, 20, 120)
    else:
        draw_text_on_window_font_as_string(preview_window, "Fullscreen: false", color_black(), "arial", 30, 20, 120)

    draw_text_on_window_font_as_string(preview_window, "Press F to toggle", color_dark_gray(), "arial", 20, 20, 190)
    refresh_window(preview_window)

close_all_windows()

Output:

---

Window Is Fullscreen  {</>}

Is the window currently fullscreen?

Parameters:

Name	Type	Description
wnd	Window	The window to check

Return Type: Boolean

Returns: True when the window is fullscreen

Signatures:

C++

bool window_is_fullscreen(window wnd)

C#

public bool Window.IsFullscreen { get }
public static bool SplashKit.WindowIsFullscreen(Window wnd);

Python

def window_is_fullscreen(wnd):

Pascal

function WindowIsFullscreen(wnd: Window): Boolean

Usage:  {</>}

See Implementations

API Documentation Code Examples:

• Window Toggle Fullscreen: Projector Screen

See Code Examples

Example 1: Window Status Board

C++

#include "splashkit.h"

void draw_window_status(window wnd, const string &name)
{
    // Ask this specific window, using its handle, whether it is fullscreen
    bool is_fullscreen = window_is_fullscreen(wnd);

    clear_window(wnd, COLOR_WHITE);
    draw_text_on_window(wnd, name, COLOR_BLACK, "arial", 40, 20, 30);

    if (is_fullscreen)
    {
        draw_text_on_window(wnd, "Fullscreen: true", COLOR_BLACK, "arial", 30, 20, 100);
    }
    else
    {
        draw_text_on_window(wnd, "Fullscreen: false", COLOR_BLACK, "arial", 30, 20, 100);
    }

    draw_text_on_window(wnd, "Press L or R to toggle a window", COLOR_DARK_GRAY, "arial", 20, 20, 170);
    refresh_window(wnd);
}

int main()
{
    window left_window = open_window("Left Window", 480, 280);
    window right_window = open_window("Right Window", 480, 280);

    // Place the windows side by side so both stay visible
    move_window_to(left_window, 60, 100);
    move_window_to(right_window, 580, 100);

    while (!quit_requested())
    {
        process_events();

        // Each key sends one window in or out of fullscreen
        if (key_typed(L_KEY))
        {
            window_toggle_fullscreen(left_window);
        }

        if (key_typed(R_KEY))
        {
            window_toggle_fullscreen(right_window);
        }

        // Every window reports its own state, so the text stays visible while it fills the screen
        draw_window_status(left_window, "Left Window");
        draw_window_status(right_window, "Right Window");
    }

    close_all_windows();
    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

void DrawWindowStatus(Window wnd, string name)
{
    // Ask this specific window, using its handle, whether it is fullscreen
    bool isFullscreen = WindowIsFullscreen(wnd);

    ClearWindow(wnd, ColorWhite());
    DrawTextOnWindow(wnd, name, ColorBlack(), "arial", 40, 20, 30);

    if (isFullscreen)
    {
        DrawTextOnWindow(wnd, "Fullscreen: true", ColorBlack(), "arial", 30, 20, 100);
    }
    else
    {
        DrawTextOnWindow(wnd, "Fullscreen: false", ColorBlack(), "arial", 30, 20, 100);
    }

    DrawTextOnWindow(wnd, "Press L or R to toggle a window", ColorDarkGray(), "arial", 20, 20, 170);
    RefreshWindow(wnd);
}

Window leftWindow = OpenWindow("Left Window", 480, 280);
Window rightWindow = OpenWindow("Right Window", 480, 280);

// Place the windows side by side so both stay visible
MoveWindowTo(leftWindow, 60, 100);
MoveWindowTo(rightWindow, 580, 100);

while (!QuitRequested())
{
    ProcessEvents();

    // Each key sends one window in or out of fullscreen
    if (KeyTyped(KeyCode.LKey))
    {
        WindowToggleFullscreen(leftWindow);
    }

    if (KeyTyped(KeyCode.RKey))
    {
        WindowToggleFullscreen(rightWindow);
    }

    // Every window reports its own state, so the text stays visible while it fills the screen
    DrawWindowStatus(leftWindow, "Left Window");
    DrawWindowStatus(rightWindow, "Right Window");
}

CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace WindowIsFullscreenExample
{
    public class Program
    {
        private static void DrawWindowStatus(Window wnd, string name)
        {
            // Ask this specific window, using its handle, whether it is fullscreen
            bool isFullscreen = SplashKit.WindowIsFullscreen(wnd);

            wnd.Clear(Color.White);
            wnd.DrawText(name, Color.Black, "arial", 40, 20, 30);

            if (isFullscreen)
            {
                wnd.DrawText("Fullscreen: true", Color.Black, "arial", 30, 20, 100);
            }
            else
            {
                wnd.DrawText("Fullscreen: false", Color.Black, "arial", 30, 20, 100);
            }

            wnd.DrawText("Press L or R to toggle a window", Color.DarkGray, "arial", 20, 20, 170);
            wnd.Refresh();
        }

        public static void Main()
        {
            Window leftWindow = SplashKit.OpenWindow("Left Window", 480, 280);
            Window rightWindow = SplashKit.OpenWindow("Right Window", 480, 280);

            // Place the windows side by side so both stay visible
            leftWindow.MoveTo(60, 100);
            rightWindow.MoveTo(580, 100);

            while (!SplashKit.QuitRequested())
            {
                SplashKit.ProcessEvents();

                // Each key sends one window in or out of fullscreen
                if (SplashKit.KeyTyped(KeyCode.LKey))
                {
                    leftWindow.ToggleFullscreen();
                }

                if (SplashKit.KeyTyped(KeyCode.RKey))
                {
                    rightWindow.ToggleFullscreen();
                }

                // Every window reports its own state, so the text stays visible while it fills the screen
                DrawWindowStatus(leftWindow, "Left Window");
                DrawWindowStatus(rightWindow, "Right Window");
            }

            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *


def draw_window_status(wnd, name):
    # Ask this specific window, using its handle, whether it is fullscreen
    is_fullscreen = window_is_fullscreen(wnd)

    clear_window(wnd, color_white())
    draw_text_on_window_font_as_string(wnd, name, color_black(), "arial", 40, 20, 30)

    if is_fullscreen:
        draw_text_on_window_font_as_string(wnd, "Fullscreen: true", color_black(), "arial", 30, 20, 100)
    else:
        draw_text_on_window_font_as_string(wnd, "Fullscreen: false", color_black(), "arial", 30, 20, 100)

    draw_text_on_window_font_as_string(wnd, "Press L or R to toggle a window", color_dark_gray(), "arial", 20, 20, 170)
    refresh_window(wnd)


left_window = open_window("Left Window", 480, 280)
right_window = open_window("Right Window", 480, 280)

# Place the windows side by side so both stay visible
move_window_to(left_window, 60, 100)
move_window_to(right_window, 580, 100)

while not quit_requested():
    process_events()

    # Each key sends one window in or out of fullscreen
    if key_typed(KeyCode.l_key):
        window_toggle_fullscreen(left_window)

    if key_typed(KeyCode.r_key):
        window_toggle_fullscreen(right_window)

    # Every window reports its own state, so the text stays visible while it fills the screen
    draw_window_status(left_window, "Left Window")
    draw_window_status(right_window, "Right Window")

close_all_windows()

Output:

---

Window Named

Returns an opened Window with the given name caption, if a window with name caption is found.

Parameters:

Name	Type	Description
caption	String	the String name of the window.

Return Type: Window

Returns: Returns a Window with the name specified by caption

Signatures:

C++

window window_named(string caption)

C#

public static Window SplashKit.WindowNamed(string caption);

Python

def window_named(caption):

Pascal

function WindowNamed(caption: String): Window

---

Window Position

Note

This function is overloaded. The following versions exist:

• Window Position (name: string)
• Window Position (wnd: window)

Window Position

The location of the window.

Parameters:

Name	Type	Description
name	String	The name of the window.

Return Type: Point 2d

Returns: Its location on the displays

Signatures:

C++

point_2d window_position(const string &name)

C#

public static Point2D SplashKit.WindowPosition(string name);

Python

def window_position_named(name):

Pascal

function WindowPosition(const name: String): Point2D

---

Window Position

The location of the window.

Parameters:

Name	Type	Description
wnd	Window	The window.

Return Type: Point 2d

Returns: Its location on the displays

Signatures:

C++

point_2d window_position(window wnd)

C#

public Point2D Window.Position { get }
public static Point2D SplashKit.WindowPosition(Window wnd);

Python

def window_position(wnd):

Pascal

function WindowPosition(wnd: Window): Point2D

---

Window Set Icon

Sets the icon of the current window.

Parameters:

Name	Type	Description
wind	Window	The window to change the icon of
bmp	Bitmap	The image with the details to show in the icon

Signatures:

C++

void window_set_icon(window wind, bitmap bmp)

C#

public void Window.Icon { set }
public static void SplashKit.WindowSetIcon(Window wind, Bitmap bmp);

Python

def window_set_icon(wind, bmp):

Pascal

procedure WindowSetIcon(wind: Window; bmp: Bitmap)

---

Window Toggle Border

Note

This function is overloaded. The following versions exist:

• Window Toggle Border (name: string)
• Window Toggle Border (wnd: window)

Window Toggle Border

Toggle the window border.

Parameters:

Name	Type	Description
name	String	The name of the window to change

Signatures:

C++

void window_toggle_border(const string &name)

C#

public static void SplashKit.WindowToggleBorder(string name);

Python

def window_toggle_border_named(name):

Pascal

procedure WindowToggleBorder(const name: String)

---

Window Toggle Border

Toggle the window border.

Parameters:

Name	Type	Description
wnd	Window	The window to change

Signatures:

C++

void window_toggle_border(window wnd)

C#

public void Window.ToggleBorder();
public static void SplashKit.WindowToggleBorder(Window wnd);

Python

def window_toggle_border(wnd):

Pascal

procedure WindowToggleBorder(wnd: Window)

---

Window Toggle Fullscreen  {</>}

Note

This function is overloaded. The following versions exist:

• Window Toggle Fullscreen (name: string)  {</>}
• Window Toggle Fullscreen (wnd: window)  {</>}

Window Toggle Fullscreen  {</>}

Toggle the fullscreen property of the window

Parameters:

Name	Type	Description
name	String	The name of the window to change

Signatures:

C++

void window_toggle_fullscreen(const string &name)

C#

public static void SplashKit.WindowToggleFullscreen(string name);

Python

def window_toggle_fullscreen_named(name):

Pascal

procedure WindowToggleFullscreen(const name: String)

Usage:  {</>}

See Implementations

API Documentation Code Examples:

• Window Is Fullscreen: Caption Status Light

See Code Examples

Example 1: Remote Control

C++

#include "splashkit.h"

int main()
{
    // The remote only needs the player's caption, so it never has to hold the player's window handle
    string player_caption = "Video Player";

    window remote_window = open_window("Remote Control", 480, 280);
    window player_window = open_window(player_caption, 480, 280);

    // Place the windows side by side so both stay visible
    move_window_to(remote_window, 60, 100);
    move_window_to(player_window, 580, 100);

    int command_count = 0;

    while (!quit_requested())
    {
        process_events();

        // Pressing F is the remote's fullscreen button, and pressing it again undoes it
        if (key_typed(F_KEY))
        {
            window_toggle_fullscreen(player_caption);
            command_count++;
        }

        clear_window(remote_window, COLOR_WHITE);
        draw_text_on_window(remote_window, "Remote Control", COLOR_BLACK, "arial", 40, 20, 40);
        draw_text_on_window(remote_window, "Press F to toggle the player", COLOR_DARK_GRAY, "arial", 20, 20, 130);
        refresh_window(remote_window);

        // Count the commands on the player itself, because the remote is hidden while the player fills the screen
        clear_window(player_window, COLOR_BLACK);
        draw_text_on_window(player_window, "Now Playing", COLOR_WHITE, "arial", 40, 20, 40);
        draw_text_on_window(player_window, "Commands received: " + std::to_string(command_count), COLOR_LIGHT_GRAY, "arial", 30, 20, 120);
        draw_text_on_window(player_window, "Press F to toggle", COLOR_LIGHT_GRAY, "arial", 20, 20, 190);
        refresh_window(player_window);
    }

    close_all_windows();
    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

// The remote only needs the player's caption, so it never has to hold the player's window handle
string playerCaption = "Video Player";

Window remoteWindow = OpenWindow("Remote Control", 480, 280);
Window playerWindow = OpenWindow(playerCaption, 480, 280);

// Place the windows side by side so both stay visible
MoveWindowTo(remoteWindow, 60, 100);
MoveWindowTo(playerWindow, 580, 100);

int commandCount = 0;

while (!QuitRequested())
{
    ProcessEvents();

    // Pressing F is the remote's fullscreen button, and pressing it again undoes it
    if (KeyTyped(KeyCode.FKey))
    {
        WindowToggleFullscreen(playerCaption);
        commandCount++;
    }

    ClearWindow(remoteWindow, ColorWhite());
    DrawTextOnWindow(remoteWindow, "Remote Control", ColorBlack(), "arial", 40, 20, 40);
    DrawTextOnWindow(remoteWindow, "Press F to toggle the player", ColorDarkGray(), "arial", 20, 20, 130);
    RefreshWindow(remoteWindow);

    // Count the commands on the player itself, because the remote is hidden while the player fills the screen
    ClearWindow(playerWindow, ColorBlack());
    DrawTextOnWindow(playerWindow, "Now Playing", ColorWhite(), "arial", 40, 20, 40);
    DrawTextOnWindow(playerWindow, $"Commands received: {commandCount}", ColorLightGray(), "arial", 30, 20, 120);
    DrawTextOnWindow(playerWindow, "Press F to toggle", ColorLightGray(), "arial", 20, 20, 190);
    RefreshWindow(playerWindow);
}

CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace WindowToggleFullscreenNamedExample
{
    public class Program
    {
        public static void Main()
        {
            // The remote only needs the player's caption, so it never has to hold the player's window handle
            string playerCaption = "Video Player";

            Window remoteWindow = SplashKit.OpenWindow("Remote Control", 480, 280);
            Window playerWindow = SplashKit.OpenWindow(playerCaption, 480, 280);

            // Place the windows side by side so both stay visible
            remoteWindow.MoveTo(60, 100);
            playerWindow.MoveTo(580, 100);

            int commandCount = 0;

            while (!SplashKit.QuitRequested())
            {
                SplashKit.ProcessEvents();

                // Pressing F is the remote's fullscreen button, and pressing it again undoes it
                if (SplashKit.KeyTyped(KeyCode.FKey))
                {
                    SplashKit.WindowToggleFullscreen(playerCaption);
                    commandCount++;
                }

                remoteWindow.Clear(Color.White);
                remoteWindow.DrawText("Remote Control", Color.Black, "arial", 40, 20, 40);
                remoteWindow.DrawText("Press F to toggle the player", Color.DarkGray, "arial", 20, 20, 130);
                remoteWindow.Refresh();

                // Count the commands on the player itself, because the remote is hidden while the player fills the screen
                playerWindow.Clear(Color.Black);
                playerWindow.DrawText("Now Playing", Color.White, "arial", 40, 20, 40);
                playerWindow.DrawText($"Commands received: {commandCount}", Color.LightGray, "arial", 30, 20, 120);
                playerWindow.DrawText("Press F to toggle", Color.LightGray, "arial", 20, 20, 190);
                playerWindow.Refresh();
            }

            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

# The remote only needs the player's caption, so it never has to hold the player's window handle
player_caption = "Video Player"

remote_window = open_window("Remote Control", 480, 280)
player_window = open_window(player_caption, 480, 280)

# Place the windows side by side so both stay visible
move_window_to(remote_window, 60, 100)
move_window_to(player_window, 580, 100)

command_count = 0

while not quit_requested():
    process_events()

    # Pressing F is the remote's fullscreen button, and pressing it again undoes it
    if key_typed(KeyCode.f_key):
        window_toggle_fullscreen_named(player_caption)
        command_count += 1

    clear_window(remote_window, color_white())
    draw_text_on_window_font_as_string(remote_window, "Remote Control", color_black(), "arial", 40, 20, 40)
    draw_text_on_window_font_as_string(remote_window, "Press F to toggle the player", color_dark_gray(), "arial", 20, 20, 130)
    refresh_window(remote_window)

    # Count the commands on the player itself, because the remote is hidden while the player fills the screen
    clear_window(player_window, color_black())
    draw_text_on_window_font_as_string(player_window, "Now Playing", color_white(), "arial", 40, 20, 40)
    draw_text_on_window_font_as_string(player_window, f"Commands received: {command_count}", color_light_gray(), "arial", 30, 20, 120)
    draw_text_on_window_font_as_string(player_window, "Press F to toggle", color_light_gray(), "arial", 20, 20, 190)
    refresh_window(player_window)

close_all_windows()

Output:

---

Window Toggle Fullscreen  {</>}

Toggle the fullscreen property of the window

Parameters:

Name	Type	Description
wnd	Window	The window to change

Signatures:

C++

void window_toggle_fullscreen(window wnd)

C#

public void Window.ToggleFullscreen();
public static void SplashKit.WindowToggleFullscreen(Window wnd);

Python

def window_toggle_fullscreen(wnd):

Pascal

procedure WindowToggleFullscreen(wnd: Window)

Usage:  {</>}

See Implementations

API Documentation Code Examples:

• Window Is Fullscreen: Window Status Board

See Code Examples

Example 1: Projector Screen

C++

#include "splashkit.h"

int main()
{
    window notes_window = open_window("Presenter Notes", 480, 280);
    window projector_window = open_window("Projector", 480, 280);

    // Place the windows side by side so both stay visible
    move_window_to(notes_window, 60, 100);
    move_window_to(projector_window, 580, 100);

    int toggle_count = 0;

    while (!quit_requested())
    {
        process_events();

        // Only the projector goes fullscreen, so the notes stay on the presenter's own screen
        if (key_typed(F_KEY))
        {
            window_toggle_fullscreen(projector_window);
            toggle_count++;
        }

        clear_window(notes_window, COLOR_WHITE);
        draw_text_on_window(notes_window, "Presenter Notes", COLOR_BLACK, "arial", 40, 20, 40);
        draw_text_on_window(notes_window, "Press F to toggle the projector", COLOR_DARK_GRAY, "arial", 20, 20, 130);
        refresh_window(notes_window);

        // Show the count on the projector itself, because the notes are hidden while it fills the screen
        if (window_is_fullscreen(projector_window))
        {
            clear_window(projector_window, COLOR_BLACK);
            draw_text_on_window(projector_window, "Big Slide", COLOR_WHITE, "arial", 40, 20, 40);
            draw_text_on_window(projector_window, "Toggles so far: " + std::to_string(toggle_count), COLOR_LIGHT_GRAY, "arial", 30, 20, 120);
        }
        else
        {
            clear_window(projector_window, COLOR_WHITE);
            draw_text_on_window(projector_window, "Big Slide", COLOR_BLACK, "arial", 40, 20, 40);
            draw_text_on_window(projector_window, "Toggles so far: " + std::to_string(toggle_count), COLOR_DARK_GRAY, "arial", 30, 20, 120);
        }

        refresh_window(projector_window);
    }

    close_all_windows();
    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

Window notesWindow = OpenWindow("Presenter Notes", 480, 280);
Window projectorWindow = OpenWindow("Projector", 480, 280);

// Place the windows side by side so both stay visible
MoveWindowTo(notesWindow, 60, 100);
MoveWindowTo(projectorWindow, 580, 100);

int toggleCount = 0;

while (!QuitRequested())
{
    ProcessEvents();

    // Only the projector goes fullscreen, so the notes stay on the presenter's own screen
    if (KeyTyped(KeyCode.FKey))
    {
        WindowToggleFullscreen(projectorWindow);
        toggleCount++;
    }

    ClearWindow(notesWindow, ColorWhite());
    DrawTextOnWindow(notesWindow, "Presenter Notes", ColorBlack(), "arial", 40, 20, 40);
    DrawTextOnWindow(notesWindow, "Press F to toggle the projector", ColorDarkGray(), "arial", 20, 20, 130);
    RefreshWindow(notesWindow);

    // Show the count on the projector itself, because the notes are hidden while it fills the screen
    if (WindowIsFullscreen(projectorWindow))
    {
        ClearWindow(projectorWindow, ColorBlack());
        DrawTextOnWindow(projectorWindow, "Big Slide", ColorWhite(), "arial", 40, 20, 40);
        DrawTextOnWindow(projectorWindow, $"Toggles so far: {toggleCount}", ColorLightGray(), "arial", 30, 20, 120);
    }
    else
    {
        ClearWindow(projectorWindow, ColorWhite());
        DrawTextOnWindow(projectorWindow, "Big Slide", ColorBlack(), "arial", 40, 20, 40);
        DrawTextOnWindow(projectorWindow, $"Toggles so far: {toggleCount}", ColorDarkGray(), "arial", 30, 20, 120);
    }

    RefreshWindow(projectorWindow);
}

CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace WindowToggleFullscreenExample
{
    public class Program
    {
        public static void Main()
        {
            Window notesWindow = SplashKit.OpenWindow("Presenter Notes", 480, 280);
            Window projectorWindow = SplashKit.OpenWindow("Projector", 480, 280);

            // Place the windows side by side so both stay visible
            notesWindow.MoveTo(60, 100);
            projectorWindow.MoveTo(580, 100);

            int toggleCount = 0;

            while (!SplashKit.QuitRequested())
            {
                SplashKit.ProcessEvents();

                // Only the projector goes fullscreen, so the notes stay on the presenter's own screen
                if (SplashKit.KeyTyped(KeyCode.FKey))
                {
                    SplashKit.WindowToggleFullscreen(projectorWindow);
                    toggleCount++;
                }

                notesWindow.Clear(Color.White);
                notesWindow.DrawText("Presenter Notes", Color.Black, "arial", 40, 20, 40);
                notesWindow.DrawText("Press F to toggle the projector", Color.DarkGray, "arial", 20, 20, 130);
                notesWindow.Refresh();

                // Show the count on the projector itself, because the notes are hidden while it fills the screen
                if (projectorWindow.IsFullscreen)
                {
                    projectorWindow.Clear(Color.Black);
                    projectorWindow.DrawText("Big Slide", Color.White, "arial", 40, 20, 40);
                    projectorWindow.DrawText($"Toggles so far: {toggleCount}", Color.LightGray, "arial", 30, 20, 120);
                }
                else
                {
                    projectorWindow.Clear(Color.White);
                    projectorWindow.DrawText("Big Slide", Color.Black, "arial", 40, 20, 40);
                    projectorWindow.DrawText($"Toggles so far: {toggleCount}", Color.DarkGray, "arial", 30, 20, 120);
                }

                projectorWindow.Refresh();
            }

            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

notes_window = open_window("Presenter Notes", 480, 280)
projector_window = open_window("Projector", 480, 280)

# Place the windows side by side so both stay visible
move_window_to(notes_window, 60, 100)
move_window_to(projector_window, 580, 100)

toggle_count = 0

while not quit_requested():
    process_events()

    # Only the projector goes fullscreen, so the notes stay on the presenter's own screen
    if key_typed(KeyCode.f_key):
        window_toggle_fullscreen(projector_window)
        toggle_count += 1

    clear_window(notes_window, color_white())
    draw_text_on_window_font_as_string(notes_window, "Presenter Notes", color_black(), "arial", 40, 20, 40)
    draw_text_on_window_font_as_string(notes_window, "Press F to toggle the projector", color_dark_gray(), "arial", 20, 20, 130)
    refresh_window(notes_window)

    # Show the count on the projector itself, because the notes are hidden while it fills the screen
    if window_is_fullscreen(projector_window):
        clear_window(projector_window, color_black())
        draw_text_on_window_font_as_string(projector_window, "Big Slide", color_white(), "arial", 40, 20, 40)
        draw_text_on_window_font_as_string(projector_window, f"Toggles so far: {toggle_count}", color_light_gray(), "arial", 30, 20, 120)
    else:
        clear_window(projector_window, color_white())
        draw_text_on_window_font_as_string(projector_window, "Big Slide", color_black(), "arial", 40, 20, 40)
        draw_text_on_window_font_as_string(projector_window, f"Toggles so far: {toggle_count}", color_dark_gray(), "arial", 30, 20, 120)

    refresh_window(projector_window)

close_all_windows()

Output:

---

Window Width  {</>}

Note

This function is overloaded. The following versions exist:

• Window Width (name: string)
• Window Width (wind: window)  {</>}

Window Width

Returns the width of the window with the indicated name in pixels.

Parameters:

Name	Type	Description
name	String	The name of the window

Return Type: Integer

Returns: The width of the window

Signatures:

C++

int window_width(const string &name)

C#

public static int SplashKit.WindowWidth(string name);

Python

def window_width_named(name):

Pascal

function WindowWidth(const name: String): Integer

---

Window Width  {</>}

Returns the width of the window in pixels.

Parameters:

Name	Type	Description
wind	Window	The window

Return Type: Integer

Returns: The width of the window

Signatures:

C++

int window_width(window wind)

C#

public int Window.Width { get }
public static int SplashKit.WindowWidth(Window wind);

Python

def window_width(wind):

Pascal

function WindowWidth(wind: Window): Integer

Usage:  {</>}

See Implementations

API Documentation Code Examples:

• Draw Quad On Window: Halved Ninja Star
• Fill Quad On Window: Halved Coloured Star
• Fill Rectangle On Window: Filled Rectangles on Separate Windows
• Fill Rectangle On Window: Filled Rectangles on Separate Windows

---

Window With Focus

Returns the window that the user currently has selected. This may be different to the current window.

Return Type: Window

Returns: The window the user has selected

Signatures:

C++

window window_with_focus()

C#

public static Window SplashKit.WindowWithFocus();

Python

def window_with_focus():

Pascal

function WindowWithFocus(): Window

---

Window X  {</>}

Note

This function is overloaded. The following versions exist:

• Window X (name: string)
• Window X (wnd: window)  {</>}

Window X

The x location of the window on the displays.

Parameters:

Name	Type	Description
name	String	The name of the window

Return Type: Integer

Returns: Its location on the displays

Signatures:

C++

int window_x(const string &name)

C#

public static int SplashKit.WindowX(string name);

Python

def window_x_named(name):

Pascal

function WindowX(const name: String): Integer

---

Window X  {</>}

The x location of the window on the displays.

Parameters:

Name	Type	Description
wnd	Window	The window

Return Type: Integer

Returns: Its location on the displays

Signatures:

C++

int window_x(window wnd)

C#

public int Window.X { get }
public static int SplashKit.WindowX(Window wnd);

Python

def window_x(wnd):

Pascal

function WindowX(wnd: Window): Integer

Usage:  {</>}

See Implementations

API Documentation Code Examples:

• Fill Rectangle On Window: Filled Rectangles on Separate Windows
• Fill Rectangle On Window: Filled Rectangles on Separate Windows
• Fill Triangle On Window: Filled Triangles on Separate Windows
• Fill Triangle On Window: Filled Triangles on Separate Windows

---

Window Y  {</>}

Note

This function is overloaded. The following versions exist:

• Window Y (name: string)
• Window Y (wnd: window)  {</>}

Window Y

The y location of the window on the displays.

Parameters:

Name	Type	Description
name	String	The name of the window

Return Type: Integer

Returns: Its location on the displays

Signatures:

C++

int window_y(const string &name)

C#

public static int SplashKit.WindowY(string name);

Python

def window_y_named(name):

Pascal

function WindowY(const name: String): Integer

---

Window Y  {</>}

The y location of the window on the displays.

Parameters:

Name	Type	Description
wnd	Window	The window

Return Type: Integer

Returns: Its location on the displays

Signatures:

C++

int window_y(window wnd)

C#

public int Window.Y { get }
public static int SplashKit.WindowY(Window wnd);

Python

def window_y(wnd):

Pascal

function WindowY(wnd: Window): Integer

Usage:  {</>}

See Implementations

API Documentation Code Examples:

• Fill Rectangle On Window: Filled Rectangles on Separate Windows
• Fill Rectangle On Window: Filled Rectangles on Separate Windows
• Fill Triangle On Window: Filled Triangles on Separate Windows
• Fill Triangle On Window: Filled Triangles on Separate Windows

---

Types

Window

The Window type is used to refer to a window that you have opened in SplashKit. You create new Windows using Open Window and they can be closed using Close Window.

• opened with Open Window

• and must be released using Close Window (to close a specific window) or delete_all_windows (to close all loaded windows).

---