From 78c0ba0f26a748297ff0f87a47aa74fcf8aab074 Mon Sep 17 00:00:00 2001 From: Andrew Cain Date: Fri, 5 Jul 2024 08:04:29 +1000 Subject: [PATCH] Update api.json --- scripts/api.json | 4594 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 4594 insertions(+) diff --git a/scripts/api.json b/scripts/api.json index 1f2f172c..5d93ea2b 100644 --- a/scripts/api.json +++ b/scripts/api.json @@ -46433,6 +46433,4600 @@ ] }, + "interface": { + "brief": "SplashKit Interface provides functions to create user interfaces, with elements such as draggable panels, buttons and text boxes.", + "description": "SplashKit`s interface library provides various functions for creating\npanels, and drawing interface elements such as buttons, text boxes, and more", + "functions": [ + { + "signature": "void add_column(int width);", + "name": "add_column", + "method_name": null, + "unique_global_name": "add_column", + "unique_method_name": null, + "suffix_name": null, + "description": "Adds a column to the current layout with width `width`.\n\n- Positive values of width just specify the width in pixels.\n- 0 means use the default control width - not always a good choice.\n- Negative values specify filling to the right _until_ `width + 1` pixels away from the edge.\n- e.g -1 fills entirely to the right, while -20 leaves a 19 pixel gap on the right.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "width": { + "type": "int", + "description": "Width of the column in pixels", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def add_column(width):" + ], + "pascal": [ + "procedure AddColumn(width: Integer)" + ], + "csharp": [ + "public static void Interface.AddColumn(int width);", + "public static void SplashKit.AddColumn(int width);" + ], + "cpp": [ + "void add_column(int width)" + ] + } + }, + { + "signature": "void add_column_relative(double width);", + "name": "add_column_relative", + "method_name": null, + "unique_global_name": "add_column_relative", + "unique_method_name": null, + "suffix_name": null, + "description": "Adds a column to the current layout with width `width` percentage of the container's width.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "width": { + "type": "double", + "description": "Percentage of the container's width (between 0 and 1)", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def add_column_relative(width):" + ], + "pascal": [ + "procedure AddColumnRelative(width: Double)" + ], + "csharp": [ + "public static void Interface.AddColumnRelative(double width);", + "public static void SplashKit.AddColumnRelative(double width);" + ], + "cpp": [ + "void add_column_relative(double width)" + ] + } + }, + { + "signature": "bool bitmap_button(bitmap bmp);", + "name": "bitmap_button", + "method_name": null, + "unique_global_name": "bitmap_button", + "unique_method_name": null, + "suffix_name": null, + "description": "Creates a button with a bitmap in it, and no label.\nReturns whether the button was clicked.", + "brief": null, + "return": { + "type": "bool", + "description": "Whether the button was clicked", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "bmp": { + "type": "bitmap", + "description": "The bitmap to show inside the button", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def bitmap_button(bmp):" + ], + "pascal": [ + "function BitmapButton(bmp: Bitmap): Boolean" + ], + "csharp": [ + "public static bool Interface.BitmapButton(Bitmap bmp);", + "public static bool SplashKit.BitmapButton(Bitmap bmp);" + ], + "cpp": [ + "bool bitmap_button(bitmap bmp)" + ] + } + }, + { + "signature": "bool bitmap_button(bitmap bmp,const rectangle& rect);", + "name": "bitmap_button", + "method_name": null, + "unique_global_name": "bitmap_button_at_position", + "unique_method_name": null, + "suffix_name": null, + "description": "Creates a button with a bitmap in it at a specific position on screen.\nReturns whether the button was clicked.", + "brief": null, + "return": { + "type": "bool", + "description": "Whether the button was clicked", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "bmp": { + "type": "bitmap", + "description": "The bitmap to show inside the button", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "rect": { + "type": "rectangle", + "description": "The rectangle to display the button in", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "suffix": "at_position", + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def bitmap_button_at_position(bmp, rect):" + ], + "pascal": [ + "function BitmapButton(bmp: Bitmap; const rect: Rectangle): Boolean" + ], + "csharp": [ + "public static bool Interface.BitmapButton(Bitmap bmp, Rectangle rect);", + "public static bool SplashKit.BitmapButton(Bitmap bmp, Rectangle rect);" + ], + "cpp": [ + "bool bitmap_button(bitmap bmp, const rectangle &rect)" + ] + } + }, + { + "signature": "bool bitmap_button(bitmap bmp,const rectangle& rect,drawing_options opts);", + "name": "bitmap_button", + "method_name": null, + "unique_global_name": "bitmap_button_at_position_with_options", + "unique_method_name": null, + "suffix_name": null, + "description": "Creates a button with a bitmap in it at a specific position on screen.\nReturns whether the button was clicked.", + "brief": null, + "return": { + "type": "bool", + "description": "Whether the button was clicked", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "bmp": { + "type": "bitmap", + "description": "The bitmap to show inside the button", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "rect": { + "type": "rectangle", + "description": "The rectangle to display the button in", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "opts": { + "type": "drawing_options", + "description": "The drawing options", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "suffix": "at_position_with_options", + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def bitmap_button_at_position_with_options(bmp, rect, opts):" + ], + "pascal": [ + "function BitmapButton(bmp: Bitmap; const rect: Rectangle; opts: DrawingOptions): Boolean" + ], + "csharp": [ + "public static bool Interface.BitmapButton(Bitmap bmp, Rectangle rect, DrawingOptions opts);", + "public static bool SplashKit.BitmapButton(Bitmap bmp, Rectangle rect, DrawingOptions opts);" + ], + "cpp": [ + "bool bitmap_button(bitmap bmp, const rectangle &rect, drawing_options opts)" + ] + } + }, + { + "signature": "bool bitmap_button(bitmap bmp,drawing_options opts);", + "name": "bitmap_button", + "method_name": null, + "unique_global_name": "bitmap_button_with_options", + "unique_method_name": null, + "suffix_name": null, + "description": "Creates a button with a bitmap in it, and no label.\nReturns whether the button was clicked.", + "brief": null, + "return": { + "type": "bool", + "description": "Whether the button was clicked", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "bmp": { + "type": "bitmap", + "description": "The bitmap to show inside the button", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "opts": { + "type": "drawing_options", + "description": "The drawing options", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "suffix": "with_options", + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def bitmap_button_with_options(bmp, opts):" + ], + "pascal": [ + "function BitmapButton(bmp: Bitmap; opts: DrawingOptions): Boolean" + ], + "csharp": [ + "public static bool Interface.BitmapButton(Bitmap bmp, DrawingOptions opts);", + "public static bool SplashKit.BitmapButton(Bitmap bmp, DrawingOptions opts);" + ], + "cpp": [ + "bool bitmap_button(bitmap bmp, drawing_options opts)" + ] + } + }, + { + "signature": "bool bitmap_button(const string& label,bitmap bmp);", + "name": "bitmap_button", + "method_name": null, + "unique_global_name": "bitmap_button_labeled", + "unique_method_name": null, + "suffix_name": null, + "description": "Creates a button with a bitmap in it and a label.\nReturns whether the button was clicked.", + "brief": null, + "return": { + "type": "bool", + "description": "Whether the button was clicked", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "label": { + "type": "string", + "description": "The label to show in front of the button", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "bmp": { + "type": "bitmap", + "description": "The bitmap to show inside the button", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "suffix": "labeled", + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def bitmap_button_labeled(label, bmp):" + ], + "pascal": [ + "function BitmapButton(const label: String; bmp: Bitmap): Boolean" + ], + "csharp": [ + "public static bool Interface.BitmapButton(string label, Bitmap bmp);", + "public static bool SplashKit.BitmapButton(string label, Bitmap bmp);" + ], + "cpp": [ + "bool bitmap_button(const string &label, bitmap bmp)" + ] + } + }, + { + "signature": "bool bitmap_button(const string& label,bitmap bmp,drawing_options opts);", + "name": "bitmap_button", + "method_name": null, + "unique_global_name": "bitmap_button_labeled_with_options", + "unique_method_name": null, + "suffix_name": null, + "description": "Creates a button with a bitmap in it and a label.\nReturns whether the button was clicked.", + "brief": null, + "return": { + "type": "bool", + "description": "Whether the button was clicked", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "label": { + "type": "string", + "description": "The label to show in front of the button", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "bmp": { + "type": "bitmap", + "description": "The bitmap to show inside the button", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "opts": { + "type": "drawing_options", + "description": "The drawing options", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "suffix": "labeled_with_options", + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def bitmap_button_labeled_with_options(label, bmp, opts):" + ], + "pascal": [ + "function BitmapButton(const label: String; bmp: Bitmap; opts: DrawingOptions): Boolean" + ], + "csharp": [ + "public static bool Interface.BitmapButton(string label, Bitmap bmp, DrawingOptions opts);", + "public static bool SplashKit.BitmapButton(string label, Bitmap bmp, DrawingOptions opts);" + ], + "cpp": [ + "bool bitmap_button(const string &label, bitmap bmp, drawing_options opts)" + ] + } + }, + { + "signature": "bool button(const string& text,const rectangle& rect);", + "name": "button", + "method_name": null, + "unique_global_name": "button_at_position", + "unique_method_name": null, + "suffix_name": null, + "description": "Creates a button at a specific position on screen.\nReturns whether the button was clicked.", + "brief": null, + "return": { + "type": "bool", + "description": "Whether the button was clicked", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "text": { + "type": "string", + "description": "The text to show inside the button", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "rect": { + "type": "rectangle", + "description": "The rectangle to display the button in", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "suffix": "at_position", + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def button_at_position(text, rect):" + ], + "pascal": [ + "function Button(const text: String; const rect: Rectangle): Boolean" + ], + "csharp": [ + "public static bool Interface.Button(string text, Rectangle rect);", + "public static bool SplashKit.Button(string text, Rectangle rect);" + ], + "cpp": [ + "bool button(const string &text, const rectangle &rect)" + ] + } + }, + { + "signature": "bool button(const string& text);", + "name": "button", + "method_name": null, + "unique_global_name": "button", + "unique_method_name": null, + "suffix_name": null, + "description": "Creates a button without a label.\nReturns whether the button was clicked.", + "brief": null, + "return": { + "type": "bool", + "description": "Whether the button was clicked", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "text": { + "type": "string", + "description": "The text to show inside the button", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def button(text):" + ], + "pascal": [ + "function Button(const text: String): Boolean" + ], + "csharp": [ + "public static bool Interface.Button(string text);", + "public static bool SplashKit.Button(string text);" + ], + "cpp": [ + "bool button(const string &text)" + ] + } + }, + { + "signature": "bool button(const string& label,const string& text);", + "name": "button", + "method_name": null, + "unique_global_name": "button_labeled", + "unique_method_name": null, + "suffix_name": null, + "description": "Creates a button with a label.\nReturns whether the button was clicked.\n\nExample usage:\n```c++\n// Test if clicked:\nif (button(\"Button 1\", \"Click me!\"))\n{\n// do stuff..\n}\n```", + "brief": null, + "return": { + "type": "bool", + "description": "Whether the button was clicked", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "label": { + "type": "string", + "description": "The label to show in front of the button", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "text": { + "type": "string", + "description": "The text to show inside the button", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "suffix": "labeled", + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def button_labeled(label, text):" + ], + "pascal": [ + "function Button(const label: String; const text: String): Boolean" + ], + "csharp": [ + "public static bool Interface.Button(string label, string text);", + "public static bool SplashKit.Button(string label, string text);" + ], + "cpp": [ + "bool button(const string &label, const string &text)" + ] + } + }, + { + "signature": "bool checkbox(const string& text,const bool& value,const rectangle& rect);", + "name": "checkbox", + "method_name": null, + "unique_global_name": "checkbox_at_position", + "unique_method_name": null, + "suffix_name": null, + "description": "Creates a checkbox at a specific position on screen.\nReturns the updated value of the checkbox.", + "brief": null, + "return": { + "type": "bool", + "description": "The updated value of the checkbox", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "text": { + "type": "string", + "description": "The text to show next to the checkbox", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "value": { + "type": "bool", + "description": "The current value of the checkbox", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "rect": { + "type": "rectangle", + "description": "The rectangle to display the checkbox in", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "suffix": "at_position", + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def checkbox_at_position(text, value, rect):" + ], + "pascal": [ + "function Checkbox(const text: String; const value: Boolean; const rect: Rectangle): Boolean" + ], + "csharp": [ + "public static bool Interface.Checkbox(string text, bool value, Rectangle rect);", + "public static bool SplashKit.Checkbox(string text, bool value, Rectangle rect);" + ], + "cpp": [ + "bool checkbox(const string &text, const bool &value, const rectangle &rect)" + ] + } + }, + { + "signature": "bool checkbox(const string& text,const bool& value);", + "name": "checkbox", + "method_name": null, + "unique_global_name": "checkbox", + "unique_method_name": null, + "suffix_name": null, + "description": "Creates a checkbox.\nReturns the updated value of the checkbox.", + "brief": null, + "return": { + "type": "bool", + "description": "The updated value of the checkbox", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "text": { + "type": "string", + "description": "The text to show next to the checkbox", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "value": { + "type": "bool", + "description": "The current value of the checkbox", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def checkbox(text, value):" + ], + "pascal": [ + "function Checkbox(const text: String; const value: Boolean): Boolean" + ], + "csharp": [ + "public static bool Interface.Checkbox(string text, bool value);", + "public static bool SplashKit.Checkbox(string text, bool value);" + ], + "cpp": [ + "bool checkbox(const string &text, const bool &value)" + ] + } + }, + { + "signature": "bool checkbox(const string& label,const string& text,const bool& value);", + "name": "checkbox", + "method_name": null, + "unique_global_name": "checkbox_labeled", + "unique_method_name": null, + "suffix_name": null, + "description": "Creates a checkbox with a label.\nReturns the updated value of the checkbox.\n\nExample usage:\n```c++\nmy_bool = checkbox(\"Checkbox 1\", \"Enabled?\", my_bool);\n```", + "brief": null, + "return": { + "type": "bool", + "description": "The updated value of the checkbox", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "label": { + "type": "string", + "description": "The label to show in front of the checkbox", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "text": { + "type": "string", + "description": "The text to show next to the checkbox", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "value": { + "type": "bool", + "description": "The current value of the checkbox", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "suffix": "labeled", + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def checkbox_labeled(label, text, value):" + ], + "pascal": [ + "function Checkbox(const label: String; const text: String; const value: Boolean): Boolean" + ], + "csharp": [ + "public static bool Interface.Checkbox(string label, string text, bool value);", + "public static bool SplashKit.Checkbox(string label, string text, bool value);" + ], + "cpp": [ + "bool checkbox(const string &label, const string &text, const bool &value)" + ] + } + }, + { + "signature": "color color_slider(const color& clr,const rectangle& rect);", + "name": "color_slider", + "method_name": null, + "unique_global_name": "color_slider_at_position", + "unique_method_name": null, + "suffix_name": null, + "description": "Creates a set of RGBA sliders to adjust a color, at a specific position on screen.\nReturns the updated color value of the slider.", + "brief": null, + "return": { + "type": "color", + "description": "The updated value of the slider", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "clr": { + "type": "color", + "description": "The current value of the color slider", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "rect": { + "type": "rectangle", + "description": "The rectangle to display the slider in.", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "suffix": "at_position", + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def color_slider_at_position(clr, rect):" + ], + "pascal": [ + "function ColorSlider(const clr: Color; const rect: Rectangle): Color" + ], + "csharp": [ + "public static Color Interface.ColorSlider(Color clr, Rectangle rect);", + "public static Color SplashKit.ColorSlider(Color clr, Rectangle rect);" + ], + "cpp": [ + "color color_slider(const color &clr, const rectangle &rect)" + ] + } + }, + { + "signature": "color color_slider(const color& clr);", + "name": "color_slider", + "method_name": null, + "unique_global_name": "color_slider", + "unique_method_name": null, + "suffix_name": null, + "description": "Creates a set of RGBA sliders to adjust a color.\nReturns the updated color value of the slider.", + "brief": null, + "return": { + "type": "color", + "description": "The updated value of the slider", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "clr": { + "type": "color", + "description": "The current value of the color slider", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def color_slider(clr):" + ], + "pascal": [ + "function ColorSlider(const clr: Color): Color" + ], + "csharp": [ + "public static Color Interface.ColorSlider(Color clr);", + "public static Color SplashKit.ColorSlider(Color clr);" + ], + "cpp": [ + "color color_slider(const color &clr)" + ] + } + }, + { + "signature": "color color_slider(const string& label,const color& clr);", + "name": "color_slider", + "method_name": null, + "unique_global_name": "color_slider_labeled", + "unique_method_name": null, + "suffix_name": null, + "description": "Creates a set of RGBA sliders to adjust a color, with a label.\nReturns the updated color value of the slider.\n\nExample usage:\n```c++\nmy_color = color_slider(\"Player Color\", my_color);\n```", + "brief": null, + "return": { + "type": "color", + "description": "The updated value of the slider", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "label": { + "type": "string", + "description": "The label to show in front of the slider", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "clr": { + "type": "color", + "description": "The current value of the color slider", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "suffix": "labeled", + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def color_slider_labeled(label, clr):" + ], + "pascal": [ + "function ColorSlider(const label: String; const clr: Color): Color" + ], + "csharp": [ + "public static Color Interface.ColorSlider(string label, Color clr);", + "public static Color SplashKit.ColorSlider(string label, Color clr);" + ], + "cpp": [ + "color color_slider(const string &label, const color &clr)" + ] + } + }, + { + "signature": "void disable_interface();", + "name": "disable_interface", + "method_name": null, + "unique_global_name": "disable_interface", + "unique_method_name": null, + "suffix_name": null, + "description": "Disables the interface temporarily. Elements created after this function will appear disabled and cannot be interacted with.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def disable_interface():" + ], + "pascal": [ + "procedure DisableInterface()" + ], + "csharp": [ + "public static void Interface.DisableInterface();", + "public static void SplashKit.DisableInterface();" + ], + "cpp": [ + "void disable_interface()" + ] + } + }, + { + "signature": "void draw_interface();", + "name": "draw_interface", + "method_name": null, + "unique_global_name": "draw_interface", + "unique_method_name": null, + "suffix_name": null, + "description": "Draws the user interface that all the previous calls (such as `start_panel`, `button`, etc) have created.\n\n**Make sure to call this!** Without calling it, the interface won't be visible.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def draw_interface():" + ], + "pascal": [ + "procedure DrawInterface()" + ], + "csharp": [ + "public static void Interface.DrawInterface();", + "public static void SplashKit.DrawInterface();" + ], + "cpp": [ + "void draw_interface()" + ] + } + }, + { + "signature": "void enable_interface();", + "name": "enable_interface", + "method_name": null, + "unique_global_name": "enable_interface", + "unique_method_name": null, + "suffix_name": null, + "description": "Re-enables the interface, reverses the effects of disabling the interface.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def enable_interface():" + ], + "pascal": [ + "procedure EnableInterface()" + ], + "csharp": [ + "public static void Interface.EnableInterface();", + "public static void SplashKit.EnableInterface();" + ], + "cpp": [ + "void enable_interface()" + ] + } + }, + { + "signature": "void end_inset(const string& name);", + "name": "end_inset", + "method_name": null, + "unique_global_name": "end_inset", + "unique_method_name": null, + "suffix_name": null, + "description": "Finishes the creation of an inset area.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "name": { + "type": "string", + "description": "The area's name - must match with `start_inset`", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def end_inset(name):" + ], + "pascal": [ + "procedure EndInset(const name: String)" + ], + "csharp": [ + "public static void Interface.EndInset(string name);", + "public static void SplashKit.EndInset(string name);" + ], + "cpp": [ + "void end_inset(const string &name)" + ] + } + }, + { + "signature": "void end_panel(const string& name);", + "name": "end_panel", + "method_name": null, + "unique_global_name": "end_panel", + "unique_method_name": null, + "suffix_name": null, + "description": "Finishes the creation of a panel.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "name": { + "type": "string", + "description": "The name shown in the panel's titlebar - must match with `start_panel`", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def end_panel(name):" + ], + "pascal": [ + "procedure EndPanel(const name: String)" + ], + "csharp": [ + "public static void Interface.EndPanel(string name);", + "public static void SplashKit.EndPanel(string name);" + ], + "cpp": [ + "void end_panel(const string &name)" + ] + } + }, + { + "signature": "void end_popup(const string& name);", + "name": "end_popup", + "method_name": null, + "unique_global_name": "end_popup", + "unique_method_name": null, + "suffix_name": null, + "description": "Finishes the creation of a popup.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "name": { + "type": "string", + "description": "The popup's name - must match with `start_popup`", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def end_popup(name):" + ], + "pascal": [ + "procedure EndPopup(const name: String)" + ], + "csharp": [ + "public static void Interface.EndPopup(string name);", + "public static void SplashKit.EndPopup(string name);" + ], + "cpp": [ + "void end_popup(const string &name)" + ] + } + }, + { + "signature": "void end_treenode(const string& label);", + "name": "end_treenode", + "method_name": null, + "unique_global_name": "end_treenode", + "unique_method_name": null, + "suffix_name": null, + "description": "Finishes the creation of a tree node.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "label": { + "type": "string", + "description": "The node's name - must match with `start_treenode`", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def end_treenode(label):" + ], + "pascal": [ + "procedure EndTreenode(const label: String)" + ], + "csharp": [ + "public static void Interface.EndTreenode(string label);", + "public static void SplashKit.EndTreenode(string label);" + ], + "cpp": [ + "void end_treenode(const string &label)" + ] + } + }, + { + "signature": "void enter_column();", + "name": "enter_column", + "method_name": null, + "unique_global_name": "enter_column", + "unique_method_name": null, + "suffix_name": null, + "description": "Begins placing elements inside the current column. Must be paired with a call to `leave_column`.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def enter_column():" + ], + "pascal": [ + "procedure EnterColumn()" + ], + "csharp": [ + "public static void Interface.EnterColumn();", + "public static void SplashKit.EnterColumn();" + ], + "cpp": [ + "void enter_column()" + ] + } + }, + { + "signature": "int get_interface_label_width();", + "name": "get_interface_label_width", + "method_name": null, + "unique_global_name": "get_interface_label_width", + "unique_method_name": null, + "suffix_name": null, + "description": "Returns the width of element labels.\n\nDefault is 60 pixels.", + "brief": null, + "return": { + "type": "int", + "description": "The width of labels", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def get_interface_label_width():" + ], + "pascal": [ + "function GetInterfaceLabelWidth(): Integer" + ], + "csharp": [ + "public static int Interface.GetInterfaceLabelWidth();", + "public static int SplashKit.GetInterfaceLabelWidth();" + ], + "cpp": [ + "int get_interface_label_width()" + ] + } + }, + { + "signature": "bool header(const string& label);", + "name": "header", + "method_name": null, + "unique_global_name": "header", + "unique_method_name": null, + "suffix_name": null, + "description": "Creates a collapsable header with a label.\nReturns whether the header is expanded or not.\n\nNote: Unlike `start_panel` and other similar functions, there is\nno need to 'end' this one. Example usage:\n```c++\nif (header(\"Section A\"))\n{\n// elements inside header go here\n}\n```", + "brief": null, + "return": { + "type": "bool", + "description": "Whether the header is expanded or not", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "label": { + "type": "string", + "description": "The label to show in the header", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def header(label):" + ], + "pascal": [ + "function Header(const label: String): Boolean" + ], + "csharp": [ + "public static bool Interface.Header(string label);", + "public static bool SplashKit.Header(string label);" + ], + "cpp": [ + "bool header(const string &label)" + ] + } + }, + { + "signature": "color hsb_color_slider(const color& clr,const rectangle& rect);", + "name": "hsb_color_slider", + "method_name": null, + "unique_global_name": "hsb_color_slider_at_position", + "unique_method_name": null, + "suffix_name": null, + "description": "Creates a set of HSBA (hue, saturation, brightness, alpha) sliders to adjust a color, at a specific position on screen.\nReturns the updated color value of the slider.", + "brief": null, + "return": { + "type": "color", + "description": "The updated value of the slider", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "clr": { + "type": "color", + "description": "The current value of the color slider", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "rect": { + "type": "rectangle", + "description": "The rectangle to display the slider in.", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "suffix": "at_position", + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def hsb_color_slider_at_position(clr, rect):" + ], + "pascal": [ + "function HSBColorSlider(const clr: Color; const rect: Rectangle): Color" + ], + "csharp": [ + "public static Color Interface.HSBColorSlider(Color clr, Rectangle rect);", + "public static Color SplashKit.HSBColorSlider(Color clr, Rectangle rect);" + ], + "cpp": [ + "color hsb_color_slider(const color &clr, const rectangle &rect)" + ] + } + }, + { + "signature": "color hsb_color_slider(const color& clr);", + "name": "hsb_color_slider", + "method_name": null, + "unique_global_name": "hsb_color_slider", + "unique_method_name": null, + "suffix_name": null, + "description": "Creates a set of HSBA (hue, saturation, brightness, alpha) sliders to adjust a color.\nReturns the updated color value of the slider.", + "brief": null, + "return": { + "type": "color", + "description": "The updated value of the slider", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "clr": { + "type": "color", + "description": "The current value of the color slider", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def hsb_color_slider(clr):" + ], + "pascal": [ + "function HSBColorSlider(const clr: Color): Color" + ], + "csharp": [ + "public static Color Interface.HSBColorSlider(Color clr);", + "public static Color SplashKit.HSBColorSlider(Color clr);" + ], + "cpp": [ + "color hsb_color_slider(const color &clr)" + ] + } + }, + { + "signature": "color hsb_color_slider(const string& label,const color& clr);", + "name": "hsb_color_slider", + "method_name": null, + "unique_global_name": "hsb_color_slider_labeled", + "unique_method_name": null, + "suffix_name": null, + "description": "Creates a set of HSBA (hue, saturation, brightness, alpha) sliders to adjust a color, with a label.\nReturns the updated color value of the slider.\n\nExample usage:\n```c++\nmy_color = hsb_color_slider(\"Player Color\", my_color);\n```", + "brief": null, + "return": { + "type": "color", + "description": "The updated value of the slider", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "label": { + "type": "string", + "description": "The label to show in front of the slider", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "clr": { + "type": "color", + "description": "The current value of the color slider", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "suffix": "labeled", + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def hsb_color_slider_labeled(label, clr):" + ], + "pascal": [ + "function HSBColorSlider(const label: String; const clr: Color): Color" + ], + "csharp": [ + "public static Color Interface.HSBColorSlider(string label, Color clr);", + "public static Color SplashKit.HSBColorSlider(string label, Color clr);" + ], + "cpp": [ + "color hsb_color_slider(const string &label, const color &clr)" + ] + } + }, + { + "signature": "bool interface_enabled();", + "name": "interface_enabled", + "method_name": null, + "unique_global_name": "interface_enabled", + "unique_method_name": null, + "suffix_name": null, + "description": "Returns if the interface is currently enabled or not.", + "brief": null, + "return": { + "type": "bool", + "description": "Whether the interface is currently enabled or not", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def interface_enabled():" + ], + "pascal": [ + "function InterfaceEnabled(): Boolean" + ], + "csharp": [ + "public static bool Interface.InterfaceEnabled();", + "public static bool SplashKit.InterfaceEnabled();" + ], + "cpp": [ + "bool interface_enabled()" + ] + } + }, + { + "signature": "void interface_style_panel(const rectangle& initial_rectangle);", + "name": "interface_style_panel", + "method_name": null, + "unique_global_name": "interface_style_panel", + "unique_method_name": null, + "suffix_name": null, + "description": "A utility function to show a 'Style Panel', which will allows you to experiment with different interface styles.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "initial_rectangle": { + "type": "rectangle", + "description": "The initial position/size the panel starts off in", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def interface_style_panel(initial_rectangle):" + ], + "pascal": [ + "procedure InterfaceStylePanel(const initialRectangle: Rectangle)" + ], + "csharp": [ + "public static void Interface.InterfaceStylePanel(Rectangle initialRectangle);", + "public static void SplashKit.InterfaceStylePanel(Rectangle initialRectangle);" + ], + "cpp": [ + "void interface_style_panel(const rectangle &initial_rectangle)" + ] + } + }, + { + "signature": "void label(const string& label);", + "name": "label", + "method_name": null, + "unique_global_name": "label", + "unique_method_name": null, + "suffix_name": null, + "description": "Creates a label.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "label": { + "type": "string", + "description": "The label to show", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def label(label):" + ], + "pascal": [ + "procedure Label(const label: String)" + ], + "csharp": [ + "public static void Interface.Label(string label);", + "public static void SplashKit.Label(string label);" + ], + "cpp": [ + "void label(const string &label)" + ] + } + }, + { + "signature": "void label(const string& label,const rectangle& rect);", + "name": "label", + "method_name": null, + "unique_global_name": "label_at_position", + "unique_method_name": null, + "suffix_name": null, + "description": "Creates a label at a specific position on screen.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "label": { + "type": "string", + "description": "The label to show", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "rect": { + "type": "rectangle", + "description": "The rectangle to display the label in", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "suffix": "at_position", + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def label_at_position(label, rect):" + ], + "pascal": [ + "procedure Label(const label: String; const rect: Rectangle)" + ], + "csharp": [ + "public static void Interface.Label(string label, Rectangle rect);", + "public static void SplashKit.Label(string label, Rectangle rect);" + ], + "cpp": [ + "void label(const string &label, const rectangle &rect)" + ] + } + }, + { + "signature": "bool last_element_changed();", + "name": "last_element_changed", + "method_name": null, + "unique_global_name": "last_element_changed", + "unique_method_name": null, + "suffix_name": null, + "description": "Returns if the last created element was changed at all (such as dragged, typed in, etc)", + "brief": null, + "return": { + "type": "bool", + "description": "Whether the last created element was changed", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def last_element_changed():" + ], + "pascal": [ + "function LastElementChanged(): Boolean" + ], + "csharp": [ + "public static bool Interface.LastElementChanged();", + "public static bool SplashKit.LastElementChanged();" + ], + "cpp": [ + "bool last_element_changed()" + ] + } + }, + { + "signature": "bool last_element_confirmed();", + "name": "last_element_confirmed", + "method_name": null, + "unique_global_name": "last_element_confirmed", + "unique_method_name": null, + "suffix_name": null, + "description": "Returns if the last created element was 'confirmed' (such as clicking a button, or hitting enter in a text box)", + "brief": null, + "return": { + "type": "bool", + "description": "Whether the last created element was confirmed", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def last_element_confirmed():" + ], + "pascal": [ + "function LastElementConfirmed(): Boolean" + ], + "csharp": [ + "public static bool Interface.LastElementConfirmed();", + "public static bool SplashKit.LastElementConfirmed();" + ], + "cpp": [ + "bool last_element_confirmed()" + ] + } + }, + { + "signature": "void leave_column();", + "name": "leave_column", + "method_name": null, + "unique_global_name": "leave_column", + "unique_method_name": null, + "suffix_name": null, + "description": "Stops placing elements inside the current column and moves to the next one.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def leave_column():" + ], + "pascal": [ + "procedure LeaveColumn()" + ], + "csharp": [ + "public static void Interface.LeaveColumn();", + "public static void SplashKit.LeaveColumn();" + ], + "cpp": [ + "void leave_column()" + ] + } + }, + { + "signature": "float number_box(const float& value,float step,const rectangle& rect);", + "name": "number_box", + "method_name": null, + "unique_global_name": "number_box_at_position", + "unique_method_name": null, + "suffix_name": null, + "description": "Creates a number entry box at a specific position on screen.\nReturns the updated value of the number box.", + "brief": null, + "return": { + "type": "float", + "description": "The updated value of the slider", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "value": { + "type": "float", + "description": "The current value of the number box", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "step": { + "type": "float", + "description": "The amount incremented when dragging on the box", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "rect": { + "type": "rectangle", + "description": "The rectangle to display the slider in", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "suffix": "at_position", + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def number_box_at_position(value, step, rect):" + ], + "pascal": [ + "function NumberBox(const value: Single; step: Single; const rect: Rectangle): Single" + ], + "csharp": [ + "public static float Interface.NumberBox(float value, float step, Rectangle rect);", + "public static float SplashKit.NumberBox(float value, float step, Rectangle rect);" + ], + "cpp": [ + "float number_box(const float &value, float step, const rectangle &rect)" + ] + } + }, + { + "signature": "float number_box(const float& value,float step);", + "name": "number_box", + "method_name": null, + "unique_global_name": "number_box", + "unique_method_name": null, + "suffix_name": null, + "description": "Creates a number entry box with a label.\nReturns the updated value of the number box.", + "brief": null, + "return": { + "type": "float", + "description": "The updated value of the slider", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "value": { + "type": "float", + "description": "The current value of the number box", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "step": { + "type": "float", + "description": "The amount incremented when dragging on the box", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def number_box(value, step):" + ], + "pascal": [ + "function NumberBox(const value: Single; step: Single): Single" + ], + "csharp": [ + "public static float Interface.NumberBox(float value, float step);", + "public static float SplashKit.NumberBox(float value, float step);" + ], + "cpp": [ + "float number_box(const float &value, float step)" + ] + } + }, + { + "signature": "float number_box(const string& label,const float& value,float step);", + "name": "number_box", + "method_name": null, + "unique_global_name": "number_box_labeled", + "unique_method_name": null, + "suffix_name": null, + "description": "Creates a number entry box with a label.\nReturns the updated value of the number box.\n\nExample usage:\n```c++\nmy_float = number_box(\"Percentage\", my_float, 1);\n```", + "brief": null, + "return": { + "type": "float", + "description": "The updated value of the slider", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "label": { + "type": "string", + "description": "The label to show in front of the number box", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "value": { + "type": "float", + "description": "The current value of the number box", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "step": { + "type": "float", + "description": "The amount incremented when dragging on the box", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "suffix": "labeled", + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def number_box_labeled(label, value, step):" + ], + "pascal": [ + "function NumberBox(const label: String; const value: Single; step: Single): Single" + ], + "csharp": [ + "public static float Interface.NumberBox(string label, float value, float step);", + "public static float SplashKit.NumberBox(string label, float value, float step);" + ], + "cpp": [ + "float number_box(const string &label, const float &value, float step)" + ] + } + }, + { + "signature": "void open_popup(const string& name);", + "name": "open_popup", + "method_name": null, + "unique_global_name": "open_popup", + "unique_method_name": null, + "suffix_name": null, + "description": "Makes the popup named `name` open/popup at the cursor's position.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "name": { + "type": "string", + "description": "The popup's name. Must match with the same name used in `start_popup`", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def open_popup(name):" + ], + "pascal": [ + "procedure OpenPopup(const name: String)" + ], + "csharp": [ + "public static void Interface.OpenPopup(string name);", + "public static void SplashKit.OpenPopup(string name);" + ], + "cpp": [ + "void open_popup(const string &name)" + ] + } + }, + { + "signature": "void paragraph(const string& text);", + "name": "paragraph", + "method_name": null, + "unique_global_name": "paragraph", + "unique_method_name": null, + "suffix_name": null, + "description": "Creates a paragraph of text that auto-wraps.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "text": { + "type": "string", + "description": "The text to show", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def paragraph(text):" + ], + "pascal": [ + "procedure Paragraph(const text: String)" + ], + "csharp": [ + "public static void Interface.Paragraph(string text);", + "public static void SplashKit.Paragraph(string text);" + ], + "cpp": [ + "void paragraph(const string &text)" + ] + } + }, + { + "signature": "void paragraph(const string& text,const rectangle& rect);", + "name": "paragraph", + "method_name": null, + "unique_global_name": "paragraph_at_position", + "unique_method_name": null, + "suffix_name": null, + "description": "Creates a paragraph of text that auto-wraps at a specific position on screen.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "text": { + "type": "string", + "description": "The text to show", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "rect": { + "type": "rectangle", + "description": "The rectangle to display the label in", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "suffix": "at_position", + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def paragraph_at_position(text, rect):" + ], + "pascal": [ + "procedure Paragraph(const text: String; const rect: Rectangle)" + ], + "csharp": [ + "public static void Interface.Paragraph(string text, Rectangle rect);", + "public static void SplashKit.Paragraph(string text, Rectangle rect);" + ], + "cpp": [ + "void paragraph(const string &text, const rectangle &rect)" + ] + } + }, + { + "signature": "void reset_layout();", + "name": "reset_layout", + "method_name": null, + "unique_global_name": "reset_layout", + "unique_method_name": null, + "suffix_name": null, + "description": "Resets to the default layout of a single column with default height.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def reset_layout():" + ], + "pascal": [ + "procedure ResetLayout()" + ], + "csharp": [ + "public static void Interface.ResetLayout();", + "public static void SplashKit.ResetLayout();" + ], + "cpp": [ + "void reset_layout()" + ] + } + }, + { + "signature": "void set_interface_accent_color(color clr,float contrast);", + "name": "set_interface_accent_color", + "method_name": null, + "unique_global_name": "set_interface_accent_color", + "unique_method_name": null, + "suffix_name": null, + "description": "Sets the color of accents in the interface, and the contrast of how strongly they appear when hovering/interacting.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "clr": { + "type": "color", + "description": "The color of accents", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "contrast": { + "type": "float", + "description": "The strength of how much the accents show (between 0 and 1)", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def set_interface_accent_color(clr, contrast):" + ], + "pascal": [ + "procedure SetInterfaceAccentColor(clr: Color; contrast: Single)" + ], + "csharp": [ + "public static void Interface.SetInterfaceAccentColor(Color clr, float contrast);", + "public static void SplashKit.SetInterfaceAccentColor(Color clr, float contrast);" + ], + "cpp": [ + "void set_interface_accent_color(color clr, float contrast)" + ] + } + }, + { + "signature": "void set_interface_border_color(color clr);", + "name": "set_interface_border_color", + "method_name": null, + "unique_global_name": "set_interface_border_color", + "unique_method_name": null, + "suffix_name": null, + "description": "Sets the interface's border color.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "clr": { + "type": "color", + "description": "The color to set borders to", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def set_interface_border_color(clr):" + ], + "pascal": [ + "procedure SetInterfaceBorderColor(clr: Color)" + ], + "csharp": [ + "public static void Interface.SetInterfaceBorderColor(Color clr);", + "public static void SplashKit.SetInterfaceBorderColor(Color clr);" + ], + "cpp": [ + "void set_interface_border_color(color clr)" + ] + } + }, + { + "signature": "void set_interface_colors_auto(color main_clr,color accent_clr,float contrast,float accent_contrast,float border_contrast);", + "name": "set_interface_colors_auto", + "method_name": null, + "unique_global_name": "set_interface_colors_auto", + "unique_method_name": null, + "suffix_name": null, + "description": "A convenience function to set the majority of the interface's colors in one go.\nSome colors will be automatically chosen based on the parameters (such as text color).", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "main_clr": { + "type": "color", + "description": "The main color of the interface - also decides if the interface is light or dark mode", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "accent_clr": { + "type": "color", + "description": "The color used to accent the interface - this will appear in highlighted areas", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "contrast": { + "type": "float", + "description": "The contrast between the frames of elements/containers and their internal elements", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "accent_contrast": { + "type": "float", + "description": "How strongly the accent color is used, for instance when highlighting elements", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "border_contrast": { + "type": "float", + "description": "Simply the opacity of the borders", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def set_interface_colors_auto(main_clr, accent_clr, contrast, accent_contrast, border_contrast):" + ], + "pascal": [ + "procedure SetInterfaceColorsAuto(mainClr: Color; accentClr: Color; contrast: Single; accentContrast: Single; borderContrast: Single)" + ], + "csharp": [ + "public static void Interface.SetInterfaceColorsAuto(Color mainClr, Color accentClr, float contrast, float accentContrast, float borderContrast);", + "public static void SplashKit.SetInterfaceColorsAuto(Color mainClr, Color accentClr, float contrast, float accentContrast, float borderContrast);" + ], + "cpp": [ + "void set_interface_colors_auto(color main_clr, color accent_clr, float contrast, float accent_contrast, float border_contrast)" + ] + } + }, + { + "signature": "void set_interface_element_color(color clr,float contrast);", + "name": "set_interface_element_color", + "method_name": null, + "unique_global_name": "set_interface_element_color", + "unique_method_name": null, + "suffix_name": null, + "description": "Sets the main color of elements in the interface, and the contrast between their frame and internal pieces.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "clr": { + "type": "color", + "description": "The color of elements", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "contrast": { + "type": "float", + "description": "The contrast between the frame of elements and their internal pieces (between 0 and 1)", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def set_interface_element_color(clr, contrast):" + ], + "pascal": [ + "procedure SetInterfaceElementColor(clr: Color; contrast: Single)" + ], + "csharp": [ + "public static void Interface.SetInterfaceElementColor(Color clr, float contrast);", + "public static void SplashKit.SetInterfaceElementColor(Color clr, float contrast);" + ], + "cpp": [ + "void set_interface_element_color(color clr, float contrast)" + ] + } + }, + { + "signature": "void set_interface_element_shadows(int radius,color clr,point_2d offset);", + "name": "set_interface_element_shadows", + "method_name": null, + "unique_global_name": "set_interface_element_shadows", + "unique_method_name": null, + "suffix_name": null, + "description": "Sets the style of element's shadows. Use a fully transparent color to disable them.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "radius": { + "type": "int", + "description": "The radius of the shadow's blur", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "clr": { + "type": "color", + "description": "The color of the shadows (commonly black, but can do coloured and semi-transparent too)", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "offset": { + "type": "point_2d", + "description": "The offset in x/y coordinates of the shadows from their casting elements", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def set_interface_element_shadows(radius, clr, offset):" + ], + "pascal": [ + "procedure SetInterfaceElementShadows(radius: Integer; clr: Color; offset: Point2D)" + ], + "csharp": [ + "public static void Interface.SetInterfaceElementShadows(int radius, Color clr, Point2D offset);", + "public static void SplashKit.SetInterfaceElementShadows(int radius, Color clr, Point2D offset);" + ], + "cpp": [ + "void set_interface_element_shadows(int radius, color clr, point_2d offset)" + ] + } + }, + { + "signature": "void set_interface_font(const string& fnt);", + "name": "set_interface_font", + "method_name": null, + "unique_global_name": "set_interface_font_font_as_string", + "unique_method_name": null, + "suffix_name": null, + "description": "Sets the interface's font.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "fnt": { + "type": "string", + "description": "The name of the font to be used", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "suffix": "font_as_string", + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def set_interface_font_font_as_string(fnt):" + ], + "pascal": [ + "procedure SetInterfaceFont(const fnt: String)" + ], + "csharp": [ + "public static void Interface.SetInterfaceFont(string fnt);", + "public static void SplashKit.SetInterfaceFont(string fnt);" + ], + "cpp": [ + "void set_interface_font(const string &fnt)" + ] + } + }, + { + "signature": "void set_interface_font(font fnt);", + "name": "set_interface_font", + "method_name": null, + "unique_global_name": "set_interface_font", + "unique_method_name": null, + "suffix_name": null, + "description": "Sets the interface's font.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "fnt": { + "type": "font", + "description": "The font to be used", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def set_interface_font(fnt):" + ], + "pascal": [ + "procedure SetInterfaceFont(fnt: Font)" + ], + "csharp": [ + "public static void Interface.SetInterfaceFont(Font fnt);", + "public static void SplashKit.SetInterfaceFont(Font fnt);" + ], + "cpp": [ + "void set_interface_font(font fnt)" + ] + } + }, + { + "signature": "void set_interface_font_size(int size);", + "name": "set_interface_font_size", + "method_name": null, + "unique_global_name": "set_interface_font_size", + "unique_method_name": null, + "suffix_name": null, + "description": "Sets the interface's font size.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "size": { + "type": "int", + "description": "The font size to be used", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def set_interface_font_size(size):" + ], + "pascal": [ + "procedure SetInterfaceFontSize(size: Integer)" + ], + "csharp": [ + "public static void Interface.SetInterfaceFontSize(int size);", + "public static void SplashKit.SetInterfaceFontSize(int size);" + ], + "cpp": [ + "void set_interface_font_size(int size)" + ] + } + }, + { + "signature": "void set_interface_label_width(int width);", + "name": "set_interface_label_width", + "method_name": null, + "unique_global_name": "set_interface_label_width", + "unique_method_name": null, + "suffix_name": null, + "description": "Sets the width of element labels. This is the maximum width\nin pixels that a label can span in front of an element.\n\nDefault is 60 pixels.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "width": { + "type": "int", + "description": "The width of labels", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def set_interface_label_width(width):" + ], + "pascal": [ + "procedure SetInterfaceLabelWidth(width: Integer)" + ], + "csharp": [ + "public static void Interface.SetInterfaceLabelWidth(int width);", + "public static void SplashKit.SetInterfaceLabelWidth(int width);" + ], + "cpp": [ + "void set_interface_label_width(int width)" + ] + } + }, + { + "signature": "void set_interface_panel_shadows(int radius,color clr,point_2d offset);", + "name": "set_interface_panel_shadows", + "method_name": null, + "unique_global_name": "set_interface_panel_shadows", + "unique_method_name": null, + "suffix_name": null, + "description": "Sets the style of panel's shadows. Use a fully transparent color to disable them.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "radius": { + "type": "int", + "description": "The radius of the shadow's blur", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "clr": { + "type": "color", + "description": "The color of the shadows (commonly black, but can do coloured and semi-transparent too)", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "offset": { + "type": "point_2d", + "description": "The offset in x/y coordinates of the shadows from their casting elements", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def set_interface_panel_shadows(radius, clr, offset):" + ], + "pascal": [ + "procedure SetInterfacePanelShadows(radius: Integer; clr: Color; offset: Point2D)" + ], + "csharp": [ + "public static void Interface.SetInterfacePanelShadows(int radius, Color clr, Point2D offset);", + "public static void SplashKit.SetInterfacePanelShadows(int radius, Color clr, Point2D offset);" + ], + "cpp": [ + "void set_interface_panel_shadows(int radius, color clr, point_2d offset)" + ] + } + }, + { + "signature": "void set_interface_root_text_color(color clr);", + "name": "set_interface_root_text_color", + "method_name": null, + "unique_global_name": "set_interface_root_text_color", + "unique_method_name": null, + "suffix_name": null, + "description": "Sets color of text drawn directly onto the main window", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "clr": { + "type": "color", + "description": "The color to set text drawn on the main window to", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def set_interface_root_text_color(clr):" + ], + "pascal": [ + "procedure SetInterfaceRootTextColor(clr: Color)" + ], + "csharp": [ + "public static void Interface.SetInterfaceRootTextColor(Color clr);", + "public static void SplashKit.SetInterfaceRootTextColor(Color clr);" + ], + "cpp": [ + "void set_interface_root_text_color(color clr)" + ] + } + }, + { + "signature": "void set_interface_shadows(int radius,color clr,point_2d offset);", + "name": "set_interface_shadows", + "method_name": null, + "unique_global_name": "set_interface_shadows", + "unique_method_name": null, + "suffix_name": null, + "description": "Sets the style of all interface shadows. Use a fully transparent color to disable them.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "radius": { + "type": "int", + "description": "The radius of the shadow's blur", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "clr": { + "type": "color", + "description": "The color of the shadows (commonly black, but can do coloured and semi-transparent too)", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "offset": { + "type": "point_2d", + "description": "The offset in x/y coordinates of the shadows from their casting elements", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def set_interface_shadows(radius, clr, offset):" + ], + "pascal": [ + "procedure SetInterfaceShadows(radius: Integer; clr: Color; offset: Point2D)" + ], + "csharp": [ + "public static void Interface.SetInterfaceShadows(int radius, Color clr, Point2D offset);", + "public static void SplashKit.SetInterfaceShadows(int radius, Color clr, Point2D offset);" + ], + "cpp": [ + "void set_interface_shadows(int radius, color clr, point_2d offset)" + ] + } + }, + { + "signature": "void set_interface_spacing(int spacing,int padding);", + "name": "set_interface_spacing", + "method_name": null, + "unique_global_name": "set_interface_spacing", + "unique_method_name": null, + "suffix_name": null, + "description": "Sets the spacing within the interface.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "spacing": { + "type": "int", + "description": "The distance between elements", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "padding": { + "type": "int", + "description": "The padding within elements", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def set_interface_spacing(spacing, padding):" + ], + "pascal": [ + "procedure SetInterfaceSpacing(spacing: Integer; padding: Integer)" + ], + "csharp": [ + "public static void Interface.SetInterfaceSpacing(int spacing, int padding);", + "public static void SplashKit.SetInterfaceSpacing(int spacing, int padding);" + ], + "cpp": [ + "void set_interface_spacing(int spacing, int padding)" + ] + } + }, + { + "signature": "void set_interface_style(interface_style style);", + "name": "set_interface_style", + "method_name": null, + "unique_global_name": "set_interface_style", + "unique_method_name": null, + "suffix_name": null, + "description": "Sets the interface style to one of the presets in the interface_style enum.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "style": { + "type": "interface_style", + "description": "The preset style to use", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def set_interface_style(style):" + ], + "pascal": [ + "procedure SetInterfaceStyle(style: InterfaceStyle)" + ], + "csharp": [ + "public static void Interface.SetInterfaceStyle(InterfaceStyle style);", + "public static void SplashKit.SetInterfaceStyle(InterfaceStyle style);" + ], + "cpp": [ + "void set_interface_style(interface_style style)" + ] + } + }, + { + "signature": "void set_interface_style(interface_style style,color clr);", + "name": "set_interface_style", + "method_name": null, + "unique_global_name": "set_interface_style_with_color", + "unique_method_name": null, + "suffix_name": null, + "description": "Sets the interface style to one of the presets in the interface_style enum.\nAlso accepts a color used to customize the interface.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "style": { + "type": "interface_style", + "description": "The preset style to use", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "clr": { + "type": "color", + "description": "The color to style the interface after", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "suffix": "with_color", + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def set_interface_style_with_color(style, clr):" + ], + "pascal": [ + "procedure SetInterfaceStyle(style: InterfaceStyle; clr: Color)" + ], + "csharp": [ + "public static void Interface.SetInterfaceStyle(InterfaceStyle style, Color clr);", + "public static void SplashKit.SetInterfaceStyle(InterfaceStyle style, Color clr);" + ], + "cpp": [ + "void set_interface_style(interface_style style, color clr)" + ] + } + }, + { + "signature": "void set_interface_text_color(color clr);", + "name": "set_interface_text_color", + "method_name": null, + "unique_global_name": "set_interface_text_color", + "unique_method_name": null, + "suffix_name": null, + "description": "Sets the interface's text color.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "clr": { + "type": "color", + "description": "The color to set text to", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def set_interface_text_color(clr):" + ], + "pascal": [ + "procedure SetInterfaceTextColor(clr: Color)" + ], + "csharp": [ + "public static void Interface.SetInterfaceTextColor(Color clr);", + "public static void SplashKit.SetInterfaceTextColor(Color clr);" + ], + "cpp": [ + "void set_interface_text_color(color clr)" + ] + } + }, + { + "signature": "void set_layout_height(int height);", + "name": "set_layout_height", + "method_name": null, + "unique_global_name": "set_layout_height", + "unique_method_name": null, + "suffix_name": null, + "description": "Sets the height of each row in the interface in pixels.\n0 resets to default.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "height": { + "type": "int", + "description": "Height of rows in pixels", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def set_layout_height(height):" + ], + "pascal": [ + "procedure SetLayoutHeight(height: Integer)" + ], + "csharp": [ + "public static void Interface.SetLayoutHeight(int height);", + "public static void SplashKit.SetLayoutHeight(int height);" + ], + "cpp": [ + "void set_layout_height(int height)" + ] + } + }, + { + "signature": "void single_line_layout();", + "name": "single_line_layout", + "method_name": null, + "unique_global_name": "single_line_layout", + "unique_method_name": null, + "suffix_name": null, + "description": "Starts layouting all elements onto a single row. Reset with `reset_layout()`.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def single_line_layout():" + ], + "pascal": [ + "procedure SingleLineLayout()" + ], + "csharp": [ + "public static void Interface.SingleLineLayout();", + "public static void SplashKit.SingleLineLayout();" + ], + "cpp": [ + "void single_line_layout()" + ] + } + }, + { + "signature": "float slider(const float& value,float min_value,float max_value,const rectangle& rect);", + "name": "slider", + "method_name": null, + "unique_global_name": "slider_at_position", + "unique_method_name": null, + "suffix_name": null, + "description": "Creates a slider at a specific position on screen.\nReturns the updated value of the slider.", + "brief": null, + "return": { + "type": "float", + "description": "The updated value of the slider", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "value": { + "type": "float", + "description": "The current value of the slider", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "min_value": { + "type": "float", + "description": "The minimum value of the slider", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "max_value": { + "type": "float", + "description": "The maximum value of the slider", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "rect": { + "type": "rectangle", + "description": "The rectangle to display the slider in", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "suffix": "at_position", + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def slider_at_position(value, min_value, max_value, rect):" + ], + "pascal": [ + "function Slider(const value: Single; minValue: Single; maxValue: Single; const rect: Rectangle): Single" + ], + "csharp": [ + "public static float Interface.Slider(float value, float minValue, float maxValue, Rectangle rect);", + "public static float SplashKit.Slider(float value, float minValue, float maxValue, Rectangle rect);" + ], + "cpp": [ + "float slider(const float &value, float min_value, float max_value, const rectangle &rect)" + ] + } + }, + { + "signature": "float slider(const float& value,float min_value,float max_value);", + "name": "slider", + "method_name": null, + "unique_global_name": "slider", + "unique_method_name": null, + "suffix_name": null, + "description": "Creates a slider without a label.\nReturns the updated value of the slider.", + "brief": null, + "return": { + "type": "float", + "description": "The updated value of the slider", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "value": { + "type": "float", + "description": "The current value of the slider", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "min_value": { + "type": "float", + "description": "The minimum value of the slider", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "max_value": { + "type": "float", + "description": "The maximum value of the slider", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def slider(value, min_value, max_value):" + ], + "pascal": [ + "function Slider(const value: Single; minValue: Single; maxValue: Single): Single" + ], + "csharp": [ + "public static float Interface.Slider(float value, float minValue, float maxValue);", + "public static float SplashKit.Slider(float value, float minValue, float maxValue);" + ], + "cpp": [ + "float slider(const float &value, float min_value, float max_value)" + ] + } + }, + { + "signature": "float slider(const string& label,const float& value,float min_value,float max_value);", + "name": "slider", + "method_name": null, + "unique_global_name": "slider_labeled", + "unique_method_name": null, + "suffix_name": null, + "description": "Creates a slider with a label.\nReturns the updated value of the slider.\n\nExample usage:\n```c++\nmy_float = slider(\"Percentage\", my_float, 0, 100);\n```", + "brief": null, + "return": { + "type": "float", + "description": "The updated value of the slider", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "label": { + "type": "string", + "description": "The label to show in front of the slider", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "value": { + "type": "float", + "description": "The current value of the slider", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "min_value": { + "type": "float", + "description": "The minimum value of the slider", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "max_value": { + "type": "float", + "description": "The maximum value of the slider", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "suffix": "labeled", + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def slider_labeled(label, value, min_value, max_value):" + ], + "pascal": [ + "function Slider(const label: String; const value: Single; minValue: Single; maxValue: Single): Single" + ], + "csharp": [ + "public static float Interface.Slider(string label, float value, float minValue, float maxValue);", + "public static float SplashKit.Slider(string label, float value, float minValue, float maxValue);" + ], + "cpp": [ + "float slider(const string &label, const float &value, float min_value, float max_value)" + ] + } + }, + { + "signature": "void split_into_columns(int count);", + "name": "split_into_columns", + "method_name": null, + "unique_global_name": "split_into_columns", + "unique_method_name": null, + "suffix_name": null, + "description": "Adds `count` columns to the current layout, with equal widths", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "count": { + "type": "int", + "description": "Number of columns to add", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def split_into_columns(count):" + ], + "pascal": [ + "procedure SplitIntoColumns(count: Integer)" + ], + "csharp": [ + "public static void Interface.SplitIntoColumns(int count);", + "public static void SplashKit.SplitIntoColumns(int count);" + ], + "cpp": [ + "void split_into_columns(int count)" + ] + } + }, + { + "signature": "void split_into_columns(int count,int last_width);", + "name": "split_into_columns", + "method_name": null, + "unique_global_name": "split_into_columns_with_last_width", + "unique_method_name": null, + "suffix_name": null, + "description": "Adds `count` columns to the current layout, with equal widths.\nHas extra parameter `last_width`, which lets you specify a specific\nwidth (in pixels) for the last column.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "count": { + "type": "int", + "description": "Number of columns to add", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "last_width": { + "type": "int", + "description": "The width of the last column in pixels", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "suffix": "with_last_width", + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def split_into_columns_with_last_width(count, last_width):" + ], + "pascal": [ + "procedure SplitIntoColumns(count: Integer; lastWidth: Integer)" + ], + "csharp": [ + "public static void Interface.SplitIntoColumns(int count, int lastWidth);", + "public static void SplashKit.SplitIntoColumns(int count, int lastWidth);" + ], + "cpp": [ + "void split_into_columns(int count, int last_width)" + ] + } + }, + { + "signature": "void split_into_columns_relative(int count,double last_width);", + "name": "split_into_columns_relative", + "method_name": null, + "unique_global_name": "split_into_columns_relative_with_last_width", + "unique_method_name": null, + "suffix_name": null, + "description": "Adds `count` columns to the current layout, with equal widths.\nHas extra parameter `last_width`, which lets you specify a specific\nwidth (relative to the width of the container, between 0 and 1) for the last column.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "count": { + "type": "int", + "description": "Number of columns to add", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "last_width": { + "type": "double", + "description": "The width of the last column as percentage of the container's width (between 0 and 1)", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "suffix": "with_last_width", + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def split_into_columns_relative_with_last_width(count, last_width):" + ], + "pascal": [ + "procedure SplitIntoColumnsRelative(count: Integer; lastWidth: Double)" + ], + "csharp": [ + "public static void Interface.SplitIntoColumnsRelative(int count, double lastWidth);", + "public static void SplashKit.SplitIntoColumnsRelative(int count, double lastWidth);" + ], + "cpp": [ + "void split_into_columns_relative(int count, double last_width)" + ] + } + }, + { + "signature": "void start_custom_layout();", + "name": "start_custom_layout", + "method_name": null, + "unique_global_name": "start_custom_layout", + "unique_method_name": null, + "suffix_name": null, + "description": "Clears the default layout so that a custom layout can be made.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def start_custom_layout():" + ], + "pascal": [ + "procedure StartCustomLayout()" + ], + "csharp": [ + "public static void Interface.StartCustomLayout();", + "public static void SplashKit.StartCustomLayout();" + ], + "cpp": [ + "void start_custom_layout()" + ] + } + }, + { + "signature": "void start_inset(const string& name,const rectangle& rect);", + "name": "start_inset", + "method_name": null, + "unique_global_name": "start_inset_at_position", + "unique_method_name": null, + "suffix_name": null, + "description": "Starts the creation of an inset area inside an arbitrary rectangle.\n\nThe function **must** be accompanied by a call to `end_inset`\nwith the same name.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "name": { + "type": "string", + "description": "The name of the area", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "rect": { + "type": "rectangle", + "description": "The rectangle for the inset", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "suffix": "at_position", + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def start_inset_at_position(name, rect):" + ], + "pascal": [ + "procedure StartInset(const name: String; const rect: Rectangle)" + ], + "csharp": [ + "public static void Interface.StartInset(string name, Rectangle rect);", + "public static void SplashKit.StartInset(string name, Rectangle rect);" + ], + "cpp": [ + "void start_inset(const string &name, const rectangle &rect)" + ] + } + }, + { + "signature": "void start_inset(const string& name,int height);", + "name": "start_inset", + "method_name": null, + "unique_global_name": "start_inset", + "unique_method_name": null, + "suffix_name": null, + "description": "Starts the creation of an inset area inside a panel/popup.\n\nUse as follows:\n```c++\nstart_inset(\"Inset area\", 60);\n// elements inside area goes here\nend_inset(\"Inset area\");\n\n```\nThe function **must** be accompanied by a call to `end_inset`\nwith the same name.", + "brief": null, + "return": { + "type": "void", + "description": null, + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "name": { + "type": "string", + "description": "The name of the area", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "height": { + "type": "int", + "description": "Height of the inset area in pixels. -1 fills entire space. Use negative heights to fill _up to_ `height` away from the bottom", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def start_inset(name, height):" + ], + "pascal": [ + "procedure StartInset(const name: String; height: Integer)" + ], + "csharp": [ + "public static void Interface.StartInset(string name, int height);", + "public static void SplashKit.StartInset(string name, int height);" + ], + "cpp": [ + "void start_inset(const string &name, int height)" + ] + } + }, + { + "signature": "bool start_panel(const string& name,rectangle initial_rectangle);", + "name": "start_panel", + "method_name": null, + "unique_global_name": "start_panel", + "unique_method_name": null, + "suffix_name": null, + "description": "Starts the creation of a draggable panel with a title bar.\nReturns whether the panel is visible or not.\n\nUse as follows:\n```c++\nif (start_panel(\"My panel\", rectangle_from(0,0,100,100)))\n{\n// Rest of interface goes here\nend_panel(\"My panel\");\n}\n```\nAfter calling this, you can then call functions to\nadd elements such as buttons and text boxes inside the panel.\nThe function **must** be accompanied by a call to `end_panel`,\nthat is only called if the panel is visible, and is passed the same `name`.", + "brief": null, + "return": { + "type": "bool", + "description": "Whether the panel is visible or not", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "name": { + "type": "string", + "description": "The name shown in the panel's titlebar", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "initial_rectangle": { + "type": "rectangle", + "description": "The initial position/size the panel starts off in", + "is_pointer": false, + "is_const": false, + "is_reference": false, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def start_panel(name, initial_rectangle):" + ], + "pascal": [ + "function StartPanel(const name: String; initialRectangle: Rectangle): Boolean" + ], + "csharp": [ + "public static bool Interface.StartPanel(string name, Rectangle initialRectangle);", + "public static bool SplashKit.StartPanel(string name, Rectangle initialRectangle);" + ], + "cpp": [ + "bool start_panel(const string &name, rectangle initial_rectangle)" + ] + } + }, + { + "signature": "bool start_popup(const string& name);", + "name": "start_popup", + "method_name": null, + "unique_global_name": "start_popup", + "unique_method_name": null, + "suffix_name": null, + "description": "Starts the creation of a popup.\nReturns whether the popup is visible or not.\n\nUsage is the same as `start_panel`, other than the 'starting rectangle' will be automatically calculated.\nThe function **must** be accompanied by a call to `end_popup`\nwith the same name.", + "brief": null, + "return": { + "type": "bool", + "description": "Whether the popup is visible or not", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "name": { + "type": "string", + "description": "The name of the popup", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def start_popup(name):" + ], + "pascal": [ + "function StartPopup(const name: String): Boolean" + ], + "csharp": [ + "public static bool Interface.StartPopup(string name);", + "public static bool SplashKit.StartPopup(string name);" + ], + "cpp": [ + "bool start_popup(const string &name)" + ] + } + }, + { + "signature": "bool start_treenode(const string& label);", + "name": "start_treenode", + "method_name": null, + "unique_global_name": "start_treenode", + "unique_method_name": null, + "suffix_name": null, + "description": "Starts the creation of a tree node (such as those in a file tree view).\nReturns whether the tree node is expanded or not.\n\nUsage is the same as `start_panel`.\nThe function **must** be accompanied by a call to `end_treenode`\nwith the same name.", + "brief": null, + "return": { + "type": "bool", + "description": "Whether the tree node is expanded or not", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "label": { + "type": "string", + "description": "The name of the node", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def start_treenode(label):" + ], + "pascal": [ + "function StartTreenode(const label: String): Boolean" + ], + "csharp": [ + "public static bool Interface.StartTreenode(string label);", + "public static bool SplashKit.StartTreenode(string label);" + ], + "cpp": [ + "bool start_treenode(const string &label)" + ] + } + }, + { + "signature": "string text_box(const string& value);", + "name": "text_box", + "method_name": null, + "unique_global_name": "text_box", + "unique_method_name": null, + "suffix_name": null, + "description": "Creates a text entry box with a label.\nReturns the updated value of the text box.", + "brief": null, + "return": { + "type": "string", + "description": "The updated value of the text box", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "value": { + "type": "string", + "description": "The current value of the text box", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def text_box(value):" + ], + "pascal": [ + "function TextBox(const value: String): String" + ], + "csharp": [ + "public static string Interface.TextBox(string value);", + "public static string SplashKit.TextBox(string value);" + ], + "cpp": [ + "string text_box(const string &value)" + ] + } + }, + { + "signature": "string text_box(const string& value,const rectangle& rect);", + "name": "text_box", + "method_name": null, + "unique_global_name": "text_box_at_position", + "unique_method_name": null, + "suffix_name": null, + "description": "Creates a text entry box at a specific position on screen.\nReturns the updated value of the text box.\n\nExample usage:\n```c++\nmy_string = text_box(\"Name\", my_string);\n```", + "brief": null, + "return": { + "type": "string", + "description": "The updated value of the text box", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "value": { + "type": "string", + "description": "The current value of the text box", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "rect": { + "type": "rectangle", + "description": "The rectangle to display the button in", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "suffix": "at_position", + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def text_box_at_position(value, rect):" + ], + "pascal": [ + "function TextBox(const value: String; const rect: Rectangle): String" + ], + "csharp": [ + "public static string Interface.TextBox(string value, Rectangle rect);", + "public static string SplashKit.TextBox(string value, Rectangle rect);" + ], + "cpp": [ + "string text_box(const string &value, const rectangle &rect)" + ] + } + }, + { + "signature": "string text_box(const string& label,const string& value);", + "name": "text_box", + "method_name": null, + "unique_global_name": "text_box_labeled", + "unique_method_name": null, + "suffix_name": null, + "description": "Creates a text entry box with a label.\nReturns the updated value of the text box.\n\nExample usage:\n```c++\nmy_string = text_box(\"Name\", my_string);\n```", + "brief": null, + "return": { + "type": "string", + "description": "The updated value of the text box", + "is_pointer": false, + "is_reference": false, + "is_vector": false, + "type_parameter": null + }, + "parameters": { + "label": { + "type": "string", + "description": "The label to show in front of the text box", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + }, + "value": { + "type": "string", + "description": "The current value of the text box", + "is_pointer": false, + "is_const": true, + "is_reference": true, + "is_array": false, + "array_dimension_sizes": [ + + ], + "is_vector": false, + "type_parameter": null + } + }, + "attributes": { + "suffix": "labeled", + "group": "interface", + "static": "interface" + }, + "signatures": { + "python": [ + "def text_box_labeled(label, value):" + ], + "pascal": [ + "function TextBox(const label: String; const value: String): String" + ], + "csharp": [ + "public static string Interface.TextBox(string label, string value);", + "public static string SplashKit.TextBox(string label, string value);" + ], + "cpp": [ + "string text_box(const string &label, const string &value)" + ] + } + } + ], + "typedefs": [ + + ], + "structs": [ + + ], + "enums": [ + + ], + "defines": [ + + ] + }, "json": { "brief": "SplashKit Json allows you to create and read JSON objects.", "description": "Splashkit's JSON library allows you to easily create or read JSON objects and\nmanipulate them to/from a JSON string or from a file containing a JSON\nstring. Create a new JSON object with a call to `create_json()` and\nread or write data to it by calling methods like\n`json_add_string(json j, string key, string value)` and\n`json_read_string(json j, string key)`.",