Graphics

Graphics

SplashKit Images allow drawing of bitmaps and sprites to graphic windows.SplashKit Text allows for drawing text in a variety of ways to graphic windows.

Functions

Draw Circle

Note

This function is overloaded. The following versions exist:

• Draw Circle (clr: color, c: circle)
• Draw Circle (clr: color, c: circle, opts: drawing_options)
• Draw Circle (clr: color, x: double, y: double, radius: double)
• Draw Circle (clr: color, x: double, y: double, radius: double, opts: drawing_options)

Draw Circle

Draw a circle on the current window. The circle is centred on its x, y coordinates, and has the provided radius.

Parameters:

Name	Type	Description
clr	Color	The color of the circle
c	Circle	The circle being drawn

Signatures:

C++

void draw_circle(color clr, const circle &c)

C#

public void Circle.Draw(Color clr);
public static void SplashKit.DrawCircle(Color clr, Circle c);

Python

def draw_circle_record(clr, c):

Pascal

procedure DrawCircle(clr: Color; const c: Circle)

Usage:

See Code Examples

Example 1: Concentric Ripple Effect with Colored Circles

C++

#include "splashkit.h"

int main()
{
    open_window("Draw Circles", 800, 600);

    // Create circles with different radii
    circle circle1 = circle_at(screen_center(), 50);
    circle circle2 = circle_at(screen_center(), 100);

    clear_screen();

    // Draw the circles with different colors
    draw_circle(COLOR_RED, circle1);
    draw_circle(COLOR_BLUE, circle2);
    draw_circle(COLOR_ORANGE, circle_at(screen_center(), 150));
    draw_circle(COLOR_GREEN, circle_at(screen_center(), 200));

    refresh_screen();

    delay(4000);
    close_all_windows();

    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

OpenWindow("Draw Circles", 800, 600);

// Create circles with different radii
Circle circle1 = CircleAt(ScreenCenter(), 50);
Circle circle2 = CircleAt(ScreenCenter(), 100);

ClearScreen();

// Draw the circles with different colors
DrawCircle(ColorRed(), circle1);
DrawCircle(ColorBlue(), circle2);
DrawCircle(ColorOrange(), CircleAt(ScreenCenter(), 150));
DrawCircle(ColorGreen(), CircleAt(ScreenCenter(), 200));

RefreshScreen();

Delay(4000);
CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace DrawCircleExample
{
    public class Program
    {
        public static void Main()
        {
            SplashKit.OpenWindow("Draw Circles", 800, 600);

            // Create circles with different radii
            Circle circle1 = new Circle { Center = SplashKit.ScreenCenter(), Radius = 50 };
            Circle circle2 = new Circle { Center = SplashKit.ScreenCenter(), Radius = 100 };

            SplashKit.ClearScreen();

            // Draw the circles with different colors
            circle1.Draw(Color.Red);
            circle2.Draw(Color.Blue);
            SplashKit.DrawCircle(Color.Orange, SplashKit.CircleAt(SplashKit.ScreenCenter(), 150));
            SplashKit.DrawCircle(Color.Green, SplashKit.CircleAt(SplashKit.ScreenCenter(), 200 ));

            SplashKit.RefreshScreen();

            SplashKit.Delay(4000);
            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

open_window("Draw Circles", 800, 600)

# Create circles with different radii
circle1 = circle_at(screen_center(), 50)
circle2 = circle_at(screen_center(), 100)

clear_screen(color_white())

# Draw the circles with different colors
draw_circle_record(color_red(), circle1)
draw_circle_record(color_blue(), circle2)
draw_circle_record(color_orange(), circle_at(screen_center(), 150))
draw_circle_record(color_green(), circle_at(screen_center(), 200))

refresh_screen()

delay(4000)
close_all_windows()

Output:

---

Draw Circle

Draw a circle with the provided drawing options, which may include options related to the drawing destination.

Parameters:

Name	Type	Description
clr	Color	The color of the circle
c	Circle	The circle being drawn
opts	Drawing Options	Drawing options to configure the drawing operation

Signatures:

C++

void draw_circle(color clr, const circle &c, drawing_options opts)

C#

public void Circle.Draw(Color clr, DrawingOptions opts);
public static void SplashKit.DrawCircle(Color clr, Circle c, DrawingOptions opts);

Python

def draw_circle_record_with_options(clr, c, opts):

Pascal

procedure DrawCircle(clr: Color; const c: Circle; opts: DrawingOptions)

---

Draw Circle

Draw a circle onto the current window. The circle is centred on its x, y coordinates, and has the provided radius.

Parameters:

Name	Type	Description
clr	Color	The color of the circle
x	Double	The x location of the circle
y	Double	The y location of the circle
radius	Double	The radius of the circle

Signatures:

C++

void draw_circle(color clr, double x, double y, double radius)

C#

public static void SplashKit.DrawCircle(Color clr, double x, double y, double radius);

Python

def draw_circle(clr, x, y, radius):

Pascal

procedure DrawCircle(clr: Color; x: Double; y: Double; radius: Double)

---

Draw Circle

Draw a circle using the supplied drawing options. The circle is centred on its x, y coordinates, and has the provided radius. This will use Drawing Options to determine the destination.

Parameters:

Name	Type	Description
clr	Color	The color of the circle
x	Double	The x location of the circle
y	Double	The y location of the circle
radius	Double	The radius of the circle
opts	Drawing Options	Drawing options to configure the drawing operation

Signatures:

C++

void draw_circle(color clr, double x, double y, double radius, drawing_options opts)

C#

public static void SplashKit.DrawCircle(Color clr, double x, double y, double radius, DrawingOptions opts);

Python

def draw_circle_with_options(clr, x, y, radius, opts):

Pascal

procedure DrawCircle(clr: Color; x: Double; y: Double; radius: Double; opts: DrawingOptions)

---

Draw Circle On Bitmap

Note

This function is overloaded. The following versions exist:

• Draw Circle On Bitmap (destination: bitmap, clr: color, x: double, y: double, radius: double)
• Draw Circle On Bitmap (destination: bitmap, clr: color, x: double, y: double, radius: double, opts: drawing_options)

Draw Circle On Bitmap

Draw a circle onto the destination bitmap. The circle is centred on its x, y coordinates, and has the provided radius.

Parameters:

Name	Type	Description
destination	Bitmap	The destination bitmap
clr	Color	The color of the circle
x	Double	The x location of the circle
y	Double	The y location of the circle
radius	Double	The radius of the circle

Signatures:

C++

void draw_circle_on_bitmap(bitmap destination, color clr, double x, double y, double radius)

C#

public void Bitmap.DrawCircle(Color clr, double x, double y, double radius);
public static void SplashKit.DrawCircleOnBitmap(Bitmap destination, Color clr, double x, double y, double radius);

Python

def draw_circle_on_bitmap(destination, clr, x, y, radius):

Pascal

procedure DrawCircleOnBitmap(destination: Bitmap; clr: Color; x: Double; y: Double; radius: Double)

Usage:

See Code Examples

Example 1: Creating a Red Planet

C++

#include "splashkit.h"

int main()
{
    // Create a Window and bitmap for the map
    window window = open_window("Window", 400, 400);
    bitmap planet = create_bitmap("planet", 400, 400);

    // Fill background with dark color
    clear_bitmap(planet, COLOR_BLACK);

    // Create color
    color red = COLOR_RED;

    // Draw the main planet circle
    fill_circle_on_bitmap(planet, rgba_color(180, 0, 0, 255), 200, 200, 150);
    draw_circle_on_bitmap(planet, red, 200, 200, 150);

    // Add some surface details with smaller circles
    for(int i = 0; i < 15; i++)
    {
        double x = rnd(100, 300);  // Random between 100 and 300
        double y = rnd(100, 300);  // Random between 100 and 300
        double size = rnd(10, 30); // Random between 10 and 30
        draw_circle_on_bitmap(planet, red, x, y, size);
    }

    while (!window_close_requested(window))
    {
        process_events();
        // Draw the bitmap to the window
        draw_bitmap(planet, 0, 0);
        refresh_screen();
    }

    free_bitmap(planet);
    close_all_windows();
    return 0;
}

C#

Top-level Statements

using static SplashKitSDK.SplashKit;
using SplashKitSDK;

// Create a Window and bitmap for the map
Window window = OpenWindow("Window", 400, 400);
Bitmap bitmap = CreateBitmap("planet", 400, 400);

// Fill background with dark color
ClearBitmap(bitmap, ColorBlack());
// Create color
Color red = ColorRed();

// Draw the main planet circle
FillCircleOnBitmap(bitmap, RGBAColor(180, 0, 0, 255), 200, 200, 150);
DrawCircleOnBitmap(bitmap, red, 200, 200, 150);

// Add some surface details with smaller circles
for (int i = 0; i < 15; i++)
{
    double x = Rnd(100, 300);  // Random between 100 and 300
    double y = Rnd(100, 300);   // Random between 100 and 300
    double size = Rnd(10, 30);  // Random between 10 and 30
    DrawCircleOnBitmap(bitmap, red, x, y, size);
}
while (!window.CloseRequested)
{
    ProcessEvents();
    // Draw the bitmap to the current window
    DrawBitmap(bitmap, 0, 0);
    RefreshScreen();
}
FreeBitmap(bitmap);
CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace DrawCircleOnBitmap
{
    public class Program
    {
        public static void Main()
        {
            // Create a Window and bitmap for the map
            Window window = new Window("Window", 400, 400);
            Bitmap bitmap = new Bitmap("planet", 400, 400);

            // Fill background with dark color
            bitmap.Clear(Color.Black);

            // Create color
            Color red = Color.Red;

            // Draw the main planet circle
            bitmap.FillCircle(Color.RGBAColor(180, 0, 0, 255), 200, 200, 150);
            bitmap.DrawCircle(red, 200, 200, 150);

            // Add some surface details with smaller circles
            for (int i = 0; i < 15; i++)
            {
                double x = SplashKit.Rnd(100, 300);  // Random between 100 and 300
                double y = SplashKit.Rnd(100, 300);  // Random between 100 and 300
                double size = SplashKit.Rnd(10, 30); // Random between 10 and 30
                bitmap.DrawCircle(red, x, y, size);
            }
            while (!window.CloseRequested)
            {
                SplashKit.ProcessEvents();
                // Draw the bitmap to the window
                window.DrawBitmap(bitmap, 0, 0);
                SplashKit.RefreshScreen();
            }
            bitmap.Free();
            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

# Create a Window and bitmap for the map
window = open_window("Window", 400, 400)
planet = create_bitmap("planet", 400, 400)

# Fill background with dark color
clear_bitmap(planet, color_black())

# Create color
red = color_red()

# Draw the main planet circle
fill_circle_on_bitmap(planet, rgba_color(180, 0, 0, 255), 200, 200, 150)
draw_circle_on_bitmap(planet, red, 200, 200, 150)

# Add some surface details with smaller circles
for i in range(15):
    x = rnd_range(100, 300)  # Random between 100 and 300
    y = rnd_range(100, 300)  # Random between 100 and 300
    size = rnd_range(10, 30) # Random between 10 and 30
    draw_circle_on_bitmap(planet, red, x, y, size)

while not window_close_requested(window):
    process_events()
    # Draw the bitmap to the window
    draw_bitmap(planet, 0, 0)
    refresh_screen()

free_bitmap(planet)
close_all_windows()

Output:

---

Draw Circle On Bitmap

Draw a circle to the bitmap using the supplied drawing options. The circle is centred on its x, y coordinates, and has the provided radius.

Parameters:

Name	Type	Description
destination	Bitmap	The destination bitmap
clr	Color	The color of the circle
x	Double	The x location of the circle
y	Double	The y location of the circle
radius	Double	The radius of the circle
opts	Drawing Options	Drawing options to configure the drawing operation

Signatures:

C++

void draw_circle_on_bitmap(bitmap destination, color clr, double x, double y, double radius, drawing_options opts)

C#

public void Bitmap.DrawCircle(Color clr, double x, double y, double radius, DrawingOptions opts);
public static void SplashKit.DrawCircleOnBitmap(Bitmap destination, Color clr, double x, double y, double radius, DrawingOptions opts);

Python

def draw_circle_on_bitmap_with_options(destination, clr, x, y, radius, opts):

Pascal

procedure DrawCircleOnBitmap(destination: Bitmap; clr: Color; x: Double; y: Double; radius: Double; opts: DrawingOptions)

---

Draw Circle On Window

Note

This function is overloaded. The following versions exist:

• Draw Circle On Window (destination: window, clr: color, x: double, y: double, radius: double)
• Draw Circle On Window (destination: window, clr: color, x: double, y: double, radius: double, opts: drawing_options)

Draw Circle On Window

Draw a circle onto the destination window. The circle is centred on its x, y coordinates, and has the provided radius.

Parameters:

Name	Type	Description
destination	Window	The destination window
clr	Color	The color of the circle
x	Double	The x location of the circle
y	Double	The y location of the circle
radius	Double	The radius of the circle

Signatures:

C++

void draw_circle_on_window(window destination, color clr, double x, double y, double radius)

C#

public void Window.DrawCircle(Color clr, double x, double y, double radius);
public static void SplashKit.DrawCircleOnWindow(Window destination, Color clr, double x, double y, double radius);

Python

def draw_circle_on_window(destination, clr, x, y, radius):

Pascal

procedure DrawCircleOnWindow(destination: Window; clr: Color; x: Double; y: Double; radius: Double)

Usage:

See Code Examples

Example 1: Bubbles

C++

#include "splashkit.h"

int main()
{
    window window = open_window("Bubbles", 800, 600);

    clear_screen(COLOR_WHITE);
    for (int i = 0; i < 50; i++)
    {
        // Set random circle values
        double x = rnd(800);
        double y = rnd(600);
        double radius = rnd(50);
        color randomColor = rgb_color(rnd(255), rnd(255), rnd(255));

        // Draw the circle base on the random data
        draw_circle_on_window(window, randomColor, x, y, radius);
    }
    refresh_screen();

    delay(4000);
    close_all_windows();

    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

Window window = OpenWindow("Bubbles", 800, 600);

ClearScreen(ColorWhite());
for (int i = 0; i < 50; i++)
{
    // Set random circle values
    double x = Rnd(800);
    double y = Rnd(600);
    double radius = Rnd(50);
    Color randomColor = RGBColor(Rnd(255), Rnd(255), Rnd(255));

    // Draw the circle base on the random data
    DrawCircleOnWindow(window, randomColor, x, y, radius);
}
RefreshScreen();

Delay(4000);
CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace DrawCircleOnWindowExample
{
    public class Program
    {
        public static void Main()
        {
            Window window = new Window("Bubbles", 800, 600);

            window.Clear(Color.White);
            for (int i = 0; i < 50; i++)
            {
                // Set random circle values
                double x = SplashKit.Rnd(800);
                double y = SplashKit.Rnd(600);
                double radius = SplashKit.Rnd(50);
                Color randomColor = SplashKit.RGBColor(SplashKit.Rnd(255), SplashKit.Rnd(255), SplashKit.Rnd(255));

                // Draw the circle base on the random data
                SplashKit.DrawCircleOnWindow(window, randomColor, x, y, radius);
            }
            window.Refresh();

            SplashKit.Delay(4000);
            window.Close();
        }
    }
}

Python

from splashkit import *

window = open_window("Bubbles", 800, 600)

clear_screen(color_white())
for _ in range(50):
    # Set random circle values
    x = rnd_int(800)
    y = rnd_int(600)
    radius = rnd_int(50)
    random_color = rgb_color(rnd_int(255), rnd_int(255), rnd_int(255))

    # Draw the circle base on the random data
    draw_circle_on_window(window, random_color, x, y, radius)
refresh_screen()

delay(4000)
close_all_windows()

Output:

---

Draw Circle On Window

Draw a circle to the window using the supplied drawing options. The circle is centred on its x, y coordinates, and has the provided radius.

Parameters:

Name	Type	Description
destination	Window	The destination window
clr	Color	The color of the circle
x	Double	The x location of the circle
y	Double	The y location of the circle
radius	Double	The radius of the circle
opts	Drawing Options	Drawing options to configure the drawing operation

Signatures:

C++

void draw_circle_on_window(window destination, color clr, double x, double y, double radius, drawing_options opts)

C#

public void Window.DrawCircle(Color clr, double x, double y, double radius, DrawingOptions opts);
public static void SplashKit.DrawCircleOnWindow(Window destination, Color clr, double x, double y, double radius, DrawingOptions opts);

Python

def draw_circle_on_window_with_options(destination, clr, x, y, radius, opts):

Pascal

procedure DrawCircleOnWindow(destination: Window; clr: Color; x: Double; y: Double; radius: Double; opts: DrawingOptions)

---

Fill Circle

Note

This function is overloaded. The following versions exist:

• Fill Circle (clr: color, c: circle)
• Fill Circle (clr: color, c: circle, opts: drawing_options)
• Fill Circle (clr: color, x: double, y: double, radius: double)
• Fill Circle (clr: color, x: double, y: double, radius: double, opts: drawing_options)

Fill Circle

Draw a circle on the current window. The circle is centred on its x, y coordinates, and has the provided radius.

Parameters:

Name	Type	Description
clr	Color	The color of the circle
c	Circle	The circle being drawn

Signatures:

C++

void fill_circle(color clr, const circle &c)

C#

public void Circle.Fill(Color clr);
public static void SplashKit.FillCircle(Color clr, Circle c);

Python

def fill_circle_record(clr, c):

Pascal

procedure FillCircle(clr: Color; const c: Circle)

---

Fill Circle

Fill a circle with the provided drawing options, which may include options related to the drawing destination.

Parameters:

Name	Type	Description
clr	Color	The color of the circle
c	Circle	The circle being drawn
opts	Drawing Options	Drawing options to configure the drawing operation

Signatures:

C++

void fill_circle(color clr, const circle &c, drawing_options opts)

C#

public void Circle.Fill(Color clr, DrawingOptions opts);
public static void SplashKit.FillCircle(Color clr, Circle c, DrawingOptions opts);

Python

def fill_circle_record_with_options(clr, c, opts):

Pascal

procedure FillCircle(clr: Color; const c: Circle; opts: DrawingOptions)

---

Fill Circle

Fill a circle onto the current window. The circle is centred on its x, y coordinates, and has the provided radius.

Parameters:

Name	Type	Description
clr	Color	The color of the circle
x	Double	The x location of the circle
y	Double	The y location of the circle
radius	Double	The radius of the circle

Signatures:

C++

void fill_circle(color clr, double x, double y, double radius)

C#

public static void SplashKit.FillCircle(Color clr, double x, double y, double radius);

Python

def fill_circle(clr, x, y, radius):

Pascal

procedure FillCircle(clr: Color; x: Double; y: Double; radius: Double)

Usage:

See Implementations in Guides

• SplashKit Camera

See Code Examples

Example 1: Basic Blue Circle

C++

#include "splashkit.h"

int main()
{
    open_window("Fill Circle", 800, 600);

    clear_screen();
    fill_circle(COLOR_BLUE, 300, 300, 200);
    refresh_screen();

    delay(4000);

    close_all_windows();

    return 0;
}

C#

Top-level Statements

using static SplashKitSDK.SplashKit;

OpenWindow("Fill Circle", 800, 600);

ClearScreen();
FillCircle(ColorBlue(), 300, 300, 200);
RefreshScreen();

Delay(4000);

CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace FillCircleExample
{
    public class Program
    {
        public static void Main()
        {
            SplashKit.OpenWindow("Fill Circle", 800, 600);

            SplashKit.ClearScreen();
            SplashKit.FillCircle(Color.Blue, 300, 300, 200);
            SplashKit.RefreshScreen();

            SplashKit.Delay(4000);

            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

open_window("Fill Circle", 800, 600)

clear_screen(color_white())

fill_circle(color_blue(), 300, 300, 200)
refresh_screen()
delay(4000)

close_all_windows()

Output:

---

Fill Circle

Fill a circle using the supplied drawing options. The circle is centred on its x, y coordinates, and has the provided radius. This will use Drawing Options to determine the destination.

Parameters:

Name	Type	Description
clr	Color	The color of the circle
x	Double	The x location of the circle
y	Double	The y location of the circle
radius	Double	The radius of the circle
opts	Drawing Options	Drawing options to configure the drawing operation

Signatures:

C++

void fill_circle(color clr, double x, double y, double radius, drawing_options opts)

C#

public static void SplashKit.FillCircle(Color clr, double x, double y, double radius, DrawingOptions opts);

Python

def fill_circle_with_options(clr, x, y, radius, opts):

Pascal

procedure FillCircle(clr: Color; x: Double; y: Double; radius: Double; opts: DrawingOptions)

---

Fill Circle On Bitmap

Note

This function is overloaded. The following versions exist:

• Fill Circle On Bitmap (destination: bitmap, clr: color, x: double, y: double, radius: double)
• Fill Circle On Bitmap (destination: bitmap, clr: color, x: double, y: double, radius: double, opts: drawing_options)

Fill Circle On Bitmap

Fill a circle onto the destination bitmap. The circle is centred on its x, y coordinates, and has the provided radius.

Parameters:

Name	Type	Description
destination	Bitmap	The destination bitmap
clr	Color	The color of the circle
x	Double	The x location of the circle
y	Double	The y location of the circle
radius	Double	The radius of the circle

Signatures:

C++

void fill_circle_on_bitmap(bitmap destination, color clr, double x, double y, double radius)

C#

public void Bitmap.FillCircle(Color clr, double x, double y, double radius);
public static void SplashKit.FillCircleOnBitmap(Bitmap destination, Color clr, double x, double y, double radius);

Python

def fill_circle_on_bitmap(destination, clr, x, y, radius):

Pascal

procedure FillCircleOnBitmap(destination: Bitmap; clr: Color; x: Double; y: Double; radius: Double)

Usage:

See Code Examples

Example 1: Rainbow Caterpillar

C++

#include "splashkit.h"

int main()
{
    // Create a window and bitmap for our caterpillar
    window window = open_window("Window", 400, 200);
    bitmap bitmap = create_bitmap("caterpillar", 400, 200);

    // Fill background with light color
    clear_bitmap(bitmap, COLOR_WHITE);

    // Create rainbow colors array
    color colors[] = {COLOR_RED, COLOR_ORANGE, COLOR_YELLOW,
                     COLOR_GREEN, COLOR_BLUE, COLOR_VIOLET};

    // Draw circles for caterpillar segments with alternating y positions
    double x = 50;
    for(int i = 0; i < 6; i++)
    {
        double y = 100 + (i % 2 == 0 ? 20 : -20);  // Alternate up and down
        fill_circle_on_bitmap(bitmap, colors[i], x, y, 40);
        x += 60;
    }

    // Draw eyes (adjusted to match first segment position)
    fill_circle_on_bitmap(bitmap, COLOR_BLACK, 60, 100, 8);
    fill_circle_on_bitmap(bitmap, COLOR_BLACK, 60, 130, 8);

    while (!window_close_requested(window))
    {
        process_events();
        // Draw the bitmap to the window
        draw_bitmap(bitmap, 0, 0);
        // Refresh the window
        refresh_screen();
    }

    free_bitmap(bitmap);
    close_window(window);

    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

// Create a window and bitmap for our caterpillar
Window window = OpenWindow("Window", 400, 200);
Bitmap bitmap = CreateBitmap("caterpillar", 400, 200);

// Fill background with light color
ClearBitmap(bitmap, ColorWhite());

// Create rainbow colors array
Color[] colors = { ColorRed(), ColorOrange(), ColorYellow(),
                          ColorGreen(), ColorBlue(), ColorViolet() };

// Draw circles for caterpillar segments with alternating y positions
double x = 50;
for (int i = 0; i < colors.Length; i++)
{
    double y = 100 + (i % 2 == 0 ? 20 : -20);  // Alternate up and down
    FillCircleOnBitmap(bitmap, colors[i], x, y, 40);
    x += 60;
}

// Draw eyes (adjusted to match first segment position)
FillCircleOnBitmap(bitmap, ColorBlack(), 60, 100, 8);
FillCircleOnBitmap(bitmap, ColorBlack(), 60, 130, 8);

while (!window.CloseRequested)
{
    ProcessEvents();
    // Draw the bitmap to the window
    DrawBitmap(bitmap, 0, 0);
    // Refresh the window
    RefreshScreen();
}

FreeBitmap(bitmap);
CloseWindow(window);

Object-Oriented

using SplashKitSDK;

namespace FillCircleOnBitmapExample
{
    public class Program
    {
        public static void Main()
        {
            // Create a window and bitmap for our caterpillar
            Window window = new Window("Window", 400, 200);
            Bitmap bitmap = new Bitmap("caterpillar", 400, 200);

            // Fill background with light color
            bitmap.Clear(Color.White);

            // Create rainbow colors array
            Color[] colors = { Color.Red, Color.Orange, Color.Yellow,
                             Color.Green, Color.Blue, Color.Violet };

            // Draw circles for caterpillar segments with alternating y positions
            double x = 50;
            for (int i = 0; i < colors.Length; i++)
            {
                double y = 100 + (i % 2 == 0 ? 20 : -20);  // Alternate up and down
                bitmap.FillCircle(colors[i], x, y, 40);
                x += 60;
            }

            // Draw eyes (adjusted to match first segment position)
            bitmap.FillCircle(Color.Black, 60, 100, 8);
            bitmap.FillCircle(Color.Black, 60, 130, 8);

            while (!window.CloseRequested)
            {
                SplashKit.ProcessEvents();
                // Draw the bitmap to the window
                window.DrawBitmap(bitmap, 0, 0);
                // Refresh the window
                SplashKit.RefreshScreen();
            }

            bitmap.Free();
            window.Close();
        }
    }
}

Python

from splashkit import *

# Create a window and bitmap for our caterpillar
window = open_window("Window", 400, 200)
bitmap = create_bitmap("caterpillar", 400, 200)

# Fill background with light color
clear_bitmap(bitmap, color_white())

# Create rainbow colors
colors = [
    color_red(),
    color_orange(),
    color_yellow(),
    color_green(),
    color_blue(),
    color_violet()
]

# Draw circles for caterpillar segments with alternating y positions
x = 50
for i, color in enumerate(colors):
    y = 100 + (20 if i % 2 == 0 else -20)  # Alternate up and down
    fill_circle_on_bitmap(bitmap, color, x, y, 40)
    x += 60

# Draw eyes (adjusted to match first segment position)
fill_circle_on_bitmap(bitmap, color_black(), 60, 100, 8)
fill_circle_on_bitmap(bitmap, color_black(), 60, 130, 8)

while not window_close_requested(window):
    process_events()
    # Draw the bitmap to the window
    draw_bitmap(bitmap, 0, 0)
    # Refresh the window
    refresh_screen()

free_bitmap(bitmap)
close_window(window)

Output:

---

Fill Circle On Bitmap

Fill a circle to the bitmap using the supplied drawing options. The circle is centred on its x, y coordinates, and has the provided radius.

Parameters:

Name	Type	Description
destination	Bitmap	The destination bitmap
clr	Color	The color of the circle
x	Double	The x location of the circle
y	Double	The y location of the circle
radius	Double	The radius of the circle
opts	Drawing Options	Drawing options to configure the drawing operation

Signatures:

C++

void fill_circle_on_bitmap(bitmap destination, color clr, double x, double y, double radius, drawing_options opts)

C#

public void Bitmap.FillCircle(Color clr, double x, double y, double radius, DrawingOptions opts);
public static void SplashKit.FillCircleOnBitmap(Bitmap destination, Color clr, double x, double y, double radius, DrawingOptions opts);

Python

def fill_circle_on_bitmap_with_options(destination, clr, x, y, radius, opts):

Pascal

procedure FillCircleOnBitmap(destination: Bitmap; clr: Color; x: Double; y: Double; radius: Double; opts: DrawingOptions)

---

Fill Circle On Window

Note

This function is overloaded. The following versions exist:

• Fill Circle On Window (destination: window, clr: color, x: double, y: double, radius: double)
• Fill Circle On Window (destination: window, clr: color, x: double, y: double, radius: double, opts: drawing_options)

Fill Circle On Window

Fill a circle onto the destination window. The circle is centred on its x, y coordinates, and has the provided radius.

Parameters:

Name	Type	Description
destination	Window	The destination window
clr	Color	The color of the circle
x	Double	The x location of the circle
y	Double	The y location of the circle
radius	Double	The radius of the circle

Signatures:

C++

void fill_circle_on_window(window destination, color clr, double x, double y, double radius)

C#

public void Window.FillCircle(Color clr, double x, double y, double radius);
public static void SplashKit.FillCircleOnWindow(Window destination, Color clr, double x, double y, double radius);

Python

def fill_circle_on_window(destination, clr, x, y, radius):

Pascal

procedure FillCircleOnWindow(destination: Window; clr: Color; x: Double; y: Double; radius: Double)

Usage:

See Code Examples

Example 1: Traffic Lights

C++

#include "splashkit.h"

int main()
{
    // Open a new window and initialize to a window variable
    window window = open_window("Traffic Lights", 800, 600);

    clear_screen(COLOR_WHITE);

    // Use function to place 3 circles in destination window as traffic lights
    fill_circle_on_window(window, COLOR_RED, 400, 100, 50);
    fill_circle_on_window(window, COLOR_YELLOW, 400, 250, 50);
    fill_circle_on_window(window, COLOR_GREEN, 400, 400, 50);

    refresh_screen();
    delay(5000);

    // Close all windows
    close_all_windows();
}

C#

Top-level Statements

using static SplashKitSDK.SplashKit;

// Open a new window and initialize to a window variable
SplashKitSDK.Window window = OpenWindow("Traffic Lights", 800, 600);

ClearScreen(ColorWhite());

// Use function to place 3 circles in destination window as traffic lights
FillCircleOnWindow(window, ColorRed(), 400, 100, 50);
FillCircleOnWindow(window, ColorYellow(), 400, 250, 50);
FillCircleOnWindow(window, ColorGreen(), 400, 400, 50);

RefreshScreen();
Delay(5000);

// Close all windows
CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace FillCircleOnWindowExample
{
    public class Program
    {
        public static void Main()
        {
            // Open a new window and initialize to a window variable
            Window window = SplashKit.OpenWindow("Traffic Lights", 800, 600);

            window.Clear(Color.White);

            // Use function to place 3 circles in destination window as traffic lights
            window.FillCircle(Color.Red, 400, 100, 50);
            window.FillCircle(Color.Yellow, 400, 250, 50);
            window.FillCircle(Color.Green, 400, 400, 50);

            window.Refresh();
            SplashKit.Delay(5000);

            // Close loaded window
            window.Close();

        }
    }
}

Python

from splashkit import *

# Open a new window and initialize to a window variable
window = open_window("Traffic Lights", 800, 600)

clear_screen(color_white())

# Use function to place 3 circles in destination window as traffic lights
fill_circle_on_window(window, color_red(), 400, 100, 50)
fill_circle_on_window(window, color_yellow(), 400, 250, 50)
fill_circle_on_window(window, color_green(), 400, 400, 50)

refresh_screen()
delay(5000)

# Close all windows
close_all_windows()

Output:

---

Fill Circle On Window

Fill a circle to the window using the supplied drawing options. The circle is centred on its x, y coordinates, and has the provided radius.

Parameters:

Name	Type	Description
destination	Window	The destination window
clr	Color	The color of the circle
x	Double	The x location of the circle
y	Double	The y location of the circle
radius	Double	The radius of the circle
opts	Drawing Options	Drawing options to configure the drawing operation

Signatures:

C++

void fill_circle_on_window(window destination, color clr, double x, double y, double radius, drawing_options opts)

C#

public void Window.FillCircle(Color clr, double x, double y, double radius, DrawingOptions opts);
public static void SplashKit.FillCircleOnWindow(Window destination, Color clr, double x, double y, double radius, DrawingOptions opts);

Python

def fill_circle_on_window_with_options(destination, clr, x, y, radius, opts):

Pascal

procedure FillCircleOnWindow(destination: Window; clr: Color; x: Double; y: Double; radius: Double; opts: DrawingOptions)

---

Current Clip

Note

This function is overloaded. The following versions exist:

• Current Clip ()
• Current Clip (bmp: bitmap)
• Current Clip (wnd: window)

Current Clip

Returns the rectangle of the current clip area for the current window

Return Type: Rectangle

Signatures:

C++

rectangle current_clip()

C#

public static Rectangle SplashKit.CurrentClip();

Python

def current_clip():

Pascal

function CurrentClip(): Rectangle

---

Current Clip

Returns the rectangle of the current clip area for a bitmap

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap to get the clipping rectangle from

Return Type: Rectangle

Signatures:

C++

rectangle current_clip(bitmap bmp)

C#

public static Rectangle SplashKit.CurrentClip(Bitmap bmp);

Python

def current_clip_for_bitmap(bmp):

Pascal

function CurrentClip(bmp: Bitmap): Rectangle

---

Current Clip

Returns the rectangle of the current clip area for a window

Parameters:

Name	Type	Description
wnd	Window	The window to get the clipping rectangle from

Return Type: Rectangle

Signatures:

C++

rectangle current_clip(window wnd)

C#

public static Rectangle SplashKit.CurrentClip(Window wnd);

Python

def current_clip_for_window(wnd):

Pascal

function CurrentClip(wnd: Window): Rectangle

---

Pop Clip

Note

This function is overloaded. The following versions exist:

• Pop Clip (wnd: window)
• Pop Clip ()
• Pop Clip (bmp: bitmap)

Pop Clip

Remove the last clipping rectangle pushed to the window. This will then apply the previously pushed clipping rectangle.

Parameters:

Name	Type	Description
wnd	Window	The window to change

Signatures:

C++

void pop_clip(window wnd)

C#

public static void SplashKit.PopClip(Window wnd);

Python

def pop_clip_for_window(wnd):

Pascal

procedure PopClip(wnd: Window)

---

Pop Clip

Remove the last clipping rectangle pushed to the current window. This will then apply the previously pushed clipping rectangle.

Signatures:

C++

void pop_clip()

C#

public static void SplashKit.PopClip();

Python

def pop_clip():

Pascal

procedure PopClip()

---

Pop Clip

Remove the last clipping rectangle pushed to the bitmap. This will then apply the previously pushed clipping rectangle.

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap to change

Signatures:

C++

void pop_clip(bitmap bmp)

C#

public static void SplashKit.PopClip(Bitmap bmp);

Python

def pop_clip_for_bitmap(bmp):

Pascal

procedure PopClip(bmp: Bitmap)

---

Push Clip

Note

This function is overloaded. The following versions exist:

• Push Clip (wnd: window, r: rectangle)
• Push Clip (bmp: bitmap, r: rectangle)
• Push Clip (r: rectangle)

Push Clip

Add the clipping rectangle of a window and uses the intersect between the new rectangle and previous clip. When a clipping rectangle is provided, drawing operations will only affect the area specified in the current clipping rectangle.

Parameters:

Name	Type	Description
wnd	Window	The window to add clipping to
r	Rectangle	The new clipping rectangle

Signatures:

C++

void push_clip(window wnd, const rectangle &r)

C#

public static void SplashKit.PushClip(Window wnd, Rectangle r);

Python

def push_clip_for_window(wnd, r):

Pascal

procedure PushClip(wnd: Window; const r: Rectangle)

---

Push Clip

Add the clipping rectangle of a bitmap and uses the intersect between the new rectangle and previous clip. When a clipping rectangle is provided, drawing operations will only affect the area specified in the current clipping rectangle.

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap to add clipping to
r	Rectangle	The new clipping rectangle

Signatures:

C++

void push_clip(bitmap bmp, const rectangle &r)

C#

public static void SplashKit.PushClip(Bitmap bmp, Rectangle r);

Python

def push_clip_for_bitmap(bmp, r):

Pascal

procedure PushClip(bmp: Bitmap; const r: Rectangle)

---

Push Clip

Push a clip rectangle to the current window. The resulting clipping rectangle will be the intersection of the existing clipping rectangle with the new rectangle provided in this call. This can be undone using Pop Clip. When a clipping rectangle is provided, drawing operations will only affect the area specified in the current clipping rectangle.

Parameters:

Name	Type	Description
r	Rectangle	The new clipping rectangle

Signatures:

C++

void push_clip(const rectangle &r)

C#

public static void SplashKit.PushClip(Rectangle r);

Python

def push_clip(r):

Pascal

procedure PushClip(const r: Rectangle)

---

Reset Clip

Note

This function is overloaded. The following versions exist:

• Reset Clip (bmp: bitmap)
• Reset Clip ()
• Reset Clip (wnd: window)

Reset Clip

Reset the clipping rectangle on a bitmap. This will clear all of the clipping rectangles pushed to the bitmap.

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap to clear the clipping rectangle

Signatures:

C++

void reset_clip(bitmap bmp)

C#

public static void SplashKit.ResetClip(Bitmap bmp);

Python

def reset_clip_for_bitmap(bmp):

Pascal

procedure ResetClip(bmp: Bitmap)

---

Reset Clip

Reset the clipping rectangle of the current window. This will clear all of the clipping rectangles pushed to the current window.

Signatures:

C++

void reset_clip()

C#

public static void SplashKit.ResetClip();

Python

def reset_clip():

Pascal

procedure ResetClip()

---

Reset Clip

Reset the clipping rectangle on a window. This will clear all of the clipping rectangles pushed to the window.

Parameters:

Name	Type	Description
wnd	Window	The window to clear the clipping rectangle

Signatures:

C++

void reset_clip(window wnd)

C#

public static void SplashKit.ResetClip(Window wnd);

Python

def reset_clip_for_window(wnd):

Pascal

procedure ResetClip(wnd: Window)

---

Set Clip

Note

This function is overloaded. The following versions exist:

• Set Clip (r: rectangle)
• Set Clip (bmp: bitmap, r: rectangle)
• Set Clip (wnd: window, r: rectangle)

Set Clip

Set the clip rectangle of the current window. This will clear any existing clipping rectangles pushed to the current window, and use the supplied rectangle for clipping.

Parameters:

Name	Type	Description
r	Rectangle	The new clipping rectangle

Signatures:

C++

void set_clip(const rectangle &r)

C#

public static void SplashKit.SetClip(Rectangle r);

Python

def set_clip(r):

Pascal

procedure SetClip(const r: Rectangle)

---

Set Clip

Set the clip rectangle of the bitmap. This will clear any existing clipping rectangles pushed to the bitmap, and use the supplied rectangle for clipping.

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap to change
r	Rectangle	The new clipping rectangle

Signatures:

C++

void set_clip(bitmap bmp, const rectangle &r)

C#

public static void SplashKit.SetClip(Bitmap bmp, Rectangle r);

Python

def set_clip_for_bitmap(bmp, r):

Pascal

procedure SetClip(bmp: Bitmap; const r: Rectangle)

---

Set Clip

Set the clip rectangle of the window. This will clear any existing clipping rectangles pushed to the window, and use the supplied rectangle for clipping.

Parameters:

Name	Type	Description
wnd	Window	The window to change
r	Rectangle	The new clipping rectangle

Signatures:

C++

void set_clip(window wnd, const rectangle &r)

C#

public static void SplashKit.SetClip(Window wnd, Rectangle r);

Python

def set_clip_for_window(wnd, r):

Pascal

procedure SetClip(wnd: Window; const r: Rectangle)

---

Option Defaults

Returns a Drawing Options with default values. This will draw to the current window, with default scale of 1, no rotation or offset, not flipped, drawing whole images, with default camera mechanisms and line width.

Return Type: Drawing Options

Signatures:

C++

drawing_options option_defaults()

C#

public static DrawingOptions SplashKit.OptionDefaults();

Python

def option_defaults():

Pascal

function OptionDefaults(): DrawingOptions

---

Option Draw To

Note

This function is overloaded. The following versions exist:

• Option Draw To (dest: bitmap)
• Option Draw To (dest: bitmap, opts: drawing_options)
• Option Draw To (dest: window)
• Option Draw To (dest: window, opts: drawing_options)

Option Draw To

Use this option to draw to a Bitmap. Pass dest the Bitmap you want to draw on.

Parameters:

Name	Type	Description
dest	Bitmap	The bitmap to draw to.

Return Type: Drawing Options

Signatures:

C++

drawing_options option_draw_to(bitmap dest)

C#

public static DrawingOptions SplashKit.OptionDrawTo(Bitmap dest);

Python

def option_draw_to_bitmap(dest):

Pascal

function OptionDrawTo(dest: Bitmap): DrawingOptions

---

Option Draw To

Use this option to draw to a Bitmap. Pass dest the Bitmap you want to draw on. Pass opts the other options you want use.

Parameters:

Name	Type	Description
dest	Bitmap	The bitmap to draw to.
opts	Drawing Options	Values for the other options.

Return Type: Drawing Options

Signatures:

C++

drawing_options option_draw_to(bitmap dest, drawing_options opts)

C#

public static DrawingOptions SplashKit.OptionDrawTo(Bitmap dest, DrawingOptions opts);

Python

def option_draw_to_bitmap_with_options(dest, opts):

Pascal

function OptionDrawTo(dest: Bitmap; opts: DrawingOptions): DrawingOptions

---

Option Draw To

Use this option to draw to a specified Window. Pass dest the Window you want to draw on.

Parameters:

Name	Type	Description
dest	Window	The window to draw onto.

Return Type: Drawing Options

Signatures:

C++

drawing_options option_draw_to(window dest)

C#

public static DrawingOptions SplashKit.OptionDrawTo(Window dest);

Python

def option_draw_to_window(dest):

Pascal

function OptionDrawTo(dest: Window): DrawingOptions

---

Option Draw To

Use this option to draw to a Bitmap. Pass dest the Bitmap you want to draw on to. Pass opts the other options you want use.

Parameters:

Name	Type	Description
dest	Window	The window to draw onto.
opts	Drawing Options	Values for the other options.

Return Type: Drawing Options

Signatures:

C++

drawing_options option_draw_to(window dest, drawing_options opts)

C#

public static DrawingOptions SplashKit.OptionDrawTo(Window dest, DrawingOptions opts);

Python

def option_draw_to_window_with_options(dest, opts):

Pascal

function OptionDrawTo(dest: Window; opts: DrawingOptions): DrawingOptions

---

Option Flip X

Note

This function is overloaded. The following versions exist:

• Option Flip X ()
• Option Flip X (opts: drawing_options)

Option Flip X

Use this option to flip an image along its X axis.

Return Type: Drawing Options

Signatures:

C++

drawing_options option_flip_x()

C#

public static DrawingOptions SplashKit.OptionFlipX();

Python

def option_flip_x():

Pascal

function OptionFlipX(): DrawingOptions

---

Option Flip X

Use this option to flip an image along its X axis.

Parameters:

Name	Type	Description
opts	Drawing Options	Values for the other options.

Return Type: Drawing Options

Signatures:

C++

drawing_options option_flip_x(drawing_options opts)

C#

public static DrawingOptions SplashKit.OptionFlipX(DrawingOptions opts);

Python

def option_flip_x_with_options(opts):

Pascal

function OptionFlipX(opts: DrawingOptions): DrawingOptions

---

Option Flip Xy

Note

This function is overloaded. The following versions exist:

• Option Flip Xy ()
• Option Flip Xy (opts: drawing_options)

Option Flip Xy

Use this option to flip the drawing of an image along both X and Y axis.

Return Type: Drawing Options

Signatures:

C++

drawing_options option_flip_xy()

C#

public static DrawingOptions SplashKit.OptionFlipXy();

Python

def option_flip_xy():

Pascal

function OptionFlipXy(): DrawingOptions

---

Option Flip Xy

Use this option to flip the drawing of an image along both X and Y axis.

Parameters:

Name	Type	Description
opts	Drawing Options	Values for the other options.

Return Type: Drawing Options

Signatures:

C++

drawing_options option_flip_xy(drawing_options opts)

C#

public static DrawingOptions SplashKit.OptionFlipXy(DrawingOptions opts);

Python

def option_flip_xy_with_options(opts):

Pascal

function OptionFlipXy(opts: DrawingOptions): DrawingOptions

---

Option Flip Y

Note

This function is overloaded. The following versions exist:

• Option Flip Y ()
• Option Flip Y (opts: drawing_options)

Option Flip Y

Use this option to flip the drawing of an image along its Y axis.

Return Type: Drawing Options

Signatures:

C++

drawing_options option_flip_y()

C#

public static DrawingOptions SplashKit.OptionFlipY();

Python

def option_flip_y():

Pascal

function OptionFlipY(): DrawingOptions

---

Option Flip Y

Use this option to flip the drawing of an image along its Y axis.

Parameters:

Name	Type	Description
opts	Drawing Options	Values for the other options.

Return Type: Drawing Options

Signatures:

C++

drawing_options option_flip_y(drawing_options opts)

C#

public static DrawingOptions SplashKit.OptionFlipY(DrawingOptions opts);

Python

def option_flip_y_with_options(opts):

Pascal

function OptionFlipY(opts: DrawingOptions): DrawingOptions

---

Option Line Width

Note

This function is overloaded. The following versions exist:

• Option Line Width (width: int)
• Option Line Width (width: int, opts: drawing_options)

Option Line Width

Use this option to change the width of line drawings.

Parameters:

Name	Type	Description
width	Integer	The new line width for line drawing.

Return Type: Drawing Options

Signatures:

C++

drawing_options option_line_width(int width)

C#

public static DrawingOptions SplashKit.OptionLineWidth(int width);

Python

def option_line_width(width):

Pascal

function OptionLineWidth(width: Integer): DrawingOptions

---

Option Line Width

Use this option to change the width of line drawings.

Parameters:

Name	Type	Description
width	Integer	The new line width for line drawing.
opts	Drawing Options	Values for the other options.

Return Type: Drawing Options

Signatures:

C++

drawing_options option_line_width(int width, drawing_options opts)

C#

public static DrawingOptions SplashKit.OptionLineWidth(int width, DrawingOptions opts);

Python

def option_line_width_with_options(width, opts):

Pascal

function OptionLineWidth(width: Integer; opts: DrawingOptions): DrawingOptions

---

Option Part Bmp

Note

This function is overloaded. The following versions exist:

• Option Part Bmp (x: double, y: double, w: double, h: double)
• Option Part Bmp (x: double, y: double, w: double, h: double, opts: drawing_options)
• Option Part Bmp (part: rectangle)
• Option Part Bmp (part: rectangle, opts: drawing_options)

Option Part Bmp

Use this option to draw only a part of a bitmap.

Parameters:

Name	Type	Description
x	Double	The x coordinate of the part within the bitmap.
y	Double	The y coordinate of the part within the bitmap.
w	Double	The width of the part within the bitmap.
h	Double	The height of the part within the bitmap.

Return Type: Drawing Options

Signatures:

C++

drawing_options option_part_bmp(double x, double y, double w, double h)

C#

public static DrawingOptions SplashKit.OptionPartBmp(double x, double y, double w, double h);

Python

def option_part_bmp(x, y, w, h):

Pascal

function OptionPartBmp(x: Double; y: Double; w: Double; h: Double): DrawingOptions

---

Option Part Bmp

Use this option to draw only a part of a bitmap.

Parameters:

Name	Type	Description
x	Double	The x coordinate of the part within the bitmap.
y	Double	The y coordinate of the part within the bitmap.
w	Double	The width of the part within the bitmap.
h	Double	The height of the part within the bitmap.
opts	Drawing Options	Values for the other options.

Return Type: Drawing Options

Signatures:

C++

drawing_options option_part_bmp(double x, double y, double w, double h, drawing_options opts)

C#

public static DrawingOptions SplashKit.OptionPartBmp(double x, double y, double w, double h, DrawingOptions opts);

Python

def option_part_bmp_with_options(x, y, w, h, opts):

Pascal

function OptionPartBmp(x: Double; y: Double; w: Double; h: Double; opts: DrawingOptions): DrawingOptions

---

Option Part Bmp

Use this option to draw only part of a bitmap.

Parameters:

Name	Type	Description
part	Rectangle	The rectangle of the part of the bitmap to draw.

Return Type: Drawing Options

Signatures:

C++

drawing_options option_part_bmp(rectangle part)

C#

public static DrawingOptions SplashKit.OptionPartBmp(Rectangle part);

Python

def option_part_bmp_from_rectangle(part):

Pascal

function OptionPartBmp(part: Rectangle): DrawingOptions

---

Option Part Bmp

Use this option to draw only part of a bitmap.

Parameters:

Name	Type	Description
part	Rectangle	The rectangle of the part of the bitmap to draw.
opts	Drawing Options	Values for the other options.

Return Type: Drawing Options

Signatures:

C++

drawing_options option_part_bmp(rectangle part, drawing_options opts)

C#

public static DrawingOptions SplashKit.OptionPartBmp(Rectangle part, DrawingOptions opts);

Python

def option_part_bmp_from_rectangle_with_options(part, opts):

Pascal

function OptionPartBmp(part: Rectangle; opts: DrawingOptions): DrawingOptions

---

Option Rotate Bmp

Note

This function is overloaded. The following versions exist:

• Option Rotate Bmp (angle: double)
• Option Rotate Bmp (angle: double, anchor_x: double, anchor_y: double)
• Option Rotate Bmp (angle: double, anchor_x: double, anchor_y: double, opts: drawing_options)
• Option Rotate Bmp (angle: double, opts: drawing_options)

Option Rotate Bmp

Use this option to rotate a bitmap around its centre point.

Parameters:

Name	Type	Description
angle	Double	The angle to rotate bitmaps.

Return Type: Drawing Options

Signatures:

C++

drawing_options option_rotate_bmp(double angle)

C#

public static DrawingOptions SplashKit.OptionRotateBmp(double angle);

Python

def option_rotate_bmp(angle):

Pascal

function OptionRotateBmp(angle: Double): DrawingOptions

---

Option Rotate Bmp

Use this option to rotate the drawing of a bitmap. This allows you to set the anchor point and rotate around that by a number of degrees. Pass opts the other options you want use.

Parameters:

Name	Type	Description
angle	Double	The angle to rotate bitmaps.
anchor_x	Double	The x location of the anchor within the bitmap
anchor_y	Double	The y location of the anchor within the bitmap

Return Type: Drawing Options

Signatures:

C++

drawing_options option_rotate_bmp(double angle, double anchor_x, double anchor_y)

C#

public static DrawingOptions SplashKit.OptionRotateBmp(double angle, double anchorX, double anchorY);

Python

def option_rotate_bmp_with_anchor(angle, anchor_x, anchor_y):

Pascal

function OptionRotateBmp(angle: Double; anchorX: Double; anchorY: Double): DrawingOptions

---

Option Rotate Bmp

Use this option to rotate the drawing of a bitmap. This allows you to set the anchor point and rotate around that by a number of degrees. Pass opts the other options you want use.

Parameters:

Name	Type	Description
angle	Double	The angle to rotate bitmaps.
anchor_x	Double	The x location of the anchor within the bitmap
anchor_y	Double	The y location of the anchor within the bitmap
opts	Drawing Options	Values for the other options.

Return Type: Drawing Options

Signatures:

C++

drawing_options option_rotate_bmp(double angle, double anchor_x, double anchor_y, drawing_options opts)

C#

public static DrawingOptions SplashKit.OptionRotateBmp(double angle, double anchorX, double anchorY, DrawingOptions opts);

Python

def option_rotate_bmp_with_anchor_and_options(angle, anchor_x, anchor_y, opts):

Pascal

function OptionRotateBmp(angle: Double; anchorX: Double; anchorY: Double; opts: DrawingOptions): DrawingOptions

---

Option Rotate Bmp

Use this option to rotate a bitmap around its centre point.

Parameters:

Name	Type	Description
angle	Double	The angle to rotate bitmaps.
opts	Drawing Options	Values for the other options.

Return Type: Drawing Options

Signatures:

C++

drawing_options option_rotate_bmp(double angle, drawing_options opts)

C#

public static DrawingOptions SplashKit.OptionRotateBmp(double angle, DrawingOptions opts);

Python

def option_rotate_bmp_with_options(angle, opts):

Pascal

function OptionRotateBmp(angle: Double; opts: DrawingOptions): DrawingOptions

---

Option Scale Bmp

Note

This function is overloaded. The following versions exist:

• Option Scale Bmp (scale_x: double, scale_y: double)
• Option Scale Bmp (scale_x: double, scale_y: double, opts: drawing_options)

Option Scale Bmp

Use this option to scale the drawing of bitmaps. You can scale x and y separately.

Parameters:

Name	Type	Description
scale_x	Double	The amount to scale bitmaps aalong the x axis
scale_y	Double	The amount to scale bitmaps aalong the y axis

Return Type: Drawing Options

Signatures:

C++

drawing_options option_scale_bmp(double scale_x, double scale_y)

C#

public static DrawingOptions SplashKit.OptionScaleBmp(double scaleX, double scaleY);

Python

def option_scale_bmp(scale_x, scale_y):

Pascal

function OptionScaleBmp(scaleX: Double; scaleY: Double): DrawingOptions

---

Option Scale Bmp

Use this option to scale the drawing of bitmaps. You can scale x and y separately. Pass opts the other options you want use.

Parameters:

Name	Type	Description
scale_x	Double	The amount to scale bitmaps aalong the x axis
scale_y	Double	The amount to scale bitmaps aalong the y axis
opts	Drawing Options	Values for the other options.

Return Type: Drawing Options

Signatures:

C++

drawing_options option_scale_bmp(double scale_x, double scale_y, drawing_options opts)

C#

public static DrawingOptions SplashKit.OptionScaleBmp(double scaleX, double scaleY, DrawingOptions opts);

Python

def option_scale_bmp_with_options(scale_x, scale_y, opts):

Pascal

function OptionScaleBmp(scaleX: Double; scaleY: Double; opts: DrawingOptions): DrawingOptions

---

Option To Screen

Note

This function is overloaded. The following versions exist:

• Option To Screen ()
• Option To Screen (opts: drawing_options)

Option To Screen

Use this option to draw to the screen, ignoring the positon of the camera.

Return Type: Drawing Options

Signatures:

C++

drawing_options option_to_screen()

C#

public static DrawingOptions SplashKit.OptionToScreen();

Python

def option_to_screen():

Pascal

function OptionToScreen(): DrawingOptions

---

Option To Screen

Use this option to draw to the screen, ignoring the positon of the camera.

Parameters:

Name	Type	Description
opts	Drawing Options	Values for the other options.

Return Type: Drawing Options

Signatures:

C++

drawing_options option_to_screen(drawing_options opts)

C#

public static DrawingOptions SplashKit.OptionToScreen(DrawingOptions opts);

Python

def option_to_screen_with_options(opts):

Pascal

function OptionToScreen(opts: DrawingOptions): DrawingOptions

---

Option To World

Note

This function is overloaded. The following versions exist:

• Option To World ()
• Option To World (opts: drawing_options)

Option To World

Use this option to draw in World coordinates — these are affected by the movement of the camera.

Return Type: Drawing Options

Signatures:

C++

drawing_options option_to_world()

C#

public static DrawingOptions SplashKit.OptionToWorld();

Python

def option_to_world():

Pascal

function OptionToWorld(): DrawingOptions

---

Option To World

Use this option to draw in World coordinates — these are affected by the movement of the camera.

Parameters:

Name	Type	Description
opts	Drawing Options	Values for the other options.

Return Type: Drawing Options

Signatures:

C++

drawing_options option_to_world(drawing_options opts)

C#

public static DrawingOptions SplashKit.OptionToWorld(DrawingOptions opts);

Python

def option_to_world_with_options(opts):

Pascal

function OptionToWorld(opts: DrawingOptions): DrawingOptions

---

Option With Animation

Note

This function is overloaded. The following versions exist:

• Option With Animation (anim: animation)
• Option With Animation (anim: animation, opts: drawing_options)

Option With Animation

Use details from the animation to select an appropriate cell from the bitmaps being drawn.

Parameters:

Name	Type	Description
anim	Animation	The animation with the cell details to be used.

Return Type: Drawing Options

Signatures:

C++

drawing_options option_with_animation(animation anim)

C#

public static DrawingOptions SplashKit.OptionWithAnimation(Animation anim);

Python

def option_with_animation(anim):

Pascal

function OptionWithAnimation(anim: Animation): DrawingOptions

Usage:

See Implementations in Guides

• Using Animations in SplashKit

---

Option With Animation

Use details from the animation to select an appropriate cell from the bitmaps being drawn. This extends the passed in drawing options with the animation details.

Parameters:

Name	Type	Description
anim	Animation	The animation with the cell details to be used.
opts	Drawing Options	The existing options to extend.

Return Type: Drawing Options

Signatures:

C++

drawing_options option_with_animation(animation anim, drawing_options opts)

C#

public static DrawingOptions SplashKit.OptionWithAnimation(Animation anim, DrawingOptions opts);

Python

def option_with_animation_with_options(anim, opts):

Pascal

function OptionWithAnimation(anim: Animation; opts: DrawingOptions): DrawingOptions

---

Option With Bitmap Cell

Note

This function is overloaded. The following versions exist:

• Option With Bitmap Cell (cell: int)
• Option With Bitmap Cell (cell: int, opts: drawing_options)

Option With Bitmap Cell

When drawing the bitmap this will only draw the cell. To use this the bitmap needs to have been provided with its cell details (see Bitmap Set Cell Details). This option overrides the animation or part drawing options.

Parameters:

Name	Type	Description
cell	Integer	The cell to draw from the bitmap (-1 for entire bitmap)

Return Type: Drawing Options

Signatures:

C++

drawing_options option_with_bitmap_cell(int cell)

C#

public static DrawingOptions SplashKit.OptionWithBitmapCell(int cell);

Python

def option_with_bitmap_cell(cell):

Pascal

function OptionWithBitmapCell(cell: Integer): DrawingOptions

---

Option With Bitmap Cell

When drawing the bitmap this will only draw the cell. To use this the bitmap needs to have been provided with its cell details (see Bitmap Set Cell Details). This option overrides the animation or part drawing options. This extends the passed in drawing options with the cell details.

Parameters:

Name	Type	Description
cell	Integer	The cell to draw from the bitmap (-1 for entire bitmap)
opts	Drawing Options	The existing options to extend.

Return Type: Drawing Options

Signatures:

C++

drawing_options option_with_bitmap_cell(int cell, drawing_options opts)

C#

public static DrawingOptions SplashKit.OptionWithBitmapCell(int cell, DrawingOptions opts);

Python

def option_with_bitmap_cell_with_options(cell, opts):

Pascal

function OptionWithBitmapCell(cell: Integer; opts: DrawingOptions): DrawingOptions

---

Draw Ellipse

Note

This function is overloaded. The following versions exist:

• Draw Ellipse (clr: color, rect: rectangle)
• Draw Ellipse (clr: color, rect: rectangle, opts: drawing_options)
• Draw Ellipse (clr: color, x: double, y: double, width: double, height: double)
• Draw Ellipse (clr: color, x: double, y: double, width: double, height: double, opts: drawing_options)

Draw Ellipse

Draws an ellipse using the provided location, and size.

Parameters:

Name	Type	Description
clr	Color	The color of the ellipse
rect	Rectangle	Indicates the location and size of the ellipse

Signatures:

C++

void draw_ellipse(color clr, const rectangle rect)

C#

public static void SplashKit.DrawEllipse(Color clr, Rectangle rect);

Python

def draw_ellipse_within_rectangle(clr, rect):

Pascal

procedure DrawEllipse(clr: Color; rect: Rectangle)

---

Draw Ellipse

Draws an ellipse using the provided location, size, and drawing options. At this stage ellipse drawing is not affected by line width from the drawing options.

Parameters:

Name	Type	Description
clr	Color	The color of the ellipse
rect	Rectangle	Indicates the location and size of the ellipse
opts	Drawing Options	The drawing options

Signatures:

C++

void draw_ellipse(color clr, const rectangle rect, drawing_options opts)

C#

public static void SplashKit.DrawEllipse(Color clr, Rectangle rect, DrawingOptions opts);

Python

def draw_ellipse_within_rectangle_with_options(clr, rect, opts):

Pascal

procedure DrawEllipse(clr: Color; rect: Rectangle; opts: DrawingOptions)

---

Draw Ellipse

Draws an ellipse using the provided location, and size.

Parameters:

Name	Type	Description
clr	Color	The color of the ellipse
x	Double	The distance from the left of the bitmap or window to the left edge of the ellipse
y	Double	The distance from the top of the bitmap or window to the top edge of the ellipse
width	Double	The width of the ellipse
height	Double	The height of the ellipse

Signatures:

C++

void draw_ellipse(color clr, double x, double y, double width, double height)

C#

public static void SplashKit.DrawEllipse(Color clr, double x, double y, double width, double height);

Python

def draw_ellipse(clr, x, y, width, height):

Pascal

procedure DrawEllipse(clr: Color; x: Double; y: Double; width: Double; height: Double)

Usage:

See Code Examples

Example 1: #### Radiating Wave

The following code shows an example of using Draw Ellipse to draw a radiating wave pattern.

C++

#include "splashkit.h"

int main()
{
    open_window("Draw Ellipse", 800, 600);

    clear_screen(COLOR_WHITE);
    // Draw 30 ellipses
    for (int i = 0; i < 30; i++)
    {
        int width = 600 - i * 20;   // Decrease width by 20 every loop
        int height = 400 - i * 10;  // Decrease height by 10 every loop
        int x = 100 + i * 10;       // Increase x position by 10 every loop
        int y = 100 + i * 5;        // Increase y position by 5 every loop

        // Draw ellipse base on the given data
        draw_ellipse(random_rgb_color(255), x, y, width, height);
    }
    refresh_screen();

    delay(4000);
    close_all_windows();

    return 0;
}

C#

Top-level Statements

using static SplashKitSDK.SplashKit;

OpenWindow("Draw Ellipse", 800, 600);

ClearScreen(ColorWhite());
// Draw 30 ellipses
for (int i = 0; i < 30; i++)
{
    int width = 600 - i * 20;   // Decrease width by 20 every loop
        int height = 400 - i * 10;  // Decrease height by 10 every loop
        int x = 100 + i * 10;       // Increase x position by 10 every loop
        int y = 100 + i * 5;        // Increase y position by 5 every loop

    // Draw ellipse based on the given data
    DrawEllipse(RandomRGBColor(255), x, y, width, height);
}
RefreshScreen();

Delay(4000);
CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace DrawEllipseExample
{
    public class Program
    {
        public static void Main()
        {
            SplashKit.OpenWindow("Draw Ellipse", 800, 600);

            SplashKit.ClearScreen(Color.White);
            // Draw 30 ellipses
            for (int i = 0; i < 30; i++)
            {
                int width = 600 - i * 20;   // Decrease width by 20 every loop
                int height = 400 - i * 10;  // Decrease height by 10 every loop
                int x = 100 + i * 10;       // Increase x position by 10 every loop
                int y = 100 + i * 5;        // Increase y position by 5 every loop

                // Draw ellipse based on the given data
                SplashKit.DrawEllipse(Color.RandomRGB(255), x, y, width, height);
            }
            SplashKit.RefreshScreen();

            SplashKit.Delay(4000);
            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

open_window("Draw Ellipse", 800, 600)

clear_screen(color_white())
# Draw 30 ellipses
for i in range(30):
    width = 600 - i * 20    # Decrease width by 20 every loop
    height = 400 - i * 10   # Decrease height by 10 every loop
    x = 100 + i * 10        # Increase x position by 10 every loop
    y = 100 + i * 5         # Increase y position by 5 every loop

    # Draw ellipse based on the given data
    draw_ellipse(random_rgb_color(255), x, y, width, height)
refresh_screen()

delay(4000)
close_all_windows()

Output:

---

Draw Ellipse

Draws an ellipse using the provided location, size, and drawing options. At this stage ellipse drawing is not affected by line width from the drawing options.

Parameters:

Name	Type	Description
clr	Color	The color of the ellipse
x	Double	The distance from the left of the bitmap or window to the left edge of the ellipse
y	Double	The distance from the top of the bitmap or window to the top edge of the ellipse
width	Double	The width of the ellipse
height	Double	The height of the ellipse
opts	Drawing Options	The drawing options

Signatures:

C++

void draw_ellipse(color clr, double x, double y, double width, double height, drawing_options opts)

C#

public static void SplashKit.DrawEllipse(Color clr, double x, double y, double width, double height, DrawingOptions opts);

Python

def draw_ellipse_with_options(clr, x, y, width, height, opts):

Pascal

procedure DrawEllipse(clr: Color; x: Double; y: Double; width: Double; height: Double; opts: DrawingOptions)

---

Draw Ellipse On Bitmap

Note

This function is overloaded. The following versions exist:

• Draw Ellipse On Bitmap (destination: bitmap, clr: color, rect: rectangle)
• Draw Ellipse On Bitmap (destination: bitmap, clr: color, rect: rectangle, opts: drawing_options)
• Draw Ellipse On Bitmap (destination: bitmap, clr: color, x: double, y: double, width: double, height: double)
• Draw Ellipse On Bitmap (destination: bitmap, clr: color, x: double, y: double, width: double, height: double, opts: drawing_options)

Draw Ellipse On Bitmap

Draws an ellipse on the given bitmap, using the provided location, and size.

Parameters:

Name	Type	Description
destination	Bitmap	the bitmap to draw the ellipse on
clr	Color	The color of the ellipse
rect	Rectangle	Indicates the location and size of the ellipse

Signatures:

C++

void draw_ellipse_on_bitmap(bitmap destination, color clr, const rectangle rect)

C#

public void Bitmap.DrawEllipse(Color clr, Rectangle rect);
public static void SplashKit.DrawEllipseOnBitmap(Bitmap destination, Color clr, Rectangle rect);

Python

def draw_ellipse_on_bitmap_within_rectangle(destination, clr, rect):

Pascal

procedure DrawEllipseOnBitmap(destination: Bitmap; clr: Color; rect: Rectangle)

---

Draw Ellipse On Bitmap

Draws an ellipse on the given bitmap, using the provided location, size, and drawing options. At this stage ellipse drawing is not affected by line width from the drawing options.

Parameters:

Name	Type	Description
destination	Bitmap	the bitmap to draw the ellipse on
clr	Color	The color of the ellipse
rect	Rectangle	Indicates the location and size of the ellipse
opts	Drawing Options	The drawing options

Signatures:

C++

void draw_ellipse_on_bitmap(bitmap destination, color clr, const rectangle rect, drawing_options opts)

C#

public void Bitmap.DrawEllipse(Color clr, Rectangle rect, DrawingOptions opts);
public static void SplashKit.DrawEllipseOnBitmap(Bitmap destination, Color clr, Rectangle rect, DrawingOptions opts);

Python

def draw_ellipse_on_bitmap_within_rectangle_with_options(destination, clr, rect, opts):

Pascal

procedure DrawEllipseOnBitmap(destination: Bitmap; clr: Color; rect: Rectangle; opts: DrawingOptions)

---

Draw Ellipse On Bitmap

Draws an ellipse on the given bitmap, using the provided location, and size.

Parameters:

Name	Type	Description
destination	Bitmap	the bitmap to draw the ellipse on
clr	Color	The color of the ellipse
x	Double	The distance from the left of the bitmap or bitmap to the left edge of the ellipse
y	Double	The distance from the top of the bitmap or bitmap to the top edge of the ellipse
width	Double	The width of the ellipse
height	Double	The height of the ellipse

Signatures:

C++

void draw_ellipse_on_bitmap(bitmap destination, color clr, double x, double y, double width, double height)

C#

public void Bitmap.DrawEllipse(Color clr, double x, double y, double width, double height);
public static void SplashKit.DrawEllipseOnBitmap(Bitmap destination, Color clr, double x, double y, double width, double height);

Python

def draw_ellipse_on_bitmap(destination, clr, x, y, width, height):

Pascal

procedure DrawEllipseOnBitmap(destination: Bitmap; clr: Color; x: Double; y: Double; width: Double; height: Double)

---

Draw Ellipse On Bitmap

Draws an ellipse to the bitmap, using the provided location, size, and drawing options. At this stage ellipse drawing is not affected by line width from the drawing options.

Parameters:

Name	Type	Description
destination	Bitmap	the bitmap to draw the ellipse on
clr	Color	The color of the ellipse
x	Double	The distance from the left of the bitmap or bitmap to the left edge of the ellipse
y	Double	The distance from the top of the bitmap or bitmap to the top edge of the ellipse
width	Double	The width of the ellipse
height	Double	The height of the ellipse
opts	Drawing Options	The drawing options

Signatures:

C++

void draw_ellipse_on_bitmap(bitmap destination, color clr, double x, double y, double width, double height, drawing_options opts)

C#

public void Bitmap.DrawEllipse(Color clr, double x, double y, double width, double height, DrawingOptions opts);
public static void SplashKit.DrawEllipseOnBitmap(Bitmap destination, Color clr, double x, double y, double width, double height, DrawingOptions opts);

Python

def draw_ellipse_on_bitmap_with_options(destination, clr, x, y, width, height, opts):

Pascal

procedure DrawEllipseOnBitmap(destination: Bitmap; clr: Color; x: Double; y: Double; width: Double; height: Double; opts: DrawingOptions)

---

Draw Ellipse On Window

Note

This function is overloaded. The following versions exist:

• Draw Ellipse On Window (destination: window, clr: color, rect: rectangle)
• Draw Ellipse On Window (destination: window, clr: color, rect: rectangle, opts: drawing_options)
• Draw Ellipse On Window (destination: window, clr: color, x: double, y: double, width: double, height: double)
• Draw Ellipse On Window (destination: window, clr: color, x: double, y: double, width: double, height: double, opts: drawing_options)

Draw Ellipse On Window

Draws an ellipse on the given window, using the provided location, and size.

Parameters:

Name	Type	Description
destination	Window	the window to draw the ellipse on
clr	Color	The color of the ellipse
rect	Rectangle	Indicates the location and size of the ellipse

Signatures:

C++

void draw_ellipse_on_window(window destination, color clr, const rectangle rect)

C#

public void Window.DrawEllipse(Color clr, Rectangle rect);
public static void SplashKit.DrawEllipseOnWindow(Window destination, Color clr, Rectangle rect);

Python

def draw_ellipse_on_window_within_rectangle(destination, clr, rect):

Pascal

procedure DrawEllipseOnWindow(destination: Window; clr: Color; rect: Rectangle)

---

Draw Ellipse On Window

Draws an ellipse on the given window, using the provided location, size, and drawing options. At this stage ellipse drawing is not affected by line width from the drawing options.

Parameters:

Name	Type	Description
destination	Window	the window to draw the ellipse on
clr	Color	The color of the ellipse
rect	Rectangle	Indicates the location and size of the ellipse
opts	Drawing Options	The drawing options

Signatures:

C++

void draw_ellipse_on_window(window destination, color clr, const rectangle rect, drawing_options opts)

C#

public void Window.DrawEllipse(Color clr, Rectangle rect, DrawingOptions opts);
public static void SplashKit.DrawEllipseOnWindow(Window destination, Color clr, Rectangle rect, DrawingOptions opts);

Python

def draw_ellipse_on_window_within_rectangle_with_options(destination, clr, rect, opts):

Pascal

procedure DrawEllipseOnWindow(destination: Window; clr: Color; rect: Rectangle; opts: DrawingOptions)

---

Draw Ellipse On Window

Draws an ellipse on the given window, using the provided location, and size.

Parameters:

Name	Type	Description
destination	Window	the window to draw the ellipse on
clr	Color	The color of the ellipse
x	Double	The distance from the left of the bitmap or window to the left edge of the ellipse
y	Double	The distance from the top of the bitmap or window to the top edge of the ellipse
width	Double	The width of the ellipse
height	Double	The height of the ellipse

Signatures:

C++

void draw_ellipse_on_window(window destination, color clr, double x, double y, double width, double height)

C#

public void Window.DrawEllipse(Color clr, double x, double y, double width, double height);
public static void SplashKit.DrawEllipseOnWindow(Window destination, Color clr, double x, double y, double width, double height);

Python

def draw_ellipse_on_window(destination, clr, x, y, width, height):

Pascal

procedure DrawEllipseOnWindow(destination: Window; clr: Color; x: Double; y: Double; width: Double; height: Double)

---

Draw Ellipse On Window

Draws an ellipse to the window, using the provided location, size, and drawing options. At this stage ellipse drawing is not affected by line width from the drawing options.

Parameters:

Name	Type	Description
destination	Window	the window to draw the ellipse on
clr	Color	The color of the ellipse
x	Double	The distance from the left of the bitmap or window to the left edge of the ellipse
y	Double	The distance from the top of the bitmap or window to the top edge of the ellipse
width	Double	The width of the ellipse
height	Double	The height of the ellipse
opts	Drawing Options	The drawing options

Signatures:

C++

void draw_ellipse_on_window(window destination, color clr, double x, double y, double width, double height, drawing_options opts)

C#

public void Window.DrawEllipse(Color clr, double x, double y, double width, double height, DrawingOptions opts);
public static void SplashKit.DrawEllipseOnWindow(Window destination, Color clr, double x, double y, double width, double height, DrawingOptions opts);

Python

def draw_ellipse_on_window_with_options(destination, clr, x, y, width, height, opts):

Pascal

procedure DrawEllipseOnWindow(destination: Window; clr: Color; x: Double; y: Double; width: Double; height: Double; opts: DrawingOptions)

---

Fill Ellipse

Note

This function is overloaded. The following versions exist:

• Fill Ellipse (clr: color, rect: rectangle)
• Fill Ellipse (clr: color, rect: rectangle, opts: drawing_options)
• Fill Ellipse (clr: color, x: double, y: double, width: double, height: double)
• Fill Ellipse (clr: color, x: double, y: double, width: double, height: double, opts: drawing_options)

Fill Ellipse

Fill an ellipse using the provided location, and size.

Parameters:

Name	Type	Description
clr	Color	The color of the ellipse
rect	Rectangle	Indicates the location and size of the ellipse

Signatures:

C++

void fill_ellipse(color clr, const rectangle rect)

C#

public static void SplashKit.FillEllipse(Color clr, Rectangle rect);

Python

def fill_ellipse_within_rectangle(clr, rect):

Pascal

procedure FillEllipse(clr: Color; rect: Rectangle)

---

Fill Ellipse

Fills an ellipse using the provided location, size, and drawing options. At this stage ellipse drawing is not affected by line width from the drawing options.

Parameters:

Name	Type	Description
clr	Color	The color of the ellipse
rect	Rectangle	Indicates the location and size of the ellipse
opts	Drawing Options	The drawing options

Signatures:

C++

void fill_ellipse(color clr, const rectangle rect, drawing_options opts)

C#

public static void SplashKit.FillEllipse(Color clr, Rectangle rect, DrawingOptions opts);

Python

def fill_ellipse_within_rectangle_with_options(clr, rect, opts):

Pascal

procedure FillEllipse(clr: Color; rect: Rectangle; opts: DrawingOptions)

---

Fill Ellipse

Fills an ellipse using the provided location, and size.

Parameters:

Name	Type	Description
clr	Color	The color of the ellipse
x	Double	The distance from the left of the bitmap or window to the left edge of the ellipse
y	Double	The distance from the top of the bitmap or window to the top edge of the ellipse
width	Double	The width of the ellipse
height	Double	The height of the ellipse

Signatures:

C++

void fill_ellipse(color clr, double x, double y, double width, double height)

C#

public static void SplashKit.FillEllipse(Color clr, double x, double y, double width, double height);

Python

def fill_ellipse(clr, x, y, width, height):

Pascal

procedure FillEllipse(clr: Color; x: Double; y: Double; width: Double; height: Double)

Usage:

See Implementations in Guides

• Drawing using Procedures

See Code Examples

Example 1: Basic Blue Ellipse

C++

#include "splashkit.h"

int main()
{
    open_window("Fill Ellipse", 800, 600);

    clear_screen();
    fill_ellipse(COLOR_BLUE, 200, 200, 400, 200);
    // Added rectangle with same arguments as above for x, y, width and height
    draw_rectangle(COLOR_RED, 200, 200, 400, 200);
    refresh_screen();

    delay(4000);
    close_all_windows();

    return 0;
}

C#

Top-level Statements

using static SplashKitSDK.SplashKit;

OpenWindow("Fill Ellipse", 800, 600);

ClearScreen();
FillEllipse(ColorBlue(), 200, 200, 400, 200);
// Added rectangle with same arguments as above for x, y, width and height
DrawRectangle(ColorRed(), 200, 200, 400, 200);
RefreshScreen();

Delay(4000);
CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace FillEllipseExample
{
    public class Program
    {
        public static void Main()
        {
            SplashKit.OpenWindow("Fill Ellipse", 800, 600);

            SplashKit.ClearScreen();
            SplashKit.FillEllipse(Color.Blue, 200, 200, 400, 200);
            // Added a rectangle with the same arguments as above for x, y, width, and height
            SplashKit.DrawRectangle(Color.Red, 200, 200, 400, 200);
            SplashKit.RefreshScreen();

            SplashKit.Delay(4000);
            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

open_window("Fill Ellipse", 800, 600)

clear_screen(color_white())

fill_ellipse(color_blue(), 200, 200, 400, 200)
# Added a rectangle with the same arguments as above for x, y, width, and height
draw_rectangle(color_red(), 200, 200, 400, 200)
refresh_screen()

delay(4000)
close_all_windows()

Output:

Example 2: Clover Drawing

C++

#include "splashkit.h"

int main()
{
    open_window("Clover Drawing with Fill Ellipse", 1000, 600);

    clear_screen();
    fill_ellipse(COLOR_GREEN, 150, 225, 400, 200);
    fill_ellipse(COLOR_GREEN, 375, 0, 200, 400);
    fill_ellipse(COLOR_GREEN, 400, 225, 400, 200);
    fill_rectangle(COLOR_BROWN, 470, 400, 10, 150);
    refresh_screen();

    delay(4000);

    close_all_windows();

    return 0;
}

C#

Top-level Statements

using static SplashKitSDK.SplashKit;

OpenWindow("Clover Drawing with Fill Ellipse", 1000, 600);

ClearScreen();
FillEllipse(ColorGreen(), 150, 225, 400, 200);
FillEllipse(ColorGreen(), 375, 0, 200, 400);
FillEllipse(ColorGreen(), 400, 225, 400, 200);
FillRectangle(ColorBrown(), 470, 400, 10, 150);
RefreshScreen();

Delay(4000);

CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace CloverDrawing
{
    public class CloverDrawing
    {
        public static void Main()
        {
            SplashKit.OpenWindow("Clover Drawing with Fill Ellipse", 1000, 600);

            SplashKit.ClearScreen();
            SplashKit.FillEllipse(Color.Green, 150, 225, 400, 200);
            SplashKit.FillEllipse(Color.Green, 375, 0, 200, 400);
            SplashKit.FillEllipse(Color.Green, 400, 225, 400, 200);
            SplashKit.FillRectangle(Color.Brown, 470, 400, 10, 150);
            SplashKit.RefreshScreen();

            SplashKit.Delay(4000);

            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

open_window("Clover Drawing with Fill Ellipse", 1000, 600)

clear_screen(color_white())

fill_ellipse(color_green(), 150, 225, 400, 200)
fill_ellipse(color_green(), 375, 0, 200, 400)
fill_ellipse(color_green(), 400, 225, 400, 200)
fill_rectangle(color_brown(), 470, 400, 10, 150)
refresh_screen()

delay(4000)

close_all_windows()

Output:

---

Fill Ellipse

Fills an ellipse using the provided location, size, and drawing options.

Parameters:

Name	Type	Description
clr	Color	The color of the ellipse
x	Double	The distance from the left of the bitmap or window to the left edge of the ellipse
y	Double	The distance from the top of the bitmap or window to the top edge of the ellipse
width	Double	The width of the ellipse
height	Double	The height of the ellipse
opts	Drawing Options	The drawing options

Signatures:

C++

void fill_ellipse(color clr, double x, double y, double width, double height, drawing_options opts)

C#

public static void SplashKit.FillEllipse(Color clr, double x, double y, double width, double height, DrawingOptions opts);

Python

def fill_ellipse_with_options(clr, x, y, width, height, opts):

Pascal

procedure FillEllipse(clr: Color; x: Double; y: Double; width: Double; height: Double; opts: DrawingOptions)

---

Fill Ellipse On Bitmap

Note

This function is overloaded. The following versions exist:

• Fill Ellipse On Bitmap (destination: bitmap, clr: color, rect: rectangle)
• Fill Ellipse On Bitmap (destination: bitmap, clr: color, rect: rectangle, opts: drawing_options)
• Fill Ellipse On Bitmap (destination: bitmap, clr: color, x: double, y: double, width: double, height: double)
• Fill Ellipse On Bitmap (destination: bitmap, clr: color, x: double, y: double, width: double, height: double, opts: drawing_options)

Fill Ellipse On Bitmap

Fill an ellipse on the given bitmap, using the provided location, and size.

Parameters:

Name	Type	Description
destination	Bitmap	the bitmap to draw the ellipse on
clr	Color	The color of the ellipse
rect	Rectangle	Indicates the location and size of the ellipse

Signatures:

C++

void fill_ellipse_on_bitmap(bitmap destination, color clr, const rectangle rect)

C#

public void Bitmap.FillEllipse(Color clr, Rectangle rect);
public static void SplashKit.FillEllipseOnBitmap(Bitmap destination, Color clr, Rectangle rect);

Python

def fill_ellipse_on_bitmap_within_rectangle(destination, clr, rect):

Pascal

procedure FillEllipseOnBitmap(destination: Bitmap; clr: Color; rect: Rectangle)

---

Fill Ellipse On Bitmap

Fills an ellipse on the given bitmap, using the provided location, size, and drawing options. At this stage ellipse drawing is not affected by line width from the drawing options.

Parameters:

Name	Type	Description
destination	Bitmap	the bitmap to draw the ellipse on
clr	Color	The color of the ellipse
rect	Rectangle	Indicates the location and size of the ellipse
opts	Drawing Options	The drawing options

Signatures:

C++

void fill_ellipse_on_bitmap(bitmap destination, color clr, const rectangle rect, drawing_options opts)

C#

public void Bitmap.FillEllipse(Color clr, Rectangle rect, DrawingOptions opts);
public static void SplashKit.FillEllipseOnBitmap(Bitmap destination, Color clr, Rectangle rect, DrawingOptions opts);

Python

def fill_ellipse_on_bitmap_within_rectangle_with_options(destination, clr, rect, opts):

Pascal

procedure FillEllipseOnBitmap(destination: Bitmap; clr: Color; rect: Rectangle; opts: DrawingOptions)

---

Fill Ellipse On Bitmap

Fills an ellipse on the given bitmap, using the provided location, and size.

Parameters:

Name	Type	Description
destination	Bitmap	the bitmap to draw the ellipse on
clr	Color	The color of the ellipse
x	Double	The distance from the left of the bitmap or bitmap to the left edge of the ellipse
y	Double	The distance from the top of the bitmap or bitmap to the top edge of the ellipse
width	Double	The width of the ellipse
height	Double	The height of the ellipse

Signatures:

C++

void fill_ellipse_on_bitmap(bitmap destination, color clr, double x, double y, double width, double height)

C#

public void Bitmap.FillEllipse(Color clr, double x, double y, double width, double height);
public static void SplashKit.FillEllipseOnBitmap(Bitmap destination, Color clr, double x, double y, double width, double height);

Python

def fill_ellipse_on_bitmap(destination, clr, x, y, width, height):

Pascal

procedure FillEllipseOnBitmap(destination: Bitmap; clr: Color; x: Double; y: Double; width: Double; height: Double)

Usage:

See Code Examples

Example 1: Water Ripples

C++

#include "splashkit.h"

int main()
{
    // Create a window and bitmap for the water surface
    window window = open_window("Window", 400, 300);
    bitmap bitmap = create_bitmap("water", 400, 300);

    // Fill background with light blue
    clear_bitmap(bitmap, rgba_color(200, 230, 255, 255));

    // Create different blue tones for ripples (from most opaque to most transparent)
    color ripple_colors[] = {
        rgba_color(100, 150, 255, 100),
        rgba_color(120, 170, 255, 80),
        rgba_color(140, 190, 255, 60),
        rgba_color(160, 210, 255, 40),
        rgba_color(180, 230, 255, 20)
    };

    // Create ripple effect with concentric ellipses
    double center_x = 200;  // Center of the bitmap
    double center_y = 150;
    for(int i = 0; i < 5; i++)
    {
        // Larger ellipses with decreasing size from center
        fill_ellipse_on_bitmap(bitmap, ripple_colors[i],
                             center_x - (100 + i*30),  // x gets further from center
                             center_y - (75 + i*20),   // y gets further from center
                             200 + i*60,               // width increases for outer ripples
                             150 + i*40);              // height increases for outer ripples
    }

    while (!window_close_requested(window))
    {
        process_events();
        // Draw the bitmap to the window
        draw_bitmap(bitmap, 0, 0);
        refresh_screen();
    }

    free_bitmap(bitmap);
    close_all_windows();
    return 0;
}

C#

Top-level Statements

using static SplashKitSDK.SplashKit;
using SplashKitSDK;

// Create a window and bitmap for the water surface
Window window = OpenWindow("Window", 400, 300);
Bitmap bitmap = CreateBitmap("water", 400, 300);

// Fill background with light blue
ClearBitmap(bitmap, RGBAColor(200, 230, 255, 255));

// Create different blue tones for ripples (from most opaque to most transparent)
Color[] rippleColors = {
    RGBAColor(100, 150, 255, 100),
    RGBAColor(120, 170, 255, 80),
    RGBAColor(140, 190, 255, 60),
    RGBAColor(160, 210, 255, 40),
    RGBAColor(180, 230, 255, 20)
};

// Create ripple effect with concentric ellipses
double centerX = 200;  // Center of the bitmap
double centerY = 150;
for (int i = 0; i < rippleColors.Length; i++)
{
    // Larger ellipses with decreasing size from center
    FillEllipseOnBitmap(bitmap, rippleColors[i],
                        centerX - (100 + i * 30),  // x gets further from center
                        centerY - (75 + i * 20),   // y gets further from center
                        200 + i * 60,              // width increases for outer ripples
                        150 + i * 40);             // height increases for outer ripples
}

while (!WindowCloseRequested(window))
{
    ProcessEvents();
    // Draw the bitmap to the window
    DrawBitmap(bitmap, 0, 0);
    RefreshScreen();
}

FreeBitmap(bitmap);
CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace FillEllipseOnBitmap
{
    public class Program
    {
        public static void Main()
        {
            // Create a window and bitmap for the water surface
            Window window = new Window("Window", 400, 300);
            Bitmap bitmap = new Bitmap("water", 400, 300);

            // Fill background with light blue
            bitmap.Clear(Color.RGBAColor(200, 230, 255, 255));

            // Create different blue tones for ripples (from most opaque to most transparent)
            Color[] rippleColors = {
                Color.RGBAColor(100, 150, 255, 100),
                Color.RGBAColor(120, 170, 255, 80),
                Color.RGBAColor(140, 190, 255, 60),
                Color.RGBAColor(160, 210, 255, 40),
                Color.RGBAColor(180, 230, 255, 20)
            };

            // Create ripple effect with concentric ellipses
            double centerX = 200;  // Center of the bitmap
            double centerY = 150;
            for (int i = 0; i < rippleColors.Length; i++)
            {
                // Larger ellipses with decreasing size from center
                bitmap.FillEllipse(rippleColors[i],
                                 centerX - (100 + i * 30),  // x gets further from center
                                 centerY - (75 + i * 20),   // y gets further from center
                                 200 + i * 60,              // width increases for outer ripples
                                 150 + i * 40);             // height increases for outer ripples
            }

            while (!window.CloseRequested)
            {
                SplashKit.ProcessEvents();
                // Draw the bitmap to the window
                window.DrawBitmap(bitmap, 0, 0);
                SplashKit.RefreshScreen();
            }

            bitmap.Free();
            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

# Create a window and bitmap for the water surface
window = open_window("Window", 400, 300)
bitmap = create_bitmap("water", 400, 300)

# Fill background with light blue
clear_bitmap(bitmap, rgba_color(200, 230, 255, 255))

# Create different blue tones for ripples (from most opaque to most transparent)
ripple_colors = [
    rgba_color(100, 150, 255, 100),
    rgba_color(120, 170, 255, 80),
    rgba_color(140, 190, 255, 60),
    rgba_color(160, 210, 255, 40),
    rgba_color(180, 230, 255, 20)
]

# Create ripple effect with concentric ellipses
center_x = 200  # Center of the bitmap
center_y = 150
for i in range(5):
    # Larger ellipses with decreasing size from center
    fill_ellipse_on_bitmap(bitmap, ripple_colors[i],
                          center_x - (100 + i*30),  # x gets further from center
                          center_y - (75 + i*20),   # y gets further from center
                          200 + i*60,               # width increases for outer ripples
                          150 + i*40)               # height increases for outer ripples

while not window_close_requested(window):
    process_events()
    # Draw the bitmap to the window
    draw_bitmap(bitmap, 0, 0)
    refresh_screen()

free_bitmap(bitmap)
close_all_windows()

Output:

---

Fill Ellipse On Bitmap

Fills an ellipse on the given bitmap, using the provided location, size, and drawing options.

Parameters:

Name	Type	Description
destination	Bitmap	the bitmap to draw the ellipse on
clr	Color	The color of the ellipse
x	Double	The distance from the left of the bitmap or bitmap to the left edge of the ellipse
y	Double	The distance from the top of the bitmap or bitmap to the top edge of the ellipse
width	Double	The width of the ellipse
height	Double	The height of the ellipse
opts	Drawing Options	The drawing options

Signatures:

C++

void fill_ellipse_on_bitmap(bitmap destination, color clr, double x, double y, double width, double height, drawing_options opts)

C#

public void Bitmap.FillEllipse(Color clr, double x, double y, double width, double height, DrawingOptions opts);
public static void SplashKit.FillEllipseOnBitmap(Bitmap destination, Color clr, double x, double y, double width, double height, DrawingOptions opts);

Python

def fill_ellipse_on_bitmap_with_options(destination, clr, x, y, width, height, opts):

Pascal

procedure FillEllipseOnBitmap(destination: Bitmap; clr: Color; x: Double; y: Double; width: Double; height: Double; opts: DrawingOptions)

---

Fill Ellipse On Window

Note

This function is overloaded. The following versions exist:

• Fill Ellipse On Window (destination: window, clr: color, rect: rectangle)
• Fill Ellipse On Window (destination: window, clr: color, rect: rectangle, opts: drawing_options)
• Fill Ellipse On Window (destination: window, clr: color, x: double, y: double, width: double, height: double)
• Fill Ellipse On Window (destination: window, clr: color, x: double, y: double, width: double, height: double, opts: drawing_options)

Fill Ellipse On Window

Fill an ellipse on the given window, using the provided location, and size.

Parameters:

Name	Type	Description
destination	Window	the window to draw the ellipse on
clr	Color	The color of the ellipse
rect	Rectangle	Indicates the location and size of the ellipse

Signatures:

C++

void fill_ellipse_on_window(window destination, color clr, const rectangle rect)

C#

public void Window.FillEllipse(Color clr, Rectangle rect);
public static void SplashKit.FillEllipseOnWindow(Window destination, Color clr, Rectangle rect);

Python

def fill_ellipse_on_window_within_rectangle(destination, clr, rect):

Pascal

procedure FillEllipseOnWindow(destination: Window; clr: Color; rect: Rectangle)

---

Fill Ellipse On Window

Fills an ellipse on the given window, using the provided location, size, and drawing options. At this stage ellipse drawing is not affected by line width from the drawing options.

Parameters:

Name	Type	Description
destination	Window	the window to draw the ellipse on
clr	Color	The color of the ellipse
rect	Rectangle	Indicates the location and size of the ellipse
opts	Drawing Options	The drawing options

Signatures:

C++

void fill_ellipse_on_window(window destination, color clr, const rectangle rect, drawing_options opts)

C#

public void Window.FillEllipse(Color clr, Rectangle rect, DrawingOptions opts);
public static void SplashKit.FillEllipseOnWindow(Window destination, Color clr, Rectangle rect, DrawingOptions opts);

Python

def fill_ellipse_on_window_within_rectangle_with_options(destination, clr, rect, opts):

Pascal

procedure FillEllipseOnWindow(destination: Window; clr: Color; rect: Rectangle; opts: DrawingOptions)

---

Fill Ellipse On Window

Fills an ellipse on the given window, using the provided location, and size.

Parameters:

Name	Type	Description
destination	Window	the window to draw the ellipse on
clr	Color	The color of the ellipse
x	Double	The distance from the left of the bitmap or window to the left edge of the ellipse
y	Double	The distance from the top of the bitmap or window to the top edge of the ellipse
width	Double	The width of the ellipse
height	Double	The height of the ellipse

Signatures:

C++

void fill_ellipse_on_window(window destination, color clr, double x, double y, double width, double height)

C#

public void Window.FillEllipse(Color clr, double x, double y, double width, double height);
public static void SplashKit.FillEllipseOnWindow(Window destination, Color clr, double x, double y, double width, double height);

Python

def fill_ellipse_on_window(destination, clr, x, y, width, height):

Pascal

procedure FillEllipseOnWindow(destination: Window; clr: Color; x: Double; y: Double; width: Double; height: Double)

---

Fill Ellipse On Window

Fills an ellipse on the given window, using the provided location, size, and drawing options.

Parameters:

Name	Type	Description
destination	Window	the window to draw the ellipse on
clr	Color	The color of the ellipse
x	Double	The distance from the left of the bitmap or window to the left edge of the ellipse
y	Double	The distance from the top of the bitmap or window to the top edge of the ellipse
width	Double	The width of the ellipse
height	Double	The height of the ellipse
opts	Drawing Options	The drawing options

Signatures:

C++

void fill_ellipse_on_window(window destination, color clr, double x, double y, double width, double height, drawing_options opts)

C#

public void Window.FillEllipse(Color clr, double x, double y, double width, double height, DrawingOptions opts);
public static void SplashKit.FillEllipseOnWindow(Window destination, Color clr, double x, double y, double width, double height, DrawingOptions opts);

Python

def fill_ellipse_on_window_with_options(destination, clr, x, y, width, height, opts):

Pascal

procedure FillEllipseOnWindow(destination: Window; clr: Color; x: Double; y: Double; width: Double; height: Double; opts: DrawingOptions)

---

Clear Screen

Note

This function is overloaded. The following versions exist:

• Clear Screen ()
• Clear Screen (clr: color)

Clear Screen

Clears the current screen to color white.

Signatures:

C++

void clear_screen()

C#

public static void SplashKit.ClearScreen();

Python

def clear_screen_to_white():

Pascal

procedure ClearScreen()

Usage:

See Implementations in Guides

• Getting Started Creating User Interfaces

---

Clear Screen

Parameters:

Name	Type	Description
clr	Color	The color to clear the screen’s background color to.

Signatures:

C++

void clear_screen(color clr)

C#

public static void SplashKit.ClearScreen(Color clr);

Python

def clear_screen(clr):

Pascal

procedure ClearScreen(clr: Color)

Usage:

See Implementations in Guides

• Get Started with SplashKit Audio
• SplashKit Camera
• Drawing using Procedures
• Using Mouse Inputs

See Code Examples

Example 1: Background Color

C++

#include "splashkit.h"

int main()
{
    open_window("Blue Background", 800, 600);

    //Use Clear Screen to change the background color to blue
    clear_screen(COLOR_BLUE);

    refresh_screen(60);
    delay(4000);
    close_all_windows();

    return 0;
}

C#

Top-level Statements

using static SplashKitSDK.SplashKit;

OpenWindow("Blue Background", 800, 600);

//Use Clear Screen to change the background color to blue
ClearScreen(ColorBlue());

RefreshScreen(60);
Delay(4000);
CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace ClearScreenExample
{
    public class Program
    {
        public static void Main()
        {
            SplashKit.OpenWindow("Blue Background", 800, 600);

            //Use Clear Screen to change the background color to blue
            SplashKit.ClearScreen(Color.Blue);

            SplashKit.RefreshScreen(60);
            SplashKit.Delay(4000);
            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

open_window("Blue Background", 800, 600)

# Use Clear Screen to change the background color to blue
clear_screen(color_blue())

refresh_screen()
delay(4000)
close_all_windows()

Output:

---

Display Details

Returns the details about one of the displays attached to the computer.

Parameters:

Name	Type	Description
index	unsigned int	The display number (from 0 to Number Of Displays - 1)

Return Type: Display

Signatures:

C++

display display_details(unsigned int index)

C#

public static Display SplashKit.DisplayDetails(uint index);

Python

def display_details(index):

Pascal

function DisplayDetails(index: Cardinal): Display

---

Display Height

Return the height of the display in pixels, read from the system details.

Parameters:

Name	Type	Description
disp	Display	The display details

Return Type: Integer

Signatures:

C++

int display_height(display disp)

C#

public int Display.Height { get }
public static int SplashKit.DisplayHeight(Display disp);

Python

def display_height(disp):

Pascal

function DisplayHeight(disp: Display): Integer

---

Display Name

Return the name of the display, read from the system details.

Parameters:

Name	Type	Description
disp	Display	The display details

Return Type: String

Signatures:

C++

string display_name(display disp)

C#

public string Display.Name { get }
public static string SplashKit.DisplayName(Display disp);

Python

def display_name(disp):

Pascal

function DisplayName(disp: Display): String

---

Display Width

Return the width of the display in pixels, read from the system details.

Parameters:

Name	Type	Description
disp	Display	The display details

Return Type: Integer

Signatures:

C++

int display_width(display disp)

C#

public int Display.Width { get }
public static int SplashKit.DisplayWidth(Display disp);

Python

def display_width(disp):

Pascal

function DisplayWidth(disp: Display): Integer

---

Display X

Return a relative x location for the display in pixels, read from the system details. This can be used to work out the arrangement of displays.

Parameters:

Name	Type	Description
disp	Display	The display details

Return Type: Integer

Signatures:

C++

int display_x(display disp)

C#

public int Display.X { get }
public static int SplashKit.DisplayX(Display disp);

Python

def display_x(disp):

Pascal

function DisplayX(disp: Display): Integer

---

Display Y

Return a relative y location for the display in pixels, read from the system details. This can be used to work out the arrangement of displays.

Parameters:

Name	Type	Description
disp	Display	The display details

Return Type: Integer

Signatures:

C++

int display_y(display disp)

C#

public int Display.Y { get }
public static int SplashKit.DisplayY(Display disp);

Python

def display_y(disp):

Pascal

function DisplayY(disp: Display): Integer

---

Number Of Displays

Returns the number of physical displays attached to the computer.

Return Type: Integer

Signatures:

C++

int number_of_displays()

C#

public static int SplashKit.NumberOfDisplays();

Python

def number_of_displays():

Pascal

function NumberOfDisplays(): Integer

---

Refresh Screen

Note

This function is overloaded. The following versions exist:

• Refresh Screen ()
• Refresh Screen (target_fps: unsigned int)

Refresh Screen

Signatures:

C++

void refresh_screen()

C#

public static void SplashKit.RefreshScreen();

Python

def refresh_screen():

Pascal

procedure RefreshScreen()

Usage:

See Implementations in Guides

• Drawing using Procedures
• Getting Started Creating User Interfaces

See Code Examples

Example 1: House Drawing

C++

#include "splashkit.h"

int main()
{
    open_window("House Drawing", 800, 600);

    clear_screen(COLOR_WHITE);
    refresh_screen();
    delay(1000);

    fill_ellipse(COLOR_BRIGHT_GREEN, 0, 400, 800, 400);
    refresh_screen();
    delay(1000);

    fill_rectangle(COLOR_GRAY, 300, 300, 200, 200);
    refresh_screen();
    delay(1000);

    fill_triangle(COLOR_RED, 250, 300, 400, 150, 550, 300);
    refresh_screen();
    delay(5000);

    close_all_windows();

    return 0;
}

C#

Top-level Statements

using static SplashKitSDK.SplashKit;

OpenWindow("House Drawing", 800, 600);

ClearScreen(ColorWhite());
RefreshScreen();
Delay(1000);

FillEllipse(ColorBrightGreen(), 0, 400, 800, 400);
RefreshScreen();
Delay(1000);

FillRectangle(ColorGray(), 300, 300, 200, 200);
RefreshScreen();
Delay(1000);

FillTriangle(ColorRed(), 250, 300, 400, 150, 550, 300);
RefreshScreen();
Delay(5000);

CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace RefreshScreen
{
    public class Program
    {
        public static void Main()
        {
            SplashKit.OpenWindow("House Drawing", 800, 600);

            SplashKit.ClearScreen(Color.White);
            SplashKit.RefreshScreen();
            SplashKit.Delay(1000);

            SplashKit.FillEllipse(Color.BrightGreen, 0, 400, 800, 400);
            SplashKit.RefreshScreen();
            SplashKit.Delay(1000);

            SplashKit.FillRectangle(Color.Gray, 300, 300, 200, 200);
            SplashKit.RefreshScreen();
            SplashKit.Delay(1000);

            SplashKit.FillTriangle(Color.Red, 250, 300, 400, 150, 550, 300);
            SplashKit.RefreshScreen();
            SplashKit.Delay(5000);

            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

open_window("House Drawing", 800, 600)

clear_screen(color_white())
refresh_screen()
delay(1000)

fill_ellipse(color_bright_green(), 0, 400, 800, 400)
refresh_screen()
delay(1000)

fill_rectangle(color_gray(), 300, 300, 200, 200)
refresh_screen()
delay(1000)

fill_triangle(color_red(), 250, 300, 400, 150, 550, 300)
refresh_screen()
delay(5000)

close_all_windows()

Output:

---

Refresh Screen

Refreshes all open windows with a target FPS (frames per second). This will delay a period of time that will approximately meet the targeted frames per second.

Parameters:

Name	Type	Description
target_fps	unsigned int	The targeted frames per second to refresh the screen at.

Signatures:

C++

void refresh_screen(unsigned int target_fps)

C#

public static void SplashKit.RefreshScreen(uint targetFps);

Python

def refresh_screen_with_target_fps(target_fps):

Pascal

procedure RefreshScreen(targetFps: Cardinal)

Usage:

See Implementations in Guides

• SplashKit Camera
• Reading Text

---

Save Bitmap

Save the bitmap to the user’s desktop.

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap to save
basename	String	The base of the filename. If there is a file of this name already, then the name will be changed to generate a unique filename.

Signatures:

C++

void save_bitmap(bitmap bmp, const string &basename)

C#

public static void SplashKit.SaveBitmap(Bitmap bmp, string basename);

Python

def save_bitmap(bmp, basename):

Pascal

procedure SaveBitmap(bmp: Bitmap; const basename: String)

---

Screen Height

Returns the height of the current window.

Return Type: Integer

Signatures:

C++

int screen_height()

C#

public static int SplashKit.ScreenHeight();

Python

def screen_height():

Pascal

function ScreenHeight(): Integer

---

Screen Width

Returns the width of the current window.

Return Type: Integer

Signatures:

C++

int screen_width()

C#

public static int SplashKit.ScreenWidth();

Python

def screen_width():

Pascal

function ScreenWidth(): Integer

---

Take Screenshot

Note

This function is overloaded. The following versions exist:

• Take Screenshot (basename: string)
• Take Screenshot (wind: window, basename: string)

Take Screenshot

Saves a screenshot of the current window to a bitmap file. The file will be saved onto the user’s desktop.

Parameters:

Name	Type	Description
basename	String	The base of the filename. If there is a file of this name already, then the name will be changed to generate a unique filename.

Signatures:

C++

void take_screenshot(const string &basename)

C#

public static void SplashKit.TakeScreenshot(string basename);

Python

def take_screenshot(basename):

Pascal

procedure TakeScreenshot(const basename: String)

---

Take Screenshot

Saves a screenshot of the current window to a bitmap file. The file will be saved onto the user’s desktop.

Parameters:

Name	Type	Description
wind	Window	The window to capture in the screenshot
basename	String	The base of the filename. If there is a file of this name already, then the name will be changed to generate a unique filename.

Signatures:

C++

void take_screenshot(window wind, const string &basename)

C#

public static void SplashKit.TakeScreenshot(Window wind, string basename);

Python

def take_screenshot_of_window(wind, basename):

Pascal

procedure TakeScreenshot(wind: Window; const basename: String)

---

Bitmap Bounding Circle

Returns a circle that will encompass the entire bitamp.

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap to encompass.
pt	Point 2d	The point where the bitmap is located.

Return Type: Circle

Signatures:

C++

circle bitmap_bounding_circle(bitmap bmp, const point_2d &pt)

C#

public Circle Bitmap.BoundingCircle(Point2D pt);
public static Circle SplashKit.BitmapBoundingCircle(Bitmap bmp, Point2D pt);

Python

def bitmap_bounding_circle(bmp, pt):

Pascal

function BitmapBoundingCircle(bmp: Bitmap; const pt: Point2D): Circle

---

Bitmap Bounding Rectangle

Note

This function is overloaded. The following versions exist:

• Bitmap Bounding Rectangle (bmp: bitmap)
• Bitmap Bounding Rectangle (bmp: bitmap, x: double, y: double)

Bitmap Bounding Rectangle

Returns a rectangle that is the same size as a bitmap (the whole bitmap).

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap

Return Type: Rectangle

Signatures:

C++

rectangle bitmap_bounding_rectangle(bitmap bmp)

C#

public Rectangle Bitmap.BoundingRectangle();
public static Rectangle SplashKit.BitmapBoundingRectangle(Bitmap bmp);

Python

def bitmap_bounding_rectangle(bmp):

Pascal

function BitmapBoundingRectangle(bmp: Bitmap): Rectangle

---

Bitmap Bounding Rectangle

Returns a rectangle that is the same size as the bitmap and is located at the indicated position.

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap
x	Double	The x location of the rectangle
y	Double	The y location of the rectangle

Return Type: Rectangle

Signatures:

C++

rectangle bitmap_bounding_rectangle(bitmap bmp, double x, double y)

C#

public Rectangle Bitmap.BoundingRectangle(double x, double y);
public static Rectangle SplashKit.BitmapBoundingRectangle(Bitmap bmp, double x, double y);

Python

def bitmap_bounding_rectangle_at_location(bmp, x, y):

Pascal

function BitmapBoundingRectangle(bmp: Bitmap; x: Double; y: Double): Rectangle

---

Bitmap Cell Center

This returns a point that represents the center of a cell from this bitmap in local space.

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap to get the center of.

Return Type: Point 2d

Signatures:

C++

point_2d bitmap_cell_center(bitmap bmp)

C#

public Point2D Bitmap.CellCenter { get }
public static Point2D SplashKit.BitmapCellCenter(Bitmap bmp);

Python

def bitmap_cell_center(bmp):

Pascal

function BitmapCellCenter(bmp: Bitmap): Point2D

---

Bitmap Cell Circle

Note

This function is overloaded. The following versions exist:

• Bitmap Cell Circle (bmp: bitmap, x: double, y: double)
• Bitmap Cell Circle (bmp: bitmap, pt: point_2d)
• Bitmap Cell Circle (bmp: bitmap, pt: point_2d, scale: double)

Bitmap Cell Circle

Returns a circle that will encompass the bitmap cell if it were drawn at the indicated point.

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap to get the details from.
x	Double	The the x location of the bitmap.
y	Double	The the y location of the bitmap.

Return Type: Circle

Signatures:

C++

circle bitmap_cell_circle(bitmap bmp, double x, double y)

C#

public Circle Bitmap.CellCircle(double x, double y);
public static Circle SplashKit.BitmapCellCircle(Bitmap bmp, double x, double y);

Python

def bitmap_cell_circle(bmp, x, y):

Pascal

function BitmapCellCircle(bmp: Bitmap; x: Double; y: Double): Circle

---

Bitmap Cell Circle

Returns a circle that will encompass the bitmap cell if it were drawn at the indicated point.

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap to get the details from.
pt	Point 2d	The point indicating the location of the bitmap.

Return Type: Circle

Signatures:

C++

circle bitmap_cell_circle(bitmap bmp, const point_2d pt)

C#

public Circle Bitmap.CellCircle(Point2D pt);
public static Circle SplashKit.BitmapCellCircle(Bitmap bmp, Point2D pt);

Python

def bitmap_cell_circle_at_point(bmp, pt):

Pascal

function BitmapCellCircle(bmp: Bitmap; pt: Point2D): Circle

---

Bitmap Cell Circle

Returns a circle that will encompass the bitmap cell if it were drawn at the indicated point, with the provided scale.

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap to get the details from.
pt	Point 2d	The point indicating the location of the bitmap.
scale	Double	The scaling factor for the bitmap drawing.

Return Type: Circle

Signatures:

C++

circle bitmap_cell_circle(bitmap bmp, const point_2d pt, double scale)

C#

public Circle Bitmap.CellCircle(Point2D pt, double scale);
public static Circle SplashKit.BitmapCellCircle(Bitmap bmp, Point2D pt, double scale);

Python

def bitmap_cell_circle_at_point_with_scale(bmp, pt, scale):

Pascal

function BitmapCellCircle(bmp: Bitmap; pt: Point2D; scale: Double): Circle

---

Bitmap Cell Columns

Returns the number of cell columns in the bitmap. This is setup using Bitmap Set Cell Details

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap to check

Return Type: Integer

Signatures:

C++

int bitmap_cell_columns(bitmap bmp)

C#

public int Bitmap.CellColumns { get }
public static int SplashKit.BitmapCellColumns(Bitmap bmp);

Python

def bitmap_cell_columns(bmp):

Pascal

function BitmapCellColumns(bmp: Bitmap): Integer

---

Bitmap Cell Count

Returns the number of cells within the bitmap.

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap to check.

Return Type: Integer

Signatures:

C++

int bitmap_cell_count(bitmap bmp)

C#

public int Bitmap.CellCount { get }
public static int SplashKit.BitmapCellCount(Bitmap bmp);

Python

def bitmap_cell_count(bmp):

Pascal

function BitmapCellCount(bmp: Bitmap): Integer

---

Bitmap Cell Height

Returns the height of each cell in this bitmap.

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap to get the details from.

Return Type: Integer

Signatures:

C++

int bitmap_cell_height(bitmap bmp)

C#

public int Bitmap.CellHeight { get }
public static int SplashKit.BitmapCellHeight(Bitmap bmp);

Python

def bitmap_cell_height(bmp):

Pascal

function BitmapCellHeight(bmp: Bitmap): Integer

---

Bitmap Cell Offset

Returns a vector that represents the movement needed to get to a given cell within a bitmap.

Parameters:

Name	Type	Description
src	Bitmap	The bitmap with the cell details.
cell	Integer	The index of the cell

Return Type: Vector 2d

Signatures:

C++

vector_2d bitmap_cell_offset(bitmap src, int cell)

C#

public Vector2D Bitmap.CellOffset(int cell);
public static Vector2D SplashKit.BitmapCellOffset(Bitmap src, int cell);

Python

def bitmap_cell_offset(src, cell):

Pascal

function BitmapCellOffset(src: Bitmap; cell: Integer): Vector2D

---

Bitmap Cell Rectangle

Note

This function is overloaded. The following versions exist:

• Bitmap Cell Rectangle (src: bitmap)
• Bitmap Cell Rectangle (src: bitmap, pt: point_2d)

Bitmap Cell Rectangle

Returns a rectangle that will encompass a cell of the bitmap.

Parameters:

Name	Type	Description
src	Bitmap	The bitmap to get the details from

Return Type: Rectangle

Signatures:

C++

rectangle bitmap_cell_rectangle(bitmap src)

C#

public Rectangle Bitmap.CellRectangle();
public static Rectangle SplashKit.BitmapCellRectangle(Bitmap src);

Python

def bitmap_cell_rectangle(src):

Pascal

function BitmapCellRectangle(src: Bitmap): Rectangle

---

Bitmap Cell Rectangle

Returns a rectangle that will encompass the bitmap cell if it were drawn at the indicated point.

Parameters:

Name	Type	Description
src	Bitmap	The bitmap to get the details from
pt	Point 2d	The point details for the rectangle.

Return Type: Rectangle

Signatures:

C++

rectangle bitmap_cell_rectangle(bitmap src, const point_2d &pt)

C#

public Rectangle Bitmap.CellRectangle(Point2D pt);
public static Rectangle SplashKit.BitmapCellRectangle(Bitmap src, Point2D pt);

Python

def bitmap_cell_rectangle_at_point(src, pt):

Pascal

function BitmapCellRectangle(src: Bitmap; const pt: Point2D): Rectangle

---

Bitmap Cell Rows

Returns the number of rows of cells in the bitmap. These details are set in Bitmap Set Cell Details.

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap to get the details from.

Return Type: Integer

Signatures:

C++

int bitmap_cell_rows(bitmap bmp)

C#

public int Bitmap.CellRows { get }
public static int SplashKit.BitmapCellRows(Bitmap bmp);

Python

def bitmap_cell_rows(bmp):

Pascal

function BitmapCellRows(bmp: Bitmap): Integer

---

Bitmap Cell Width

Returns the width of each cell in this bitmap.

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap to get the details from.

Return Type: Integer

Signatures:

C++

int bitmap_cell_width(bitmap bmp)

C#

public int Bitmap.CellWidth { get }
public static int SplashKit.BitmapCellWidth(Bitmap bmp);

Python

def bitmap_cell_width(bmp):

Pascal

function BitmapCellWidth(bmp: Bitmap): Integer

---

Bitmap Center

This returns a point that represents the center of the bitmap in local space.

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap to get the center of.

Return Type: Point 2d

Signatures:

C++

point_2d bitmap_center(bitmap bmp)

C#

public Point2D Bitmap.Center { get }
public static Point2D SplashKit.BitmapCenter(Bitmap bmp);

Python

def bitmap_center(bmp):

Pascal

function BitmapCenter(bmp: Bitmap): Point2D

---

Bitmap Filename

Returns the filename from which the bitmap was loaded. This will be an empty string for created bitmaps.

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap to get the filename from.

Return Type: String

Signatures:

C++

string bitmap_filename(bitmap bmp)

C#

public string Bitmap.Filename { get }
public static string SplashKit.BitmapFilename(Bitmap bmp);

Python

def bitmap_filename(bmp):

Pascal

function BitmapFilename(bmp: Bitmap): String

---

Bitmap Height

Note

This function is overloaded. The following versions exist:

• Bitmap Height (bmp: bitmap)
• Bitmap Height (name: string)

Bitmap Height

Returns the total height of the bitmap. If the bitmap contains cells, you ca get the height of a cell using Bitmap Cell Height.

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap to get the details from.

Return Type: Integer

Signatures:

C++

int bitmap_height(bitmap bmp)

C#

public int Bitmap.Height { get }
public static int SplashKit.BitmapHeight(Bitmap bmp);

Python

def bitmap_height(bmp):

Pascal

function BitmapHeight(bmp: Bitmap): Integer

---

Bitmap Height

Returns the total height of the bitmap. If the bitmap contains cells, you ca get the height of a cell using Bitmap Cell Height.

Parameters:

Name	Type	Description
name	String	The name of the bitmap to get the details from.

Return Type: Integer

Signatures:

C++

int bitmap_height(string name)

C#

public static int SplashKit.BitmapHeight(string name);

Python

def bitmap_height_of_bitmap_named(name):

Pascal

function BitmapHeight(name: String): Integer

---

Bitmap Name

Returns the name of the bitmap was loaded. This is the name you can use to access this bitmap.

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap to get the name from.

Return Type: String

Signatures:

C++

string bitmap_name(bitmap bmp)

C#

public string Bitmap.Name { get }
public static string SplashKit.BitmapName(Bitmap bmp);

Python

def bitmap_name(bmp):

Pascal

function BitmapName(bmp: Bitmap): String

---

Bitmap Named

Returns the Bitmap that has been loaded with the specified name, see Load Bitmap. This will attempt to load the bitmap if it has not been loaded.

Parameters:

Name	Type	Description
name	String	The name of the bitmap to check.

Return Type: Bitmap

Signatures:

C++

bitmap bitmap_named(string name)

C#

public static Bitmap SplashKit.BitmapNamed(string name);

Python

def bitmap_named(name):

Pascal

function BitmapNamed(name: String): Bitmap

Usage:

See Implementations in Guides

• Using Animations in SplashKit

---

Bitmap Rectangle Of Cell

Returns a rectangle that can be used to access the part of a bitmap related to an individual cell.

Parameters:

Name	Type	Description
src	Bitmap	The bitmap
cell	Integer	The cell

Return Type: Rectangle

Signatures:

C++

rectangle bitmap_rectangle_of_cell(bitmap src, int cell)

C#

public Rectangle Bitmap.RectangleOfCell(int cell);
public static Rectangle SplashKit.BitmapRectangleOfCell(Bitmap src, int cell);

Python

def bitmap_rectangle_of_cell(src, cell):

Pascal

function BitmapRectangleOfCell(src: Bitmap; cell: Integer): Rectangle

---

Bitmap Set Cell Details

Initialise the bitmap cell details. This allows parts of the bitmap to be drawn as individual cells.

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap
width	Integer	The width of each cell
height	Integer	The height of each cell
columns	Integer	The number of cell columns within the bitmap
rows	Integer	The number of cell rows within the bitmap
count	Integer	The total number of cells, may be fewer than columns * rows

Signatures:

C++

void bitmap_set_cell_details(bitmap bmp, int width, int height, int columns, int rows, int count)

C#

public void Bitmap.SetCellDetails(int width, int height, int columns, int rows, int count);
public static void SplashKit.BitmapSetCellDetails(Bitmap bmp, int width, int height, int columns, int rows, int count);

Python

def bitmap_set_cell_details(bmp, width, height, columns, rows, count):

Pascal

procedure BitmapSetCellDetails(bmp: Bitmap; width: Integer; height: Integer; columns: Integer; rows: Integer; count: Integer)

---

Bitmap Valid

Lets you test if bitmap value is valid. This will return true when it is a valid bitmap.

Parameters:

Name	Type	Description
bmp	Bitmap	the bitmap to test

Return Type: Boolean

Signatures:

C++

bool bitmap_valid(bitmap bmp)

C#

public static bool SplashKit.BitmapValid(Bitmap bmp);

Python

def bitmap_valid(bmp):

Pascal

function BitmapValid(bmp: Bitmap): Boolean

---

Bitmap Width

Note

This function is overloaded. The following versions exist:

• Bitmap Width (bmp: bitmap)
• Bitmap Width (name: string)

Bitmap Width

Returns the width of the bitmap.

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap

Return Type: Integer

Signatures:

C++

int bitmap_width(bitmap bmp)

C#

public int Bitmap.Width { get }
public static int SplashKit.BitmapWidth(Bitmap bmp);

Python

def bitmap_width(bmp):

Pascal

function BitmapWidth(bmp: Bitmap): Integer

---

Bitmap Width

Returns the width of the bitmap.

Parameters:

Name	Type	Description
name	String	The name of the bitmap

Return Type: Integer

Signatures:

C++

int bitmap_width(string name)

C#

public static int SplashKit.BitmapWidth(string name);

Python

def bitmap_width_of_bitmap_named(name):

Pascal

function BitmapWidth(name: String): Integer

---

Clear Bitmap

Note

This function is overloaded. The following versions exist:

• Clear Bitmap (bmp: bitmap, clr: color)
• Clear Bitmap (name: string, clr: color)

Clear Bitmap

Clear the bitmap to the indicated color. This will ensure the entire surface of the bitmap is set to that color.

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap
clr	Color	The new color for the surface of the bitmap

Signatures:

C++

void clear_bitmap(bitmap bmp, color clr)

C#

public void Bitmap.Clear(Color clr);
public static void SplashKit.ClearBitmap(Bitmap bmp, Color clr);

Python

def clear_bitmap(bmp, clr):

Pascal

procedure ClearBitmap(bmp: Bitmap; clr: Color)

---

Clear Bitmap

Clear the bitmap to the indicated color. This will ensure the entire surface of the bitmap is set to that color.

Parameters:

Name	Type	Description
name	String	The name of the bitmap
clr	Color	The new color for the surface of the bitmap

Signatures:

C++

void clear_bitmap(string name, color clr)

C#

public static void SplashKit.ClearBitmap(string name, Color clr);

Python

def clear_bitmap_named(name, clr):

Pascal

procedure ClearBitmap(name: String; clr: Color)

---

Create Bitmap

Creates a new bitmap that you can draw to. Initially the bitmap will be transparent.

Parameters:

Name	Type	Description
name	String	The name of the bitmap resource to be created. If this already exists SplashKit will alter the name to make it unique.
width	Integer	The width of the created bitmap
height	Integer	The height of the created bitmap

Return Type: Bitmap

Signatures:

C++

bitmap create_bitmap(string name, int width, int height)

C#

public static Bitmap SplashKit.CreateBitmap(string name, int width, int height);
public Bitmap(string name, int width, int height);

Python

def create_bitmap(name, width, height):

Pascal

function CreateBitmap(name: String; width: Integer; height: Integer): Bitmap

---

Draw Bitmap

Note

This function is overloaded. The following versions exist:

• Draw Bitmap (bmp: bitmap, x: double, y: double)
• Draw Bitmap (bmp: bitmap, x: double, y: double, opts: drawing_options)
• Draw Bitmap (name: string, x: double, y: double)
• Draw Bitmap (name: string, x: double, y: double, opts: drawing_options)

Draw Bitmap

Draws the bitmap supplied into bmp to the current window. at x and y.

Parameters:

Name	Type	Description
bmp	Bitmap	the bitmap which will be drawn to the screen
x	Double	the x location which represents where the bitmap will be drawn
y	Double	the y location which represents where the bitmap will be drawn

Signatures:

C++

void draw_bitmap(bitmap bmp, double x, double y)

C#

public void Bitmap.Draw(double x, double y);
public static void SplashKit.DrawBitmap(Bitmap bmp, double x, double y);

Python

def draw_bitmap(bmp, x, y):

Pascal

procedure DrawBitmap(bmp: Bitmap; x: Double; y: Double)

---

Draw Bitmap

Draws the bitmap supplied into bmp to the current window. with extra drawing options supplied in opts at x and y.

Parameters:

Name	Type	Description
bmp	Bitmap	the bitmap which will be drawn to the screen
x	Double	the x location which represents where the bitmap will be drawn
y	Double	the y location which represents where the bitmap will be drawn
opts	Drawing Options	the Drawing Options which provide extra information for how to draw the Bitmap

Signatures:

C++

void draw_bitmap(bitmap bmp, double x, double y, drawing_options opts)

C#

public void Bitmap.Draw(double x, double y, DrawingOptions opts);
public static void SplashKit.DrawBitmap(Bitmap bmp, double x, double y, DrawingOptions opts);

Python

def draw_bitmap_with_options(bmp, x, y, opts):

Pascal

procedure DrawBitmap(bmp: Bitmap; x: Double; y: Double; opts: DrawingOptions)

Usage:

See Implementations in Guides

• Using Animations in SplashKit

---

Draw Bitmap

Searches and draws a bitmap with name name to the current window. with extra drawing options supplied in opts at x and y.

Parameters:

Name	Type	Description
name	String	the name of the bitmap which will be drawn to the screen
x	Double	the x location which represents where the bitmap will be drawn
y	Double	the y location which represents where the bitmap will be drawn

Signatures:

C++

void draw_bitmap(string name, double x, double y)

C#

public static void SplashKit.DrawBitmap(string name, double x, double y);

Python

def draw_bitmap_named(name, x, y):

Pascal

procedure DrawBitmap(name: String; x: Double; y: Double)

Usage:

See Code Examples

Example 1: SplashKit Logo

Note

To test this example code you can download these Resources.

C++

SplashKit

#include "splashkit.h"

int main()
{
    // Open Window
    open_window("Basic Bitmap Drawing", 315, 330);

    // Load bitmap image
    load_bitmap("skbox", "skbox.png");

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

        clear_screen(rgb_color(67, 80, 175));
        draw_bitmap("skbox", 50, 50); // draw bitmap image
        refresh_screen();
    }
    close_all_windows();
    free_all_bitmaps();

    return 0;
}

Beyond SplashKit

See the Graphics or Audio Beyond SplashKit guides for help compiling without SplashKit.

#include <iostream>
#ifdef __APPLE__
#include <SDL.h>
#include <SDL_image.h>
#else
#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
#endif

SDL_Window *sdl_open_window(const char *window_title, const int width, const int height)
{
    // Declare Variables
    SDL_Window *window = nullptr;

    // Check for successful initialisation
    if (SDL_Init(SDL_INIT_VIDEO) < 0)
    {
        std::cout << "SDL could not be initialized: " << SDL_GetError();
        exit(1);
    }

    // Create Window
    window = SDL_CreateWindow(
        window_title,
        SDL_WINDOWPOS_CENTERED,
        SDL_WINDOWPOS_CENTERED,
        width,
        height,
        SDL_WINDOW_OPENGL);

    // Error handling for window
    if (window == NULL)
    {
        SDL_LogError(SDL_LOG_CATEGORY_ERROR, "Could not create window: %s\n", SDL_GetError());
        exit(1);
    }

    return window;
}

SDL_Renderer *sdl_create_renderer(SDL_Window *window)
{
    SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    if (renderer == NULL)
    {
        SDL_LogError(SDL_LOG_CATEGORY_ERROR, "Could not create rederer: %s\n", SDL_GetError());
        exit(1);
    }
    return renderer;
}

int main(int argv, char **args)
{
    // Open Window
    SDL_Window *window = sdl_open_window("Basic Bitmap Drawing", 315, 330);
    SDL_Renderer *renderer = sdl_create_renderer(window);

    // Load bitmap image
    // Create a surface for imported image
    SDL_Surface *image = IMG_Load("Resources/images/skbox.png");
    if (image == NULL)
    {
        std::cout << "Failed to load skbox.png" << SDL_GetError();
        exit(1);
    }

    // Convert surface to texture
    SDL_Texture *image_texture = SDL_CreateTextureFromSurface(renderer, image);
    if (image_texture == NULL)
    {
        std::cout << "Failed to create texture" << SDL_GetError();
        exit(1);
    }

    // Free memory
    SDL_FreeSurface(image);

    // Get image size to avoid stretching
    int background_width = 0, background_height = 0;
    SDL_QueryTexture(image_texture, NULL, NULL, &background_width, &background_height);

    // Hang window until quit
    SDL_Event event;
    while (event.type != SDL_QUIT)
    {
        SDL_PollEvent(&event);

        // Clear screen with blue
        SDL_SetRenderDrawColor(renderer, 67, 80, 175, 255);
        SDL_RenderClear(renderer);

        // Draw image to screen
        SDL_Rect image_rect = { 50, 50, background_width, background_height };
        SDL_RenderCopy(renderer, image_texture, NULL, &image_rect);

        // Display drawing
        SDL_RenderPresent(renderer);
    }

    // Cleanup and free memory
    SDL_DestroyWindow(window);
    SDL_DestroyRenderer(renderer);

    return 0;
}

C#

Top-level Statements

using static SplashKitSDK.SplashKit;

// Open Window
OpenWindow("Basic Bitmap Drawing", 315, 330);

// Load bitmap image
LoadBitmap("skbox", "skbox.png");

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

    ClearScreen(RGBColor(67, 80, 175));
    DrawBitmap("skbox", 50, 50); // draw bitmap image
    RefreshScreen();
}
CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace DrawBitmapNamed
{
    public class Program
    {
        public static void Main()
        {
            // Open Window
            Window window = new Window("Basic Bitmap Drawing", 315, 330);

            // Load bitmap image
            SplashKit.LoadBitmap("skbox", "skbox.png");

            while (!window.CloseRequested)
            {
                SplashKit.ProcessEvents();

                SplashKit.ClearScreen(Color.RGBColor(67, 80, 175));
                SplashKit.DrawBitmap("skbox", 50, 50); // draw bitmap image
                SplashKit.RefreshScreen();
            }
            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

# Open Window
open_window("Basic Bitmap Drawing", 315, 330)

# Load bitmap image
load_bitmap("skbox", "skbox.png")

while (not quit_requested()):
    process_events()

    clear_screen(rgb_color(67, 80, 175))
    draw_bitmap_named("skbox", 50, 50); # draw bitmap image
    refresh_screen()
close_all_windows()

Output:

Example 2: Hello World! This is SplashKit!

Originally created for the programmers.guide website.

C++

#include "splashkit.h"

int main()
{
    // Download resources
    download_sound_effect("Hello World", "https://programmers.guide/resources/code-examples/part-0/hello-world-snippet-saddle-club.ogg", 443);
    download_font("main", "https://programmers.guide/resources/code-examples/part-0/Roboto-Italic.ttf", 443);
    download_bitmap("Earth", "https://programmers.guide/resources/code-examples/part-0/earth.png", 443);
    download_bitmap("SmallEarth", "https://programmers.guide/resources/code-examples/part-0/earth-small.png", 443);
    download_bitmap("SplashKitBox", "https://programmers.guide/resources/code-examples/part-0/skbox.png", 443);

    open_window("Hello World: Using Resources with SplashKit", 800, 600);
    play_sound_effect("Hello World");

    clear_screen(COLOR_WHITE);
    draw_text("Anyone remember the \"Hello World\" Saddle Club song?", COLOR_BLACK, "main", 30, 40, 200);
    refresh_screen();
    delay(2500);

    clear_screen(COLOR_WHITE);

    // H
    draw_bitmap("SmallEarth", 20, 100);
    draw_bitmap("SmallEarth", 20, 130);
    draw_bitmap("SmallEarth", 20, 160);
    draw_bitmap("SmallEarth", 20, 190);
    draw_bitmap("SmallEarth", 20, 220);
    draw_bitmap("SmallEarth", 52, 160);
    draw_bitmap("SmallEarth", 84, 100);
    draw_bitmap("SmallEarth", 84, 130);
    draw_bitmap("SmallEarth", 84, 160);
    draw_bitmap("SmallEarth", 84, 190);
    draw_bitmap("SmallEarth", 84, 220);
    refresh_screen();
    delay(200);

    // E
    draw_bitmap("SmallEarth", 148, 100);
    draw_bitmap("SmallEarth", 148, 130);
    draw_bitmap("SmallEarth", 148, 160);
    draw_bitmap("SmallEarth", 148, 190);
    draw_bitmap("SmallEarth", 148, 220);
    draw_bitmap("SmallEarth", 180, 100);
    draw_bitmap("SmallEarth", 212, 100);
    draw_bitmap("SmallEarth", 180, 160);
    draw_bitmap("SmallEarth", 180, 220);
    draw_bitmap("SmallEarth", 212, 220);
    refresh_screen();
    delay(200);

    // L
    draw_bitmap("SmallEarth", 276, 100);
    draw_bitmap("SmallEarth", 276, 130);
    draw_bitmap("SmallEarth", 276, 160);
    draw_bitmap("SmallEarth", 276, 190);
    draw_bitmap("SmallEarth", 276, 220);
    draw_bitmap("SmallEarth", 308, 220);
    draw_bitmap("SmallEarth", 340, 220);
    refresh_screen();
    delay(200);

    // L
    draw_bitmap("SmallEarth", 404, 100);
    draw_bitmap("SmallEarth", 404, 130);
    draw_bitmap("SmallEarth", 404, 160);
    draw_bitmap("SmallEarth", 404, 190);
    draw_bitmap("SmallEarth", 404, 220);
    draw_bitmap("SmallEarth", 436, 220);
    draw_bitmap("SmallEarth", 468, 220);
    refresh_screen();
    delay(200);

    // O
    draw_bitmap("SmallEarth", 530, 160);
    draw_bitmap("SmallEarth", 622, 160);
    draw_bitmap("SmallEarth", 540, 128);
    draw_bitmap("SmallEarth", 560, 100);
    draw_bitmap("SmallEarth", 592, 100);
    draw_bitmap("SmallEarth", 612, 128);
    draw_bitmap("SmallEarth", 540, 192);
    draw_bitmap("SmallEarth", 560, 220);
    draw_bitmap("SmallEarth", 592, 220);
    draw_bitmap("SmallEarth", 612, 192);
    refresh_screen();
    delay(500);

    // World
    draw_bitmap("Earth", 100, 350);
    refresh_screen();
    delay(2000);

    // SplashKit ("Me")
    draw_bitmap("SplashKitBox", 450, 300);
    draw_text("SplashKit!", COLOR_BLACK, "main", 50, 450, 530);
    refresh_screen();
    delay(2000);

    close_all_windows();

    return 0;
}

C#

Top-level Statements

using static SplashKitSDK.SplashKit;

// Download resources
DownloadSoundEffect("Hello World", "https://programmers.guide/resources/code-examples/part-0/hello-world-snippet-saddle-club.ogg", 443);
DownloadFont("main", "https://programmers.guide/resources/code-examples/part-0/Roboto-Italic.ttf", 443);
DownloadBitmap("Earth", "https://programmers.guide/resources/code-examples/part-0/earth.png", 443);
DownloadBitmap("SmallEarth", "https://programmers.guide/resources/code-examples/part-0/earth-small.png", 443);
DownloadBitmap("SplashKitBox", "https://programmers.guide/resources/code-examples/part-0/skbox.png", 443);

OpenWindow("Hello World: Using Resources with SplashKit", 800, 600);
PlaySoundEffect("Hello World");

ClearScreen(ColorWhite());
DrawText("Anyone remember the \"Hello World\" Saddle Club song?", ColorBlack(), "main", 30, 40, 200);
RefreshScreen();
Delay(2500);

ClearScreen(ColorWhite());

// H
DrawBitmap("SmallEarth", 20, 100);
DrawBitmap("SmallEarth", 20, 130);
DrawBitmap("SmallEarth", 20, 160);
DrawBitmap("SmallEarth", 20, 190);
DrawBitmap("SmallEarth", 20, 220);
DrawBitmap("SmallEarth", 52, 160);
DrawBitmap("SmallEarth", 84, 100);
DrawBitmap("SmallEarth", 84, 130);
DrawBitmap("SmallEarth", 84, 160);
DrawBitmap("SmallEarth", 84, 190);
DrawBitmap("SmallEarth", 84, 220);
RefreshScreen();
Delay(200);

// E
DrawBitmap("SmallEarth", 148, 100);
DrawBitmap("SmallEarth", 148, 130);
DrawBitmap("SmallEarth", 148, 160);
DrawBitmap("SmallEarth", 148, 190);
DrawBitmap("SmallEarth", 148, 220);
DrawBitmap("SmallEarth", 180, 100);
DrawBitmap("SmallEarth", 212, 100);
DrawBitmap("SmallEarth", 180, 160);
DrawBitmap("SmallEarth", 180, 220);
DrawBitmap("SmallEarth", 212, 220);
RefreshScreen();
Delay(200);

// L
DrawBitmap("SmallEarth", 276, 100);
DrawBitmap("SmallEarth", 276, 130);
DrawBitmap("SmallEarth", 276, 160);
DrawBitmap("SmallEarth", 276, 190);
DrawBitmap("SmallEarth", 276, 220);
DrawBitmap("SmallEarth", 308, 220);
DrawBitmap("SmallEarth", 340, 220);
RefreshScreen();
Delay(200);

// L
DrawBitmap("SmallEarth", 404, 100);
DrawBitmap("SmallEarth", 404, 130);
DrawBitmap("SmallEarth", 404, 160);
DrawBitmap("SmallEarth", 404, 190);
DrawBitmap("SmallEarth", 404, 220);
DrawBitmap("SmallEarth", 436, 220);
DrawBitmap("SmallEarth", 468, 220);
RefreshScreen();
Delay(200);

// O
DrawBitmap("SmallEarth", 530, 160);
DrawBitmap("SmallEarth", 622, 160);
DrawBitmap("SmallEarth", 540, 128);
DrawBitmap("SmallEarth", 560, 100);
DrawBitmap("SmallEarth", 592, 100);
DrawBitmap("SmallEarth", 612, 128);
DrawBitmap("SmallEarth", 540, 192);
DrawBitmap("SmallEarth", 560, 220);
DrawBitmap("SmallEarth", 592, 220);
DrawBitmap("SmallEarth", 612, 192);
RefreshScreen();
Delay(500);

// World
DrawBitmap("Earth", 100, 350);
RefreshScreen();
Delay(2000);

// SplashKit ("Me")
DrawBitmap("SplashKitBox", 450, 300);
DrawText("SplashKit!", ColorBlack(), "main", 50, 450, 530);
RefreshScreen();
Delay(2000);

Object-Oriented

using SplashKitSDK;

namespace GUIHelloWorld
{
    public class Program
    {
        public static void Main()
        {
            // Download resources
            SplashKit.DownloadSoundEffect("Hello World", "https://programmers.guide/resources/code-examples/part-0/hello-world-snippet-saddle-club.ogg", 443);
            SplashKit.DownloadFont("main", "https://programmers.guide/resources/code-examples/part-0/Roboto-Italic.ttf", 443);
            SplashKit.DownloadBitmap("Earth", "https://programmers.guide/resources/code-examples/part-0/earth.png", 443);
            SplashKit.DownloadBitmap("SmallEarth", "https://programmers.guide/resources/code-examples/part-0/earth-small.png", 443);
            SplashKit.DownloadBitmap("SplashKitBox", "https://programmers.guide/resources/code-examples/part-0/skbox.png", 443);

            SplashKit.OpenWindow("Hello World: Using Resources with SplashKit", 800, 600);
            SplashKit.PlaySoundEffect("Hello World");

            SplashKit.ClearScreen(Color.White);
            SplashKit.DrawText("Anyone remember the \"Hello World\" Saddle Club song?", Color.Black, "main", 30, 40, 200);
            SplashKit.RefreshScreen();
            SplashKit.Delay(2500);

            SplashKit.ClearScreen(Color.White);

            // H
            SplashKit.DrawBitmap("SmallEarth", 20, 100);
            SplashKit.DrawBitmap("SmallEarth", 20, 130);
            SplashKit.DrawBitmap("SmallEarth", 20, 160);
            SplashKit.DrawBitmap("SmallEarth", 20, 190);
            SplashKit.DrawBitmap("SmallEarth", 20, 220);
            SplashKit.DrawBitmap("SmallEarth", 52, 160);
            SplashKit.DrawBitmap("SmallEarth", 84, 100);
            SplashKit.DrawBitmap("SmallEarth", 84, 130);
            SplashKit.DrawBitmap("SmallEarth", 84, 160);
            SplashKit.DrawBitmap("SmallEarth", 84, 190);
            SplashKit.DrawBitmap("SmallEarth", 84, 220);
            SplashKit.RefreshScreen();
            SplashKit.Delay(200);

            // E
            SplashKit.DrawBitmap("SmallEarth", 148, 100);
            SplashKit.DrawBitmap("SmallEarth", 148, 130);
            SplashKit.DrawBitmap("SmallEarth", 148, 160);
            SplashKit.DrawBitmap("SmallEarth", 148, 190);
            SplashKit.DrawBitmap("SmallEarth", 148, 220);
            SplashKit.DrawBitmap("SmallEarth", 180, 100);
            SplashKit.DrawBitmap("SmallEarth", 212, 100);
            SplashKit.DrawBitmap("SmallEarth", 180, 160);
            SplashKit.DrawBitmap("SmallEarth", 180, 220);
            SplashKit.DrawBitmap("SmallEarth", 212, 220);
            SplashKit.RefreshScreen();
            SplashKit.Delay(200);

            // L
            SplashKit.DrawBitmap("SmallEarth", 276, 100);
            SplashKit.DrawBitmap("SmallEarth", 276, 130);
            SplashKit.DrawBitmap("SmallEarth", 276, 160);
            SplashKit.DrawBitmap("SmallEarth", 276, 190);
            SplashKit.DrawBitmap("SmallEarth", 276, 220);
            SplashKit.DrawBitmap("SmallEarth", 308, 220);
            SplashKit.DrawBitmap("SmallEarth", 340, 220);
            SplashKit.RefreshScreen();
            SplashKit.Delay(200);

            // L
            SplashKit.DrawBitmap("SmallEarth", 404, 100);
            SplashKit.DrawBitmap("SmallEarth", 404, 130);
            SplashKit.DrawBitmap("SmallEarth", 404, 160);
            SplashKit.DrawBitmap("SmallEarth", 404, 190);
            SplashKit.DrawBitmap("SmallEarth", 404, 220);
            SplashKit.DrawBitmap("SmallEarth", 436, 220);
            SplashKit.DrawBitmap("SmallEarth", 468, 220);
            SplashKit.RefreshScreen();
            SplashKit.Delay(200);

            // O
            SplashKit.DrawBitmap("SmallEarth", 530, 160);
            SplashKit.DrawBitmap("SmallEarth", 622, 160);
            SplashKit.DrawBitmap("SmallEarth", 540, 128);
            SplashKit.DrawBitmap("SmallEarth", 560, 100);
            SplashKit.DrawBitmap("SmallEarth", 592, 100);
            SplashKit.DrawBitmap("SmallEarth", 612, 128);
            SplashKit.DrawBitmap("SmallEarth", 540, 192);
            SplashKit.DrawBitmap("SmallEarth", 560, 220);
            SplashKit.DrawBitmap("SmallEarth", 592, 220);
            SplashKit.DrawBitmap("SmallEarth", 612, 192);
            SplashKit.RefreshScreen();
            SplashKit.Delay(500);

            // World
            SplashKit.DrawBitmap("Earth", 100, 350);
            SplashKit.RefreshScreen();
            SplashKit.Delay(2000);

            // SplashKit ("Me")
            SplashKit.DrawBitmap("SplashKitBox", 450, 300);
            SplashKit.DrawText("SplashKit!", Color.Black, "main", 50, 450, 530);
            SplashKit.RefreshScreen();
            SplashKit.Delay(2000);

            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

# Download resources
download_sound_effect("Hello World", "https://programmers.guide/resources/code-examples/part-0/hello-world-snippet-saddle-club.ogg", 443)
download_font("main", "https://programmers.guide/resources/code-examples/part-0/Roboto-Italic.ttf", 443)
download_bitmap("Earth", "https://programmers.guide/resources/code-examples/part-0/earth.png", 443)
download_bitmap("SmallEarth", "https://programmers.guide/resources/code-examples/part-0/earth-small.png", 443)
download_bitmap("SplashKitBox", "https://programmers.guide/resources/code-examples/part-0/skbox.png", 443)

open_window("Hello World: Using Resources with SplashKit", 800, 600)
play_sound_effect_named("Hello World")

clear_screen(color_white())
draw_text_font_as_string("Anyone remember the \"Hello World\" Saddle Club song?", color_black(), "main", 30, 40, 200)
refresh_screen()
delay(2500)

clear_screen(color_white())

# H
draw_bitmap_named("SmallEarth", 20, 100)
draw_bitmap_named("SmallEarth", 20, 130)
draw_bitmap_named("SmallEarth", 20, 160)
draw_bitmap_named("SmallEarth", 20, 190)
draw_bitmap_named("SmallEarth", 20, 220)
draw_bitmap_named("SmallEarth", 52, 160)
draw_bitmap_named("SmallEarth", 84, 100)
draw_bitmap_named("SmallEarth", 84, 130)
draw_bitmap_named("SmallEarth", 84, 160)
draw_bitmap_named("SmallEarth", 84, 190)
draw_bitmap_named("SmallEarth", 84, 220)
refresh_screen()
delay(200)

# E
draw_bitmap_named("SmallEarth", 148, 100)
draw_bitmap_named("SmallEarth", 148, 130)
draw_bitmap_named("SmallEarth", 148, 160)
draw_bitmap_named("SmallEarth", 148, 190)
draw_bitmap_named("SmallEarth", 148, 220)
draw_bitmap_named("SmallEarth", 180, 100)
draw_bitmap_named("SmallEarth", 212, 100)
draw_bitmap_named("SmallEarth", 180, 160)
draw_bitmap_named("SmallEarth", 180, 220)
draw_bitmap_named("SmallEarth", 212, 220)
refresh_screen()
delay(200)

# L
draw_bitmap_named("SmallEarth", 276, 100)
draw_bitmap_named("SmallEarth", 276, 130)
draw_bitmap_named("SmallEarth", 276, 160)
draw_bitmap_named("SmallEarth", 276, 190)
draw_bitmap_named("SmallEarth", 276, 220)
draw_bitmap_named("SmallEarth", 308, 220)
draw_bitmap_named("SmallEarth", 340, 220)
refresh_screen()
delay(200)

# L
draw_bitmap_named("SmallEarth", 404, 100)
draw_bitmap_named("SmallEarth", 404, 130)
draw_bitmap_named("SmallEarth", 404, 160)
draw_bitmap_named("SmallEarth", 404, 190)
draw_bitmap_named("SmallEarth", 404, 220)
draw_bitmap_named("SmallEarth", 436, 220)
draw_bitmap_named("SmallEarth", 468, 220)
refresh_screen()
delay(200)

# O
draw_bitmap_named("SmallEarth", 530, 160)
draw_bitmap_named("SmallEarth", 622, 160)
draw_bitmap_named("SmallEarth", 540, 128)
draw_bitmap_named("SmallEarth", 560, 100)
draw_bitmap_named("SmallEarth", 592, 100)
draw_bitmap_named("SmallEarth", 612, 128)
draw_bitmap_named("SmallEarth", 540, 192)
draw_bitmap_named("SmallEarth", 560, 220)
draw_bitmap_named("SmallEarth", 592, 220)
draw_bitmap_named("SmallEarth", 612, 192)
refresh_screen()
delay(500)

# World
draw_bitmap_named("Earth", 100, 350)
refresh_screen()
delay(2000)

# SplashKit ("Me")
draw_bitmap_named("SplashKitBox", 450, 300)
draw_text_font_as_string("SplashKit!", color_black(), "main", 50, 450, 530)
refresh_screen()
delay(2000)

close_all_windows()

Output:

---

Draw Bitmap

Searches and draws a bitmap with name name to the current window. with extra drawing options supplied in opts at x and y.

Parameters:

Name	Type	Description
name	String	the name of the bitmap which will be drawn to the screen
x	Double	the x location which represents where the bitmap will be drawn
y	Double	the y location which represents where the bitmap will be drawn
opts	Drawing Options	the Drawing Options which provide extra information for how to draw the Bitmap

Signatures:

C++

void draw_bitmap(string name, double x, double y, drawing_options opts)

C#

public static void SplashKit.DrawBitmap(string name, double x, double y, DrawingOptions opts);

Python

def draw_bitmap_named_with_options(name, x, y, opts):

Pascal

procedure DrawBitmap(name: String; x: Double; y: Double; opts: DrawingOptions)

---

Draw Bitmap On Bitmap

Note

This function is overloaded. The following versions exist:

• Draw Bitmap On Bitmap (destination: bitmap, bmp: bitmap, x: double, y: double)
• Draw Bitmap On Bitmap (destination: bitmap, bmp: bitmap, x: double, y: double, opts: drawing_options)

Draw Bitmap On Bitmap

Draws the bitmap supplied into bmp to the given bitmap. at x and y.

Parameters:

Name	Type	Description
destination	Bitmap	the bitmap to draw the bitmap to
bmp	Bitmap	the bitmap which will be drawn to the screen
x	Double	the x location which represents where the bitmap will be drawn
y	Double	the y location which represents where the bitmap will be drawn

Signatures:

C++

void draw_bitmap_on_bitmap(bitmap destination, bitmap bmp, double x, double y)

C#

public void Bitmap.DrawBitmap(Bitmap destination, double x, double y);
public static void SplashKit.DrawBitmapOnBitmap(Bitmap destination, Bitmap bmp, double x, double y);

Python

def draw_bitmap_on_bitmap_on_bitmap(destination, bmp, x, y):

Pascal

procedure DrawBitmapOnBitmap(destination: Bitmap; bmp: Bitmap; x: Double; y: Double)

---

Draw Bitmap On Bitmap

Draws the bitmap supplied into bmp to the given bitmap. with extra drawing options supplied in opts at x and y.

Parameters:

Name	Type	Description
destination	Bitmap	the bitmap to draw the bitmap to
bmp	Bitmap	the bitmap which will be drawn to the screen
x	Double	the x location which represents where the bitmap will be drawn
y	Double	the y location which represents where the bitmap will be drawn
opts	Drawing Options	the Drawing Options which provide extra information for how to draw the Bitmap

Signatures:

C++

void draw_bitmap_on_bitmap(bitmap destination, bitmap bmp, double x, double y, drawing_options opts)

C#

public void Bitmap.DrawBitmap(Bitmap destination, double x, double y, DrawingOptions opts);
public static void SplashKit.DrawBitmapOnBitmap(Bitmap destination, Bitmap bmp, double x, double y, DrawingOptions opts);

Python

def draw_bitmap_on_bitmap_on_bitmap_with_options(destination, bmp, x, y, opts):

Pascal

procedure DrawBitmapOnBitmap(destination: Bitmap; bmp: Bitmap; x: Double; y: Double; opts: DrawingOptions)

---

Draw Bitmap On Window

Note

This function is overloaded. The following versions exist:

• Draw Bitmap On Window (destination: window, bmp: bitmap, x: double, y: double)
• Draw Bitmap On Window (destination: window, bmp: bitmap, x: double, y: double, opts: drawing_options)

Draw Bitmap On Window

Draws the bitmap supplied into bmp to the given window. at x and y.

Parameters:

Name	Type	Description
destination	Window	the window to draw the bitmap to
bmp	Bitmap	the bitmap which will be drawn to the screen
x	Double	the x location which represents where the bitmap will be drawn
y	Double	the y location which represents where the bitmap will be drawn

Signatures:

C++

void draw_bitmap_on_window(window destination, bitmap bmp, double x, double y)

C#

public void Window.DrawBitmap(Bitmap bmp, double x, double y);
public static void SplashKit.DrawBitmapOnWindow(Window destination, Bitmap bmp, double x, double y);

Python

def draw_bitmap_on_window(destination, bmp, x, y):

Pascal

procedure DrawBitmapOnWindow(destination: Window; bmp: Bitmap; x: Double; y: Double)

---

Draw Bitmap On Window

Draws the bitmap supplied into bmp to the given window. with extra drawing options supplied in opts at x and y.

Parameters:

Name	Type	Description
destination	Window	the window to draw the bitmap to
bmp	Bitmap	the bitmap which will be drawn to the screen
x	Double	the x location which represents where the bitmap will be drawn
y	Double	the y location which represents where the bitmap will be drawn
opts	Drawing Options	the Drawing Options which provide extra information for how to draw the Bitmap

Signatures:

C++

void draw_bitmap_on_window(window destination, bitmap bmp, double x, double y, drawing_options opts)

C#

public void Window.DrawBitmap(Bitmap bmp, double x, double y, DrawingOptions opts);
public static void SplashKit.DrawBitmapOnWindow(Window destination, Bitmap bmp, double x, double y, DrawingOptions opts);

Python

def draw_bitmap_on_window_with_options(destination, bmp, x, y, opts):

Pascal

procedure DrawBitmapOnWindow(destination: Window; bmp: Bitmap; x: Double; y: Double; opts: DrawingOptions)

---

Free All Bitmaps

Free all of the loaded bitmap resources.

Signatures:

C++

void free_all_bitmaps()

C#

public static void SplashKit.FreeAllBitmaps();

Python

def free_all_bitmaps():

Pascal

procedure FreeAllBitmaps()

---

Free Bitmap

Frees the bitmap resource.

Parameters:

Name	Type	Description
to_delete	Bitmap	The bitmap to be freed.

Signatures:

C++

void free_bitmap(bitmap to_delete)

C#

public void Bitmap.Free();
public static void SplashKit.FreeBitmap(Bitmap toDelete);

Python

def free_bitmap(to_delete):

Pascal

procedure FreeBitmap(toDelete: Bitmap)

---

Has Bitmap

Determines if SplashKit has a bitmap loaded for the supplied name. This checks against all bitmaps loaded.

Parameters:

Name	Type	Description
name	String	The name to check

Return Type: Boolean

Signatures:

C++

bool has_bitmap(string name)

C#

public static bool SplashKit.HasBitmap(string name);

Python

def has_bitmap(name):

Pascal

function HasBitmap(name: String): Boolean

---

Load Bitmap

Loads and returns a bitmap. The supplied filename is used to locate the Bitmap to load. The supplied name indicates the name to use to refer to this Bitmap in SplashKit. The Bitmap can then be retrieved by passing this name to the Bitmap Named function.

Parameters:

Name	Type	Description
name	String	The name of the bitmap resource in SplashKit
filename	String	The filename to load

Return Type: Bitmap

Signatures:

C++

bitmap load_bitmap(string name, string filename)

C#

public static Bitmap SplashKit.LoadBitmap(string name, string filename);
public Bitmap(string name, string filename);

Python

def load_bitmap(name, filename):

Pascal

function LoadBitmap(name: String; filename: String): Bitmap

---

Pixel Drawn At Point

Note

This function is overloaded. The following versions exist:

• Pixel Drawn At Point (bmp: bitmap, pt: point_2d)
• Pixel Drawn At Point (bmp: bitmap, x: double, y: double)
• Pixel Drawn At Point (bmp: bitmap, cell: int, pt: point_2d)
• Pixel Drawn At Point (bmp: bitmap, cell: int, x: double, y: double)

Pixel Drawn At Point

Check if the bitmap has a pixel drawn at the indicated point.

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap to check.
pt	Point 2d	The point within the bitmap to check.

Return Type: Boolean

Signatures:

C++

bool pixel_drawn_at_point(bitmap bmp, const point_2d &pt)

C#

public bool Bitmap.PixelDrawnAtPoint(Point2D pt);
public static bool SplashKit.PixelDrawnAtPoint(Bitmap bmp, Point2D pt);

Python

def pixel_drawn_at_point_pt(bmp, pt):

Pascal

function PixelDrawnAtPoint(bmp: Bitmap; const pt: Point2D): Boolean

---

Pixel Drawn At Point

Check if the bitmap has a pixel drawn at the indicated point.

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap to check.
x	Double	The x coordinate within the bitmap to check
y	Double	The y coordinate within the bitmap to check

Return Type: Boolean

Signatures:

C++

bool pixel_drawn_at_point(bitmap bmp, double x, double y)

C#

public bool Bitmap.PixelDrawnAtPoint(double x, double y);
public static bool SplashKit.PixelDrawnAtPoint(Bitmap bmp, double x, double y);

Python

def pixel_drawn_at_point(bmp, x, y):

Pascal

function PixelDrawnAtPoint(bmp: Bitmap; x: Double; y: Double): Boolean

---

Pixel Drawn At Point

Check if the bitmap has a pixel drawn at the indicated point in the cell.

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap to check.
cell	Integer	The bitmap cell to check.
pt	Point 2d	The point within the bitmap to check.

Return Type: Boolean

Signatures:

C++

bool pixel_drawn_at_point(bitmap bmp, int cell, const point_2d &pt)

C#

public bool Bitmap.PixelDrawnAtPointInCell(int cell, Point2D pt);
public static bool SplashKit.PixelDrawnAtPoint(Bitmap bmp, int cell, Point2D pt);

Python

def pixel_drawn_at_point_in_cell_pt(bmp, cell, pt):

Pascal

function PixelDrawnAtPoint(bmp: Bitmap; cell: Integer; const pt: Point2D): Boolean

---

Pixel Drawn At Point

Check if the bitmap has a pixel drawn at the indicated point in the cell.

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap to check.
cell	Integer	The bitmap cell to check.
x	Double	The x coordinate within the bitmap to check
y	Double	The y coordinate within the bitmap to check

Return Type: Boolean

Signatures:

C++

bool pixel_drawn_at_point(bitmap bmp, int cell, double x, double y)

C#

public bool Bitmap.PixelDrawnAtPoint(int cell, double x, double y);
public static bool SplashKit.PixelDrawnAtPoint(Bitmap bmp, int cell, double x, double y);

Python

def pixel_drawn_at_point_in_cell(bmp, cell, x, y):

Pascal

function PixelDrawnAtPoint(bmp: Bitmap; cell: Integer; x: Double; y: Double): Boolean

---

Setup Collision Mask

Sets up the collision mask for a bitmap. This enables collision detection between this bitmap and other bitmaps or shapes. This is automatically called when a bitmap is loaded, and only needs to be called on bitmaps created using Create Bitmap, and when a bitmap is changed by drawing onto the bitmap.

Parameters:

Name	Type	Description
bmp	Bitmap	the bitmap to setup

Signatures:

C++

void setup_collision_mask(bitmap bmp)

C#

public void Bitmap.SetupCollisionMask();
public static void SplashKit.SetupCollisionMask(Bitmap bmp);

Python

def setup_collision_mask(bmp):

Pascal

procedure SetupCollisionMask(bmp: Bitmap)

---

Draw Line

Note

This function is overloaded. The following versions exist:

• Draw Line (clr: color, l: line)
• Draw Line (clr: color, l: line, opts: drawing_options)
• Draw Line (clr: color, from_pt: point_2d, to_pt: point_2d)
• Draw Line (clr: color, from_pt: point_2d, to_pt: point_2d, opts: drawing_options)
• Draw Line (clr: color, x1: double, y1: double, x2: double, y2: double)
• Draw Line (clr: color, x1: double, y1: double, x2: double, y2: double, opts: drawing_options)

Draw Line

Draws a line onto the current window.

Parameters:

Name	Type	Description
clr	Color	The color of the line
l	Line	The line’s details

Signatures:

C++

void draw_line(color clr, const line &l)

C#

public static void SplashKit.DrawLine(Color clr, Line l);

Python

def draw_line_record(clr, l):

Pascal

procedure DrawLine(clr: Color; const l: Line)

---

Draw Line

Draws a line.

Parameters:

Name	Type	Description
clr	Color	The color of the line
l	Line	The line’s details
opts	Drawing Options	The drawing options

Signatures:

C++

void draw_line(color clr, const line &l, drawing_options opts)

C#

public static void SplashKit.DrawLine(Color clr, Line l, DrawingOptions opts);

Python

def draw_line_record_with_options(clr, l, opts):

Pascal

procedure DrawLine(clr: Color; const l: Line; opts: DrawingOptions)

---

Draw Line

Draw a line from one point to another on the current window.

Parameters:

Name	Type	Description
clr	Color	The color of the line
from_pt	Point 2d	The start of the line
to_pt	Point 2d	The end of the line

Signatures:

C++

void draw_line(color clr, const point_2d &from_pt, const point_2d &to_pt)

C#

public static void SplashKit.DrawLine(Color clr, Point2D fromPt, Point2D toPt);

Python

def draw_line_point_to_point(clr, from_pt, to_pt):

Pascal

procedure DrawLine(clr: Color; const fromPt: Point2D; const toPt: Point2D)

---

Draw Line

Draw a line from one point to another on the current window.

Parameters:

Name	Type	Description
clr	Color	The color of the line
from_pt	Point 2d	The start of the line
to_pt	Point 2d	The end of the line
opts	Drawing Options	The drawing options

Signatures:

C++

void draw_line(color clr, const point_2d &from_pt, const point_2d &to_pt, const drawing_options &opts)

C#

public static void SplashKit.DrawLine(Color clr, Point2D fromPt, Point2D toPt, DrawingOptions opts);

Python

def draw_line_point_to_point_with_options(clr, from_pt, to_pt, opts):

Pascal

procedure DrawLine(clr: Color; const fromPt: Point2D; const toPt: Point2D; const opts: DrawingOptions)

---

Draw Line

Draw a line from one point to another on the current window.

Parameters:

Name	Type	Description
clr	Color	The color of the line
x1	Double	The distance from the left of the window/bitmap to the first point
y1	Double	The distance from the top of the window/bitmap to the first point
x2	Double	The distance from the left of the window/bitmap to the second point
y2	Double	The distance from the top of the window/bitmap to the second point

Signatures:

C++

void draw_line(color clr, double x1, double y1, double x2, double y2)

C#

public static void SplashKit.DrawLine(Color clr, double x1, double y1, double x2, double y2);

Python

def draw_line(clr, x1, y1, x2, y2):

Pascal

procedure DrawLine(clr: Color; x1: Double; y1: Double; x2: Double; y2: Double)

Usage:

See Implementations in Guides

• Get Started with SplashKit Audio

See Code Examples

Example 1: Colourful Starburst

C++

#include "splashkit.h"

int main()
{
    open_window("Colourful Starburst", 600, 600);
    clear_screen(COLOR_BLACK);

    // Draws starburst pattern with changing colours to window
    draw_line(COLOR_YELLOW, 0, 0, 600, 600);
    draw_line(COLOR_GREEN, 0, 150, 600, 450);
    draw_line(COLOR_TEAL, 0, 300, 600, 300);
    draw_line(COLOR_BLUE, 0, 450, 600, 150);
    draw_line(COLOR_VIOLET, 0, 600, 600, 0);
    draw_line(COLOR_PURPLE, 150, 0, 450, 600);
    draw_line(COLOR_PINK, 300, 0, 300, 600);
    draw_line(COLOR_RED, 450, 0, 150, 600);
    draw_line(COLOR_ORANGE, 600, 0, 0, 600);

    refresh_screen();
    delay(5000);
    close_all_windows();
    return 0;
}

C#

Top-level Statements

using static SplashKitSDK.SplashKit;

OpenWindow("Colourful Starburst", 600, 600);
ClearScreen(ColorBlack());

// Draws starburst pattern with changing colours
DrawLine(ColorYellow(), 0, 0, 600, 600);
DrawLine(ColorGreen(), 0, 150, 600, 450);
DrawLine(ColorTeal(), 0, 300, 600, 300);
DrawLine(ColorBlue(), 0, 450, 600, 150);
DrawLine(ColorViolet(), 0, 600, 600, 0);
DrawLine(ColorPurple(), 150, 0, 450, 600);
DrawLine(ColorPink(), 300, 0, 300, 600);
DrawLine(ColorRed(), 450, 0, 150, 600);
DrawLine(ColorOrange(), 600, 0, 0, 600);

RefreshScreen();
Delay(5000);
CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace DrawLineExample
{
    public class Program
    {
        public static void Main()
        {
            Window window = new Window("Colourful Starburst", 600, 600);
            window.Clear(Color.Black);

            // Draws starburst pattern with changing colours to window
            window.DrawLine(Color.Yellow, 0, 0, 600, 600);
            window.DrawLine(Color.Green, 0, 150, 600, 450);
            window.DrawLine(Color.Teal, 0, 300, 600, 300);
            window.DrawLine(Color.Blue, 0, 450, 600, 150);
            window.DrawLine(Color.Violet, 0, 600, 600, 0);
            window.DrawLine(Color.Purple, 150, 0, 450, 600);
            window.DrawLine(Color.Pink, 300, 0, 300, 600);
            window.DrawLine(Color.Red, 450, 0, 150, 600);
            window.DrawLine(Color.Orange, 600, 0, 0, 600);

            window.Refresh();
            SplashKit.Delay(5000);
            window.Close();
        }
    }
}

Python

from splashkit import *

open_window("Colourful Starburst", 600, 600)
clear_screen(color_black())

# Draws starburst pattern with changing colours to window
draw_line(color_yellow(), 0, 0, 600, 600)
draw_line(color_green(), 0, 150, 600, 450)
draw_line(color_teal(), 0, 300, 600, 300)
draw_line(color_blue(), 0, 450, 600, 150)
draw_line(color_violet(), 0, 600, 600, 0)
draw_line(color_purple(), 150, 0, 450, 600)
draw_line(color_pink(), 300, 0, 300, 600)
draw_line(color_red(), 450, 0, 150, 600)
draw_line(color_orange(), 600, 0, 0, 600)

refresh_screen()
delay(5000)
close_all_windows()

Output:

---

Draw Line

Draw a line from one point to another

Parameters:

Name	Type	Description
clr	Color	The color of the line
x1	Double	The distance from the left of the window/bitmap to the first point
y1	Double	The distance from the top of the window/bitmap to the first point
x2	Double	The distance from the left of the window/bitmap to the second point
y2	Double	The distance from the top of the window/bitmap to the second point
opts	Drawing Options	The drawing options

Signatures:

C++

void draw_line(color clr, double x1, double y1, double x2, double y2, const drawing_options &opts)

C#

public static void SplashKit.DrawLine(Color clr, double x1, double y1, double x2, double y2, DrawingOptions opts);

Python

def draw_line_with_options(clr, x1, y1, x2, y2, opts):

Pascal

procedure DrawLine(clr: Color; x1: Double; y1: Double; x2: Double; y2: Double; const opts: DrawingOptions)

---

Draw Line On Bitmap

Note

This function is overloaded. The following versions exist:

• Draw Line On Bitmap (destination: bitmap, clr: color, l: line)
• Draw Line On Bitmap (destination: bitmap, clr: color, l: line, opts: drawing_options)
• Draw Line On Bitmap (destination: bitmap, clr: color, from_pt: point_2d, to_pt: point_2d)
• Draw Line On Bitmap (destination: bitmap, clr: color, from_pt: point_2d, to_pt: point_2d, opts: drawing_options)
• Draw Line On Bitmap (destination: bitmap, clr: color, x1: double, y1: double, x2: double, y2: double)
• Draw Line On Bitmap (destination: bitmap, clr: color, x1: double, y1: double, x2: double, y2: double, opts: drawing_options)

Draw Line On Bitmap

Draws a line onto the given bitmap.

Parameters:

Name	Type	Description
destination	Bitmap	The destination bitmap
clr	Color	The color of the line
l	Line	The line’s details

Signatures:

C++

void draw_line_on_bitmap(bitmap destination, color clr, const line &l)

C#

public void Bitmap.DrawLine(Color clr, Line l);
public static void SplashKit.DrawLineOnBitmap(Bitmap destination, Color clr, Line l);

Python

def draw_line_on_bitmap_record(destination, clr, l):

Pascal

procedure DrawLineOnBitmap(destination: Bitmap; clr: Color; const l: Line)

---

Draw Line On Bitmap

Draws a line on the given bitmap.

Parameters:

Name	Type	Description
destination	Bitmap	The destination bitmap
clr	Color	The color of the line
l	Line	The line’s details
opts	Drawing Options	The drawing options

Signatures:

C++

void draw_line_on_bitmap(bitmap destination, color clr, const line &l, drawing_options opts)

C#

public void Bitmap.DrawLine(Color clr, Line l, DrawingOptions opts);
public static void SplashKit.DrawLineOnBitmap(Bitmap destination, Color clr, Line l, DrawingOptions opts);

Python

def draw_line_on_bitmap_record_with_options(destination, clr, l, opts):

Pascal

procedure DrawLineOnBitmap(destination: Bitmap; clr: Color; const l: Line; opts: DrawingOptions)

---

Draw Line On Bitmap

Draw a line from one point to another on the given bitmap.

Parameters:

Name	Type	Description
destination	Bitmap	The destination bitmap
clr	Color	The color of the line
from_pt	Point 2d	The start of the line
to_pt	Point 2d	The end of the line

Signatures:

C++

void draw_line_on_bitmap(bitmap destination, color clr, const point_2d &from_pt, const point_2d &to_pt)

C#

public void Bitmap.DrawLine(Color clr, Point2D fromPt, Point2D toPt);
public static void SplashKit.DrawLineOnBitmap(Bitmap destination, Color clr, Point2D fromPt, Point2D toPt);

Python

def draw_line_on_bitmap_point_to_point(destination, clr, from_pt, to_pt):

Pascal

procedure DrawLineOnBitmap(destination: Bitmap; clr: Color; const fromPt: Point2D; const toPt: Point2D)

---

Draw Line On Bitmap

Draw a line from one point to another on the given bitmap.

Parameters:

Name	Type	Description
destination	Bitmap	The destination bitmap
clr	Color	The color of the line
from_pt	Point 2d	The start of the line
to_pt	Point 2d	The end of the line
opts	Drawing Options	The drawing options

Signatures:

C++

void draw_line_on_bitmap(bitmap destination, color clr, const point_2d &from_pt, const point_2d &to_pt, const drawing_options &opts)

C#

public void Bitmap.DrawLine(Color clr, Point2D fromPt, Point2D toPt, DrawingOptions opts);
public static void SplashKit.DrawLineOnBitmap(Bitmap destination, Color clr, Point2D fromPt, Point2D toPt, DrawingOptions opts);

Python

def draw_line_on_bitmap_point_to_point_with_options(destination, clr, from_pt, to_pt, opts):

Pascal

procedure DrawLineOnBitmap(destination: Bitmap; clr: Color; const fromPt: Point2D; const toPt: Point2D; const opts: DrawingOptions)

---

Draw Line On Bitmap

Draw a line from one point to another on the given bitmap.

Parameters:

Name	Type	Description
destination	Bitmap	The destination bitmap
clr	Color	The color of the line
x1	Double	The distance from the left of the bitmap/bitmap to the first point
y1	Double	The distance from the top of the bitmap/bitmap to the first point
x2	Double	The distance from the left of the bitmap/bitmap to the second point
y2	Double	The distance from the top of the bitmap/bitmap to the second point

Signatures:

C++

void draw_line_on_bitmap(bitmap destination, color clr, double x1, double y1, double x2, double y2)

C#

public void Bitmap.DrawLine(Color clr, double x1, double y1, double x2, double y2);
public static void SplashKit.DrawLineOnBitmap(Bitmap destination, Color clr, double x1, double y1, double x2, double y2);

Python

def draw_line_on_bitmap(destination, clr, x1, y1, x2, y2):

Pascal

procedure DrawLineOnBitmap(destination: Bitmap; clr: Color; x1: Double; y1: Double; x2: Double; y2: Double)

Usage:

See Code Examples

Example 1: Drawing a Route on a Map

C++

#include "splashkit.h"

int main()
{
    // Create a Window and bitmap for the map
    window window = open_window("Window", 400, 300);
    bitmap bitmap = create_bitmap("map", 400, 300);

    // Fill background with white
    clear_bitmap(bitmap, COLOR_WHITE);

    // Draw the route line and points
    draw_line_on_bitmap(bitmap, COLOR_GREEN,
                       100, 80,    // Starting point (x1, y1)
                       300, 220);  // End point (x2, y2)
    fill_circle_on_bitmap(bitmap, COLOR_RED, 100, 80, 5);    // Start point
    fill_circle_on_bitmap(bitmap, COLOR_RED, 300, 220, 5);   // End point

    while (!window_close_requested(window))
    {
        process_events();
        // Draw the bitmap to the current window
        draw_bitmap(bitmap, 0, 0);
        refresh_screen();
    }

    free_bitmap(bitmap);
    close_all_windows();
    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

// Create a Window and bitmap for the map
Window window = OpenWindow("Window", 400, 300);
Bitmap bitmap = CreateBitmap("map", 400, 300);

// Fill background with white
ClearBitmap(bitmap, ColorWhite());

// Draw the route line and points
DrawLineOnBitmap(bitmap, ColorGreen(),
                100, 80,    // Starting point (x1, y1)
                300, 220);  // End point (x2, y2)
FillCircleOnBitmap(bitmap, ColorRed(), 100, 80, 5);    // Start point
FillCircleOnBitmap(bitmap, ColorRed(), 300, 220, 5);   // End point

while (!window.CloseRequested)
{
    ProcessEvents();
    // Draw the bitmap to the current window
    DrawBitmap(bitmap, 0, 0);
    RefreshScreen();
}

FreeBitmap(bitmap);
CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace DrawLineOnBitmap
{
    public class Program
    {
        public static void Main()
        {
            // Create a Window and bitmap for the map
            Window window = new Window("Window", 400, 300);
            Bitmap bitmap = new Bitmap("map", 400, 300);

            // Fill background with white
            SplashKit.ClearBitmap(bitmap, Color.White);

            // Draw the route line and points
            SplashKit.DrawLineOnBitmap(bitmap, Color.Green,
                          100, 80,    // Starting point (x1, y1)
                          300, 220);  // End point (x2, y2)
            SplashKit.FillCircleOnBitmap(bitmap, Color.Red, 100, 80, 5);    // Start point
            SplashKit.FillCircleOnBitmap(bitmap, Color.Red, 300, 220, 5);   // End point

            while (!window.CloseRequested)
            {
                SplashKit.ProcessEvents();
                // Draw the bitmap to the current window
                window.DrawBitmap(bitmap, 0, 0);
                SplashKit.RefreshScreen();
            }
            bitmap.Free();
            window.Cl
        }
    }
}

Python

from splashkit import *

# Create a Window and bitmap for the map
window = open_window("Window", 400, 300)
bitmap = create_bitmap("map", 400, 300)

# Fill background with white
clear_bitmap(bitmap, color_white())

# Draw the route line and points
draw_line_on_bitmap(bitmap, color_green(),
                   100, 80,    # Starting point (x1, y1)
                   300, 220)   # End point (x2, y2)
fill_circle_on_bitmap(bitmap, color_red(), 100, 80, 5)    # Start point
fill_circle_on_bitmap(bitmap, color_red(), 300, 220, 5)   # End point

while not window_close_requested(window):
    process_events()
    # Draw the bitmap to the current window
    draw_bitmap(bitmap, 0, 0)
    refresh_screen()

free_bitmap(bitmap)
close_all_windows()

Output:

---

Draw Line On Bitmap

Draw a line from one point to another

Parameters:

Name	Type	Description
destination	Bitmap	The destination bitmap
clr	Color	The color of the line
x1	Double	The distance from the left of the bitmap/bitmap to the first point
y1	Double	The distance from the top of the bitmap/bitmap to the first point
x2	Double	The distance from the left of the bitmap/bitmap to the second point
y2	Double	The distance from the top of the bitmap/bitmap to the second point
opts	Drawing Options	The drawing options

Signatures:

C++

void draw_line_on_bitmap(bitmap destination, color clr, double x1, double y1, double x2, double y2, const drawing_options &opts)

C#

public void Bitmap.DrawLine(Color clr, double x1, double y1, double x2, double y2, DrawingOptions opts);
public static void SplashKit.DrawLineOnBitmap(Bitmap destination, Color clr, double x1, double y1, double x2, double y2, DrawingOptions opts);

Python

def draw_line_on_bitmap_with_options(destination, clr, x1, y1, x2, y2, opts):

Pascal

procedure DrawLineOnBitmap(destination: Bitmap; clr: Color; x1: Double; y1: Double; x2: Double; y2: Double; const opts: DrawingOptions)

---

Draw Line On Window

Note

This function is overloaded. The following versions exist:

• Draw Line On Window (destination: window, clr: color, l: line)
• Draw Line On Window (destination: window, clr: color, l: line, opts: drawing_options)
• Draw Line On Window (destination: window, clr: color, from_pt: point_2d, to_pt: point_2d)
• Draw Line On Window (destination: window, clr: color, from_pt: point_2d, to_pt: point_2d, opts: drawing_options)
• Draw Line On Window (destination: window, clr: color, x1: double, y1: double, x2: double, y2: double)
• Draw Line On Window (destination: window, clr: color, x1: double, y1: double, x2: double, y2: double, opts: drawing_options)

Draw Line On Window

Draws a line onto the given window.

Parameters:

Name	Type	Description
destination	Window	The destination bitmap
clr	Color	The color of the line
l	Line	The line’s details

Signatures:

C++

void draw_line_on_window(window destination, color clr, const line &l)

C#

public void Window.DrawLine(Color clr, Line l);
public static void SplashKit.DrawLineOnWindow(Window destination, Color clr, Line l);

Python

def draw_line_on_window_record(destination, clr, l):

Pascal

procedure DrawLineOnWindow(destination: Window; clr: Color; const l: Line)

---

Draw Line On Window

Draws a line on the given window.

Parameters:

Name	Type	Description
destination	Window	The destination bitmap
clr	Color	The color of the line
l	Line	The line’s details
opts	Drawing Options	The drawing options

Signatures:

C++

void draw_line_on_window(window destination, color clr, const line &l, drawing_options opts)

C#

public void Window.DrawLine(Color clr, Line l, DrawingOptions opts);
public static void SplashKit.DrawLineOnWindow(Window destination, Color clr, Line l, DrawingOptions opts);

Python

def draw_line_on_window_record_with_options(destination, clr, l, opts):

Pascal

procedure DrawLineOnWindow(destination: Window; clr: Color; const l: Line; opts: DrawingOptions)

---

Draw Line On Window

Draw a line from one point to another on the given window.

Parameters:

Name	Type	Description
destination	Window	The destination bitmap
clr	Color	The color of the line
from_pt	Point 2d	The start of the line
to_pt	Point 2d	The end of the line

Signatures:

C++

void draw_line_on_window(window destination, color clr, const point_2d &from_pt, const point_2d &to_pt)

C#

public void Window.DrawLine(Color clr, Point2D fromPt, Point2D toPt);
public static void SplashKit.DrawLineOnWindow(Window destination, Color clr, Point2D fromPt, Point2D toPt);

Python

def draw_line_on_window_point_to_point(destination, clr, from_pt, to_pt):

Pascal

procedure DrawLineOnWindow(destination: Window; clr: Color; const fromPt: Point2D; const toPt: Point2D)

---

Draw Line On Window

Draw a line from one point to another on the given window.

Parameters:

Name	Type	Description
destination	Window	The destination bitmap
clr	Color	The color of the line
from_pt	Point 2d	The start of the line
to_pt	Point 2d	The end of the line
opts	Drawing Options	The drawing options

Signatures:

C++

void draw_line_on_window(window destination, color clr, const point_2d &from_pt, const point_2d &to_pt, const drawing_options &opts)

C#

public void Window.DrawLine(Color clr, Point2D fromPt, Point2D toPt, DrawingOptions opts);
public static void SplashKit.DrawLineOnWindow(Window destination, Color clr, Point2D fromPt, Point2D toPt, DrawingOptions opts);

Python

def draw_line_on_window_point_to_point_with_options(destination, clr, from_pt, to_pt, opts):

Pascal

procedure DrawLineOnWindow(destination: Window; clr: Color; const fromPt: Point2D; const toPt: Point2D; const opts: DrawingOptions)

---

Draw Line On Window

Draw a line from one point to another on the given window.

Parameters:

Name	Type	Description
destination	Window	The destination bitmap
clr	Color	The color of the line
x1	Double	The distance from the left of the window/bitmap to the first point
y1	Double	The distance from the top of the window/bitmap to the first point
x2	Double	The distance from the left of the window/bitmap to the second point
y2	Double	The distance from the top of the window/bitmap to the second point

Signatures:

C++

void draw_line_on_window(window destination, color clr, double x1, double y1, double x2, double y2)

C#

public void Window.DrawLine(Color clr, double x1, double y1, double x2, double y2);
public static void SplashKit.DrawLineOnWindow(Window destination, Color clr, double x1, double y1, double x2, double y2);

Python

def draw_line_on_window(destination, clr, x1, y1, x2, y2):

Pascal

procedure DrawLineOnWindow(destination: Window; clr: Color; x1: Double; y1: Double; x2: Double; y2: Double)

Usage:

See Code Examples

Example 1: Basic Line Drawing

C++

#include "splashkit.h"

int main()
{
    // Create Window
    window window = open_window("Colourful Starburst", 600, 600);

    clear_screen(COLOR_BLACK);

    // Draws starburst pattern with changing colours to specific window
    draw_line_on_window(window, COLOR_YELLOW, 0, 0, 600, 600);
    draw_line_on_window(window, COLOR_GREEN, 0, 150, 600, 450);
    draw_line_on_window(window, COLOR_TEAL, 0, 300, 600, 300);
    draw_line_on_window(window, COLOR_BLUE, 0, 450, 600, 150);
    draw_line_on_window(window, COLOR_VIOLET, 0, 600, 600, 0);
    draw_line_on_window(window, COLOR_PURPLE, 150, 0, 450, 600);
    draw_line_on_window(window, COLOR_PINK, 300, 0, 300, 600);
    draw_line_on_window(window, COLOR_RED, 450, 0, 150, 600);
    draw_line_on_window(window, COLOR_ORANGE, 600, 0, 0, 600);

    refresh_screen();

    delay(5000);
    close_all_windows();

    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;


// Create Window
Window window = OpenWindow("Colourful Starburst", 600, 600);

ClearScreen(ColorBlack());

// Draws starburst pattern with changing colours to specific window
DrawLineOnWindow(window, ColorYellow(), 0, 0, 600, 600);
DrawLineOnWindow(window, ColorGreen(), 0, 150, 600, 450);
DrawLineOnWindow(window, ColorTeal(), 0, 300, 600, 300);
DrawLineOnWindow(window, ColorBlue(), 0, 450, 600, 150);
DrawLineOnWindow(window, ColorViolet(), 0, 600, 600, 0);
DrawLineOnWindow(window, ColorPurple(), 150, 0, 450, 600);
DrawLineOnWindow(window, ColorPink(), 300, 0, 300, 600);
DrawLineOnWindow(window, ColorRed(), 450, 0, 150, 600);
DrawLineOnWindow(window, ColorOrange(), 600, 0, 0, 600);

RefreshScreen();

Delay(5000);
CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace DrawLineOnWindowExample
{
    public class Program
    {
        public static void Main()
        {
            // Create Window
            Window window = new Window("Colourful Starburst", 600, 600);

            window.Clear(Color.Black);

            // Draws starburst pattern with changing colours to specific window
            window.DrawLine(Color.Yellow, 0, 0, 600, 600);
            window.DrawLine(Color.Green, 0, 150, 600, 450);
            window.DrawLine(Color.Teal, 0, 300, 600, 300);
            window.DrawLine(Color.Blue, 0, 450, 600, 150);
            window.DrawLine(Color.Violet, 0, 600, 600, 0);
            window.DrawLine(Color.Purple, 150, 0, 450, 600);
            window.DrawLine(Color.Pink, 300, 0, 300, 600);
            window.DrawLine(Color.Red, 450, 0, 150, 600);
            window.DrawLine(Color.Orange, 600, 0, 0, 600);

            window.Refresh();

            SplashKit.Delay(5000);
            window.Close();
        }
    }
}

Python

from splashkit import *

# Create Window
window = open_window("Colourful Starburst", 600, 600)

clear_screen(color_black())

# Draws starburst pattern with changing colours to specific window
draw_line_on_window(window, color_yellow(), 0, 0, 600, 600)
draw_line_on_window(window, color_green(), 0, 150, 600, 450)
draw_line_on_window(window, color_teal(), 0, 300, 600, 300)
draw_line_on_window(window, color_blue(), 0, 450, 600, 150)
draw_line_on_window(window, color_violet(), 0, 600, 600, 0)
draw_line_on_window(window, color_purple(), 150, 0, 450, 600)
draw_line_on_window(window, color_pink(), 300, 0, 300, 600)
draw_line_on_window(window, color_red(), 450, 0, 150, 600)
draw_line_on_window(window, color_orange(), 600, 0, 0, 600)

refresh_screen()

delay(5000)
close_all_windows()

Output:

---

Draw Line On Window

Draw a line from one point to another

Parameters:

Name	Type	Description
destination	Window	The destination bitmap
clr	Color	The color of the line
x1	Double	The distance from the left of the window/bitmap to the first point
y1	Double	The distance from the top of the window/bitmap to the first point
x2	Double	The distance from the left of the window/bitmap to the second point
y2	Double	The distance from the top of the window/bitmap to the second point
opts	Drawing Options	The drawing options

Signatures:

C++

void draw_line_on_window(window destination, color clr, double x1, double y1, double x2, double y2, const drawing_options &opts)

C#

public void Window.DrawLine(Color clr, double x1, double y1, double x2, double y2, DrawingOptions opts);
public static void SplashKit.DrawLineOnWindow(Window destination, Color clr, double x1, double y1, double x2, double y2, DrawingOptions opts);

Python

def draw_line_on_window_with_options(destination, clr, x1, y1, x2, y2, opts):

Pascal

procedure DrawLineOnWindow(destination: Window; clr: Color; x1: Double; y1: Double; x2: Double; y2: Double; const opts: DrawingOptions)

---

Draw Pixel

Note

This function is overloaded. The following versions exist:

• Draw Pixel (clr: color, pt: point_2d)
• Draw Pixel (clr: color, pt: point_2d, opts: drawing_options)
• Draw Pixel (clr: color, x: double, y: double)
• Draw Pixel (clr: color, x: double, y: double, opts: drawing_options)

Draw Pixel

Draws an individual pixel to the current window.

Parameters:

Name	Type	Description
clr	Color	The color of the pixel
pt	Point 2d	The location of the pixel to draw

Signatures:

C++

void draw_pixel(color clr, const point_2d &pt)

C#

public static void SplashKit.DrawPixel(Color clr, Point2D pt);

Python

def draw_pixel_at_point(clr, pt):

Pascal

procedure DrawPixel(clr: Color; const pt: Point2D)

---

Draw Pixel

Draws an individual pixel with the supplied options.

Parameters:

Name	Type	Description
clr	Color	The color of the pixel
pt	Point 2d	The location of the pixel to draw
opts	Drawing Options	The drawing options

Signatures:

C++

void draw_pixel(color clr, const point_2d &pt, drawing_options opts)

C#

public static void SplashKit.DrawPixel(Color clr, Point2D pt, DrawingOptions opts);

Python

def draw_pixel_at_point_with_options(clr, pt, opts):

Pascal

procedure DrawPixel(clr: Color; const pt: Point2D; opts: DrawingOptions)

---

Draw Pixel

Draws an individual pixel to the current window.

Parameters:

Name	Type	Description
clr	Color	The color of the pixel
x	Double	The distance from the left edge of the window to the pixel
y	Double	The distance from the top edge of the window to the pixel

Signatures:

C++

void draw_pixel(color clr, double x, double y)

C#

public static void SplashKit.DrawPixel(Color clr, double x, double y);

Python

def draw_pixel(clr, x, y):

Pascal

procedure DrawPixel(clr: Color; x: Double; y: Double)

Usage:

See Code Examples

Example 1: Cursor Trail

C++

#include "splashkit.h"

int main()
{
    // declare variables
    const int TRAIL_LENGTH = 50;
    point_2d mouse_point;
    point_2d mouse_history[TRAIL_LENGTH] = {};
    color color_list[5] = { color_blue(), color_red(), color_green(), color_yellow(), color_pink() };

    open_window("Cursor Trail", 600, 600);

    while (!quit_requested())
    {
        mouse_point = mouse_position();
        clear_screen(color_black());

        // set mouse position history
        for (int i = 0; i < TRAIL_LENGTH - 1; i++)
        {
            // shuffle forward
            mouse_history[i] = mouse_history[i + 1];
        }

        mouse_history[TRAIL_LENGTH - 1] = mouse_point;

        // draw mouse trail
        for (int i = 0; i < TRAIL_LENGTH; i++)
        {
            draw_pixel(color_list[i % 5], mouse_history[i]);
        }

        process_events();
        refresh_screen(60);
    }

    close_all_windows();
    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

// Declare variables
const int TrailLength = 50;
Point2D mousePoint;
Point2D[] mouseHistory = new Point2D[TrailLength];
Color[] colorList = { ColorBlue(), ColorRed(), ColorGreen(), ColorYellow(), ColorPink() };

OpenWindow("Cursor Trail", 600, 600);

while (!QuitRequested())
{
    mousePoint = MousePosition();
    ClearScreen(ColorBlack());

    // Set mouse position history
    for (int i = 0; i < TrailLength - 1; i++)
    {
        // Shuffle forward
        mouseHistory[i] = mouseHistory[i + 1];
    }

    mouseHistory[TrailLength - 1] = mousePoint;

    // Draw mouse trail
    for (int i = 0; i < TrailLength; i++)
    {
        DrawPixel(colorList[i % 5], mouseHistory[i]);
    }

    ProcessEvents();
    RefreshScreen(60);
}

CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace DrawPixelExample
{
    public class Program
    {
        public static void Main()
        {
            // Declare variables
            const int TrailLength = 50;
            Point2D mousePoint;
            Point2D[] mouseHistory = new Point2D[TrailLength];
            Color[] colorList = { Color.Blue, Color.Red, Color.Green, Color.Yellow, Color.Pink };

            Window window = new Window("Cursor Trail", 600, 600);

            while (!SplashKit.QuitRequested())
            {
                mousePoint = SplashKit.MousePosition();
                window.Clear(Color.Black);
                // Set mouse position history
                for (int i = 0; i < TrailLength - 1; i++)
                {
                    // Shuffle forward
                    mouseHistory[i] = mouseHistory[i + 1];
                }

                mouseHistory[TrailLength - 1] = mousePoint;

                // Draw mouse trail
                for (int i = 0; i < TrailLength; i++)
                {
                    SplashKit.DrawPixel(colorList[i % 5], mouseHistory[i]);
                }

                SplashKit.ProcessEvents();
                window.Refresh(60);
            }
            window.Close();
        }
    }
}

Python

from splashkit import *

# Declare variables
TRAIL_LENGTH = 50
pixel_point = point_at(-10, -10)
mouse_history = [pixel_point for _ in range(TRAIL_LENGTH)]
color_list = [color_blue(), color_red(), color_green(), color_yellow(), color_pink()]

open_window("Cursor Trail", 600, 600)

while not quit_requested():
    mouse_point = mouse_position()
    clear_screen(color_black())

    # Set mouse position history
    for i in range(TRAIL_LENGTH - 1):
        # Shuffle forward
        mouse_history[i] = mouse_history[i + 1]

    mouse_history[TRAIL_LENGTH - 1] = mouse_point

    # Draw mouse trail
    for i in range(TRAIL_LENGTH):
        draw_pixel_at_point(color_list[i % 5], mouse_history[i])

    process_events()
    refresh_screen_with_target_fps(60)

close_all_windows()

Output:

---

Draw Pixel

Draws an individual pixel with the supplied options.

Parameters:

Name	Type	Description
clr	Color	The color of the pixel
x	Double	The distance from the left edge of the window/bitmap to the pixel
y	Double	The distance from the top edge of the window/bitmap to the pixel
opts	Drawing Options	The drawing options

Signatures:

C++

void draw_pixel(color clr, double x, double y, drawing_options opts)

C#

public static void SplashKit.DrawPixel(Color clr, double x, double y, DrawingOptions opts);

Python

def draw_pixel_with_options(clr, x, y, opts):

Pascal

procedure DrawPixel(clr: Color; x: Double; y: Double; opts: DrawingOptions)

---

Draw Pixel On Bitmap

Note

This function is overloaded. The following versions exist:

• Draw Pixel On Bitmap (destination: bitmap, clr: color, pt: point_2d)
• Draw Pixel On Bitmap (destination: bitmap, clr: color, pt: point_2d, opts: drawing_options)
• Draw Pixel On Bitmap (destination: bitmap, clr: color, x: double, y: double)
• Draw Pixel On Bitmap (destination: bitmap, clr: color, x: double, y: double, opts: drawing_options)

Draw Pixel On Bitmap

Draws an individual pixel to the given bitmap.

Parameters:

Name	Type	Description
destination	Bitmap	the bitmap to draw the pixel on
clr	Color	The color of the pixel
pt	Point 2d	The location of the pixel to draw

Signatures:

C++

void draw_pixel_on_bitmap(bitmap destination, color clr, const point_2d &pt)

C#

public void Bitmap.DrawPixel(Color clr, Point2D pt);
public static void SplashKit.DrawPixelOnBitmap(Bitmap destination, Color clr, Point2D pt);

Python

def draw_pixel_on_bitmap_at_point(destination, clr, pt):

Pascal

procedure DrawPixelOnBitmap(destination: Bitmap; clr: Color; const pt: Point2D)

---

Draw Pixel On Bitmap

Draws an individual pixel to the given bitmap with the given drawing options.

Parameters:

Name	Type	Description
destination	Bitmap	the bitmap to draw the pixel on
clr	Color	The color of the pixel
pt	Point 2d	The location of the pixel to draw
opts	Drawing Options	The drawing options

Signatures:

C++

void draw_pixel_on_bitmap(bitmap destination, color clr, const point_2d &pt, drawing_options opts)

C#

public void Bitmap.DrawPixel(Color clr, Point2D pt, DrawingOptions opts);
public static void SplashKit.DrawPixelOnBitmap(Bitmap destination, Color clr, Point2D pt, DrawingOptions opts);

Python

def draw_pixel_on_bitmap_at_point_with_options(destination, clr, pt, opts):

Pascal

procedure DrawPixelOnBitmap(destination: Bitmap; clr: Color; const pt: Point2D; opts: DrawingOptions)

---

Draw Pixel On Bitmap

Draws an individual pixel to the given bitmap.

Parameters:

Name	Type	Description
destination	Bitmap	the bitmap to draw the pixel on
clr	Color	The color of the pixel
x	Double	The distance from the left edge of the bitmap to the pixel
y	Double	The distance from the top edge of the bitmap to the pixel

Signatures:

C++

void draw_pixel_on_bitmap(bitmap destination, color clr, double x, double y)

C#

public void Bitmap.DrawPixel(Color clr, double x, double y);
public static void SplashKit.DrawPixelOnBitmap(Bitmap destination, Color clr, double x, double y);

Python

def draw_pixel_on_bitmap(destination, clr, x, y):

Pascal

procedure DrawPixelOnBitmap(destination: Bitmap; clr: Color; x: Double; y: Double)

---

Draw Pixel On Bitmap

Draws an individual pixel to the given bitmap with the given drawing options.

Parameters:

Name	Type	Description
destination	Bitmap	the bitmap to draw the pixel on
clr	Color	The color of the pixel
x	Double	The distance from the left edge of the bitmap to the pixel
y	Double	The distance from the top edge of the bitmap to the pixel
opts	Drawing Options	The drawing options

Signatures:

C++

void draw_pixel_on_bitmap(bitmap destination, color clr, double x, double y, drawing_options opts)

C#

public void Bitmap.DrawPixel(Color clr, double x, double y, DrawingOptions opts);
public static void SplashKit.DrawPixelOnBitmap(Bitmap destination, Color clr, double x, double y, DrawingOptions opts);

Python

def draw_pixel_on_bitmap_with_options(destination, clr, x, y, opts):

Pascal

procedure DrawPixelOnBitmap(destination: Bitmap; clr: Color; x: Double; y: Double; opts: DrawingOptions)

---

Draw Pixel On Window

Note

This function is overloaded. The following versions exist:

• Draw Pixel On Window (destination: window, clr: color, pt: point_2d)
• Draw Pixel On Window (destination: window, clr: color, pt: point_2d, opts: drawing_options)
• Draw Pixel On Window (destination: window, clr: color, x: double, y: double)
• Draw Pixel On Window (destination: window, clr: color, x: double, y: double, opts: drawing_options)

Draw Pixel On Window

Draws an individual pixel to the given window.

Parameters:

Name	Type	Description
destination	Window	The window to draw the pixel on
clr	Color	The color of the pixel
pt	Point 2d	The location of the pixel to draw

Signatures:

C++

void draw_pixel_on_window(window destination, color clr, const point_2d &pt)

C#

public static void SplashKit.DrawPixelOnWindow(Window destination, Color clr, Point2D pt);

Python

def draw_pixel_on_window_at_point(destination, clr, pt):

Pascal

procedure DrawPixelOnWindow(destination: Window; clr: Color; const pt: Point2D)

---

Draw Pixel On Window

Draws an individual pixel to the given window with the given drawing options.

Parameters:

Name	Type	Description
destination	Window	The window to draw the pixel on
clr	Color	The color of the pixel
pt	Point 2d	The location of the pixel to draw
opts	Drawing Options	The drawing options

Signatures:

C++

void draw_pixel_on_window(window destination, color clr, const point_2d &pt, drawing_options opts)

C#

public static void SplashKit.DrawPixelOnWindow(Window destination, Color clr, Point2D pt, DrawingOptions opts);

Python

def draw_pixel_on_window_at_point_with_options(destination, clr, pt, opts):

Pascal

procedure DrawPixelOnWindow(destination: Window; clr: Color; const pt: Point2D; opts: DrawingOptions)

---

Draw Pixel On Window

Draws an individual pixel to the given window.

Parameters:

Name	Type	Description
destination	Window	the window to draw the pixel on
clr	Color	The color of the pixel
x	Double	The distance from the left edge of the window to the pixel
y	Double	The distance from the top edge of the window to the pixel

Signatures:

C++

void draw_pixel_on_window(window destination, color clr, double x, double y)

C#

public static void SplashKit.DrawPixelOnWindow(Window destination, Color clr, double x, double y);

Python

def draw_pixel_on_window(destination, clr, x, y):

Pascal

procedure DrawPixelOnWindow(destination: Window; clr: Color; x: Double; y: Double)

---

Draw Pixel On Window

Draws an individual pixel to the given window with the given drawing options.

Parameters:

Name	Type	Description
destination	Window	The window to draw the pixel on
clr	Color	The color of the pixel
x	Double	The distance from the left edge of the window to the pixel
y	Double	The distance from the top edge of the window to the pixel
opts	Drawing Options	The drawing options

Signatures:

C++

void draw_pixel_on_window(window destination, color clr, double x, double y, drawing_options opts)

C#

public static void SplashKit.DrawPixelOnWindow(Window destination, Color clr, double x, double y, DrawingOptions opts);

Python

def draw_pixel_on_window_with_options(destination, clr, x, y, opts):

Pascal

procedure DrawPixelOnWindow(destination: Window; clr: Color; x: Double; y: Double; opts: DrawingOptions)

---

Get Pixel

Note

This function is overloaded. The following versions exist:

• Get Pixel (bmp: bitmap, pt: point_2d)
• Get Pixel (bmp: bitmap, x: double, y: double)
• Get Pixel (pt: point_2d)
• Get Pixel (x: double, y: double)
• Get Pixel (wnd: window, pt: point_2d)
• Get Pixel (wnd: window, x: double, y: double)

Get Pixel

Returns the color of the pixel at the location on the supplied bitmap.

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap to get the color from
pt	Point 2d	The position of the pixel

Return Type: Color

Signatures:

C++

color get_pixel(bitmap bmp, const point_2d &pt)

C#

public static Color SplashKit.GetPixel(Bitmap bmp, Point2D pt);

Python

def get_pixel_from_bitmap_at_point(bmp, pt):

Pascal

function GetPixel(bmp: Bitmap; const pt: Point2D): Color

---

Get Pixel

Returns the color of the pixel at the x,y location on the supplied bitmap.

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap to get the color from
x	Double	The distance from the left edge of the bitmap to the pixel to read
y	Double	The distance from the top of the bitmap to the pixel to read

Return Type: Color

Signatures:

C++

color get_pixel(bitmap bmp, double x, double y)

C#

public static Color SplashKit.GetPixel(Bitmap bmp, double x, double y);

Python

def get_pixel_from_bitmap(bmp, x, y):

Pascal

function GetPixel(bmp: Bitmap; x: Double; y: Double): Color

---

Get Pixel

Returns the color of the pixel at the x,y location on the current window.

Parameters:

Name	Type	Description
pt	Point 2d	The position of the pixel

Return Type: Color

Signatures:

C++

color get_pixel(const point_2d &pt)

C#

public static Color SplashKit.GetPixel(Point2D pt);

Python

def get_pixel_at_point(pt):

Pascal

function GetPixel(const pt: Point2D): Color

---

Get Pixel

Returns the color of the pixel at the x,y location on the current window.

Parameters:

Name	Type	Description
x	Double	The distance from the left edge of the window to the pixel to read
y	Double	The distance from the top of the window to the pixel to read

Return Type: Color

Signatures:

C++

color get_pixel(double x, double y)

C#

public static Color SplashKit.GetPixel(double x, double y);

Python

def get_pixel(x, y):

Pascal

function GetPixel(x: Double; y: Double): Color

---

Get Pixel

Returns the color of the pixel at the location on the supplied window.

Parameters:

Name	Type	Description
wnd	Window	The window to get the color from
pt	Point 2d	The position of the pixel

Return Type: Color

Signatures:

C++

color get_pixel(window wnd, const point_2d &pt)

C#

public static Color SplashKit.GetPixel(Window wnd, Point2D pt);

Python

def get_pixel_from_window_at_point(wnd, pt):

Pascal

function GetPixel(wnd: Window; const pt: Point2D): Color

---

Get Pixel

Returns the color of the pixel at the x,y location on the supplied window.

Parameters:

Name	Type	Description
wnd	Window	The window to get the color from
x	Double	The distance from the left edge of the window to the pixel to read
y	Double	The distance from the top of the window to the pixel to read

Return Type: Color

Signatures:

C++

color get_pixel(window wnd, double x, double y)

C#

public static Color SplashKit.GetPixel(Window wnd, double x, double y);

Python

def get_pixel_from_window(wnd, x, y):

Pascal

function GetPixel(wnd: Window; x: Double; y: Double): Color

---

Get Pixel From Window

Note

This function is overloaded. The following versions exist:

• Get Pixel From Window (destination: window, pt: point_2d)
• Get Pixel From Window (destination: window, x: double, y: double)

Get Pixel From Window

Returns the color of the pixel at the x,y location on the given window.

Parameters:

Name	Type	Description
destination	Window	The window to draw the pixel on
pt	Point 2d	The position of the pixel

Return Type: Color

Signatures:

C++

color get_pixel_from_window(window destination, const point_2d &pt)

C#

public static Color SplashKit.GetPixelFromWindow(Window destination, Point2D pt);

Python

def get_pixel_from_window_at_point_from_window(destination, pt):

Pascal

function GetPixelFromWindow(destination: Window; const pt: Point2D): Color

---

Get Pixel From Window

Returns the color of the pixel at the x,y location on the given window.

Parameters:

Name	Type	Description
destination	Window	The window to draw the pixel on
x	Double	The distance from the left edge of the window to the pixel to read
y	Double	The distance from the top of the window to the pixel to read

Return Type: Color

Signatures:

C++

color get_pixel_from_window(window destination, double x, double y)

C#

public static Color SplashKit.GetPixelFromWindow(Window destination, double x, double y);

Python

def get_pixel_from_window_from_window(destination, x, y):

Pascal

function GetPixelFromWindow(destination: Window; x: Double; y: Double): Color

---

Draw Quad

Note

This function is overloaded. The following versions exist:

• Draw Quad (clr: color, q: quad)
• Draw Quad (clr: color, q: quad, opts: drawing_options)

Draw Quad

Draw a quad to the current window.

Parameters:

Name	Type	Description
clr	Color	The color for the quad
q	Quad	The details of the quad

Signatures:

C++

void draw_quad(color clr, const quad &q)

C#

public static void SplashKit.DrawQuad(Color clr, Quad q);

Python

def draw_quad(clr, q):

Pascal

procedure DrawQuad(clr: Color; const q: Quad)

Usage:

See Code Examples

Example 1: Ninja Star

C++

#include "splashkit.h"

int main()
{
    // Create 4 diamond shapes using quads
    quad q1 = quad_from(400, 200, 300, 300, 300, 0, 200, 200);
    quad q2 = quad_from(400, 210, 310, 300, 600, 300, 400, 390);
    quad q3 = quad_from(200, 400, 300, 300, 300, 600, 400, 400);
    quad q4 = quad_from(200, 390, 290, 300, 0, 300, 200, 210);

    open_window("Ninja Star", 600, 600);
    clear_screen(COLOR_WHITE);

    // Draw the quads
    draw_quad(COLOR_BLACK, q1);
    draw_quad(COLOR_GREEN, q2);
    draw_quad(COLOR_RED, q3);
    draw_quad(COLOR_BLUE, q4);

    refresh_screen();
    delay(5000);
    close_all_windows();
    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

// Create 4 diamond shapes using quads
Quad q1 = QuadFrom(400, 200, 300, 300, 300, 0, 200, 200);
Quad q2 = QuadFrom(400, 210, 310, 300, 600, 300, 400, 390);
Quad q3 = QuadFrom(200, 400, 300, 300, 300, 600, 400, 400);
Quad q4 = QuadFrom(200, 390, 290, 300, 0, 300, 200, 210);

OpenWindow("Ninja Star", 600, 600);
ClearScreen(ColorWhite());

// Draw the quads
DrawQuad(ColorBlack(), q1);
DrawQuad(ColorGreen(), q2);
DrawQuad(ColorRed(),   q3);
DrawQuad(ColorBlue(),  q4);

RefreshScreen();
Delay(5000);
CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace DrawQuadExample
{
    public class Program
    {
        public static void Main()
        {
            // Create 4 diamond shapes using quads
            Quad q1 = SplashKit.QuadFrom(400, 200, 300, 300, 300, 0, 200, 200);
            Quad q2 = SplashKit.QuadFrom(400, 210, 310, 300, 600, 300, 400, 390);
            Quad q3 = SplashKit.QuadFrom(200, 400, 300, 300, 300, 600, 400, 400);
            Quad q4 = SplashKit.QuadFrom(200, 390, 290, 300, 0, 300, 200, 210);

            SplashKit.OpenWindow("Ninja Star", 600, 600);
            SplashKit.ClearScreen(Color.White);

            // Draw the quads
            SplashKit.DrawQuad(Color.Black, q1);
            SplashKit.DrawQuad(Color.Green, q2);
            SplashKit.DrawQuad(Color.Red, q3);
            SplashKit.DrawQuad(Color.Blue, q4);

            SplashKit.RefreshScreen();
            SplashKit.Delay(5000);
            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

# Create 4 diamond shapes using quads
q1 = quad_from(400, 200, 300, 300, 300, 0, 200, 200)
q2 = quad_from(400, 210, 310, 300, 600, 300, 400, 390)
q3 = quad_from(200, 400, 300, 300, 300, 600, 400, 400)
q4 = quad_from(200, 390, 290, 300, 0, 300, 200, 210)

open_window("Ninja Star", 600, 600)
clear_screen(color_white())

# Draw the quads
draw_quad(color_black(), q1)
draw_quad(color_green(), q2)
draw_quad(color_red(), q3)
draw_quad(color_blue(), q4)

refresh_screen()
delay(5000)
close_all_windows()

Output:

---

Draw Quad

Draw a quad using the supplied drawing options.

Parameters:

Name	Type	Description
clr	Color	The color for the quad
q	Quad	The details of the quad
opts	Drawing Options	The drawing options

Signatures:

C++

void draw_quad(color clr, const quad &q, const drawing_options &opts)

C#

public static void SplashKit.DrawQuad(Color clr, Quad q, DrawingOptions opts);

Python

def draw_quad_with_options(clr, q, opts):

Pascal

procedure DrawQuad(clr: Color; const q: Quad; const opts: DrawingOptions)

---

Draw Quad On Bitmap

Note

This function is overloaded. The following versions exist:

• Draw Quad On Bitmap (destination: bitmap, clr: color, q: quad)
• Draw Quad On Bitmap (destination: bitmap, clr: color, q: quad, opts: drawing_options)

Draw Quad On Bitmap

Draw a quad on the supplied bitmap to the current bitmap.

Parameters:

Name	Type	Description
destination	Bitmap	The destination bitmap
clr	Color	The color for the quad
q	Quad	The details of the quad

Signatures:

C++

void draw_quad_on_bitmap(bitmap destination, color clr, const quad &q)

C#

public void Bitmap.DrawQuad(Color clr, Quad q);
public static void SplashKit.DrawQuadOnBitmap(Bitmap destination, Color clr, Quad q);

Python

def draw_quad_on_bitmap(destination, clr, q):

Pascal

procedure DrawQuadOnBitmap(destination: Bitmap; clr: Color; const q: Quad)

Usage:

See Code Examples

Example 1: 3D Cube

C++

#include "splashkit.h"

int main()
{
    // Create a window and bitmap to draw on
    window window = open_window("Cube", 800, 600);
    bitmap bitmap = create_bitmap("cube", 800, 600);

    // Fill background with light color
    clear_bitmap(bitmap, COLOR_WHITE);

    // Define the color for the cube
    color cube_color = COLOR_BLUE;

    // Define the coordinates of the front and back faces of the cube
    quad front_face = quad_from(
        300, 200,    // Top-left
        500, 200,    // Top-right
        300, 400,    // Bottom-left
        500, 400     // Bottom-right
    );

    quad back_face = quad_from(
        350, 150,    // Top-left
        550, 150,    // Top-right
        350, 350,    // Bottom-left
        550, 350     // Bottom-right
    );

    // Draw the faces of the cube
    draw_quad_on_bitmap(bitmap, cube_color, front_face);
    draw_quad_on_bitmap(bitmap, cube_color, back_face);

    // Connect the front and back faces for the 3D effect
    draw_line_on_bitmap(bitmap, cube_color, 300, 200, 350, 150);
    draw_line_on_bitmap(bitmap, cube_color, 500, 200, 550, 150);
    draw_line_on_bitmap(bitmap, cube_color, 300, 400, 350, 350);
    draw_line_on_bitmap(bitmap, cube_color, 500, 400, 550, 350);

    while (!window_close_requested(window))
    {
        process_events();
        // Draw the bitmap to the window
        draw_bitmap(bitmap, 0, 0);
        // Refresh the window
        refresh_screen();
    }

    free_bitmap(bitmap);
    close_window(window);

    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

// Create a window and bitmap to draw on
Window window = OpenWindow("Cube", 800, 600);
Bitmap bitmap = CreateBitmap("cube", 800, 600);

// Fill background with light color
ClearBitmap(bitmap, ColorWhite());

// Define the color for the cube
Color cubeColor = ColorBlue();

// Define the coordinates of the front and back faces of the cube
Quad frontFace = QuadFrom(
    300, 200,    // Top-left
    500, 200,    // Top-right
    300, 400,    // Bottom-left
    500, 400     // Bottom-right
);

Quad backFace = QuadFrom(
    350, 150,    // Top-left
    550, 150,    // Top-right
    350, 350,    // Bottom-left
    550, 350     // Bottom-right
);

// Draw the faces of the cube
DrawQuadOnBitmap(bitmap, cubeColor, frontFace);
DrawQuadOnBitmap(bitmap, cubeColor, backFace);

// Connect the front and back faces for the 3D effect
DrawLineOnBitmap(bitmap, cubeColor, 300, 200, 350, 150);
DrawLineOnBitmap(bitmap, cubeColor, 500, 200, 550, 150);
DrawLineOnBitmap(bitmap, cubeColor, 300, 400, 350, 350);
DrawLineOnBitmap(bitmap, cubeColor, 500, 400, 550, 350);

while (!window.CloseRequested)
{
    ProcessEvents();
    // Draw the bitmap to the window
    DrawBitmap(bitmap, 0, 0);
    // Refresh the window
    RefreshScreen();
}

FreeBitmap(bitmap);
CloseWindow(window);

Object-Oriented

using SplashKitSDK;

namespace DrawQuadOnBitmapExample
{
    public class Program
    {
        public static void Main()
        {
            // Create a window and bitmap to draw on
            Window window = new Window("Cube", 800, 600);
            Bitmap bitmap = new Bitmap("cube", 800, 600);

            // Fill background with light color
            bitmap.Clear(Color.White);

            // Define the color for the cube
            Color cubeColor = Color.Blue;

            // Define the coordinates of the front and back faces of the cube
            Quad frontFace = SplashKit.QuadFrom(
                300, 200,    // Top-left
                500, 200,    // Top-right
                300, 400,    // Bottom-left
                500, 400     // Bottom-right
            );

            Quad backFace = SplashKit.QuadFrom(
                350, 150,    // Top-left
                550, 150,    // Top-right
                350, 350,    // Bottom-left
                550, 350     // Bottom-right
            );

            // Draw the faces of the cube
            bitmap.DrawQuad(cubeColor, frontFace);
            bitmap.DrawQuad(cubeColor, backFace);

            // Connect the front and back faces for the 3D effect
            bitmap.DrawLine(cubeColor, 300, 200, 350, 150);
            bitmap.DrawLine(cubeColor, 500, 200, 550, 150);
            bitmap.DrawLine(cubeColor, 300, 400, 350, 350);
            bitmap.DrawLine(cubeColor, 500, 400, 550, 350);

            while (!window.CloseRequested)
            {
                SplashKit.ProcessEvents();
                // Draw the bitmap to the window
                window.DrawBitmap(bitmap, 0, 0);
                // Refresh the window
                SplashKit.RefreshScreen();
            }

            bitmap.Free();
            window.Close();
        }
    }
}

Python

from splashkit import *

# Create a window and bitmap to draw on
window = open_window("Cube", 800, 600)
bitmap = create_bitmap("cube", 800, 600)

# Fill background with light color
clear_bitmap(bitmap, color_white())

# Define the color for the cube
cube_color = color_blue()

# Define the coordinates of the front and back faces of the cube
front_face = quad_from(
    300, 200,    # Top-left
    500, 200,    # Top-right
    300, 400,    # Bottom-left
    500, 400     # Bottom-right
)

back_face = quad_from(
    350, 150,    # Top-left
    550, 150,    # Top-right
    350, 350,    # Bottom-left
    550, 350     # Bottom-right
)

# Draw the faces of the cube
draw_quad_on_bitmap(bitmap, cube_color, front_face)
draw_quad_on_bitmap(bitmap, cube_color, back_face)

# Connect the front and back faces for the 3D effect
draw_line_on_bitmap(bitmap, cube_color, 300, 200, 350, 150)
draw_line_on_bitmap(bitmap, cube_color, 500, 200, 550, 150)
draw_line_on_bitmap(bitmap, cube_color, 300, 400, 350, 350)
draw_line_on_bitmap(bitmap, cube_color, 500, 400, 550, 350)

while not window_close_requested(window):
    process_events()
    # Draw the bitmap to the window
    draw_bitmap(bitmap, 0, 0)
    # Refresh the window
    refresh_screen()

free_bitmap(bitmap)
close_window(window)

Output:

---

Draw Quad On Bitmap

Draw a quad on the supplied bitmap using the supplied drawing options.

Parameters:

Name	Type	Description
destination	Bitmap	The destination bitmap
clr	Color	The color for the quad
q	Quad	The details of the quad
opts	Drawing Options	The drawing options

Signatures:

C++

void draw_quad_on_bitmap(bitmap destination, color clr, const quad &q, const drawing_options &opts)

C#

public void Bitmap.DrawQuad(Color clr, Quad q, DrawingOptions opts);
public static void SplashKit.DrawQuadOnBitmap(Bitmap destination, Color clr, Quad q, DrawingOptions opts);

Python

def draw_quad_on_bitmap_with_options(destination, clr, q, opts):

Pascal

procedure DrawQuadOnBitmap(destination: Bitmap; clr: Color; const q: Quad; const opts: DrawingOptions)

---

Draw Quad On Window

Note

This function is overloaded. The following versions exist:

• Draw Quad On Window (destination: window, clr: color, q: quad)
• Draw Quad On Window (destination: window, clr: color, q: quad, opts: drawing_options)

Draw Quad On Window

Draw a quad on the supplied window to the current window.

Parameters:

Name	Type	Description
destination	Window	The destination window
clr	Color	The color for the quad
q	Quad	The details of the quad

Signatures:

C++

void draw_quad_on_window(window destination, color clr, const quad &q)

C#

public void Window.DrawQuad(Color clr, Quad q);
public static void SplashKit.DrawQuadOnWindow(Window destination, Color clr, Quad q);

Python

def draw_quad_on_window(destination, clr, q):

Pascal

procedure DrawQuadOnWindow(destination: Window; clr: Color; const q: Quad)

Usage:

See Code Examples

Example 1: Halved Ninja Star

C++

#include "splashkit.h"

int main()
{
    // Create diamond shaped quads
    quad q1 = quad_from(400, 200, 300, 300, 300, 0, 200, 200);
    quad q2 = quad_from(400, 210, 310, 300, 600, 300, 400, 390);
    quad q3 = quad_from(200, 400, 300, 300, 300, 600, 400, 400);
    quad q4 = quad_from(200, 390, 290, 300, 0, 300, 200, 210);

    // Create two windows
    window window_1 = open_window("Diamonds On Window 1", 600, 600);
    window window_2 = open_window("Diamonds On Window 2", 600, 600);

    // Move windows to see both side by side
    move_window_to(window_1, 0, 0);
    move_window_to(window_2, window_width(window_1), 0);

    clear_screen(COLOR_WHITE);

    // Draw the first and second quad on first window
    draw_quad_on_window(window_1, COLOR_BLACK, q1);
    draw_quad_on_window(window_1, COLOR_GREEN, q2);

    // Draw the third and fourth quad on second window
    draw_quad_on_window(window_2, COLOR_RED, q3);
    draw_quad_on_window(window_2, COLOR_BLUE, q4);

    refresh_screen();
    delay(5000);
    close_all_windows();

    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

// Create diamond shaped quads
Quad q1 = QuadFrom(400, 200, 300, 300, 300, 0, 200, 200);
Quad q2 = QuadFrom(400, 210, 310, 300, 600, 300, 400, 390);
Quad q3 = QuadFrom(200, 400, 300, 300, 300, 600, 400, 400);
Quad q4 = QuadFrom(200, 390, 290, 300, 0, 300, 200, 210);

// Create two Windows
Window window1 = OpenWindow("Diamonds On Window 1", 600, 600);
Window window2 = OpenWindow("Diamonds On Window 2", 600, 600);

// Move windows to see both side by side
MoveWindowTo(window1, 0, 0);
MoveWindowTo(window2, WindowWidth(window1), 0);

ClearScreen(ColorWhite());

// Draw the first and second quad on first window
DrawQuadOnWindow(window1, ColorBlack(), q1);
DrawQuadOnWindow(window1, ColorGreen(), q2);

// Draw the third and fourth quad on second window
DrawQuadOnWindow(window2, ColorRed(), q3);
DrawQuadOnWindow(window2, ColorBlue(), q4);

RefreshScreen();
Delay(5000);
CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace DrawQuadOnWindowExample
{
    public class Program
    {
        public static void Main()
        {
            // Create diamond shaped quads
            Quad q1 = SplashKit.QuadFrom(400, 200, 300, 300, 300, 0, 200, 200);
            Quad q2 = SplashKit.QuadFrom(400, 210, 310, 300, 600, 300, 400, 390);
            Quad q3 = SplashKit.QuadFrom(200, 400, 300, 300, 300, 600, 400, 400);
            Quad q4 = SplashKit.QuadFrom(200, 390, 290, 300, 0, 300, 200, 210);

            // Create two Windows
            Window window1 = SplashKit.OpenWindow("Diamonds On Window 1", 600, 600);
            Window window2 = SplashKit.OpenWindow("Diamonds On Window 2", 600, 600);

            // Move windows to see both side by side
            window1.MoveTo(0, 0);
            window2.MoveTo(window1.Width, 0);

            SplashKit.ClearScreen(Color.White);

            // Draw the first and second quad on first window
            window1.DrawQuad(Color.Black, q1);
            window1.DrawQuad(Color.Green, q2);
            // Draw the third and fourth quad on second window
            window2.DrawQuad(Color.Red, q3);
            window2.DrawQuad(Color.Blue, q4);

            SplashKit.RefreshScreen();
            SplashKit.Delay(5000);
            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

# Create diamond shaped quads
q1 = quad_from(400, 200, 300, 300, 300, 0, 200, 200)
q2 = quad_from(400, 210, 310, 300, 600, 300, 400, 390)
q3 = quad_from(200, 400, 300, 300, 300, 600, 400, 400)
q4 = quad_from(200, 390, 290, 300, 0, 300, 200, 210)

# Create two Windows
window_1 = open_window("Diamonds On Window 1", 600, 600)
window_2 = open_window("Diamonds On Window 2", 600, 600)

# Move windows to see both side by side
move_window_to(window_1, 0, 0)
move_window_to(window_2, window_width(window_1), 0)

clear_screen(color_white())

# Draw the first and second quad on first window
draw_quad_on_window(window_1, color_black(), q1)
draw_quad_on_window(window_1, color_green(), q2)

# Draw the third and fourth quad on second window
draw_quad_on_window(window_2, color_red(), q3)
draw_quad_on_window(window_2, color_blue(), q4)

refresh_screen()
delay(5000)
close_all_windows()

Output:

---

Draw Quad On Window

Draw a quad on the supplied window using the supplied drawing options.

Parameters:

Name	Type	Description
destination	Window	The destination window
clr	Color	The color for the quad
q	Quad	The details of the quad
opts	Drawing Options	The drawing options

Signatures:

C++

void draw_quad_on_window(window destination, color clr, const quad &q, const drawing_options &opts)

C#

public void Window.DrawQuad(Color clr, Quad q, DrawingOptions opts);
public static void SplashKit.DrawQuadOnWindow(Window destination, Color clr, Quad q, DrawingOptions opts);

Python

def draw_quad_on_window_with_options(destination, clr, q, opts):

Pascal

procedure DrawQuadOnWindow(destination: Window; clr: Color; const q: Quad; const opts: DrawingOptions)

---

Draw Rectangle

Note

This function is overloaded. The following versions exist:

• Draw Rectangle (clr: color, rect: rectangle)
• Draw Rectangle (clr: color, rect: rectangle, opts: drawing_options)
• Draw Rectangle (clr: color, x: double, y: double, width: double, height: double)
• Draw Rectangle (clr: color, x: double, y: double, width: double, height: double, opts: drawing_options)

Draw Rectangle

Draw a rectangle onto the current window.

Parameters:

Name	Type	Description
clr	Color	The color of the rectangle
rect	Rectangle	The rectangle to draw

Signatures:

C++

void draw_rectangle(color clr, const rectangle &rect)

C#

public static void SplashKit.DrawRectangle(Color clr, Rectangle rect);

Python

def draw_rectangle_record(clr, rect):

Pascal

procedure DrawRectangle(clr: Color; const rect: Rectangle)

Usage:

See Implementations in Guides

• Reading Text

---

Draw Rectangle

Draw a rectangle using the supplied drawing options.

Parameters:

Name	Type	Description
clr	Color	The color of the rectangle
rect	Rectangle	The rectangle to draw
opts	Drawing Options	The drawing options

Signatures:

C++

void draw_rectangle(color clr, const rectangle &rect, const drawing_options &opts)

C#

public static void SplashKit.DrawRectangle(Color clr, Rectangle rect, DrawingOptions opts);

Python

def draw_rectangle_record_with_options(clr, rect, opts):

Pascal

procedure DrawRectangle(clr: Color; const rect: Rectangle; const opts: DrawingOptions)

---

Draw Rectangle

Draw a rectangle to the current window.

Parameters:

Name	Type	Description
clr	Color	The color of the rectangle
x	Double	The distance from the left of the window/bitmap to the rectangle
y	Double	The distance from the top of the window/bitmap to the rectangle
width	Double	The width of the rectangle
height	Double	The height of the rectangle

Signatures:

C++

void draw_rectangle(color clr, double x, double y, double width, double height)

C#

public static void SplashKit.DrawRectangle(Color clr, double x, double y, double width, double height);

Python

def draw_rectangle(clr, x, y, width, height):

Pascal

procedure DrawRectangle(clr: Color; x: Double; y: Double; width: Double; height: Double)

Usage:

See Code Examples

Example 1: Rectangle Staircase

C++

#include "splashkit.h"

int main()
{
    open_window("Draw Rectangle", 800, 600);
    clear_screen(COLOR_WHITE);

    for (int i = 0; i < 21; i++)
    {
        int x = i * 40 - 40;
        int y = 600 - i * 30;

        // Draw rectangle using x and y above with width 40 and height 30
        draw_rectangle(random_rgb_color(255), x, y, 40, 30);
    }

    refresh_screen();
    delay(4000);
    close_all_windows();

    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

OpenWindow("Draw Rectangle", 800, 600);
ClearScreen(ColorWhite());

for (int i = 0; i < 21; i++)
{
    int x = i * 40 - 40;
    int y = 600 - i * 30;

    // Draw rectangle using x and y above with width 40 and height 30
    DrawRectangle(RandomRGBColor(255), x, y, 40, 30);
}

RefreshScreen();
Delay(4000);
CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace DrawRectangleExample
{
    public class Program
    {
        public static void Main()
        {
            Window window = new Window("Draw Rectangle", 800, 600);
            window.Clear(Color.White);

            for (int i = 0; i < 21; i++)
            {
                int x = i * 40 - 40;
                int y = 600 - i * 30;

                // Draw rectangle using x and y above with width 40 and height 30
                SplashKit.DrawRectangle(SplashKit.RandomRGBColor(255), x, y, 40, 30);
            }

            window.Refresh();
            SplashKit.Delay(4000);
            window.Close();
        }
    }
}

Python

from splashkit import *

open_window("Draw Rectangle", 800, 600)
clear_screen(color_white())

for i in range(21):
    x = i * 40 - 40
    y = 600 - i * 30

    # Draw rectangle using x and y above with width 40 and height 30
    draw_rectangle(random_rgb_color(255), x, y, 40, 30)

refresh_screen()
delay(4000)
close_all_windows()

Output:

---

Draw Rectangle

Draw a rectangle using the supplied drawing options.

Parameters:

Name	Type	Description
clr	Color	The color of the rectangle
x	Double	The distance from the left of the window/bitmap to the rectangle
y	Double	The distance from the top of the window/bitmap to the rectangle
width	Double	The width of the rectangle
height	Double	The height of the rectangle
opts	Drawing Options	The drawing options

Signatures:

C++

void draw_rectangle(color clr, double x, double y, double width, double height, const drawing_options &opts)

C#

public static void SplashKit.DrawRectangle(Color clr, double x, double y, double width, double height, DrawingOptions opts);

Python

def draw_rectangle_with_options(clr, x, y, width, height, opts):

Pascal

procedure DrawRectangle(clr: Color; x: Double; y: Double; width: Double; height: Double; const opts: DrawingOptions)

---

Draw Rectangle On Bitmap

Note

This function is overloaded. The following versions exist:

• Draw Rectangle On Bitmap (destination: bitmap, clr: color, rect: rectangle)
• Draw Rectangle On Bitmap (destination: bitmap, clr: color, rect: rectangle, opts: drawing_options)
• Draw Rectangle On Bitmap (destination: bitmap, clr: color, x: double, y: double, width: double, height: double)
• Draw Rectangle On Bitmap (destination: bitmap, clr: color, x: double, y: double, width: double, height: double, opts: drawing_options)

Draw Rectangle On Bitmap

Draw a rectangle to the bitmap using the supplied rect. The rectangle is centred on its x, y coordinates, and has the provided width and height.

Parameters:

Name	Type	Description
destination	Bitmap	The destination bitmap
clr	Color	The color of the rectangle
rect	Rectangle	the rectangle to be drawn to the bitmap

Signatures:

C++

void draw_rectangle_on_bitmap(bitmap destination, color clr, const rectangle &rect)

C#

public void Bitmap.DrawRectangle(Color clr, Rectangle rect);
public static void SplashKit.DrawRectangleOnBitmap(Bitmap destination, Color clr, Rectangle rect);

Python

def draw_rectangle_on_bitmap_record(destination, clr, rect):

Pascal

procedure DrawRectangleOnBitmap(destination: Bitmap; clr: Color; const rect: Rectangle)

---

Draw Rectangle On Bitmap

Draw a rectangle to the bitmap using the supplied rect and drawing options. The rectangle is centred on its x, y coordinates, and has the provided width and height.

Parameters:

Name	Type	Description
destination	Bitmap	The destination bitmap
clr	Color	The color of the rectangle
rect	Rectangle	the rectangle to be drawn to the bitmap
opts	Drawing Options	Drawing options to configure the drawing operation

Signatures:

C++

void draw_rectangle_on_bitmap(bitmap destination, color clr, const rectangle &rect, const drawing_options &opts)

C#

public void Bitmap.DrawRectangle(Color clr, Rectangle rect, DrawingOptions opts);
public static void SplashKit.DrawRectangleOnBitmap(Bitmap destination, Color clr, Rectangle rect, DrawingOptions opts);

Python

def draw_rectangle_on_bitmap_record_with_options(destination, clr, rect, opts):

Pascal

procedure DrawRectangleOnBitmap(destination: Bitmap; clr: Color; const rect: Rectangle; const opts: DrawingOptions)

---

Draw Rectangle On Bitmap

Draw a rectangle to the bitmap using. The rectangle is centred on its x, y coordinates, and has the provided width and height.

Parameters:

Name	Type	Description
destination	Bitmap	The destination bitmap
clr	Color	The color of the rectangle
x	Double	The x location of the rectangle
y	Double	The y location of the rectangle
width	Double	The width of the rectangle
height	Double	The height of the rectangle

Signatures:

C++

void draw_rectangle_on_bitmap(bitmap destination, color clr, double x, double y, double width, double height)

C#

public void Bitmap.DrawRectangle(Color clr, double x, double y, double width, double height);
public static void SplashKit.DrawRectangleOnBitmap(Bitmap destination, Color clr, double x, double y, double width, double height);

Python

def draw_rectangle_on_bitmap(destination, clr, x, y, width, height):

Pascal

procedure DrawRectangleOnBitmap(destination: Bitmap; clr: Color; x: Double; y: Double; width: Double; height: Double)

---

Draw Rectangle On Bitmap

Draw a rectangle to the bitmap using the supplied drawing options. The rectangle is centred on its x, y coordinates, and has the provided width and height.

Parameters:

Name	Type	Description
destination	Bitmap	The destination bitmap
clr	Color	The color of the rectangle
x	Double	The x location of the rectangle
y	Double	The y location of the rectangle
width	Double	The width of the rectangle
height	Double	The height of the rectangle
opts	Drawing Options	Drawing options to configure the drawing operation

Signatures:

C++

void draw_rectangle_on_bitmap(bitmap destination, color clr, double x, double y, double width, double height, drawing_options opts)

C#

public void Bitmap.DrawRectangle(Color clr, double x, double y, double width, double height, DrawingOptions opts);
public static void SplashKit.DrawRectangleOnBitmap(Bitmap destination, Color clr, double x, double y, double width, double height, DrawingOptions opts);

Python

def draw_rectangle_on_bitmap_with_options(destination, clr, x, y, width, height, opts):

Pascal

procedure DrawRectangleOnBitmap(destination: Bitmap; clr: Color; x: Double; y: Double; width: Double; height: Double; opts: DrawingOptions)

---

Draw Rectangle On Window

Note

This function is overloaded. The following versions exist:

• Draw Rectangle On Window (destination: window, clr: color, rect: rectangle)
• Draw Rectangle On Window (destination: window, clr: color, rect: rectangle, opts: drawing_options)
• Draw Rectangle On Window (destination: window, clr: color, x: double, y: double, width: double, height: double)
• Draw Rectangle On Window (destination: window, clr: color, x: double, y: double, width: double, height: double, opts: drawing_options)

Draw Rectangle On Window

Draw a rectangle to the window using the supplied rect. The rectangle is centred on its x, y coordinates, and has the provided width and height.

Parameters:

Name	Type	Description
destination	Window	The destination window
clr	Color	The color of the rectangle
rect	Rectangle	the rectangle to be drawn to the window

Signatures:

C++

void draw_rectangle_on_window(window destination, color clr, const rectangle &rect)

C#

public void Window.DrawRectangle(Color clr, Rectangle rect);
public static void SplashKit.DrawRectangleOnWindow(Window destination, Color clr, Rectangle rect);

Python

def draw_rectangle_on_window_record(destination, clr, rect):

Pascal

procedure DrawRectangleOnWindow(destination: Window; clr: Color; const rect: Rectangle)

---

Draw Rectangle On Window

Draw a rectangle to the window using the supplied rect and drawing options. The rectangle is centred on its x, y coordinates, and has the provided width and height.

Parameters:

Name	Type	Description
destination	Window	The destination window
clr	Color	The color of the rectangle
rect	Rectangle	the rectangle to be drawn to the window
opts	Drawing Options	Drawing options to configure the drawing operation

Signatures:

C++

void draw_rectangle_on_window(window destination, color clr, const rectangle &rect, const drawing_options &opts)

C#

public void Window.DrawRectangle(Color clr, Rectangle rect, DrawingOptions opts);
public static void SplashKit.DrawRectangleOnWindow(Window destination, Color clr, Rectangle rect, DrawingOptions opts);

Python

def draw_rectangle_on_window_record_with_options(destination, clr, rect, opts):

Pascal

procedure DrawRectangleOnWindow(destination: Window; clr: Color; const rect: Rectangle; const opts: DrawingOptions)

---

Draw Rectangle On Window

Draw a rectangle to the window using. The rectangle is centred on its x, y coordinates, and has the provided width and height.

Parameters:

Name	Type	Description
destination	Window	The destination window
clr	Color	The color of the rectangle
x	Double	The x location of the rectangle
y	Double	The y location of the rectangle
width	Double	The width of the rectangle
height	Double	The height of the rectangle

Signatures:

C++

void draw_rectangle_on_window(window destination, color clr, double x, double y, double width, double height)

C#

public void Window.DrawRectangle(Color clr, double x, double y, double width, double height);
public static void SplashKit.DrawRectangleOnWindow(Window destination, Color clr, double x, double y, double width, double height);

Python

def draw_rectangle_on_window(destination, clr, x, y, width, height):

Pascal

procedure DrawRectangleOnWindow(destination: Window; clr: Color; x: Double; y: Double; width: Double; height: Double)

---

Draw Rectangle On Window

Draw a rectangle to the window using the supplied drawing options. The rectangle is centred on its x, y coordinates, and has the provided width and height.

Parameters:

Name	Type	Description
destination	Window	The destination window
clr	Color	The color of the rectangle
x	Double	The x location of the rectangle
y	Double	The y location of the rectangle
width	Double	The width of the rectangle
height	Double	The height of the rectangle
opts	Drawing Options	Drawing options to configure the drawing operation

Signatures:

C++

void draw_rectangle_on_window(window destination, color clr, double x, double y, double width, double height, drawing_options opts)

C#

public void Window.DrawRectangle(Color clr, double x, double y, double width, double height, DrawingOptions opts);
public static void SplashKit.DrawRectangleOnWindow(Window destination, Color clr, double x, double y, double width, double height, DrawingOptions opts);

Python

def draw_rectangle_on_window_with_options(destination, clr, x, y, width, height, opts):

Pascal

procedure DrawRectangleOnWindow(destination: Window; clr: Color; x: Double; y: Double; width: Double; height: Double; opts: DrawingOptions)

---

Fill Quad

Note

This function is overloaded. The following versions exist:

• Fill Quad (clr: color, q: quad)
• Fill Quad (clr: color, q: quad, opts: drawing_options)

Fill Quad

Fill a quad on the current window.

Parameters:

Name	Type	Description
clr	Color	The color for the quad
q	Quad	The details of the quad

Signatures:

C++

void fill_quad(color clr, const quad &q)

C#

public static void SplashKit.FillQuad(Color clr, Quad q);

Python

def fill_quad(clr, q):

Pascal

procedure FillQuad(clr: Color; const q: Quad)

Usage:

See Code Examples

Example 1: Coloured Star

C++

#include "splashkit.h"

int main()
{
    // Create 4 diamond shapes using quads
    quad q1 = quad_from(400, 200, 300, 300, 300, 0, 200, 200);
    quad q2 = quad_from(400, 210, 310, 300, 600, 300, 400, 390);
    quad q3 = quad_from(200, 400, 300, 300, 300, 600, 400, 400);
    quad q4 = quad_from(200, 390, 290, 300, 0, 300, 200, 210);

    open_window("Coloured Star", 600, 600);
    clear_screen(COLOR_WHITE);

    // Draw filled-in quads
    fill_quad(COLOR_BLACK, q1);
    fill_quad(COLOR_GREEN, q2);
    fill_quad(COLOR_RED, q3);
    fill_quad(COLOR_BLUE, q4);

    refresh_screen();
    delay(5000);
    close_all_windows();

    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

// Create 4 diamond shapes using quads
Quad Q1 = QuadFrom(400, 200, 300, 300, 300, 0, 200, 200);
Quad Q2 = QuadFrom(400, 210, 310, 300, 600, 300, 400, 390);
Quad Q3 = QuadFrom(200, 400, 300, 300, 300, 600, 400, 400);
Quad Q4 = QuadFrom(200, 390, 290, 300, 0, 300, 200, 210);

OpenWindow("Coloured Star", 600, 600);
ClearScreen(ColorWhite());

// Draw filled-in quads
FillQuad(ColorBlack(), Q1);
FillQuad(ColorGreen(), Q2);
FillQuad(ColorRed(), Q3);
FillQuad(ColorBlue(), Q4);

RefreshScreen();
Delay(5000);
CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace FillQuadExample
{
    public class Program
    {
        public static void Main()
        {
            // Create 4 diamond shapes using quads
            Quad Q1 = SplashKit.QuadFrom(400, 200, 300, 300, 300, 0, 200, 200);
            Quad Q2 = SplashKit.QuadFrom(400, 210, 310, 300, 600, 300, 400, 390);
            Quad Q3 = SplashKit.QuadFrom(200, 400, 300, 300, 300, 600, 400, 400);
            Quad Q4 = SplashKit.QuadFrom(200, 390, 290, 300, 0, 300, 200, 210);

            SplashKit.OpenWindow("Coloured Star", 600, 600);
            SplashKit.ClearScreen(Color.White);

            // Draw filled-in quads
            SplashKit.FillQuad(Color.Black, Q1);
            SplashKit.FillQuad(Color.Green, Q2);
            SplashKit.FillQuad(Color.Red, Q3);
            SplashKit.FillQuad(Color.Blue, Q4);

            SplashKit.RefreshScreen();
            SplashKit.Delay(5000);
            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

# Create 4 diamond shapes using quads
q1 = quad_from(400, 200, 300, 300, 300, 0, 200, 200)
q2 = quad_from(400, 210, 310, 300, 600, 300, 400, 390)
q3 = quad_from(200, 400, 300, 300, 300, 600, 400, 400)
q4 = quad_from(200, 390, 290, 300, 0, 300, 200, 210)

# Create Window
open_window("Coloured Star", 600, 600)
clear_screen(color_white())

# Draw filled-in quads
fill_quad(color_black(), q1)
fill_quad(color_green(), q2)
fill_quad(color_red(), q3)
fill_quad(color_blue(), q4)

refresh_screen()
delay(5000)
close_all_windows()

Output:

---

Fill Quad

Fill a quad using the supplied drawing options.

Parameters:

Name	Type	Description
clr	Color	The color for the quad
q	Quad	The details of the quad
opts	Drawing Options	The drawing options

Signatures:

C++

void fill_quad(color clr, const quad &q, const drawing_options &opts)

C#

public static void SplashKit.FillQuad(Color clr, Quad q, DrawingOptions opts);

Python

def fill_quad_with_options(clr, q, opts):

Pascal

procedure FillQuad(clr: Color; const q: Quad; const opts: DrawingOptions)

---

Fill Quad On Bitmap

Note

This function is overloaded. The following versions exist:

• Fill Quad On Bitmap (destination: bitmap, clr: color, q: quad)
• Fill Quad On Bitmap (destination: bitmap, clr: color, q: quad, opts: drawing_options)

Fill Quad On Bitmap

Fill a quad on the supplied bitmap on the current bitmap.

Parameters:

Name	Type	Description
destination	Bitmap	The destination bitmap
clr	Color	The color for the quad
q	Quad	The details of the quad

Signatures:

C++

void fill_quad_on_bitmap(bitmap destination, color clr, const quad &q)

C#

public void Bitmap.FillQuad(Color clr, Quad q);
public static void SplashKit.FillQuadOnBitmap(Bitmap destination, Color clr, Quad q);

Python

def fill_quad_on_bitmap(destination, clr, q):

Pascal

procedure FillQuadOnBitmap(destination: Bitmap; clr: Color; const q: Quad)

Usage:

See Code Examples

Example 1: Microsoft Windows Logo

C++

#include "splashkit.h"

int main()
{
    // Create a window and bitmap for the window
    window window = open_window("Windows Logo", 400, 300);
    bitmap bitmap = create_bitmap("Windows Logo Bitmap", 400, 300);

    // Fill background with windows blue
    clear_bitmap(bitmap, rgba_color(51, 118, 212, 255));

    // Draw the four Window panels
    quad panels[] = {
        quad_from(
            85, 50,
            180, 41,
            85, 130,
            180, 130
        ),
        quad_from(
            193, 40,
            323, 26,
            193, 130,
            323, 130
        ),
        quad_from(
            85, 143,
            180, 143,
            85, 222,
            180, 233
        ),
        quad_from(
            193, 143,
            323, 143,
            193, 235,
            323, 250
        )
    };

    // Draw each panel
    for (int i = 0; i < 4; i++)
    {
        fill_quad_on_bitmap(bitmap, COLOR_WHITE, panels[i]);
    }

    while (!window_close_requested(window))
    {
        process_events();
        // Draw the bitmap to the window
        draw_bitmap(bitmap, 0, 0);
        // Refresh the window
        refresh_screen();
    }

    free_bitmap(bitmap);
    return 0;
}

C#

Top-level Statements

using static SplashKitSDK.SplashKit;
using SplashKitSDK;

// Create a window and bitmap for the window
Window window = OpenWindow("Windows Logo", 400, 300);
Bitmap bitmap = CreateBitmap("Windows Logo Bitmap", 400, 300);

// Fill background with windows blue
ClearBitmap(bitmap, RGBAColor(51, 118, 212, 255));

// Draw the four Window panels
Quad[] panels = {
    QuadFrom(
        85, 50,
        180, 41,
        85, 130,
        180, 130
    ),
    QuadFrom(
        193, 40,
        323, 26,
        193, 130,
        323, 130
    ),
    QuadFrom(
        85, 143,
        180, 143,
        85, 222,
        180, 233
    ),
    QuadFrom(
        193, 143,
        323, 143,
        193, 235,
        323, 250
    )
};

// Draw each panel
for (int i = 0; i < panels.Length; i++)
{
    FillQuadOnBitmap(bitmap, ColorWhite(), panels[i]);
}

while (!window.CloseRequested)
{
    ProcessEvents();
    // Draw the bitmap to the window
    DrawBitmap(bitmap, 0, 0);
    // Refresh the window
    RefreshScreen();
}

FreeBitmap(bitmap);

Object-Oriented

using SplashKitSDK;

namespace FillQuadOnBitmap
{
    public class Program
    {
        public static void Main()
        {
            // Create a window and bitmap for the window
            Window window = new Window("Windows Logo", 400, 300);
            Bitmap bitmap = new Bitmap("Windows Logo Bitmap", 400, 300);

            // Fill background with windows blue
            bitmap.Clear(Color.RGBAColor(51, 118, 212, 255));

            // Create color
            Color color = Color.White;

            // Draw the four Window panels
            Quad[] panels = {
                SplashKit.QuadFrom(
                    85, 50,
                    180, 41,
                    85, 130,
                    180, 130
                ),
                SplashKit.QuadFrom(
                    193, 40,
                    323, 26,
                    193, 130,
                    323, 130
                ),
                SplashKit.QuadFrom(
                    85, 143,
                    180, 143,
                    85, 222,
                    180, 233
                ),
                SplashKit.QuadFrom(
                    193, 143,
                    323, 143,
                    193, 235,
                    323, 250
                )
            };

            // Draw each panel
            for (int i = 0; i < panels.Length; i++)
            {
                bitmap.FillQuad(color, panels[i]);
            }

            while (!window.CloseRequested)
            {
                SplashKit.ProcessEvents();
                // Draw the bitmap to the window
                window.DrawBitmap(bitmap, 0, 0);
                // Refresh the window
                SplashKit.RefreshScreen();
            }

            bitmap.Free();
        }
    }
}

Python

from splashkit import *

# Create a window and bitmap for the window
window = open_window("Windows Logo", 400, 300)
bitmap = create_bitmap("Windows Logo Bitmap", 400, 300)

# Fill background with windows blue
clear_bitmap(bitmap, rgba_color(51, 118, 212, 255))

# Draw the four Window panels
panels = [
    quad_from(
        85, 50,
        180, 41,
        85, 130,
        180, 130
    ),
    quad_from(
        193, 40,
        323, 26,
        193, 130,
        323, 130
    ),
    quad_from(
        85, 143,
        180, 143,
        85, 222,
        180, 233
    ),
    quad_from(
        193, 143,
        323, 143,
        193, 235,
        323, 250
    )
]

# Draw each panel
for panel in panels:
    fill_quad_on_bitmap(bitmap, color_white(), panel)

while not window_close_requested(window):
    process_events()
    # Draw the bitmap to the window
    draw_bitmap(bitmap, 0, 0)
    # Refresh the window
    refresh_screen()

free_bitmap(bitmap)

Output:

---

Fill Quad On Bitmap

Fill a quad on the supplied bitmap using the supplied drawing options.

Parameters:

Name	Type	Description
destination	Bitmap	The destination bitmap
clr	Color	The color for the quad
q	Quad	The details of the quad
opts	Drawing Options	The drawing options

Signatures:

C++

void fill_quad_on_bitmap(bitmap destination, color clr, const quad &q, const drawing_options &opts)

C#

public void Bitmap.FillQuad(Color clr, Quad q, DrawingOptions opts);
public static void SplashKit.FillQuadOnBitmap(Bitmap destination, Color clr, Quad q, DrawingOptions opts);

Python

def fill_quad_on_bitmap_with_options(destination, clr, q, opts):

Pascal

procedure FillQuadOnBitmap(destination: Bitmap; clr: Color; const q: Quad; const opts: DrawingOptions)

---

Fill Quad On Window

Note

This function is overloaded. The following versions exist:

• Fill Quad On Window (destination: window, clr: color, q: quad)
• Fill Quad On Window (destination: window, clr: color, q: quad, opts: drawing_options)

Fill Quad On Window

Fill a quad on the supplied window on the current window.

Parameters:

Name	Type	Description
destination	Window	The destination window
clr	Color	The color for the quad
q	Quad	The details of the quad

Signatures:

C++

void fill_quad_on_window(window destination, color clr, const quad &q)

C#

public void Window.FillQuad(Color clr, Quad q);
public static void SplashKit.FillQuadOnWindow(Window destination, Color clr, Quad q);

Python

def fill_quad_on_window(destination, clr, q):

Pascal

procedure FillQuadOnWindow(destination: Window; clr: Color; const q: Quad)

Usage:

See Code Examples

Example 1: Halved Coloured Star

C++

#include "splashkit.h"

int main()
{
    // Create diamond shaped quads
    quad q1 = quad_from(400, 200, 300, 300, 300, 0, 200, 200);
    quad q2 = quad_from(400, 210, 310, 300, 600, 300, 400, 390);
    quad q3 = quad_from(200, 400, 300, 300, 300, 600, 400, 400);
    quad q4 = quad_from(200, 390, 290, 300, 0, 300, 200, 210);

    // Create two Windows
    window window1 = open_window("Filled Diamond On Window 1", 600, 600);
    window window2 = open_window("Filled Diamond On Window 2", 600, 600);

    // Move windows to see both side by side
    move_window_to(window1, 0, 0);
    move_window_to(window2, window_width(window1), 0);

    clear_screen(COLOR_WHITE);

    // Draw the first and second quad on first window
    fill_quad_on_window(window1, COLOR_BLACK, q1);
    fill_quad_on_window(window1, COLOR_GREEN, q2);

    // Draw the third and fourth quad on second window
    fill_quad_on_window(window2, COLOR_RED, q3);
    fill_quad_on_window(window2, COLOR_BLUE, q4);

    refresh_screen();
    delay(5000);
    close_all_windows();
    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

// Create diamond shaped quads
Quad q1 = QuadFrom(400, 200, 300, 300, 300, 0, 200, 200);
Quad q2 = QuadFrom(400, 210, 310, 300, 600, 300, 400, 390);
Quad q3 = QuadFrom(200, 400, 300, 300, 300, 600, 400, 400);
Quad q4 = QuadFrom(200, 390, 290, 300, 0, 300, 200, 210);

// Create two Windows
Window window1 = OpenWindow("Filled Diamond On Window 1", 600, 600);
Window window2 = OpenWindow("Filled Diamond On Window 2", 600, 600);

// Move windows to see both side by side
MoveWindowTo(window1, 0, 0);
MoveWindowTo(window2, WindowWidth(window1), 0);

ClearScreen(ColorWhite());

// Draw the first and second quad on first window
FillQuadOnWindow(window1, ColorBlack(), q1);
FillQuadOnWindow(window1, ColorGreen(), q2);

// Draw the third and fourth quad on second window
FillQuadOnWindow(window2, ColorRed(),  q3);
FillQuadOnWindow(window2, ColorBlue(), q4);

RefreshScreen();
Delay(5000);
CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace FillQuadOnWindowExample
{
    public class Program
    {
        public static void Main()
        {
            // Create diamond shaped quads
            Quad q1 = SplashKit.QuadFrom(400, 200, 300, 300, 300, 0, 200, 200);
            Quad q2 = SplashKit.QuadFrom(400, 210, 310, 300, 600, 300, 400, 390);
            Quad q3 = SplashKit.QuadFrom(200, 400, 300, 300, 300, 600, 400, 400);
            Quad q4 = SplashKit.QuadFrom(200, 390, 290, 300, 0, 300, 200, 210);

            // Create two Windows
            Window window1 = new Window("Filled Diamond On Window 1", 600, 600);
            Window window2 = new Window("Filled Diamond On Window 2", 600, 600);

            // Move windows to see both side by side
            window1.MoveTo(0, 0);
            window2.MoveTo(window1.Width, 0);

            SplashKit.ClearScreen(Color.White);

            // Draw the first and second quad on first window
            window1.FillQuad(Color.Black, q1);
            window1.FillQuad(Color.Green, q2);

            // Draw the third and fourth quad on second window
            window2.FillQuad(Color.Red, q3);
            window2.FillQuad(Color.Blue, q4);

            SplashKit.RefreshScreen();
            SplashKit.Delay(5000);
            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

# Create diamond shaped quads
q1 = quad_from(400, 200, 300, 300, 300, 0, 200, 200)
q2 = quad_from(400, 210, 310, 300, 600, 300, 400, 390)
q3 = quad_from(200, 400, 300, 300, 300, 600, 400, 400)
q4 = quad_from(200, 390, 290, 300, 0, 300, 200, 210)

# Create two Windows
window1 = open_window("Filled Diamond On Window 1", 600, 600)
window2 = open_window("Filled Diamond On Window 2", 600, 600)

# Move windows to see both side by side
move_window_to(window1, 0, 0)
move_window_to(window2, window_width(window1), 0)

clear_screen(color_white())

# Draw the first and second quad on first window
fill_quad_on_window(window1, color_black(), q1)
fill_quad_on_window(window1, color_green(), q2)

# Draw the third and fourth quad on second window
fill_quad_on_window(window2, color_red(), q3)
fill_quad_on_window(window2, color_blue(), q4)

refresh_screen()
delay(5000)
close_all_windows()

Output:

---

Fill Quad On Window

Fill a quad on the supplied window using the supplied drawing options.

Parameters:

Name	Type	Description
destination	Window	The destination window
clr	Color	The color for the quad
q	Quad	The details of the quad
opts	Drawing Options	The drawing options

Signatures:

C++

void fill_quad_on_window(window destination, color clr, const quad &q, const drawing_options &opts)

C#

public static void SplashKit.FillQuadOnWindow(Window destination, Color clr, Quad q, DrawingOptions opts);

Python

def fill_quad_on_window_with_options(destination, clr, q, opts):

Pascal

procedure FillQuadOnWindow(destination: Window; clr: Color; const q: Quad; const opts: DrawingOptions)

---

Fill Rectangle

Note

This function is overloaded. The following versions exist:

• Fill Rectangle (clr: color, rect: rectangle)
• Fill Rectangle (clr: color, rect: rectangle, opts: drawing_options)
• Fill Rectangle (clr: color, x: double, y: double, width: double, height: double)
• Fill Rectangle (clr: color, x: double, y: double, width: double, height: double, opts: drawing_options)

Fill Rectangle

Fill a rectangle onto the current window.

Parameters:

Name	Type	Description
clr	Color	The color of the rectangle
rect	Rectangle	The rectangle to draw

Signatures:

C++

void fill_rectangle(color clr, const rectangle &rect)

C#

public static void SplashKit.FillRectangle(Color clr, Rectangle rect);

Python

def fill_rectangle_record(clr, rect):

Pascal

procedure FillRectangle(clr: Color; const rect: Rectangle)

---

Fill Rectangle

Fills a rectangle using the supplied drawing options.

Parameters:

Name	Type	Description
clr	Color	The color of the rectangle
rect	Rectangle	The rectangle to draw
opts	Drawing Options	The drawing options

Signatures:

C++

void fill_rectangle(color clr, const rectangle &rect, const drawing_options &opts)

C#

public static void SplashKit.FillRectangle(Color clr, Rectangle rect, DrawingOptions opts);

Python

def fill_rectangle_record_with_options(clr, rect, opts):

Pascal

procedure FillRectangle(clr: Color; const rect: Rectangle; const opts: DrawingOptions)

---

Fill Rectangle

Fills a rectangle to the current window.

Parameters:

Name	Type	Description
clr	Color	The color of the rectangle
x	Double	The distance from the left of the window/bitmap to the rectangle
y	Double	The distance from the top of the window/bitmap to the rectangle
width	Double	The width of the rectangle
height	Double	The height of the rectangle

Signatures:

C++

void fill_rectangle(color clr, double x, double y, double width, double height)

C#

public static void SplashKit.FillRectangle(Color clr, double x, double y, double width, double height);

Python

def fill_rectangle(clr, x, y, width, height):

Pascal

procedure FillRectangle(clr: Color; x: Double; y: Double; width: Double; height: Double)

Usage:

See Implementations in Guides

• Get Started with SplashKit Audio
• SplashKit Camera
• Drawing using Procedures

See Code Examples

Example 1: Basic Blue Rectangle

C++

#include "splashkit.h"

int main()
{
    open_window("Fill rectangle", 800, 600);

    clear_screen();
    fill_rectangle(COLOR_BLUE, 200, 200, 200, 100);
    refresh_screen();

    delay(4000);

    close_all_windows();

    return 0;
}

C#

Top-level Statements

using static SplashKitSDK.SplashKit;

OpenWindow("Fill rectangle", 800, 600);

ClearScreen();
FillRectangle(ColorBlue(), 200, 200, 200, 100);
RefreshScreen();

Delay(4000);

CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace FillRectangleExample
{
    public class Program
    {
        public static void Main()
        {
            SplashKit.OpenWindow("Fill rectangle", 800, 600);

            SplashKit.ClearScreen();
            SplashKit.FillRectangle(Color.Blue, 200, 200, 200, 100);
            SplashKit.RefreshScreen();

            SplashKit.Delay(4000);

            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

open_window("Fill rectangle", 800, 600)

clear_screen_to_white()
fill_rectangle(color_blue(), 200, 200, 200, 100)
refresh_screen()

delay(4000)

close_all_windows()

Output:

---

Fill Rectangle

Fills a rectangle using the supplied drawing options.

Parameters:

Name	Type	Description
clr	Color	The color of the rectangle
x	Double	The distance from the left of the window/bitmap to the rectangle
y	Double	The distance from the top of the window/bitmap to the rectangle
width	Double	The width of the rectangle
height	Double	The height of the rectangle
opts	Drawing Options	The drawing options

Signatures:

C++

void fill_rectangle(color clr, double x, double y, double width, double height, const drawing_options &opts)

C#

public static void SplashKit.FillRectangle(Color clr, double x, double y, double width, double height, DrawingOptions opts);

Python

def fill_rectangle_with_options(clr, x, y, width, height, opts):

Pascal

procedure FillRectangle(clr: Color; x: Double; y: Double; width: Double; height: Double; const opts: DrawingOptions)

---

Fill Rectangle On Bitmap

Note

This function is overloaded. The following versions exist:

• Fill Rectangle On Bitmap (destination: bitmap, clr: color, rect: rectangle)
• Fill Rectangle On Bitmap (destination: bitmap, clr: color, rect: rectangle, opts: drawing_options)
• Fill Rectangle On Bitmap (destination: bitmap, clr: color, x: double, y: double, width: double, height: double)
• Fill Rectangle On Bitmap (destination: bitmap, clr: color, x: double, y: double, width: double, height: double, opts: drawing_options)

Fill Rectangle On Bitmap

Fill a rectangle on the supplied bitmap onto the current bitmap.

Parameters:

Name	Type	Description
destination	Bitmap	The destination bitmap
clr	Color	The color of the rectangle
rect	Rectangle	The rectangle to draw

Signatures:

C++

void fill_rectangle_on_bitmap(bitmap destination, color clr, const rectangle &rect)

C#

public void Bitmap.FillRectangle(Color clr, Rectangle rect);
public static void SplashKit.FillRectangleOnBitmap(Bitmap destination, Color clr, Rectangle rect);

Python

def fill_rectangle_on_bitmap_record(destination, clr, rect):

Pascal

procedure FillRectangleOnBitmap(destination: Bitmap; clr: Color; const rect: Rectangle)

---

Fill Rectangle On Bitmap

Fills a rectangle on the supplied bitmap using the supplied drawing options.

Parameters:

Name	Type	Description
destination	Bitmap	The destination bitmap
clr	Color	The color of the rectangle
rect	Rectangle	The rectangle to draw
opts	Drawing Options	The drawing options

Signatures:

C++

void fill_rectangle_on_bitmap(bitmap destination, color clr, const rectangle &rect, const drawing_options &opts)

C#

public void Bitmap.FillRectangle(Color clr, Rectangle rect, DrawingOptions opts);
public static void SplashKit.FillRectangleOnBitmap(Bitmap destination, Color clr, Rectangle rect, DrawingOptions opts);

Python

def fill_rectangle_on_bitmap_record_with_options(destination, clr, rect, opts):

Pascal

procedure FillRectangleOnBitmap(destination: Bitmap; clr: Color; const rect: Rectangle; const opts: DrawingOptions)

---

Fill Rectangle On Bitmap

Fills a rectangle on the supplied bitmap to the current bitmap.

Parameters:

Name	Type	Description
destination	Bitmap	The destination bitmap
clr	Color	The color of the rectangle
x	Double	The distance from the left of the bitmap/bitmap to the rectangle
y	Double	The distance from the top of the bitmap/bitmap to the rectangle
width	Double	The width of the rectangle
height	Double	The height of the rectangle

Signatures:

C++

void fill_rectangle_on_bitmap(bitmap destination, color clr, double x, double y, double width, double height)

C#

public void Bitmap.FillRectangle(Color clr, double x, double y, double width, double height);
public static void SplashKit.FillRectangleOnBitmap(Bitmap destination, Color clr, double x, double y, double width, double height);

Python

def fill_rectangle_on_bitmap(destination, clr, x, y, width, height):

Pascal

procedure FillRectangleOnBitmap(destination: Bitmap; clr: Color; x: Double; y: Double; width: Double; height: Double)

Usage:

See Code Examples

Example 1: Cityscape

Note

To test this example code you can download these Resources.

C++

#include "splashkit.h"

int main()
{
    // Create a new window with title and dimensions
    open_window("Night Sky", 500, 533);

    // Create and load new bitmap using the picture file and initialise new bitmap variable
    bitmap night_sky = load_bitmap("night_sky", "sky.jpg");

    // Create black rectangles for buildings, with x and y axis and dimensions
    fill_rectangle_on_bitmap(night_sky, COLOR_BLACK, 40, 200, 100, 400); //Building 1
    fill_rectangle_on_bitmap(night_sky, COLOR_BLACK, 200, 400, 100, 400); //Building 2
    fill_rectangle_on_bitmap(night_sky, COLOR_BLACK, 350, 300, 100, 300); //Building 3

    // For loop to create the illumimated windows on each building with different numbers depending
    // on the placement of the building
    // Building 1
    for (int j = 220; j < 700; j += 50)
    {
        for (int i = 55; i < 135; i += 20)
        {
            fill_rectangle_on_bitmap(night_sky, COLOR_ORANGE, i, j, 10, 20);
        }
    }

    // Building 2
    for (int j = 420; j < 570; j += 50)
    {
        for (int i = 215; i < 295; i += 20)
        {
            fill_rectangle_on_bitmap(night_sky, COLOR_YELLOW, i, j, 10, 20);
        }
    }

    // Building 3
    for (int j = 320; j < 700; j += 50)
    {
        for (int i = 365; i < 440; i += 20)
        {
            fill_rectangle_on_bitmap(night_sky, COLOR_ORANGE, i, j, 10, 20);
        }
    }

    // Clear screen and draw bitmap
    clear_screen();
    draw_bitmap(night_sky, 0, 0);
    refresh_screen();
    delay(5000);

    // Free resources and close windows
    free_all_bitmaps();
    close_all_windows();
}

C#

Top-level Statements

using static SplashKitSDK.SplashKit;

// Create a new window with title and dimensions
OpenWindow("Night Sky", 500, 533);

// Create and load new bitmap using the picture file and initialise new bitmap variable
SplashKitSDK.Bitmap night_sky = LoadBitmap("night_sky", "sky.jpg");

// Create black rectangles for buildings, with x and y axis and dimensions
FillRectangleOnBitmap(night_sky, ColorBlack(), 40, 200, 100, 400); //Building 1
FillRectangleOnBitmap(night_sky, ColorBlack(), 200, 400, 100, 400); // Building 2
FillRectangleOnBitmap(night_sky, ColorBlack(), 350, 300, 100, 300); // Building 3

// For loop to create the illumimated windows on each building with different numbers depending
// on the placement of the building
// Building 1
for (int j = 220; j < 700; j += 50)
{
    for (int i = 55; i < 135; i += 20)
        {
            FillRectangleOnBitmap(night_sky, ColorOrange(), i, j, 10, 20);
        }
}

// Building 2
for (int j = 420; j < 570; j += 50)
{
    for (int i = 215; i < 295; i += 20)
    {
        FillRectangleOnBitmap(night_sky, ColorYellow(), i, j, 10, 20);
    }
}

// Building 3
for (int j = 320; j < 700; j += 50)
{
    for (int i = 365; i < 440; i += 20)
    {
        FillRectangleOnBitmap(night_sky, ColorOrange(), i, j, 10, 20);
    }
}

// Clear screen and draw bitmap
ClearScreen();
DrawBitmap(night_sky, 0, 0);
RefreshScreen();
Delay(5000);

// Free resources and close windows
FreeAllBitmaps();
CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace FillRectangleOnBitmapExample
{
    public class Program
    {
        public static void Main()
        {
            // Create a new window with title and dimensions
            SplashKit.OpenWindow("Night Sky", 500, 533);
            // Create and load new bitmap using the picture file and initialise new bitmap variable
            Bitmap night_sky = SplashKit.LoadBitmap("night_sky", "sky.jpg");

            // Create black rectangles for buildings, with x and y axis and dimensions
            SplashKit.FillRectangleOnBitmap(night_sky, Color.Black, 40, 200, 100, 400); // Building 1
            SplashKit.FillRectangleOnBitmap(night_sky, Color.Black, 200, 400, 100, 400); // Building 2
            SplashKit.FillRectangleOnBitmap(night_sky, Color.Black, 350, 300, 100, 300); // Building 3

            // For loop to create the illumimated windows on each building with different numbers depending
            // on the placement of the building
            // Building 1
            for (int j = 220; j < 700; j += 50)
            {
                for (int i = 55; i < 135; i += 20)
                {
                    SplashKit.FillRectangleOnBitmap(night_sky, Color.Orange, i, j, 10, 20);
                }
            }

            // Building 2
            for (int j = 420; j < 570; j += 50)
            {
                for (int i = 215; i < 295; i += 20)
                {
                    SplashKit.FillRectangleOnBitmap(night_sky, Color.Yellow, i, j, 10, 20);
                }
            }

            // Building 3
            for (int j = 320; j < 700; j += 50)
            {
                for (int i = 365; i < 440; i += 20)
                {
                    SplashKit.FillRectangleOnBitmap(night_sky, Color.Orange, i, j, 10, 20);
                }
            }

            // Clear screen and draw bitmap
            SplashKit.ClearScreen();
            SplashKit.DrawBitmap(night_sky, 0, 0);
            SplashKit.RefreshScreen();
            SplashKit.Delay(5000);

            // Free resources and close window/s
            SplashKit.FreeAllBitmaps();
            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

# Create a new window with title and dimensions
open_window("Night Sky", 500, 533)

# Create and load new bitmap using the picture file and initialise new bitmap variable
night_sky = load_bitmap("night_sky", "sky.jpg")

# Create black rectangles for buildings, with x and y axis and dimensions
fill_rectangle_on_bitmap(night_sky, color_black(), 40, 200, 100, 400) # Building 1
fill_rectangle_on_bitmap(night_sky, color_black(), 200, 400, 100, 400) # Building 2
fill_rectangle_on_bitmap(night_sky, color_black(), 350, 300, 100, 300) # Building 3

# Building 1
for j in range(220, 700, 50):
    for i in range(55, 135, 20):
        fill_rectangle_on_bitmap(night_sky, color_orange(), i, j, 10, 20)

# Building 2
for j in range(420, 570, 50):
    for i in range(215, 295, 20):
          fill_rectangle_on_bitmap(night_sky, color_yellow(), i, j, 10, 20)

# Building 3
for j in range(320, 700, 50):
    for i in range(365, 440, 20):
        fill_rectangle_on_bitmap(night_sky, color_orange(), i, j, 10, 20)

# Clear screen and draw bitmap
clear_screen_to_white()
draw_bitmap(night_sky, 0, 0)
refresh_screen()
delay(5000)

# Free resources and close windows
free_all_bitmaps()
close_all_windows()

Output:

---

Fill Rectangle On Bitmap

Fills a rectangle on the supplied bitmap, using the supplied drawing options.

Parameters:

Name	Type	Description
destination	Bitmap	The destination bitmap
clr	Color	The color of the rectangle
x	Double	The distance from the left of the bitmap/bitmap to the rectangle
y	Double	The distance from the top of the bitmap/bitmap to the rectangle
width	Double	The width of the rectangle
height	Double	The height of the rectangle
opts	Drawing Options	The drawing options

Signatures:

C++

void fill_rectangle_on_bitmap(bitmap destination, color clr, double x, double y, double width, double height, const drawing_options &opts)

C#

public void Bitmap.FillRectangle(Color clr, double x, double y, double width, double height, DrawingOptions opts);
public static void SplashKit.FillRectangleOnBitmap(Bitmap destination, Color clr, double x, double y, double width, double height, DrawingOptions opts);

Python

def fill_rectangle_on_bitmap_with_options(destination, clr, x, y, width, height, opts):

Pascal

procedure FillRectangleOnBitmap(destination: Bitmap; clr: Color; x: Double; y: Double; width: Double; height: Double; const opts: DrawingOptions)

---

Fill Rectangle On Window

Note

This function is overloaded. The following versions exist:

• Fill Rectangle On Window (destination: window, clr: color, rect: rectangle)
• Fill Rectangle On Window (destination: window, clr: color, rect: rectangle, opts: drawing_options)
• Fill Rectangle On Window (destination: window, clr: color, x: double, y: double, width: double, height: double)
• Fill Rectangle On Window (destination: window, clr: color, x: double, y: double, width: double, height: double, opts: drawing_options)

Fill Rectangle On Window

Fill a rectangle on the supplied window onto the current window.

Parameters:

Name	Type	Description
destination	Window	The destination window
clr	Color	The color of the rectangle
rect	Rectangle	The rectangle to draw

Signatures:

C++

void fill_rectangle_on_window(window destination, color clr, const rectangle &rect)

C#

public void Window.FillRectangle(Color clr, Rectangle rect);
public static void SplashKit.FillRectangleOnWindow(Window destination, Color clr, Rectangle rect);

Python

def fill_rectangle_on_window_record(destination, clr, rect):

Pascal

procedure FillRectangleOnWindow(destination: Window; clr: Color; const rect: Rectangle)

Usage:

See Code Examples

Example 1: Filled Rectangles on Separate Windows

C++

#include "splashkit.h"

int main()
{
    window blue_window = open_window("Blue Rectangle", 200, 200);
    window red_window = open_window("Red Rectangle", 200, 200);
    move_window_to(red_window, window_x(blue_window) + window_width(blue_window), window_y(blue_window));

    // Define the rectangles to draw
    rectangle blue_rect = rectangle_from(50, 50, 100, 50); // x, y, width, height
    rectangle red_rect = rectangle_from(50, 50, 100, 50);  // x, y, width, height

    // Fill a blue rectangle on the first window
    clear_window(blue_window, COLOR_WHITE);
    fill_rectangle_on_window(blue_window, COLOR_BLUE, blue_rect);
    refresh_window(blue_window);

    // Fill a red rectangle on the second window
    clear_window(red_window, COLOR_WHITE);
    fill_rectangle_on_window(red_window, COLOR_RED, red_rect);
    refresh_window(red_window);

    delay(5000);

    close_window(blue_window);
    close_window(red_window);

    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

Window blueWindow = OpenWindow("Blue Rectangle", 200, 200);
Window redWindow = OpenWindow("Red Rectangle", 200, 200);
MoveWindowTo(redWindow, WindowX(blueWindow) + WindowWidth(blueWindow), WindowY(blueWindow));

// Define the rectangles to draw
Rectangle blueRect = RectangleFrom(50, 50, 100, 50); // x, y, width, height
Rectangle redRect = RectangleFrom(50, 50, 100, 50); // x, y, width, height

// Fill a blue rectangle on the first window
ClearWindow(blueWindow, ColorWhite());
FillRectangleOnWindow(blueWindow, ColorBlue(), blueRect);
RefreshWindow(blueWindow);

// Fill a red rectangle on the second window
ClearWindow(redWindow, ColorWhite());
FillRectangleOnWindow(redWindow, ColorRed(), redRect);
RefreshWindow(redWindow);

Delay(5000);

CloseWindow(blueWindow);
CloseWindow(redWindow);

Object-Oriented

using SplashKitSDK;

namespace FillRectangleOnWindowExample
{
    public class Program
    {
        public static void Main()
        {
            Window blueWindow = SplashKit.OpenWindow("Blue Rectangle", 200, 200);
            Window redWindow = SplashKit.OpenWindow("Red Rectangle", 200, 200);
            redWindow.MoveTo(blueWindow.X + blueWindow.Width, blueWindow.Y);

            // Define the rectangles to draw
            Rectangle blueRect = SplashKit.RectangleFrom(50, 50, 100, 50); // x, y, width, height
            Rectangle redRect = SplashKit.RectangleFrom(50, 50, 100, 50); // x, y, width, height

            // Fill a blue rectangle on the first window
            blueWindow.Clear(Color.White);
            SplashKit.FillRectangleOnWindow(blueWindow, Color.Blue, blueRect);
            blueWindow.Refresh();

            // Fill a red rectangle on the second window
            redWindow.Clear(Color.White);
            SplashKit.FillRectangleOnWindow(redWindow, Color.Red, redRect);
            redWindow.Refresh();

            SplashKit.Delay(5000);

            SplashKit.CloseWindow(blueWindow);
            SplashKit.CloseWindow(redWindow);
        }
    }
}

Python

from splashkit import *

blue_window = open_window("Blue Rectangle", 200, 200)
red_window = open_window("Red Rectangle", 200, 200)
move_window_to(red_window, window_x(blue_window) + window_width(blue_window), window_y(blue_window))

# Define the rectangles to draw
blue_rect = rectangle_from(50, 50, 100, 50) # x, y, width, height
red_rect = rectangle_from(50, 50, 100, 50)  # x, y, width, height

# Fill a blue rectangle on the first window
clear_window(blue_window, color_white())
fill_rectangle_on_window_record(blue_window, color_blue(), blue_rect)
refresh_window(blue_window)

# Fill a red rectangle on the second window
clear_window(red_window, color_white())
fill_rectangle_on_window_record(red_window, color_red(), red_rect)
refresh_window(red_window)

delay(5000)

close_window(blue_window)
close_window(red_window)

Output:

---

Fill Rectangle On Window

Fills a rectangle on the supplied window using the supplied drawing options.

Parameters:

Name	Type	Description
destination	Window	The destination window
clr	Color	The color of the rectangle
rect	Rectangle	The rectangle to draw
opts	Drawing Options	The drawing options

Signatures:

C++

void fill_rectangle_on_window(window destination, color clr, const rectangle &rect, const drawing_options &opts)

C#

public void Window.FillRectangle(Color clr, Rectangle rect, DrawingOptions opts);
public static void SplashKit.FillRectangleOnWindow(Window destination, Color clr, Rectangle rect, DrawingOptions opts);

Python

def fill_rectangle_on_window_record_with_options(destination, clr, rect, opts):

Pascal

procedure FillRectangleOnWindow(destination: Window; clr: Color; const rect: Rectangle; const opts: DrawingOptions)

---

Fill Rectangle On Window

Fills a rectangle on the supplied window to the current window.

Parameters:

Name	Type	Description
destination	Window	The destination window
clr	Color	The color of the rectangle
x	Double	The distance from the left of the window/bitmap to the rectangle
y	Double	The distance from the top of the window/bitmap to the rectangle
width	Double	The width of the rectangle
height	Double	The height of the rectangle

Signatures:

C++

void fill_rectangle_on_window(window destination, color clr, double x, double y, double width, double height)

C#

public void Window.FillRectangle(Color clr, double x, double y, double width, double height);
public static void SplashKit.FillRectangleOnWindow(Window destination, Color clr, double x, double y, double width, double height);

Python

def fill_rectangle_on_window(destination, clr, x, y, width, height):

Pascal

procedure FillRectangleOnWindow(destination: Window; clr: Color; x: Double; y: Double; width: Double; height: Double)

Usage:

See Code Examples

Example 1: Filled Rectangles on Separate Windows

C++

#include "splashkit.h"

int main()
{
    window blue_window = open_window("Blue Rectangle", 200, 200);
    window red_window = open_window("Red Rectangle", 200, 200);
    move_window_to(red_window, window_x(blue_window) + window_width(blue_window), window_y(blue_window));

    // Fill a blue rectangle on the first window
    clear_window(blue_window, COLOR_WHITE);
    fill_rectangle_on_window(blue_window, COLOR_BLUE, 50, 50, 100, 50);
    refresh_window(blue_window);

    // Fill a red rectangle on the second window
    clear_window(red_window, COLOR_WHITE);
    fill_rectangle_on_window(red_window, COLOR_RED, 50, 50, 100, 50);
    refresh_window(red_window);

    delay(5000);

    close_window(blue_window);
    close_window(red_window);

    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

Window blueWindow = OpenWindow("Blue Rectangle", 200, 200);
Window redWindow = OpenWindow("Red Rectangle", 200, 200);
MoveWindowTo(redWindow, WindowX(blueWindow) + WindowWidth(blueWindow), WindowY(blueWindow));

// Fill a blue rectangle on the first window
ClearWindow(blueWindow, ColorWhite());
FillRectangleOnWindow(blueWindow, ColorBlue(), 50, 50, 100, 50);
RefreshWindow(blueWindow);

// Fill a red rectangle on the second window
ClearWindow(redWindow, ColorWhite());
FillRectangleOnWindow(redWindow, ColorRed(), 50, 50, 100, 50);
RefreshWindow(redWindow);

Delay(5000);

CloseWindow(blueWindow);
CloseWindow(redWindow);

Object-Oriented

using SplashKitSDK;

namespace FillRectangleOnWindowExample
{
    public class Program
    {
        public static void Main()
        {
            Window blueWindow = SplashKit.OpenWindow("Blue Rectangle", 200, 200);
            Window redWindow = SplashKit.OpenWindow("Red Rectangle", 200, 200);
            redWindow.MoveTo(blueWindow.X + blueWindow.Width, blueWindow.Y);

            // Fill a blue rectangle on the first window
            blueWindow.Clear(Color.White);
            SplashKit.FillRectangleOnWindow(blueWindow, Color.Blue, 50, 50, 100, 50);
            blueWindow.Refresh();

            // Fill a red rectangle on the second window
            redWindow.Clear(Color.White);
            SplashKit.FillRectangleOnWindow(redWindow, Color.Red, 50, 50, 100, 50);
            redWindow.Refresh();

            SplashKit.Delay(5000);

            SplashKit.CloseWindow(blueWindow);
            SplashKit.CloseWindow(redWindow);
        }
    }
}

Python

from splashkit import *

blue_window = open_window("Blue Rectangle", 200, 200)
red_window = open_window("Red Rectangle", 200, 200)
move_window_to(red_window, window_x(blue_window) + window_width(blue_window), window_y(blue_window))

# Define the rectangles to draw
blue_rect = rectangle_from(50, 50, 100, 50) # x, y, width, height
red_rect = rectangle_from(50, 50, 100, 50)  # x, y, width, height

# Fill a blue rectangle on the first window
clear_window(blue_window, color_white())
fill_rectangle_on_window(blue_window, color_blue(), 50, 50, 100, 50)
refresh_window(blue_window)

# Fill a red rectangle on the second window
clear_window(red_window, color_white())
fill_rectangle_on_window(red_window, color_red(), 50, 50, 100, 50)
refresh_window(red_window)

delay(5000)

close_window(blue_window)
close_window(red_window)

Output:

---

Fill Rectangle On Window

Fills a rectangle on the supplied window, using the supplied drawing options.

Parameters:

Name	Type	Description
destination	Window	The destination window
clr	Color	The color of the rectangle
x	Double	The distance from the left of the window/bitmap to the rectangle
y	Double	The distance from the top of the window/bitmap to the rectangle
width	Double	The width of the rectangle
height	Double	The height of the rectangle
opts	Drawing Options	The drawing options

Signatures:

C++

void fill_rectangle_on_window(window destination, color clr, double x, double y, double width, double height, const drawing_options &opts)

C#

public void Window.FillRectangle(Color clr, double x, double y, double width, double height, DrawingOptions opts);
public static void SplashKit.FillRectangleOnWindow(Window destination, Color clr, double x, double y, double width, double height, DrawingOptions opts);

Python

def fill_rectangle_on_window_with_options(destination, clr, x, y, width, height, opts):

Pascal

procedure FillRectangleOnWindow(destination: Window; clr: Color; x: Double; y: Double; width: Double; height: Double; const opts: DrawingOptions)

---

Draw Text

Note

This function is overloaded. The following versions exist:

• Draw Text (text: string, clr: color, fnt: string, font_size: int, x: double, y: double)
• Draw Text (text: string, clr: color, fnt: string, font_size: int, x: double, y: double, opts: drawing_options)
• Draw Text (text: string, clr: color, x: double, y: double)
• Draw Text (text: string, clr: color, x: double, y: double, opts: drawing_options)
• Draw Text (text: string, clr: color, fnt: font, font_size: int, x: double, y: double)
• Draw Text (text: string, clr: color, fnt: font, font_size: int, x: double, y: double, opts: drawing_options)

Draw Text

Parameters:

Name	Type	Description
text	String	The text string to be written to the window.
clr	Color	The desired Color of the text to be written.
fnt	String	The name of the Font which will be used to draw the text
font_size	Integer	The size of the font which will be drawn.
x	Double	The x location to draw the text.
y	Double	The y location to draw the text.

Signatures:

C++

void draw_text(const string &text, const color &clr, const string &fnt, int font_size, double x, double y)

C#

public static void SplashKit.DrawText(string text, Color clr, string fnt, int fontSize, double x, double y);

Python

def draw_text_font_as_string(text, clr, fnt, font_size, x, y):

Pascal

procedure DrawText(const text: String; const clr: Color; const fnt: String; fontSize: Integer; x: Double; y: Double)

Usage:

See Implementations in Guides

• Get Started with SplashKit Audio

---

Draw Text

Parameters:

Name	Type	Description
text	String	The text string to be written to the window.
clr	Color	The desired Color of the text to be written.
fnt	String	The name of the Font which will be used to draw the text
font_size	Integer	The size of the font which will be drawn.
x	Double	The x location to draw the text.
y	Double	The y location to draw the text.
opts	Drawing Options	The Drawing Options which provide extra information for how to draw the text.

Signatures:

C++

void draw_text(const string &text, const color &clr, const string &fnt, int font_size, double x, double y, const drawing_options &opts)

C#

public static void SplashKit.DrawText(string text, Color clr, string fnt, int fontSize, double x, double y, DrawingOptions opts);

Python

def draw_text_with_options_font_as_string(text, clr, fnt, font_size, x, y, opts):

Pascal

procedure DrawText(const text: String; const clr: Color; const fnt: String; fontSize: Integer; x: Double; y: Double; const opts: DrawingOptions)

---

Draw Text

Parameters:

Name	Type	Description
text	String	The text string to be written to the window.
clr	Color	The desired Color of the text to be written.
x	Double	The x location to draw the text.
y	Double	The y location to draw the text.

Signatures:

C++

void draw_text(const string &text, const color &clr, double x, double y)

C#

public static void SplashKit.DrawText(string text, Color clr, double x, double y);

Python

def draw_text_no_font_no_size(text, clr, x, y):

Pascal

procedure DrawText(const text: String; const clr: Color; x: Double; y: Double)

Usage:

See Implementations in Guides

• Using Animations in SplashKit

---

Draw Text

Parameters:

Name	Type	Description
text	String	The text string to be written to the window.
clr	Color	The desired Color of the text to be written.
x	Double	The x location to draw the text.
y	Double	The y location to draw the text.
opts	Drawing Options	The Drawing Options which provide extra information for how to draw the text.

Signatures:

C++

void draw_text(const string &text, const color &clr, double x, double y, const drawing_options &opts)

C#

public static void SplashKit.DrawText(string text, Color clr, double x, double y, DrawingOptions opts);

Python

def draw_text_no_font_no_size_with_options(text, clr, x, y, opts):

Pascal

procedure DrawText(const text: String; const clr: Color; x: Double; y: Double; const opts: DrawingOptions)

Usage:

See Implementations in Guides

• SplashKit Camera
• SplashKit Camera

---

Draw Text

Parameters:

Name	Type	Description
text	String	The text string to be written to the window.
clr	Color	The desired Color of the text to be written.
fnt	Font	The Font to be used to draw the text.
font_size	Integer	The size of the font which will be drawn.
x	Double	The x location to draw the text.
y	Double	The y location to draw the text.

Signatures:

C++

void draw_text(const string &text, const color &clr, font fnt, int font_size, double x, double y)

C#

public static void SplashKit.DrawText(string text, Color clr, Font fnt, int fontSize, double x, double y);

Python

def draw_text(text, clr, fnt, font_size, x, y):

Pascal

procedure DrawText(const text: String; const clr: Color; fnt: Font; fontSize: Integer; x: Double; y: Double)

Usage:

See Implementations in Guides

• Reading Text

---

Draw Text

Parameters:

Name	Type	Description
text	String	The text string to be written to the window.
clr	Color	The desired Color of the text to be written.
fnt	Font	The Font to be used to draw the text.
font_size	Integer	The desired size of the font.
x	Double	The x location to draw the text.
y	Double	The y location to draw the text.
opts	Drawing Options	The Drawing Options which provide extra information for how to draw the text.

Signatures:

C++

void draw_text(const string &text, const color &clr, font fnt, int font_size, double x, double y, const drawing_options &opts)

C#

public static void SplashKit.DrawText(string text, Color clr, Font fnt, int fontSize, double x, double y, DrawingOptions opts);

Python

def draw_text_with_options(text, clr, fnt, font_size, x, y, opts):

Pascal

procedure DrawText(const text: String; const clr: Color; fnt: Font; fontSize: Integer; x: Double; y: Double; const opts: DrawingOptions)

---

Draw Text On Bitmap

Note

This function is overloaded. The following versions exist:

• Draw Text On Bitmap (bmp: bitmap, text: string, clr: color, fnt: string, font_size: int, x: double, y: double)
• Draw Text On Bitmap (bmp: bitmap, text: string, clr: color, fnt: string, font_size: int, x: double, y: double, opts: drawing_options)
• Draw Text On Bitmap (bmp: bitmap, text: string, clr: color, x: double, y: double)
• Draw Text On Bitmap (bmp: bitmap, text: string, clr: color, x: double, y: double, opts: drawing_options)
• Draw Text On Bitmap (bmp: bitmap, text: string, clr: color, fnt: font, font_size: int, x: double, y: double)
• Draw Text On Bitmap (bmp: bitmap, text: string, clr: color, fnt: font, font_size: int, x: double, y: double, opts: drawing_options)

Draw Text On Bitmap

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap to draw to
text	String	The text string to be written to the bitmap.
clr	Color	The desired Color of the text to be written.
fnt	String	The name of the Font which will be used to draw the text
font_size	Integer	The size of the font which will be drawn.
x	Double	The x location to draw the text.
y	Double	The y location to draw the text.

Signatures:

C++

void draw_text_on_bitmap(bitmap bmp, const string &text, const color &clr, const string &fnt, int font_size, double x, double y)

C#

public void Bitmap.DrawText(string text, Color clr, string fnt, int fontSize, double x, double y);
public static void SplashKit.DrawTextOnBitmap(Bitmap bmp, string text, Color clr, string fnt, int fontSize, double x, double y);

Python

def draw_text_on_bitmap_font_as_string(bmp, text, clr, fnt, font_size, x, y):

Pascal

procedure DrawTextOnBitmap(bmp: Bitmap; const text: String; const clr: Color; const fnt: String; fontSize: Integer; x: Double; y: Double)

---

Draw Text On Bitmap

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap to draw to
text	String	The text string to be written to the bitmap.
clr	Color	The desired Color of the text to be written.
fnt	String	The name of the Font which will be used to draw the text
font_size	Integer	The size of the font which will be drawn.
x	Double	The x location to draw the text.
y	Double	The y location to draw the text.
opts	Drawing Options	The Drawing Options which provide extra information for how to draw the text.

Signatures:

C++

void draw_text_on_bitmap(bitmap bmp, const string &text, const color &clr, const string &fnt, int font_size, double x, double y, const drawing_options &opts)

C#

public void Bitmap.DrawText(string text, Color clr, string fnt, int fontSize, double x, double y, DrawingOptions opts);
public static void SplashKit.DrawTextOnBitmap(Bitmap bmp, string text, Color clr, string fnt, int fontSize, double x, double y, DrawingOptions opts);

Python

def draw_text_on_bitmap_with_options_font_as_string(bmp, text, clr, fnt, font_size, x, y, opts):

Pascal

procedure DrawTextOnBitmap(bmp: Bitmap; const text: String; const clr: Color; const fnt: String; fontSize: Integer; x: Double; y: Double; const opts: DrawingOptions)

---

Draw Text On Bitmap

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap to draw to
text	String	The text string to be written to the bitmap.
clr	Color	The desired Color of the text to be written.
x	Double	The x location to draw the text.
y	Double	The y location to draw the text.

Signatures:

C++

void draw_text_on_bitmap(bitmap bmp, const string &text, const color &clr, double x, double y)

C#

public void Bitmap.DrawText(string text, Color clr, double x, double y);
public static void SplashKit.DrawTextOnBitmap(Bitmap bmp, string text, Color clr, double x, double y);

Python

def draw_text_on_bitmap_no_font_no_size(bmp, text, clr, x, y):

Pascal

procedure DrawTextOnBitmap(bmp: Bitmap; const text: String; const clr: Color; x: Double; y: Double)

---

Draw Text On Bitmap

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap to draw to
text	String	The text string to be written to the bitmap.
clr	Color	The desired Color of the text to be written.
x	Double	The x location to draw the text.
y	Double	The y location to draw the text.
opts	Drawing Options	The Drawing Options which provide extra information for how to draw the text.

Signatures:

C++

void draw_text_on_bitmap(bitmap bmp, const string &text, const color &clr, double x, double y, const drawing_options &opts)

C#

public void Bitmap.DrawText(string text, Color clr, double x, double y, DrawingOptions opts);
public static void SplashKit.DrawTextOnBitmap(Bitmap bmp, string text, Color clr, double x, double y, DrawingOptions opts);

Python

def draw_text_on_bitmap_no_font_no_size_with_options(bmp, text, clr, x, y, opts):

Pascal

procedure DrawTextOnBitmap(bmp: Bitmap; const text: String; const clr: Color; x: Double; y: Double; const opts: DrawingOptions)

---

Draw Text On Bitmap

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap to draw to
text	String	The text string to be written to the bitmap.
clr	Color	The desired Color of the text to be written.
fnt	Font	The Font to be used to draw the text.
font_size	Integer	The size of the font which will be drawn.
x	Double	The x location to draw the text.
y	Double	The y location to draw the text.

Signatures:

C++

void draw_text_on_bitmap(bitmap bmp, const string &text, const color &clr, font fnt, int font_size, double x, double y)

C#

public void Bitmap.DrawText(string text, Color clr, Font fnt, int fontSize, double x, double y);
public static void SplashKit.DrawTextOnBitmap(Bitmap bmp, string text, Color clr, Font fnt, int fontSize, double x, double y);

Python

def draw_text_on_bitmap(bmp, text, clr, fnt, font_size, x, y):

Pascal

procedure DrawTextOnBitmap(bmp: Bitmap; const text: String; const clr: Color; fnt: Font; fontSize: Integer; x: Double; y: Double)

---

Draw Text On Bitmap

Parameters:

Name	Type	Description
bmp	Bitmap	The bitmap to draw to
text	String	The text string to be written to the bitmap.
clr	Color	The desired Color of the text to be written.
fnt	Font	The Font to be used to draw the text.
font_size	Integer	The desired size of the font.
x	Double	The x location to draw the text.
y	Double	The y location to draw the text.
opts	Drawing Options	The Drawing Options which provide extra information for how to draw the text.

Signatures:

C++

void draw_text_on_bitmap(bitmap bmp, const string &text, const color &clr, font fnt, int font_size, double x, double y, const drawing_options &opts)

C#

public void Bitmap.DrawText(string text, Color clr, Font fnt, int fontSize, double x, double y, DrawingOptions opts);
public static void SplashKit.DrawTextOnBitmap(Bitmap bmp, string text, Color clr, Font fnt, int fontSize, double x, double y, DrawingOptions opts);

Python

def draw_text_on_bitmap_with_options(bmp, text, clr, fnt, font_size, x, y, opts):

Pascal

procedure DrawTextOnBitmap(bmp: Bitmap; const text: String; const clr: Color; fnt: Font; fontSize: Integer; x: Double; y: Double; const opts: DrawingOptions)

---

Draw Text On Window

Note

This function is overloaded. The following versions exist:

• Draw Text On Window (wnd: window, text: string, clr: color, fnt: string, font_size: int, x: double, y: double)
• Draw Text On Window (wnd: window, text: string, clr: color, fnt: string, font_size: int, x: double, y: double, opts: drawing_options)
• Draw Text On Window (wnd: window, text: string, clr: color, x: double, y: double)
• Draw Text On Window (wnd: window, text: string, clr: color, x: double, y: double, opts: drawing_options)
• Draw Text On Window (wnd: window, text: string, clr: color, fnt: font, font_size: int, x: double, y: double)
• Draw Text On Window (wnd: window, text: string, clr: color, fnt: font, font_size: int, x: double, y: double, opts: drawing_options)

Draw Text On Window

Parameters:

Name	Type	Description
wnd	Window	The window to draw to
text	String	The text string to be written to the window.
clr	Color	The desired Color of the text to be written.
fnt	String	The name of the Font which will be used to draw the text
font_size	Integer	The size of the font which will be drawn.
x	Double	The x location to draw the text.
y	Double	The y location to draw the text.

Signatures:

C++

void draw_text_on_window(window wnd, const string &text, const color &clr, const string &fnt, int font_size, double x, double y)

C#

public void Window.DrawText(string text, Color clr, string fnt, int fontSize, double x, double y);
public static void SplashKit.DrawTextOnWindow(Window wnd, string text, Color clr, string fnt, int fontSize, double x, double y);

Python

def draw_text_on_window_font_as_string(wnd, text, clr, fnt, font_size, x, y):

Pascal

procedure DrawTextOnWindow(wnd: Window; const text: String; const clr: Color; const fnt: String; fontSize: Integer; x: Double; y: Double)

---

Draw Text On Window

Parameters:

Name	Type	Description
wnd	Window	The window to draw to
text	String	The text string to be written to the window.
clr	Color	The desired Color of the text to be written.
fnt	String	The name of the Font which will be used to draw the text
font_size	Integer	The size of the font which will be drawn.
x	Double	The x location to draw the text.
y	Double	The y location to draw the text.
opts	Drawing Options	The Drawing Options which provide extra information for how to draw the text.

Signatures:

C++

void draw_text_on_window(window wnd, const string &text, const color &clr, const string &fnt, int font_size, double x, double y, const drawing_options &opts)

C#

public void Window.DrawText(string text, Color clr, string fnt, int fontSize, double x, double y, DrawingOptions opts);
public static void SplashKit.DrawTextOnWindow(Window wnd, string text, Color clr, string fnt, int fontSize, double x, double y, DrawingOptions opts);

Python

def draw_text_on_window_with_options_font_as_string(wnd, text, clr, fnt, font_size, x, y, opts):

Pascal

procedure DrawTextOnWindow(wnd: Window; const text: String; const clr: Color; const fnt: String; fontSize: Integer; x: Double; y: Double; const opts: DrawingOptions)

---

Draw Text On Window

Parameters:

Name	Type	Description
wnd	Window	The window to draw to
text	String	The text string to be written to the window.
clr	Color	The desired Color of the text to be written.
x	Double	The x location to draw the text.
y	Double	The y location to draw the text.

Signatures:

C++

void draw_text_on_window(window wnd, const string &text, const color &clr, double x, double y)

C#

public void Window.DrawText(string text, Color clr, double x, double y);
public static void SplashKit.DrawTextOnWindow(Window wnd, string text, Color clr, double x, double y);

Python

def draw_text_on_window_no_font_no_size(wnd, text, clr, x, y):

Pascal

procedure DrawTextOnWindow(wnd: Window; const text: String; const clr: Color; x: Double; y: Double)

---

Draw Text On Window

Parameters:

Name	Type	Description
wnd	Window	The window to draw to
text	String	The text string to be written to the window.
clr	Color	The desired Color of the text to be written.
x	Double	The x location to draw the text.
y	Double	The y location to draw the text.
opts	Drawing Options	The Drawing Options which provide extra information for how to draw the text.

Signatures:

C++

void draw_text_on_window(window wnd, const string &text, const color &clr, double x, double y, const drawing_options &opts)

C#

public void Window.DrawText(string text, Color clr, double x, double y, DrawingOptions opts);
public static void SplashKit.DrawTextOnWindow(Window wnd, string text, Color clr, double x, double y, DrawingOptions opts);

Python

def draw_text_on_window_no_font_no_size_with_options(wnd, text, clr, x, y, opts):

Pascal

procedure DrawTextOnWindow(wnd: Window; const text: String; const clr: Color; x: Double; y: Double; const opts: DrawingOptions)

---

Draw Text On Window

Parameters:

Name	Type	Description
wnd	Window	The window to draw to
text	String	The text string to be written to the window.
clr	Color	The desired Color of the text to be written.
fnt	Font	The Font to be used to draw the text.
font_size	Integer	The size of the font which will be drawn.
x	Double	The x location to draw the text.
y	Double	The y location to draw the text.

Signatures:

C++

void draw_text_on_window(window wnd, const string &text, const color &clr, font fnt, int font_size, double x, double y)

C#

public void Window.DrawText(string text, Color clr, Font fnt, int fontSize, double x, double y);
public static void SplashKit.DrawTextOnWindow(Window wnd, string text, Color clr, Font fnt, int fontSize, double x, double y);

Python

def draw_text_on_window(wnd, text, clr, fnt, font_size, x, y):

Pascal

procedure DrawTextOnWindow(wnd: Window; const text: String; const clr: Color; fnt: Font; fontSize: Integer; x: Double; y: Double)

---

Draw Text On Window

Parameters:

Name	Type	Description
wnd	Window	The window to draw to
text	String	The text string to be written to the window.
clr	Color	The desired Color of the text to be written.
fnt	Font	The Font to be used to draw the text.
font_size	Integer	The desired size of the font.
x	Double	The x location to draw the text.
y	Double	The y location to draw the text.
opts	Drawing Options	The Drawing Options which provide extra information for how to draw the text.

Signatures:

C++

void draw_text_on_window(window wnd, const string &text, const color &clr, font fnt, int font_size, double x, double y, const drawing_options &opts)

C#

public void Window.DrawText(string text, Color clr, Font fnt, int fontSize, double x, double y, DrawingOptions opts);
public static void SplashKit.DrawTextOnWindow(Window wnd, string text, Color clr, Font fnt, int fontSize, double x, double y, DrawingOptions opts);

Python

def draw_text_on_window_with_options(wnd, text, clr, fnt, font_size, x, y, opts):

Pascal

procedure DrawTextOnWindow(wnd: Window; const text: String; const clr: Color; fnt: Font; fontSize: Integer; x: Double; y: Double; const opts: DrawingOptions)

---

Font Has Size

Note

This function is overloaded. The following versions exist:

• Font Has Size (name: string, font_size: int)
• Font Has Size (fnt: font, font_size: int)

Font Has Size

Parameters:

Name	Type	Description
name	String	The name of the Font to be checked.
font_size	Integer	The size to check.

Return Type: Boolean

Signatures:

C++

bool font_has_size(const string &name, int font_size)

C#

public static bool SplashKit.FontHasSize(string name, int fontSize);

Python

def font_has_size_name_as_string(name, font_size):

Pascal

function FontHasSize(const name: String; fontSize: Integer): Boolean

---

Font Has Size

Parameters:

Name	Type	Description
fnt	Font	The Font to be checked.
font_size	Integer	The size to check.

Return Type: Boolean

Signatures:

C++

bool font_has_size(font fnt, int font_size)

C#

public bool Font.HasSize(int fontSize);
public static bool SplashKit.FontHasSize(Font fnt, int fontSize);

Python

def font_has_size(fnt, font_size):

Pascal

function FontHasSize(fnt: Font; fontSize: Integer): Boolean

---

Font Load Size

Note

This function is overloaded. The following versions exist:

• Font Load Size (name: string, font_size: int)
• Font Load Size (fnt: font, font_size: int)

Font Load Size

Parameters:

Name	Type	Description
name	String	The name of the Font to load the size for.
font_size	Integer	The desired size of the Font.

Signatures:

C++

void font_load_size(const string &name, int font_size)

C#

public static void SplashKit.FontLoadSize(string name, int fontSize);

Python

def font_load_size_name_as_string(name, font_size):

Pascal

procedure FontLoadSize(const name: String; fontSize: Integer)

---

Font Load Size

Parameters:

Name	Type	Description
fnt	Font	The Font to load the size for.
font_size	Integer	The desired size of the Font.

Signatures:

C++

void font_load_size(font fnt, int font_size)

C#

public void Font.LoadSize(int fontSize);
public static void SplashKit.FontLoadSize(Font fnt, int fontSize);

Python

def font_load_size(fnt, font_size):

Pascal

procedure FontLoadSize(fnt: Font; fontSize: Integer)

---

Font Named

Parameters:

Name	Type	Description
name	String	The name of the font to find.

Return Type: Font

Signatures:

C++

font font_named(string name)

C#

public static Font SplashKit.FontNamed(string name);

Python

def font_named(name):

Pascal

function FontNamed(name: String): Font

---

Free All Fonts

Signatures:

C++

void free_all_fonts()

C#

public static void Text.FreeAll();
public static void SplashKit.FreeAllFonts();

Python

def free_all_fonts():

Pascal

procedure FreeAllFonts()

---

Free Font

Parameters:

Name	Type	Description
fnt	Font	The font to be freed.

Signatures:

C++

void free_font(font fnt)

C#

public void Font.Free();
public static void SplashKit.FreeFont(Font fnt);

Python

def free_font(fnt):

Pascal

procedure FreeFont(fnt: Font)

Usage:

See Code Examples

Example 1: Freeing Fonts

Note

To test this example code you can download these Resources.

C++

#include "splashkit.h"

int main()
{
    open_window("Freeing Fonts", 800, 200);
    font bebas_neue = load_font("BebasNeue", "BebasNeue.ttf");

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

        clear_screen();
        if (has_font(bebas_neue))
        {
            draw_text("Using BebasNeue Font: Press Space bar to free font", COLOR_BLACK, bebas_neue, 30, 20, 50);
        }
        else
        {
            draw_text("Using System Font: BebasNeue font has been freed", COLOR_BLACK, get_system_font(), 30, 20, 50);
            draw_text("Press Space bar to load BebasNeue font again", COLOR_BLACK, get_system_font(), 30, 20, 100);
        }
        refresh_screen();

        if (key_typed(SPACE_KEY))
        {
            // If the font is loaded, it is freed
            // If the font has been free, it is loaded again
            if (has_font(bebas_neue))
            {
                free_font(bebas_neue);
            }
            else
            {
                bebas_neue = load_font("BebasNeue", "BebasNeue.ttf");
            }
        }
    }

    // Clean up
    if (has_font(bebas_neue))
    {
        free_font(bebas_neue);
    }
    close_all_windows();

    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

OpenWindow("Freeing Fonts", 800, 200);
Font bebasNeue = LoadFont("BebasNeue", "BebasNeue.ttf");

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

    ClearScreen();
    if (HasFont(bebasNeue))
    {
        DrawText("Using BebasNeue Font: Press Space bar to free font", ColorBlack(), bebasNeue, 30, 20, 50);
    }
    else
    {
        DrawText("Using System Font: BebasNeue font has been freed", ColorBlack(), GetSystemFont(), 30, 20, 50);
        DrawText("Press Space bar to load BebasNeue font again", ColorBlack(), GetSystemFont(), 30, 20, 100);
    }
    RefreshScreen();

    if (KeyTyped(KeyCode.SpaceKey))
    {
        // If the font is loaded, it is freed
        // If the font has been free, it is loaded again
        if (HasFont(bebasNeue))
        {
            FreeFont(bebasNeue);
        }
        else
        {
            bebasNeue = LoadFont("BebasNeue", "BebasNeue.ttf");
        }
    }
}

// Clean up
if (HasFont(bebasNeue))
{
    FreeFont(bebasNeue);
}
CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace FreeFontExample
{
    public class Program
    {
        public static void Main()
        {
            SplashKit.OpenWindow("Freeing Fonts", 800, 200);
            Font bebasNeue = SplashKit.LoadFont("BebasNeue", "BebasNeue.ttf");

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

                SplashKit.ClearScreen();
                if (SplashKit.HasFont(bebasNeue))
                {
                    SplashKit.DrawText("Using BebasNeue Font: Press Space bar to free font", Color.Black, bebasNeue, 30, 20, 50);
                }
                else
                {
                    SplashKit.DrawText("Using System Font: BebasNeue font has been freed", Color.Black, SplashKit.GetSystemFont(), 30, 20, 50);
                    SplashKit.DrawText("Press Space bar to load BebasNeue font again", Color.Black, SplashKit.GetSystemFont(), 30, 20, 100);
                }
                SplashKit.RefreshScreen();

                if (SplashKit.KeyTyped(KeyCode.SpaceKey))
                {
                    // If the font is loaded, it is freed
                    // If the font has been free, it is loaded again
                    if (SplashKit.HasFont(bebasNeue))
                    {
                        SplashKit.FreeFont(bebasNeue);
                    }
                    else
                    {
                        bebasNeue = SplashKit.LoadFont("BebasNeue", "BebasNeue.ttf");
                    }
                }
            }

            // Clean up
            if (SplashKit.HasFont(bebasNeue))
            {
                SplashKit.FreeFont(bebasNeue);
            }
            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

open_window("Freeing Fonts", 800, 200)
bebas_neue = load_font("BebasNeue", "BebasNeue.ttf")

while (not quit_requested()):
    process_events()

    clear_screen_to_white()
    if (has_font(bebas_neue)):
        draw_text("Using BebasNeue Font: Press Space bar to free font", color_black(), bebas_neue, 30, 20, 50)
    else:
        draw_text("Using System Font: BebasNeue font has been freed", color_black(), get_system_font(), 30, 20, 50)
        draw_text("Press Space bar to load BebasNeue font again", color_black(), get_system_font(), 30, 20, 100)
    refresh_screen()

    if (key_typed(KeyCode.space_key)):
        # If the font is loaded, it is freed
        # If the font has been free, it is loaded again
        if (has_font(bebas_neue)):
            free_font(bebas_neue)
        else:
            bebas_neue = load_font("BebasNeue", "BebasNeue.ttf")

# Clean up
if (has_font(bebas_neue)):
    free_font(bebas_neue)

close_all_windows()

Output:

---

Get Font Style

Note

This function is overloaded. The following versions exist:

• Get Font Style (name: string)
• Get Font Style (fnt: font)

Get Font Style

Parameters:

Name	Type	Description
name	String	The name of the font to return the style of.

Return Type: Font Style

Signatures:

C++

font_style get_font_style(const string &name)

C#

public static FontStyle SplashKit.GetFontStyle(string name);

Python

def get_font_style_name_as_string(name):

Pascal

function GetFontStyle(const name: String): FontStyle

---

Get Font Style

Parameters:

Name	Type	Description
fnt	Font	The Font to return the style of.

Return Type: Font Style

Signatures:

C++

font_style get_font_style(font fnt)

C#

public FontStyle Font.Style { get }
public static FontStyle SplashKit.GetFontStyle(Font fnt);

Python

def get_font_style(fnt):

Pascal

function GetFontStyle(fnt: Font): FontStyle

---

Get System Font

Searches for and (if found) returns a default system font. Otherwise defaults to the in-built font.

Return Type: Font

Signatures:

C++

font get_system_font()

C#

public static Font SplashKit.GetSystemFont();

Python

def get_system_font():

Pascal

function GetSystemFont(): Font

---

Has Font

Note

This function is overloaded. The following versions exist:

• Has Font (fnt: font)
• Has Font (name: string)

Has Font

Parameters:

Name	Type	Description
fnt	Font	The Font to check if loaded.

Return Type: Boolean

Signatures:

C++

bool has_font(font fnt)

C#

public static bool SplashKit.HasFont(Font fnt);

Python

def has_font(fnt):

Pascal

function HasFont(fnt: Font): Boolean

Usage:

See Code Examples

Example 1: Checking for Font using Variable

C++

#include "splashkit.h"

int main()
{
    // Check if program has font
    write("Font available before loading: ");
    if (has_font(font_named("MyFont")))
        write_line("True");
    else
        write_line("False");

    // Load font
    font my_font = load_font("MyFont", "arial.ttf");

    // Check if program has font again
    write("Font available after loading: ");
    if (has_font(my_font))
        write_line("True");
    else
        write_line("False");

    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

// Check if program has font
Write("Font available before loading: ");
if (HasFont(FontNamed("MyFont")))
    WriteLine("True");
else
    WriteLine("False");

// Load font
Font myFont = LoadFont("MyFont", "arial.ttf");

// Check if program has font again
Write("Font available after loading: ");
if (HasFont(myFont))
    WriteLine("True");
else
    WriteLine("False");

Object-Oriented

using SplashKitSDK;

namespace HasFontExample
{
    public class Program
    {
        public static void Main()
        {
            // Check if program has font
            SplashKit.Write("Font available before loading: ");
            if (SplashKit.HasFont(SplashKit.FontNamed("MyFont")))
                SplashKit.WriteLine("True");
            else
                SplashKit.WriteLine("False");

            // Load font
            Font myFont = SplashKit.LoadFont("MyFont", "arial.ttf");

            // Check if program has font again
            SplashKit.Write("Font available after loading: ");
            if (SplashKit.HasFont(myFont))
                SplashKit.WriteLine("True");
            else
                SplashKit.WriteLine("False");
        }
    }
}

Python

from splashkit import *

# Check if program has font
write("Font available before loading: ")
if (has_font(font_named("MyFont"))):
    write_line("True")
else:
    write_line("False")

# Load font
my_font = load_font("MyFont", "arial.ttf")

# Check if program has font again
write("Font available after loading: ")
if (has_font(my_font)):
    write_line("True")
else:
    write_line("False")

Output:

---

Has Font

Parameters:

Name	Type	Description
name	String	The name of Font to check if loaded.

Return Type: Boolean

Signatures:

C++

bool has_font(string name)

C#

public static bool SplashKit.HasFont(string name);

Python

def has_font_name_as_string(name):

Pascal

function HasFont(name: String): Boolean

Usage:

See Code Examples

Example 1: Checking for Loaded Font using Name string

C++

#include "splashkit.h"

int main()
{
    // Load a font
    load_font("my_font", "arial.ttf");

    // Display the text to show the result
    if (has_font("my_font"))
    {
        write_line("Font found!");
    }
    else
    {
        write_line("Font not found!");
    }
}

C#

Top-level Statements

using static SplashKitSDK.SplashKit;

// Load a font
LoadFont("my_font", "arial.ttf");

// Display the result
if (HasFont("my_font"))
{
    WriteLine("Font found!");
}
else
{
    WriteLine("Font not found!");
}

Object-Oriented

using SplashKitSDK;

namespace HasFontExample
{
    public class Program
    {
        public static void Main()
        {
            // Load a font
            SplashKit.LoadFont("my_font", "arial.ttf");

            // Check if the font exists
            if (SplashKit.HasFont("my_font"))
            {
                SplashKit.WriteLine("Font found!");
            }
            else
            {
                SplashKit.WriteLine("Font not found!");
            }
        }
    }
}

Python

from splashkit import *

# Load a font
load_font("my_font", "arial.ttf")

# Display the text to show the result
if has_font_name_as_string("my_font"):
    write_line("Font found!")
else:
    write_line("Font not found!")

Output:

---

Load Font

Parameters:

Name	Type	Description
name	String	The name of the Font to be loaded from file.
filename	String	The name of the file to load the Font from.

Return Type: Font

Signatures:

C++

font load_font(const string &name, const string &filename)

C#

public static Font SplashKit.LoadFont(string name, string filename);
public Font(string name, string filename);

Python

def load_font(name, filename):

Pascal

function LoadFont(const name: String; const filename: String): Font

Usage:

See Implementations in Guides

• Reading Text

See Code Examples

Example 1: Using Fonts

Note

To test this example code you can download these Resources.

C++

#include "splashkit.h"

int main()
{
  // Load font
  font my_font = load_font("MyFont", "RobotoSlab.ttf");

  open_window("Font Load Example", 800, 600);

  // Draw text using loaded font
  draw_text("Hello, SplashKit!", color_black(), my_font, 40, 250, 270);
  refresh_screen();

  delay(5000);
  close_all_windows();
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

// Load font
Font myFont = LoadFont("MyFont", "RobotoSlab.ttf");

OpenWindow("Font Load Example", 800, 600);

// Draw text using loaded font
DrawText("Hello, SplashKit!", ColorBlack(), myFont, 40, 250, 270);
RefreshScreen();

Delay(5000);
CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace LoadFontExample
{
    public class Program
    {
        public static void Main()
        {
            // Load font
            Font myFont = SplashKit.LoadFont("MyFont", "RobotoSlab.ttf");

            SplashKit.OpenWindow("Font Load Example", 800, 600);

            // Draw text using loaded font
            SplashKit.DrawText("Hello, SplashKit!", SplashKit.ColorBlack(), myFont, 40, 250, 270);
            SplashKit.RefreshScreen();

            SplashKit.Delay(5000);
            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

# Load font
my_font = load_font("my_font", "RobotoSlab.ttf")

open_window("Load Font Example", 800, 600)

# Draw text using loaded font
draw_text("Hello, SplashKit!", color_black(), my_font, 40, 250, 270)
refresh_screen()

delay(5000)
close_all_windows()

Output:

---

Set Font Style

Note

This function is overloaded. The following versions exist:

• Set Font Style (name: string, style: font_style)
• Set Font Style (fnt: font, style: font_style)

Set Font Style

Parameters:

Name	Type	Description
name	String	The name of the Font to set the style of.
style	Font Style	The new style for the Font.

Signatures:

C++

void set_font_style(const string &name, font_style style)

C#

public static void SplashKit.SetFontStyle(string name, FontStyle style);

Python

def set_font_style_name_as_string(name, style):

Pascal

procedure SetFontStyle(const name: String; style: FontStyle)

Usage:

See Implementations in Guides

• Get Started with SplashKit Audio

---

Set Font Style

Parameters:

Name	Type	Description
fnt	Font	The Font to set the style of.
style	Font Style	The new style for the Font.

Signatures:

C++

void set_font_style(font fnt, font_style style)

C#

public void Font.Style { set }
public static void SplashKit.SetFontStyle(Font fnt, FontStyle style);

Python

def set_font_style(fnt, style):

Pascal

procedure SetFontStyle(fnt: Font; style: FontStyle)

---

Text Height

Note

This function is overloaded. The following versions exist:

• Text Height (text: string, fnt: string, font_size: int)
• Text Height (text: string, fnt: font, font_size: int)

Text Height

Parameters:

Name	Type	Description
text	String	The text string to check the length of.
fnt	String	The font used for the text.
font_size	Integer	The size of the font used for the text.

Return Type: Integer

Signatures:

C++

int text_height(const string &text, const string &fnt, int font_size)

C#

public static int Text.Height(string text, string fnt, int fontSize);
public static int SplashKit.TextHeight(string text, string fnt, int fontSize);

Python

def text_height_font_named(text, fnt, font_size):

Pascal

function TextHeight(const text: String; const fnt: String; fontSize: Integer): Integer

---

Text Height

Parameters:

Name	Type	Description
text	String	The text string to check the length of.
fnt	Font	The font used for the text.
font_size	Integer	The size of the font used for the text.

Return Type: Integer

Signatures:

C++

int text_height(const string &text, font fnt, int font_size)

C#

public static int Text.Height(string text, Font fnt, int fontSize);
public static int SplashKit.TextHeight(string text, Font fnt, int fontSize);

Python

def text_height(text, fnt, font_size):

Pascal

function TextHeight(const text: String; fnt: Font; fontSize: Integer): Integer

---

Text Width

Note

This function is overloaded. The following versions exist:

• Text Width (text: string, fnt: string, font_size: int)
• Text Width (text: string, fnt: font, font_size: int)

Text Width

Parameters:

Name	Type	Description
text	String	The text string to check the length of.
fnt	String	The font used for the text.
font_size	Integer	The size of the font used for the text.

Return Type: Integer

Signatures:

C++

int text_width(const string &text, const string &fnt, int font_size)

C#

public static int Text.Width(string text, string fnt, int fontSize);
public static int SplashKit.TextWidth(string text, string fnt, int fontSize);

Python

def text_width_font_named(text, fnt, font_size):

Pascal

function TextWidth(const text: String; const fnt: String; fontSize: Integer): Integer

---

Text Width

Parameters:

Name	Type	Description
text	String	The text string to check the length of.
fnt	Font	The font used for the text.
font_size	Integer	The size of the font used for the text.

Return Type: Integer

Signatures:

C++

int text_width(const string &text, font fnt, int font_size)

C#

public static int Text.Width(string text, Font fnt, int fontSize);
public static int SplashKit.TextWidth(string text, Font fnt, int fontSize);

Python

def text_width(text, fnt, font_size):

Pascal

function TextWidth(const text: String; fnt: Font; fontSize: Integer): Integer

---

Draw Triangle

Note

This function is overloaded. The following versions exist:

• Draw Triangle (clr: color, tri: triangle)
• Draw Triangle (clr: color, tri: triangle, opts: drawing_options)
• Draw Triangle (clr: color, x1: double, y1: double, x2: double, y2: double, x3: double, y3: double)
• Draw Triangle (clr: color, x1: double, y1: double, x2: double, y2: double, x3: double, y3: double, opts: drawing_options)

Draw Triangle

Draw a triangle onto the current window.

Parameters:

Name	Type	Description
clr	Color	The color for the triangle
tri	Triangle	The triangles details

Signatures:

C++

void draw_triangle(color clr, const triangle &tri)

C#

public static void SplashKit.DrawTriangle(Color clr, Triangle tri);

Python

def draw_triangle_record(clr, tri):

Pascal

procedure DrawTriangle(clr: Color; const tri: Triangle)

---

Draw Triangle

Draw a triangle using the supplied drawing options.

Parameters:

Name	Type	Description
clr	Color	The color for the triangle
tri	Triangle	The triangles details
opts	Drawing Options	The drawing options

Signatures:

C++

void draw_triangle(color clr, const triangle &tri, drawing_options opts)

C#

public static void SplashKit.DrawTriangle(Color clr, Triangle tri, DrawingOptions opts);

Python

def draw_triangle_record_with_options(clr, tri, opts):

Pascal

procedure DrawTriangle(clr: Color; const tri: Triangle; opts: DrawingOptions)

---

Draw Triangle

Draw a triangle to the current window.

Parameters:

Name	Type	Description
clr	Color	The color for the triangle
x1	Double	The distance from the left side of the window to the first point of the triangle
y1	Double	The distance from the top of the window to the first point of the triangle
x2	Double	The distance from the left side of the window to the second point of the triangle
y2	Double	The distance from the top of the window to the second point of the triangle
x3	Double	The distance from the left side of the window to the third point of the triangle
y3	Double	The distance from the top of the window to the third point of the triangle

Signatures:

C++

void draw_triangle(color clr, double x1, double y1, double x2, double y2, double x3, double y3)

C#

public static void SplashKit.DrawTriangle(Color clr, double x1, double y1, double x2, double y2, double x3, double y3);

Python

def draw_triangle(clr, x1, y1, x2, y2, x3, y3):

Pascal

procedure DrawTriangle(clr: Color; x1: Double; y1: Double; x2: Double; y2: Double; x3: Double; y3: Double)

Usage:

See Code Examples

Example 1: Triangle Coordinates

C++

#include "splashkit.h"

int main()
{
    open_window("Triangle Coordinates", 800, 400);

    // Top middle triangle point
    int x1 = 400;
    int y1 = 100;

    // Bottom left triangle point
    int x2 = 200;
    int y2 = 300;

    // Bottom right triangle point
    int x3 = 600;
    int y3 = 300;

    clear_screen();

    // Draw triangle using the points above
    draw_triangle(COLOR_RED, x1, y1, x2, y2, x3, y3);

    // Draw triangle information
    fill_circle(COLOR_BLUE, x1, y1, 3);
    fill_circle(COLOR_BLUE, x2, y2, 3);
    fill_circle(COLOR_BLUE, x3, y3, 3);
    draw_text("(x=" + std::to_string(x1) + ", y=" + std::to_string(y1) + ")", COLOR_BLUE, x1 - 50, y1 - 20);
    draw_text("(x=" + std::to_string(x2) + ", y=" + std::to_string(y2) + ")", COLOR_BLUE, x2 - 120, y2);
    draw_text("(x=" + std::to_string(x3) + ", y=" + std::to_string(y3) + ")", COLOR_BLUE, x3 + 10, y3);
    refresh_screen();
    delay(10000);

    close_all_windows();
    return 0;
}

C#

Top-level Statements

using static SplashKitSDK.SplashKit;

OpenWindow("Triangle Coordinates", 800, 400);

// Top middle triangle point
int x1 = 400;
int y1 = 100;

// Bottom left triangle point
int x2 = 200;
int y2 = 300;

// Bottom right triangle point
int x3 = 600;
int y3 = 300;

ClearScreen();

// Draw triangle using the points above
DrawTriangle(ColorRed(), x1, y1, x2, y2, x3, y3);

// Draw triangle information
FillCircle(ColorBlue(), x1, y1, 3);
FillCircle(ColorBlue(), x2, y2, 3);
FillCircle(ColorBlue(), x3, y3, 3);
DrawText($"(x={x1}, y={y1})", ColorBlue(), x1 - 50, y1 - 20);
DrawText($"(x={x2}, y={y2})", ColorBlue(), x2 - 120, y2);
DrawText($"(x={x3}, y={y3})", ColorBlue(), x3 + 10, y3);
RefreshScreen();
Delay(10000);

CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace DrawTriangleExample
{
    public class Program
    {
        public static void Main()
        {
            SplashKit.OpenWindow("Triangle Coordinates", 800, 400);

            // Top middle triangle point
            int x1 = 400;
            int y1 = 100;

            // Bottom left triangle point
            int x2 = 200;
            int y2 = 300;

            // Bottom right triangle point
            int x3 = 600;
            int y3 = 300;

            SplashKit.ClearScreen();

            // Draw triangle using the points above
            SplashKit.DrawTriangle(Color.Red, x1, y1, x2, y2, x3, y3);

            // Draw triangle information
            SplashKit.FillCircle(Color.Blue, x1, y1, 3);
            SplashKit.FillCircle(Color.Blue, x2, y2, 3);
            SplashKit.FillCircle(Color.Blue, x3, y3, 3);
            SplashKit.DrawText($"(x={x1}, y={y1})", Color.Blue, x1 - 50, y1 - 20);
            SplashKit.DrawText($"(x={x2}, y={y2})", Color.Blue, x2 - 120, y2);
            SplashKit.DrawText($"(x={x3}, y={y3})", Color.Blue, x3 + 10, y3);
            SplashKit.RefreshScreen();
            SplashKit.Delay(10000);

            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

open_window("Triangle Coordinates", 800, 400)

# Top middle triangle point
x1 = 400
y1 = 100

# Bottom left triangle point
x2 = 200
y2 = 300

# Bottom right triangle point
x3 = 600
y3 = 300

clear_screen_to_white()

# Draw triangle using the points above
draw_triangle(color_red(), x1, y1, x2, y2, x3, y3)

# Draw triangle information
fill_circle(color_blue(), x1, y1, 3)
fill_circle(color_blue(), x2, y2, 3)
fill_circle(color_blue(), x3, y3, 3)
draw_text_no_font_no_size(f"(x={x1}, y={y1})", color_blue(), x1 - 50, y1 - 20)
draw_text_no_font_no_size(f"(x={x2}, y={y2})", color_blue(), x2 - 120, y2)
draw_text_no_font_no_size(f"(x={x3}, y={y3})", color_blue(), x3 + 10, y3)
refresh_screen()
delay(10000)

close_all_windows()

Output:

Example 2: Random Colourful Triangles

C++

#include "splashkit.h"

int main()
{
    open_window("Random Colourful Triangles", 800, 600);

    clear_screen();
    for (int i = 0; i < 10; i++)
    {
        // Random point 1 for the triangle (x1,y1)
        int x1 = rnd(800);
        int y1 = rnd(600);

        // Random point 2 for the triangle (x2,y2)
        int x2 = rnd(800);
        int y2 = rnd(600);

        // Random point 3 for the triangle (x3,y3)
        int x3 = rnd(800);
        int y3 = rnd(600);

        // Draw triangle using the random points above
        draw_triangle(random_rgb_color(255), x1, y1, x2, y2, x3, y3);
    }

    refresh_screen();
    delay(4000);

    close_all_windows();

    return 0;
}

C#

Top-level Statements

using static SplashKitSDK.SplashKit;

OpenWindow("Random Colourful Triangles", 800, 600);

ClearScreen();
for (int i = 0; i < 10; i++)
{
    // Random point 1 for the triangle (x1,y1)
    int x1 = Rnd(800);
    int y1 = Rnd(600);

    // Random point 2 for the triangle (x2,y2)
    int x2 = Rnd(800);
    int y2 = Rnd(600);

    // Random point 3 for the triangle (x3,y3)
    int x3 = Rnd(800);
    int y3 = Rnd(600);

    // Draw triangle using the random points above
    DrawTriangle(RandomRGBColor(255), x1, y1, x2, y2, x3, y3);
}

RefreshScreen();
Delay(4000);

CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace DrawTriangleExample
{
    public class Program
    {
        public static void Main()
        {
            SplashKit.OpenWindow("Random Colourful Triangles", 800, 600);

            SplashKit.ClearScreen();
            for (int i = 0; i < 10; i++)
            {
                // Random point 1 for the triangle (x1,y1)
                int x1 = SplashKit.Rnd(800);
                int y1 = SplashKit.Rnd(600);

                // Random point 2 for the triangle (x2,y2)
                int x2 = SplashKit.Rnd(800);
                int y2 = SplashKit.Rnd(600);

                // Random point 3 for the triangle (x3,y3)
                int x3 = SplashKit.Rnd(800);
                int y3 = SplashKit.Rnd(600);

                // Draw triangle using the random points above
                SplashKit.DrawTriangle(SplashKit.RandomRGBColor(255), x1, y1, x2, y2, x3, y3);
            }

            SplashKit.RefreshScreen();
            SplashKit.Delay(4000);

            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

open_window("Random Colourful Triangles", 800, 600)

clear_screen_to_white()
for i in range(10):
    # Random point 1 for the triangle (x1,y1)
    x1 = rnd_range(0,800)
    y1 = rnd_range(0,600)

    # Random point 2 for the triangle (x2,y2)
    x2 = rnd_range(0,800)
    y2 = rnd_range(0,600)

    # Random point 3 for the triangle (x3,y3)
    x3 = rnd_range(0,800)
    y3 = rnd_range(0,600)

    # Draw triangle using the random points above
    draw_triangle(random_rgb_color(255), x1, y1, x2, y2, x3, y3)

refresh_screen()
delay(4000)

close_all_windows()

Output:

---

Draw Triangle

Draw a triangle using the supplied drawing options.

Parameters:

Name	Type	Description
clr	Color	The color for the triangle
x1	Double	The distance from the left side of the bitmap/window to the first point of the triangle
y1	Double	The distance from the top of the bitmap/window to the first point of the triangle
x2	Double	The distance from the left side of the bitmap/window to the second point of the triangle
y2	Double	The distance from the top of the bitmap/window to the second point of the triangle
x3	Double	The distance from the left side of the bitmap/window to the third point of the triangle
y3	Double	The distance from the top of the bitmap/window to the third point of the triangle
opts	Drawing Options	The drawing options

Signatures:

C++

void draw_triangle(color clr, double x1, double y1, double x2, double y2, double x3, double y3, drawing_options opts)

C#

public static void SplashKit.DrawTriangle(Color clr, double x1, double y1, double x2, double y2, double x3, double y3, DrawingOptions opts);

Python

def draw_triangle_with_options(clr, x1, y1, x2, y2, x3, y3, opts):

Pascal

procedure DrawTriangle(clr: Color; x1: Double; y1: Double; x2: Double; y2: Double; x3: Double; y3: Double; opts: DrawingOptions)

---

Draw Triangle On Bitmap

Note

This function is overloaded. The following versions exist:

• Draw Triangle On Bitmap (destination: bitmap, clr: color, tri: triangle)
• Draw Triangle On Bitmap (destination: bitmap, clr: color, tri: triangle, opts: drawing_options)
• Draw Triangle On Bitmap (destination: bitmap, clr: color, x1: double, y1: double, x2: double, y2: double, x3: double, y3: double)
• Draw Triangle On Bitmap (destination: bitmap, clr: color, x1: double, y1: double, x2: double, y2: double, x3: double, y3: double, opts: drawing_options)

Draw Triangle On Bitmap

Draw a triangle on a given bitmap, using the supplied drawing options.

Parameters:

Name	Type	Description
destination	Bitmap	The bitmap which the triangle will be drawn on.
clr	Color	The color for the triangle
tri	Triangle	The triangles details

Signatures:

C++

void draw_triangle_on_bitmap(bitmap destination, color clr, const triangle &tri)

C#

public void Bitmap.DrawTriangle(Color clr, Triangle tri);
public static void SplashKit.DrawTriangleOnBitmap(Bitmap destination, Color clr, Triangle tri);

Python

def draw_triangle_on_bitmap_record(destination, clr, tri):

Pascal

procedure DrawTriangleOnBitmap(destination: Bitmap; clr: Color; const tri: Triangle)

---

Draw Triangle On Bitmap

Draw a triangle on a given bitmap, using the supplied drawing options.

Parameters:

Name	Type	Description
destination	Bitmap	The bitmap which the triangle will be drawn on.
clr	Color	The color for the triangle
tri	Triangle	The triangles details
opts	Drawing Options	The drawing options

Signatures:

C++

void draw_triangle_on_bitmap(bitmap destination, color clr, const triangle &tri, drawing_options opts)

C#

public void Bitmap.DrawTriangle(Color clr, Triangle tri, DrawingOptions opts);
public static void SplashKit.DrawTriangleOnBitmap(Bitmap destination, Color clr, Triangle tri, DrawingOptions opts);

Python

def draw_triangle_on_bitmap_record_with_options(destination, clr, tri, opts):

Pascal

procedure DrawTriangleOnBitmap(destination: Bitmap; clr: Color; const tri: Triangle; opts: DrawingOptions)

---

Draw Triangle On Bitmap

Draw a triangle to the given bitmap.

Parameters:

Name	Type	Description
destination	Bitmap	The bitmap which the triangle will be drawn on.
clr	Color	The color for the triangle
x1	Double	The distance from the left side of the bitmap to the first point of the triangle
y1	Double	The distance from the top of the bitmap to the first point of the triangle
x2	Double	The distance from the left side of the bitmap to the second point of the triangle
y2	Double	The distance from the top of the bitmap to the second point of the triangle
x3	Double	The distance from the left side of the bitmap to the third point of the triangle
y3	Double	The distance from the top of the bitmap to the third point of the triangle

Signatures:

C++

void draw_triangle_on_bitmap(bitmap destination, color clr, double x1, double y1, double x2, double y2, double x3, double y3)

C#

public void Bitmap.DrawTriangle(Color clr, double x1, double y1, double x2, double y2, double x3, double y3);
public static void SplashKit.DrawTriangleOnBitmap(Bitmap destination, Color clr, double x1, double y1, double x2, double y2, double x3, double y3);

Python

def draw_triangle_on_bitmap(destination, clr, x1, y1, x2, y2, x3, y3):

Pascal

procedure DrawTriangleOnBitmap(destination: Bitmap; clr: Color; x1: Double; y1: Double; x2: Double; y2: Double; x3: Double; y3: Double)

Usage:

See Code Examples

Example 1: Mountain Peaks

C++

#include "splashkit.h"

int main()
{
    // Create a window and bitmap for the mountain scene
    window window = open_window("Window", 400, 300);
    bitmap bitmap = create_bitmap("mountain", 400, 300);

    // Fill background with light blue color
    clear_bitmap(bitmap, COLOR_LIGHT_BLUE);

    // Draw right peak (smallest)
    draw_triangle_on_bitmap(bitmap, COLOR_GRAY,
                          175, 250,   // Left base
                          275, 175,   // Peak
                          375, 250);  // Right base

    // Draw left peak (medium)
    draw_triangle_on_bitmap(bitmap, COLOR_GRAY,
                          25, 250,    // Left base
                          125, 125,   // Peak
                          225, 250);  // Right base

    // Draw center peak (tallest)
    draw_triangle_on_bitmap(bitmap, COLOR_GRAY,
                          100, 250,   // Left base
                          200, 100,   // Peak
                          300, 250);  // Right base

    while (!window_close_requested(window))
    {
        process_events();
        // Draw the bitmap to the window
        draw_bitmap(bitmap, 0, 0);
        refresh_screen();
    }

    free_bitmap(bitmap);
    close_all_windows();
    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

// Create a window and bitmap for the mountain scene
Window window = OpenWindow("Window", 400, 300);
Bitmap bitmap = CreateBitmap("mountain", 400, 300);

// Fill background with light blue color
ClearBitmap(bitmap, ColorLightBlue());

// Draw right peak (smallest)
DrawTriangleOnBitmap(bitmap, ColorGray(),
                     175, 250,   // Left base
                     275, 175,   // Peak
                     375, 250);  // Right base

// Draw left peak (medium)
DrawTriangleOnBitmap(bitmap, ColorGray(),
                     25, 250,    // Left base
                     125, 125,   // Peak
                     225, 250);  // Right base

// Draw center peak (tallest)
DrawTriangleOnBitmap(bitmap, ColorGray(),
                     100, 250,   // Left base
                     200, 100,   // Peak
                     300, 250);  // Right base

while (!WindowCloseRequested(window))
{
    ProcessEvents();
    // Draw the bitmap to the window
    DrawBitmap(bitmap, 0, 0);
    RefreshScreen();
}

FreeBitmap(bitmap);
CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace DrawTriangleOnBitmap
{
    public class Program
    {
        public static void Main()
        {
            // Create a window and bitmap for the mountain scene
            Window window = new Window("Window", 400, 300);
            Bitmap bitmap = new Bitmap("mountain", 400, 300);

            // Fill background with light blue color
            bitmap.Clear(Color.LightBlue);

            // Draw right peak (smallest)
            bitmap.DrawTriangle(Color.Gray,
                              175, 250,   // Left base
                              275, 175,   // Peak
                              375, 250);  // Right base

            // Draw left peak (medium)
            bitmap.DrawTriangle(Color.Gray,
                              25, 250,    // Left base
                              125, 125,   // Peak
                              225, 250);  // Right base

            // Draw center peak (tallest)
            bitmap.DrawTriangle(Color.Gray,
                              100, 250,   // Left base
                              200, 100,   // Peak
                              300, 250);  // Right base

            while (!window.CloseRequested)
            {
                SplashKit.ProcessEvents();
                // Draw the bitmap to the window
                window.DrawBitmap(bitmap, 0, 0);
                SplashKit.RefreshScreen();
            }

            bitmap.Free();
            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

# Create a window and bitmap for the mountain scene
window = open_window("Window", 400, 300)
bitmap = create_bitmap("mountain", 400, 300)

# Fill background with light blue color
clear_bitmap(bitmap, color_light_blue())

# Draw right peak (smallest)
draw_triangle_on_bitmap(bitmap, color_gray(),
                       175, 250,   # Left base
                       275, 175,   # Peak
                       375, 250)   # Right base

# Draw left peak (medium)
draw_triangle_on_bitmap(bitmap, color_gray(),
                       25, 250,    # Left base
                       125, 125,   # Peak
                       225, 250)   # Right base

# Draw center peak (tallest)
draw_triangle_on_bitmap(bitmap, color_gray(),
                       100, 250,   # Left base
                       200, 100,   # Peak
                       300, 250)   # Right base

while not window_close_requested(window):
    process_events()
    # Draw the bitmap to the window
    draw_bitmap(bitmap, 0, 0)
    refresh_screen()

free_bitmap(bitmap)
close_all_windows()

Output:

---

Draw Triangle On Bitmap

Draw a triangle to the given bitmap, using the supplied drawing options.

Parameters:

Name	Type	Description
destination	Bitmap	The bitmap which the triangle will be drawn on.
clr	Color	The color for the triangle
x1	Double	The distance from the left side of the bitmap/bitmap to the first point of the triangle
y1	Double	The distance from the top of the bitmap/bitmap to the first point of the triangle
x2	Double	The distance from the left side of the bitmap/bitmap to the second point of the triangle
y2	Double	The distance from the top of the bitmap/bitmap to the second point of the triangle
x3	Double	The distance from the left side of the bitmap/bitmap to the third point of the triangle
y3	Double	The distance from the top of the bitmap/bitmap to the third point of the triangle
opts	Drawing Options	The drawing options

Signatures:

C++

void draw_triangle_on_bitmap(bitmap destination, color clr, double x1, double y1, double x2, double y2, double x3, double y3, drawing_options opts)

C#

public void Bitmap.DrawTriangle(Color clr, double x1, double y1, double x2, double y2, double x3, double y3, DrawingOptions opts);
public static void SplashKit.DrawTriangleOnBitmap(Bitmap destination, Color clr, double x1, double y1, double x2, double y2, double x3, double y3, DrawingOptions opts);

Python

def draw_triangle_on_bitmap_with_options(destination, clr, x1, y1, x2, y2, x3, y3, opts):

Pascal

procedure DrawTriangleOnBitmap(destination: Bitmap; clr: Color; x1: Double; y1: Double; x2: Double; y2: Double; x3: Double; y3: Double; opts: DrawingOptions)

---

Draw Triangle On Window

Note

This function is overloaded. The following versions exist:

• Draw Triangle On Window (destination: window, clr: color, tri: triangle)
• Draw Triangle On Window (destination: window, clr: color, tri: triangle, opts: drawing_options)
• Draw Triangle On Window (destination: window, clr: color, x1: double, y1: double, x2: double, y2: double, x3: double, y3: double)
• Draw Triangle On Window (destination: window, clr: color, x1: double, y1: double, x2: double, y2: double, x3: double, y3: double, opts: drawing_options)

Draw Triangle On Window

Draw a triangle on a given window, using the supplied drawing options.

Parameters:

Name	Type	Description
destination	Window	The window which the triangle will be drawn on.
clr	Color	The color for the triangle
tri	Triangle	The triangles details

Signatures:

C++

void draw_triangle_on_window(window destination, color clr, const triangle &tri)

C#

public void Window.DrawTriangle(Color clr, Triangle tri);
public static void SplashKit.DrawTriangleOnWindow(Window destination, Color clr, Triangle tri);

Python

def draw_triangle_on_window_record(destination, clr, tri):

Pascal

procedure DrawTriangleOnWindow(destination: Window; clr: Color; const tri: Triangle)

---

Draw Triangle On Window

Draw a triangle on a given window, using the supplied drawing options.

Parameters:

Name	Type	Description
destination	Window	The window which the triangle will be drawn on.
clr	Color	The color for the triangle
tri	Triangle	The triangles details
opts	Drawing Options	The drawing options

Signatures:

C++

void draw_triangle_on_window(window destination, color clr, const triangle &tri, drawing_options opts)

C#

public void Window.DrawTriangle(Color clr, Triangle tri, DrawingOptions opts);
public static void SplashKit.DrawTriangleOnWindow(Window destination, Color clr, Triangle tri, DrawingOptions opts);

Python

def draw_triangle_on_window_record_with_options(destination, clr, tri, opts):

Pascal

procedure DrawTriangleOnWindow(destination: Window; clr: Color; const tri: Triangle; opts: DrawingOptions)

---

Draw Triangle On Window

Draw a triangle to the given window.

Parameters:

Name	Type	Description
destination	Window	The window which the triangle will be drawn on.
clr	Color	The color for the triangle
x1	Double	The distance from the left side of the window to the first point of the triangle
y1	Double	The distance from the top of the window to the first point of the triangle
x2	Double	The distance from the left side of the window to the second point of the triangle
y2	Double	The distance from the top of the window to the second point of the triangle
x3	Double	The distance from the left side of the window to the third point of the triangle
y3	Double	The distance from the top of the window to the third point of the triangle

Signatures:

C++

void draw_triangle_on_window(window destination, color clr, double x1, double y1, double x2, double y2, double x3, double y3)

C#

public void Window.DrawTriangle(Color clr, double x1, double y1, double x2, double y2, double x3, double y3);
public static void SplashKit.DrawTriangleOnWindow(Window destination, Color clr, double x1, double y1, double x2, double y2, double x3, double y3);

Python

def draw_triangle_on_window(destination, clr, x1, y1, x2, y2, x3, y3):

Pascal

procedure DrawTriangleOnWindow(destination: Window; clr: Color; x1: Double; y1: Double; x2: Double; y2: Double; x3: Double; y3: Double)

Usage:

See Code Examples

Example 1: Colourful Bunting Flags

C++

#include "splashkit.h"

int main()
{
    window window = open_window("Draw Triangle on Window", 800, 600);

    clear_screen(COLOR_WHITE);
    for (int i = 0; i < 20; i++)
    {
        // Set the x position for triangles increase by 40 * i every round
        double x = 40 * i;

        // Draw the triangles by increasing x position
        draw_triangle_on_window(window, random_rgb_color(255), 0 + x, 0, 20 + x, 40, 40 + x, 0);
    }
    refresh_screen();

    delay(4000);
    close_all_windows();

    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

Window window = OpenWindow("Draw Triangle on Window", 800, 600);

ClearScreen(ColorWhite());
for (int i = 0; i < 20; i++)
{
    // Set the x position for triangles increase by 40 * i every round
    double x = 40 * i;

    // Draw the triangles by increasing x position
    DrawTriangleOnWindow(window, RandomRGBColor(255), 0 + x, 0, 20 + x, 40, 40 + x, 0);
}
RefreshScreen();

Delay(4000);
CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace DrawTriangleOnWindowExample
{
    public class Program
    {
        public static void Main()
        {
            Window window = new Window("Draw Triangle on Window", 800, 600);

            window.Clear(Color.White);
            for (int i = 0; i < 20; i++)
            {
                // Set the x position for triangles increase by 40 * i every round
                double x = 40 * i;

                // Draw the triangles by increasing x position
                SplashKit.DrawTriangleOnWindow(window, Color.RandomRGB(255), 0 + x, 0, 20 + x, 40, 40 + x, 0);
            }
            window.Refresh();

            SplashKit.Delay(4000);
            window.Close();
        }
    }
}

Python

from splashkit import *

window = open_window("Draw Triangle on Window", 800, 600)

clear_screen(color_white())
for i in range(20):
    # Set the x position for triangles increase by 40 * i every loop
    x = 40 * i

    # Draw the triangles by increasing x position
    draw_triangle_on_window(window, random_rgb_color(255), 0 + x, 0, 20 + x, 40, 40 + x, 0)
refresh_screen()

delay(4000)
close_all_windows()

Output:

---

Draw Triangle On Window

Draw a triangle to the given window, using the supplied drawing options.

Parameters:

Name	Type	Description
destination	Window	The window which the triangle will be drawn on.
clr	Color	The color for the triangle
x1	Double	The distance from the left side of the bitmap/window to the first point of the triangle
y1	Double	The distance from the top of the bitmap/window to the first point of the triangle
x2	Double	The distance from the left side of the bitmap/window to the second point of the triangle
y2	Double	The distance from the top of the bitmap/window to the second point of the triangle
x3	Double	The distance from the left side of the bitmap/window to the third point of the triangle
y3	Double	The distance from the top of the bitmap/window to the third point of the triangle
opts	Drawing Options	The drawing options

Signatures:

C++

void draw_triangle_on_window(window destination, color clr, double x1, double y1, double x2, double y2, double x3, double y3, drawing_options opts)

C#

public void Window.DrawTriangle(Color clr, double x1, double y1, double x2, double y2, double x3, double y3, DrawingOptions opts);
public static void SplashKit.DrawTriangleOnWindow(Window destination, Color clr, double x1, double y1, double x2, double y2, double x3, double y3, DrawingOptions opts);

Python

def draw_triangle_on_window_with_options(destination, clr, x1, y1, x2, y2, x3, y3, opts):

Pascal

procedure DrawTriangleOnWindow(destination: Window; clr: Color; x1: Double; y1: Double; x2: Double; y2: Double; x3: Double; y3: Double; opts: DrawingOptions)

---

Fill Triangle

Note

This function is overloaded. The following versions exist:

• Fill Triangle (clr: color, tri: triangle)
• Fill Triangle (clr: color, tri: triangle, opts: drawing_options)
• Fill Triangle (clr: color, x1: double, y1: double, x2: double, y2: double, x3: double, y3: double)
• Fill Triangle (clr: color, x1: double, y1: double, x2: double, y2: double, x3: double, y3: double, opts: drawing_options)

Fill Triangle

Draw a triangle onto the current window.

Parameters:

Name	Type	Description
clr	Color	The color for the triangle
tri	Triangle	The triangles details

Signatures:

C++

void fill_triangle(color clr, const triangle &tri)

C#

public static void SplashKit.FillTriangle(Color clr, Triangle tri);

Python

def fill_triangle_record(clr, tri):

Pascal

procedure FillTriangle(clr: Color; const tri: Triangle)

---

Fill Triangle

Fill a triangle using the supplied drawing options.

Parameters:

Name	Type	Description
clr	Color	The color for the triangle
tri	Triangle	The triangles details
opts	Drawing Options	The drawing options

Signatures:

C++

void fill_triangle(color clr, const triangle &tri, drawing_options opts)

C#

public static void SplashKit.FillTriangle(Color clr, Triangle tri, DrawingOptions opts);

Python

def fill_triangle_record_with_options(clr, tri, opts):

Pascal

procedure FillTriangle(clr: Color; const tri: Triangle; opts: DrawingOptions)

---

Fill Triangle

Fills a triangle on the current window.

Parameters:

Name	Type	Description
clr	Color	The color for the triangle
x1	Double	The distance from the left side of the window to the first point of the triangle
y1	Double	The distance from the top of the window to the first point of the triangle
x2	Double	The distance from the left side of the window to the second point of the triangle
y2	Double	The distance from the top of the window to the second point of the triangle
x3	Double	The distance from the left side of the window to the third point of the triangle
y3	Double	The distance from the top of the window to the third point of the triangle

Signatures:

C++

void fill_triangle(color clr, double x1, double y1, double x2, double y2, double x3, double y3)

C#

public static void SplashKit.FillTriangle(Color clr, double x1, double y1, double x2, double y2, double x3, double y3);

Python

def fill_triangle(clr, x1, y1, x2, y2, x3, y3):

Pascal

procedure FillTriangle(clr: Color; x1: Double; y1: Double; x2: Double; y2: Double; x3: Double; y3: Double)

Usage:

See Implementations in Guides

• Drawing using Procedures

See Code Examples

Example 1: Basic Red Triangle

C++

#include "splashkit.h"

int main()
{
    open_window("Fill Triangle Example", 800, 600);

    clear_screen();
    fill_triangle(COLOR_RED, 100, 100, 200, 200, 300, 100);
    refresh_screen();

    delay(5000);
    close_all_windows();

    return 0;
}

C#

Top-level Statements

using static SplashKitSDK.SplashKit;

OpenWindow("Fill Triangle Example", 800, 600);

ClearScreen();
FillTriangle(ColorRed(), 100, 100, 200, 200, 300, 100);
RefreshScreen();

Delay(5000);
CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace FillTriangleExample
{
    public class Program
    {
        public static void Main()
        {
            SplashKit.OpenWindow("Fill Triangle Example", 800, 600);

            SplashKit.ClearScreen();
            SplashKit.FillTriangle(Color.Red, 100, 100, 200, 200, 300, 100);
            SplashKit.RefreshScreen();

            SplashKit.Delay(5000);
            SplashKit.CloseAllWindows();
        }
    }
}

Python

from splashkit import *

open_window("Fill Triangle Example", 800, 600)

clear_screen_to_white()
fill_triangle(color_red(), 100, 100, 200, 200, 300, 100)
refresh_screen()

delay(5000)
close_all_windows()

Output:

---

Fill Triangle

Fills a triangle using the supplied drawing options.

Parameters:

Name	Type	Description
clr	Color	The color for the triangle
x1	Double	The distance from the left side of the bitmap/window to the first point of the triangle
y1	Double	The distance from the top of the bitmap/window to the first point of the triangle
x2	Double	The distance from the left side of the bitmap/window to the second point of the triangle
y2	Double	The distance from the top of the bitmap/window to the second point of the triangle
x3	Double	The distance from the left side of the bitmap/window to the third point of the triangle
y3	Double	The distance from the top of the bitmap/window to the third point of the triangle
opts	Drawing Options	The drawing options

Signatures:

C++

void fill_triangle(color clr, double x1, double y1, double x2, double y2, double x3, double y3, drawing_options opts)

C#

public static void SplashKit.FillTriangle(Color clr, double x1, double y1, double x2, double y2, double x3, double y3, DrawingOptions opts);

Python

def fill_triangle_with_options(clr, x1, y1, x2, y2, x3, y3, opts):

Pascal

procedure FillTriangle(clr: Color; x1: Double; y1: Double; x2: Double; y2: Double; x3: Double; y3: Double; opts: DrawingOptions)

---

Fill Triangle On Bitmap

Note

This function is overloaded. The following versions exist:

• Fill Triangle On Bitmap (destination: bitmap, clr: color, tri: triangle)
• Fill Triangle On Bitmap (destination: bitmap, clr: color, tri: triangle, opts: drawing_options)
• Fill Triangle On Bitmap (destination: bitmap, clr: color, x1: double, y1: double, x2: double, y2: double, x3: double, y3: double)
• Fill Triangle On Bitmap (destination: bitmap, clr: color, x1: double, y1: double, x2: double, y2: double, x3: double, y3: double, opts: drawing_options)

Fill Triangle On Bitmap

Fill a triangle on a given bitmap

Parameters:

Name	Type	Description
destination	Bitmap	The bitmap which the triangle will be drawn on.
clr	Color	The color for the triangle
tri	Triangle	The triangles details

Signatures:

C++

void fill_triangle_on_bitmap(bitmap destination, color clr, const triangle &tri)

C#

public void Bitmap.FillTriangle(Color clr, Triangle tri);
public static void SplashKit.FillTriangleOnBitmap(Bitmap destination, Color clr, Triangle tri);

Python

def fill_triangle_on_bitmap_record(destination, clr, tri):

Pascal

procedure FillTriangleOnBitmap(destination: Bitmap; clr: Color; const tri: Triangle)

---

Fill Triangle On Bitmap

Fill a triangle on a given bitmap, using given drawing options

Parameters:

Name	Type	Description
destination	Bitmap	The bitmap which the triangle will be drawn on.
clr	Color	The color for the triangle
tri	Triangle	The triangles details
opts	Drawing Options	The drawing options

Signatures:

C++

void fill_triangle_on_bitmap(bitmap destination, color clr, const triangle &tri, drawing_options opts)

C#

public void Bitmap.FillTriangle(Color clr, Triangle tri, DrawingOptions opts);
public static void SplashKit.FillTriangleOnBitmap(Bitmap destination, Color clr, Triangle tri, DrawingOptions opts);

Python

def fill_triangle_on_bitmap_record_with_options(destination, clr, tri, opts):

Pascal

procedure FillTriangleOnBitmap(destination: Bitmap; clr: Color; const tri: Triangle; opts: DrawingOptions)

---

Fill Triangle On Bitmap

Fill a triangle on a given bitmap

Parameters:

Name	Type	Description
destination	Bitmap	The bitmap which the triangle will be drawn on.
clr	Color	The color for the triangle
x1	Double	The distance from the left side of the bitmap to the first point of the triangle
y1	Double	The distance from the top of the bitmap to the first point of the triangle
x2	Double	The distance from the left side of the bitmap to the second point of the triangle
y2	Double	The distance from the top of the bitmap to the second point of the triangle
x3	Double	The distance from the left side of the bitmap to the third point of the triangle
y3	Double	The distance from the top of the bitmap to the third point of the triangle

Signatures:

C++

void fill_triangle_on_bitmap(bitmap destination, color clr, double x1, double y1, double x2, double y2, double x3, double y3)

C#

public void Bitmap.FillTriangle(Color clr, double x1, double y1, double x2, double y2, double x3, double y3);
public static void SplashKit.FillTriangleOnBitmap(Bitmap destination, Color clr, double x1, double y1, double x2, double y2, double x3, double y3);

Python

def fill_triangle_on_bitmap(destination, clr, x1, y1, x2, y2, x3, y3):

Pascal

procedure FillTriangleOnBitmap(destination: Bitmap; clr: Color; x1: Double; y1: Double; x2: Double; y2: Double; x3: Double; y3: Double)

Usage:

See Code Examples

Example 1: Hooray! A Red Hat

Note

To test this example code you can download these Resources.

C++

#include "splashkit.h"

int main()
{
    // Open a window
    open_window("Happy Hat", 618, 618);

    // Load the bitmaps for sad and smiling emojis (https://openmoji.org/library/#group=smileys-emotion)
    bitmap sad_emoji = load_bitmap("sad_emoji", "sad_emoji.png");
    bitmap smiling_emoji = load_bitmap("smiling_emoji", "smiling_emoji.png");

    // Draw the sad emoji and add a hat
    clear_screen(COLOR_BLACK);
    draw_bitmap(sad_emoji, 0, 0);
    refresh_screen();
    delay(1000);

    // Draw a triangle hat on the smiling emoji
    fill_triangle_on_bitmap(smiling_emoji, COLOR_RED, 100, 200, 309, 20, 520, 200);

    // Clear screen and switch to the smiling emoji
    clear_screen(COLOR_BLACK);
    draw_bitmap(smiling_emoji, 0, 0);
    refresh_screen();
    delay(1000);

    // Spin the smiling emoji with the hat
    for (int i = 0; i < 360; i++)
    {
        clear_screen(COLOR_BLACK);
        draw_bitmap(smiling_emoji, 0, 0, option_rotate_bmp(i));
        refresh_screen();
        delay(10);
    }

    // Free the bitmap resource
    free_all_bitmaps();
    // Close all windows
    close_all_windows();

    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

// Open a window
OpenWindow("Happy Hat", 618, 618);

// Load the bitmaps for sad and smiling emojis (https://openmoji.org/library/#group=smileys-emotion)
Bitmap sadEmoji = LoadBitmap("sad_emoji", "sad_emoji.png");
Bitmap smilingEmoji = LoadBitmap("smiling_emoji", "smiling_emoji.png");

// Draw the sad emoji and add a hat
ClearScreen(ColorBlack());
DrawBitmap(sadEmoji, 0, 0);
RefreshScreen();
Delay(1000);

// Draw a triangle hat on the smiling emoji
FillTriangleOnBitmap(smilingEmoji, ColorRed(), 100, 200, 309, 20, 520, 200);

// Clear screen and switch to the smiling emoji
ClearScreen(ColorBlack());
DrawBitmap(smilingEmoji, 0, 0);
RefreshScreen();
Delay(1000);

// Spin the smiling emoji with the hat
for (int i = 0; i < 360; i++)
{
    ClearScreen(ColorBlack());
    DrawBitmap(smilingEmoji, 0, 0, OptionRotateBmp(i));
    RefreshScreen();
    Delay(10);
}

// Free the bitmap resource
FreeAllBitmaps();
// Close all windows
CloseAllWindows();

Object-Oriented

using SplashKitSDK;

namespace FillTriangleOnBitmapExample
{
    public class Program
    {
        public static void Main()
        {
            //Open a Window
            SplashKit.OpenWindow("Happy Hat", 618, 618);

            //Load the bitmaps for sad and smiling emojis (https://openmoji.org/library/#group=smileys-emotion)
            Bitmap sadEmoji = SplashKit.LoadBitmap("sad_emoji", "sad_emoji.png");
            Bitmap smilingEmoji = SplashKit.LoadBitmap("smiling_emoji", "smiling_emoji.png");

            // Draw the sad emoji and add a hat
            SplashKit.ClearScreen(Color.Black);
            SplashKit.DrawBitmap(sadEmoji, 0, 0);
            SplashKit.RefreshScreen();
            SplashKit.Delay(1000);

            // Draw a triangle hat on the smiling emoji
            // SplashKit.FillTriangleOnBitmap(smilingEmoji, Color.Red, 100, 200, 309, 20, 520, 200);
            smilingEmoji.FillTriangle(Color.Red, 100, 200, 309, 20, 520, 200);

            // Clear Screen and switch to smiling emoji
            SplashKit.ClearScreen(Color.Black);
            SplashKit.DrawBitmap(smilingEmoji, 0, 0);
            SplashKit.RefreshScreen();
            SplashKit.Delay(1000);

            // Spin the smiling emoji with the hat
            for (int i = 0; i < 360; i++)
            {
                SplashKit.ClearScreen(Color.Black);
                SplashKit.DrawBitmap(smilingEmoji, 0, 0, SplashKit.OptionRotateBmp(i));
                SplashKit.RefreshScreen();
                SplashKit.Delay(10);
            }

            // Free the bitmap resource
            SplashKit.FreeAllBitmaps();
            // CLose all windows
            SplashKit.CloseAllWindows();

        }
    }
}

Python

from splashkit import *

# Open a window
open_window("Happy Hat", 618, 618)

# Load the bitmaps for sad and smiling emojis (https://openmoji.org/library/#group=smileys-emotion)
sad_emoji = load_bitmap("sad_emoji", "sad_emoji.png")
smiling_emoji = load_bitmap("smiling_emoji", "smiling_emoji.png")

# Draw the sad emoji and add a hat
clear_screen(color_black())
draw_bitmap(sad_emoji, 0, 0)
refresh_screen()
delay(1000)

# Draw a triangle hat on the smiling emoji
fill_triangle_on_bitmap(smiling_emoji, color_red(), 100, 200, 309, 20, 520, 200);

# Clear screen and switch to the smiling emoji
clear_screen(color_black())
draw_bitmap(smiling_emoji, 0, 0)
refresh_screen()
delay(1000)

# Spin the smiling emoji with the hat
for i in range(0, 360):
    clear_screen(color_black())
    draw_bitmap_with_options(smiling_emoji, 0 , 0, option_rotate_bmp(i))
    refresh_screen()
    delay(10)

# Free the bitmap resource
free_all_bitmaps()
# Close all windows
close_all_windows()

Output:

---

Fill Triangle On Bitmap

Fill a triangle on a given bitmap, using the supplied drawing options.

Parameters:

Name	Type	Description
destination	Bitmap	The bitmap which the triangle will be drawn on.
clr	Color	The color for the triangle
x1	Double	The distance from the left side of the bitmap/bitmap to the first point of the triangle
y1	Double	The distance from the top of the bitmap/bitmap to the first point of the triangle
x2	Double	The distance from the left side of the bitmap/bitmap to the second point of the triangle
y2	Double	The distance from the top of the bitmap/bitmap to the second point of the triangle
x3	Double	The distance from the left side of the bitmap/bitmap to the third point of the triangle
y3	Double	The distance from the top of the bitmap/bitmap to the third point of the triangle
opts	Drawing Options	The drawing options

Signatures:

C++

void fill_triangle_on_bitmap(bitmap destination, color clr, double x1, double y1, double x2, double y2, double x3, double y3, drawing_options opts)

C#

public void Bitmap.FillTriangle(Color clr, double x1, double y1, double x2, double y2, double x3, double y3, DrawingOptions opts);
public static void SplashKit.FillTriangleOnBitmap(Bitmap destination, Color clr, double x1, double y1, double x2, double y2, double x3, double y3, DrawingOptions opts);

Python

def fill_triangle_on_bitmap_with_options(destination, clr, x1, y1, x2, y2, x3, y3, opts):

Pascal

procedure FillTriangleOnBitmap(destination: Bitmap; clr: Color; x1: Double; y1: Double; x2: Double; y2: Double; x3: Double; y3: Double; opts: DrawingOptions)

---

Fill Triangle On Window

Note

This function is overloaded. The following versions exist:

• Fill Triangle On Window (destination: window, clr: color, tri: triangle)
• Fill Triangle On Window (destination: window, clr: color, tri: triangle, opts: drawing_options)
• Fill Triangle On Window (destination: window, clr: color, x1: double, y1: double, x2: double, y2: double, x3: double, y3: double)
• Fill Triangle On Window (destination: window, clr: color, x1: double, y1: double, x2: double, y2: double, x3: double, y3: double, opts: drawing_options)

Fill Triangle On Window

Fill a triangle on a given window

Parameters:

Name	Type	Description
destination	Window	The window which the triangle will be drawn on.
clr	Color	The color for the triangle
tri	Triangle	The triangles details

Signatures:

C++

void fill_triangle_on_window(window destination, color clr, const triangle &tri)

C#

public void Window.FillTriangle(Color clr, Triangle tri);
public static void SplashKit.FillTriangleOnWindow(Window destination, Color clr, Triangle tri);

Python

def fill_triangle_on_window_record(destination, clr, tri):

Pascal

procedure FillTriangleOnWindow(destination: Window; clr: Color; const tri: Triangle)

Usage:

See Code Examples

Example 1: Filled Triangles on Separate Windows

C++

#include "splashkit.h"

int main()
{
    window blue_window = open_window("Blue Triangle", 200, 200);
    window red_window = open_window("Red Triangle", 200, 200);
    move_window_to(red_window, window_x(blue_window) + window_width(blue_window), window_y(blue_window));

    // Define the triangles to draw
    triangle blue_triangle = triangle_from(point_at(50, 100), point_at(100, 50), point_at(150, 100));
    triangle red_triangle =  triangle_from(point_at(50, 50), point_at(100, 100), point_at(150, 50));

    // Fill a blue triangle on the first window
    clear_window(blue_window, COLOR_WHITE);
    fill_triangle_on_window(blue_window, COLOR_BLUE, blue_triangle);
    refresh_window(blue_window);

    // Fill a red triangle on the second window
    clear_window(red_window, COLOR_WHITE);
    fill_triangle_on_window(red_window, COLOR_RED, red_triangle);
    refresh_window(red_window);

    delay(5000);

    close_window(blue_window);
    close_window(red_window);

    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

Window blueWindow = OpenWindow("Blue Triangle", 200, 200);
Window redWindow = OpenWindow("Red Triangle", 200, 200);
MoveWindowTo(redWindow, WindowX(blueWindow) + WindowWidth(blueWindow), WindowY(blueWindow));

// Define the triangles to draw
Triangle blueTriangle = TriangleFrom(PointAt(50, 100), PointAt(100, 50), PointAt(150, 100));
Triangle redTriangle = TriangleFrom(PointAt(50, 50), PointAt(100, 100), PointAt(150, 50));

// Fill a blue triangle on the first window
ClearWindow(blueWindow, ColorWhite());
FillTriangleOnWindow(blueWindow, ColorBlue(), blueTriangle);
RefreshWindow(blueWindow);

// Fill a red triangle on the second window
ClearWindow(redWindow, ColorWhite());
FillTriangleOnWindow(redWindow, ColorRed(), redTriangle);
RefreshWindow(redWindow);

Delay(10000);

CloseWindow(blueWindow);
CloseWindow(redWindow);

Object-Oriented

using SplashKitSDK;

namespace FillTriangleOnWindowExample
{
    public class Program
    {
        public static void Main()
        {

            Window blueWindow = SplashKit.OpenWindow("Blue Triangle", 200, 200);
            Window redWindow = SplashKit.OpenWindow("Red Triangle", 200, 200);
            redWindow.MoveTo(blueWindow.X + blueWindow.Width, blueWindow.Y);

            // Define the triangles to draw
            Triangle blueTriangle = SplashKit.TriangleFrom(SplashKit.PointAt(50, 100), SplashKit.PointAt(100, 50), SplashKit.PointAt(150, 100));
            Triangle redTriangle = SplashKit.TriangleFrom(SplashKit.PointAt(50, 50), SplashKit.PointAt(100, 100), SplashKit.PointAt(150, 50));

            // Fill a blue triangle on the first window
            blueWindow.Clear(Color.White);
            SplashKit.FillTriangleOnWindow(blueWindow, Color.Blue, blueTriangle);
            blueWindow.Refresh();

            // Fill a red triangle on the second window
            redWindow.Clear(Color.White);
            SplashKit.FillTriangleOnWindow(redWindow, Color.Red, redTriangle);
            redWindow.Refresh();

            SplashKit.Delay(10000);

            SplashKit.CloseWindow(blueWindow);
            SplashKit.CloseWindow(redWindow);
        }
    }
}

Python

from splashkit import *

blue_window = open_window("Blue Triangle", 200, 200)
red_window = open_window("Red Triangle", 200, 200)
move_window_to(red_window, window_x(blue_window) + window_width(blue_window), window_y(blue_window))

# Define the triangles to draw
blue_triangle = triangle_from(point_at(50, 100), point_at(100, 50), point_at(150, 100))
red_triangle =  triangle_from(point_at(50, 50), point_at(100, 100), point_at(150, 50))

# Fill a blue triangle on the first window
clear_window(blue_window, color_white())
fill_triangle_on_window_record(blue_window, color_blue(), blue_triangle)
refresh_window(blue_window)

# Fill a red triangle on the second window
clear_window(red_window, color_white())
fill_triangle_on_window_record(red_window, color_red(), red_triangle)
refresh_window(red_window)

delay(10000)

close_window(blue_window)
close_window(red_window)

Output:

---

Fill Triangle On Window

Fill a triangle on a given window, using given drawing options

Parameters:

Name	Type	Description
destination	Window	The window which the triangle will be drawn on.
clr	Color	The color for the triangle
tri	Triangle	The triangles details
opts	Drawing Options	The drawing options

Signatures:

C++

void fill_triangle_on_window(window destination, color clr, const triangle &tri, drawing_options opts)

C#

public void Window.FillTriangle(Color clr, Triangle tri, DrawingOptions opts);
public static void SplashKit.FillTriangleOnWindow(Window destination, Color clr, Triangle tri, DrawingOptions opts);

Python

def fill_triangle_on_window_record_with_options(destination, clr, tri, opts):

Pascal

procedure FillTriangleOnWindow(destination: Window; clr: Color; const tri: Triangle; opts: DrawingOptions)

---

Fill Triangle On Window

Fill a triangle on a given window

Parameters:

Name	Type	Description
destination	Window	The window which the triangle will be drawn on.
clr	Color	The color for the triangle
x1	Double	The distance from the left side of the window to the first point of the triangle
y1	Double	The distance from the top of the window to the first point of the triangle
x2	Double	The distance from the left side of the window to the second point of the triangle
y2	Double	The distance from the top of the window to the second point of the triangle
x3	Double	The distance from the left side of the window to the third point of the triangle
y3	Double	The distance from the top of the window to the third point of the triangle

Signatures:

C++

void fill_triangle_on_window(window destination, color clr, double x1, double y1, double x2, double y2, double x3, double y3)

C#

public void Window.FillTriangle(Color clr, double x1, double y1, double x2, double y2, double x3, double y3);
public static void SplashKit.FillTriangleOnWindow(Window destination, Color clr, double x1, double y1, double x2, double y2, double x3, double y3);

Python

def fill_triangle_on_window(destination, clr, x1, y1, x2, y2, x3, y3):

Pascal

procedure FillTriangleOnWindow(destination: Window; clr: Color; x1: Double; y1: Double; x2: Double; y2: Double; x3: Double; y3: Double)

Usage:

See Code Examples

Example 1: Filled Triangles on Separate Windows

C++

#include "splashkit.h"

int main()
{
    window blue_window = open_window("Blue Triangle", 200, 200);
    window red_window = open_window("Red Triangle", 200, 200);
    move_window_to(red_window, window_x(blue_window) + window_width(blue_window), window_y(blue_window));

    // Fill a blue triangle on the first window
    clear_window(blue_window, COLOR_WHITE);
    fill_triangle_on_window(blue_window, COLOR_BLUE, 50, 100, 100, 50, 150, 100);
    refresh_window(blue_window);

    // Fill a red triangle on the second window
    clear_window(red_window, COLOR_WHITE);
    fill_triangle_on_window(red_window, COLOR_RED, 50, 50, 100, 100, 150, 50);
    refresh_window(red_window);

    delay(5000);

    close_window(blue_window);
    close_window(red_window);

    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

Window blueWindow = OpenWindow("Blue Triangle", 200, 200);
Window redWindow = OpenWindow("Red Triangle", 200, 200);
MoveWindowTo(redWindow, WindowX(blueWindow) + WindowWidth(blueWindow), WindowY(blueWindow));

// Fill a blue triangle on the first window
ClearWindow(blueWindow, ColorWhite());
FillTriangleOnWindow(blueWindow, ColorBlue(), 50, 100, 100, 50, 150, 100);
RefreshWindow(blueWindow);

// Fill a red triangle on the second window
ClearWindow(redWindow, ColorWhite());
FillTriangleOnWindow(redWindow, ColorRed(), 50, 50, 100, 100, 150, 50);
RefreshWindow(redWindow);

Delay(10000);

CloseWindow(blueWindow);
CloseWindow(redWindow);

Object-Oriented

using SplashKitSDK;

namespace FillTriangleOnWindowExample
{
    public class Program
    {
        public static void Main()
        {

            Window blueWindow = SplashKit.OpenWindow("Blue Triangle", 200, 200);
            Window redWindow = SplashKit.OpenWindow("Red Triangle", 200, 200);
            redWindow.MoveTo(blueWindow.X + blueWindow.Width, blueWindow.Y);

            // Fill a blue triangle on the first window
            blueWindow.Clear(Color.White);
            SplashKit.FillTriangleOnWindow(blueWindow, Color.Blue, 50, 100, 100, 50, 150, 100);
            blueWindow.Refresh();

            // Fill a red triangle on the second window
            redWindow.Clear(Color.White);
            SplashKit.FillTriangleOnWindow(redWindow, Color.Red, 50, 50, 100, 100, 150, 50);
            redWindow.Refresh();

            SplashKit.Delay(10000);

            SplashKit.CloseWindow(blueWindow);
            SplashKit.CloseWindow(redWindow);
        }
    }
}

Python

from splashkit import *

blue_window = open_window("Blue Triangle", 200, 200)
red_window = open_window("Red Triangle", 200, 200)
move_window_to(red_window, window_x(blue_window) + window_width(blue_window), window_y(blue_window))

# Fill a blue triangle on the first window
clear_window(blue_window, color_white())
fill_triangle_on_window(blue_window, color_blue(), 50, 100, 100, 50, 150, 100)
refresh_window(blue_window)

# Fill a red triangle on the second window
clear_window(red_window, color_white())
fill_triangle_on_window(red_window, color_red(), 50, 50, 100, 100, 150, 50)
refresh_window(red_window)

delay(10000)

close_window(blue_window)
close_window(red_window)

Output:

---

Fill Triangle On Window

Fill a triangle on a given window, using the supplied drawing options.

Parameters:

Name	Type	Description
destination	Window	The window which the triangle will be drawn on.
clr	Color	The color for the triangle
x1	Double	The distance from the left side of the bitmap/window to the first point of the triangle
y1	Double	The distance from the top of the bitmap/window to the first point of the triangle
x2	Double	The distance from the left side of the bitmap/window to the second point of the triangle
y2	Double	The distance from the top of the bitmap/window to the second point of the triangle
x3	Double	The distance from the left side of the bitmap/window to the third point of the triangle
y3	Double	The distance from the top of the bitmap/window to the third point of the triangle
opts	Drawing Options	The drawing options

Signatures:

C++

void fill_triangle_on_window(window destination, color clr, double x1, double y1, double x2, double y2, double x3, double y3, drawing_options opts)

C#

public void Window.FillTriangle(Color clr, double x1, double y1, double x2, double y2, double x3, double y3, DrawingOptions opts);
public static void SplashKit.FillTriangleOnWindow(Window destination, Color clr, double x1, double y1, double x2, double y2, double x3, double y3, DrawingOptions opts);

Python

def fill_triangle_on_window_with_options(destination, clr, x1, y1, x2, y2, x3, y3, opts):

Pascal

procedure FillTriangleOnWindow(destination: Window; clr: Color; x1: Double; y1: Double; x2: Double; y2: Double; x3: Double; y3: Double; opts: DrawingOptions)

---