ScaleformUI

https://manups4e.github.io/ScaleformUI/
Admin
A Scaleform-based library for creating Rockstar-like menus, pause menus, notifications, and HUD...
Tokens:103,848
Snippets:1,162
Trust Score:9.7
Update:4 months ago
Show doc for...
Tokens:
Raw
### ShowNotification Invocation Examples

Source: https://manups4e.github.io/ScaleformUI/hud/ShowNotifications

These examples demonstrate how to call the ShowNotification functions. The first example shows a basic notification call, while the second demonstrates calling the color variant.

```lua
:ShowNotification(msg, blink, showBrief)

```

```lua
:ShowNotificationWithColor(msg, color, blink, showBrief)

```

--------------------------------

### Lua UIMenu Initialization Example

Source: https://manups4e.github.io/ScaleformUI/UIMenu

Basic initialization of a UIMenu object in Lua.

```lua
local mainMenu = UIMenu.New("Banner Title", "SUBTITLE", 0, 0)
```

--------------------------------

### C# UIMenu Initialization Example

Source: https://manups4e.github.io/ScaleformUI/UIMenu

Basic initialization of a UIMenu object in C#.

```csharp
UIMenu mainMenu = new UIMenu("Banner Title", "SUBTITLE", new PointF(0, 0));
```

--------------------------------

### Start Countdown

Source: https://manups4e.github.io/ScaleformUI/Scaleforms/Countdown

Starts a countdown sequence with customizable audio and visual settings. The countdown plays audio for each number and a 'GO' sound at the end. The function is awaitable and returns when the 'GO' signal is displayed.

```APIDOC
## Start Countdown

### Description
Starts a countdown sequence with customizable audio and visual settings. The countdown plays audio for each number and a 'GO' sound at the end. The function is awaitable and returns when the 'GO' signal is displayed.

### Method
`Start`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
* **number** (int) - Optional - The number to start the countdown from. Defaults to 3.
* **hudColor** (HudColor) - Optional - The hud color to use for the countdown. Defaults to HudColor.HUD_COLOUR_GREEN.
* **countdownAudioName** (string) - Optional - The audio name to play for each number. Defaults to "321".
* **countdownAudioRef** (string) - Optional - The audio ref to play for each number. Defaults to "Car_Club_Races_Pursuit_Series_Sounds".
* **goAudioName** (string) - Optional - The audio name to play when the countdown is finished. Defaults to "Go".
* **goAudioRef** (string) - Optional - The audio ref to play when the countdown is finished. Defaults to "Car_Club_Races_Pursuit_Series_Sounds".

### Request Example
```lua
ScaleformUI.Scaleforms.Countdown.Start(5, HudColor.HUD_COLOUR_RED, "54321", "MyAudioRef", "Start", "MyAudioRef")
```

### Response
#### Success Response
This method is awaitable and returns a promise that resolves when the countdown shows "GO".

#### Response Example
```lua
-- The promise resolves without a specific value upon completion.
```
```

--------------------------------

### C# Example: Load, Message, and Typing

Source: https://manups4e.github.io/ScaleformUI/Scaleforms/MultiplayerChat

Demonstrates loading the multiplayer chat, adding messages, and handling input to toggle typing mode in C#.

```csharp
using System;

using System.Threading.Tasks;

using CitizenFX.Core;

using CitizenFX.Core.Native;

using ScaleformUI.Scaleforms;  

public class ChatTest : BaseScript  
{
    private MultiplayerChatHandler _chat;

    public ChatTest()
    {
        _chat = new MultiplayerChatHandler();
        Tick += OnTick;
    }

    private async Task OnTick()
    {
        if (_chat == null) return;

        // Load the scaleform if it's not loaded yet  
        await _chat.Load();

        // Render the chat scaleform every frame  
        _chat.Update();

        // Press T to start typing  
        if (API.IsControlJustPressed(0, 245)) // INPUT_MP_TEXT_CHAT_ALL  
        {
            if (!_chat.IsTyping())
            {
                _chat.StartTyping();
                _chat.SetFocus(ChatVisibility.Typing, ChatScope.Global, "All", Game.Player.Name, HudColor.HUD_COLOUR_BLUE);
            }
        }

        // Press ESC to close chat if typing  
        if (_chat.IsTyping() && API.IsControlJustPressed(0, 200)) // INPUT_FRONTEND_PAUSE_ALTERNATE  
        {
            _chat.AbortText();
            _chat.Close();
        }

        // Example command to add a test message  
        if (API.IsControlJustPressed(0, 38)) // INPUT_CONTEXT  
        {
            _chat.AddMessage("System", "Welcome to the server!", ChatScope.Global, false, HudColor.HUD_COLOUR_GOLD);
        }
    }
}
```

--------------------------------

### Start Countdown Function

Source: https://manups4e.github.io/ScaleformUI/Scaleforms/Countdown

Starts a countdown sequence with customizable audio and HUD color. The function is awaitable and completes when the 'GO' signal is displayed.

```csharp
async Task Start(int number = 3, HudColor hudColor = HudColor.HUD_COLOUR_GREEN, string countdownAudioName = "321", string countdownAudioRef = "Car_Club_Races_Pursuit_Series_Sounds", string goAudioName = "Go", string goAudioRef = "Car_Club_Races_Pursuit_Series_Sounds")  

// This will start a countdown and play the audio for each step, default is 3, 2, 1, GO  

// method is awaitable and will return when the countdown shows "GO"  
```

--------------------------------

### Start Typing in Chat (C#)

Source: https://manups4e.github.io/ScaleformUI/Scaleforms/MultiplayerChat

Activates the chat interface for typing.

```csharp
public void StartTyping()
{
    
}
```

--------------------------------

### DrawText3D Function Usage Example

Source: https://manups4e.github.io/ScaleformUI/hud/DrawText3D

A simplified example demonstrating the usage of the DrawText3D function with coordinates, color, text, font, and size.

```lua
:DrawText3D(coords, color, text, font, size)
```

--------------------------------

### C# Scaleform Wide Screen Example

Source: https://manups4e.github.io/ScaleformUI/Scaleforms/ScaleformWideScreen

Demonstrates loading a Scaleform Wide Screen, calling a function on it, and rendering it fullscreen in C#.

```csharp
using CitizenFX.Core;

using ScaleformUI.Scaleforms;

using System.Threading.Tasks;

public class ScaleformTest : BaseScript
{
    private ScaleformWideScreen _myScaleform;

    public ScaleformTest()
    {
        Tick += OnTick;
    }

    private async Task OnTick()
    {
        if (_myScaleform == null)
        {
            _myScaleform = new ScaleformWideScreen("MP_BIG_MESSAGE_FREEMODE");
        }

        if (!_myScaleform.IsLoaded)
        {
            await Delay(0);
            return;
        }

        // Call a function on the scaleform
        _myScaleform.CallFunction("SHOW_CENTERED_MP_MESSAGE", "TEST TITLE", "Test Subtitle", 100, true);

        // Render the scaleform fullscreen
        _myScaleform.Render2D();
    }

}
```

--------------------------------

### UIMenuDetailsWindow Function Usage Examples

Source: https://manups4e.github.io/ScaleformUI/UIMenu/Windows/uimenudetailswindow

Illustrates common usage patterns for UIMenuDetailsWindow functions, demonstrating how to update labels and manage statistics within the UI.

```csharp
UpdateLabels(top, mid, bot, leftDetail)

UIMenuDetailsWindow:AddStatsListToWheel(stats)

UIMenuDetailsWindow:AddStatSingleToWheel(stat)

UIMenuDetailsWindow:UpdateStatsToWheel()
```

--------------------------------

### C# Example: Instructional Button Lifecycle

Source: https://manups4e.github.io/ScaleformUI/Scaleforms/Instructionalbuttons

Demonstrates creating, registering events for, updating, and cleaning up instructional buttons in C#. The library handles drawing and input checks automatically.

```csharp
using System;

using System.Collections.Generic;

using System.Threading.Tasks;

using CitizenFX.Core;

using ScaleformUI;

using ScaleformUI.Scaleforms;

public class InstructionalButtonsDemo : BaseScript
{
    private List<InstructionalButton> myButtons;

    private bool isDemoActive = false;

    public InstructionalButtonsDemo()
    {
        Tick += OnTick;
          
        // Initialize buttons
        myButtons = new List<InstructionalButton>()
        {
            new InstructionalButton(Control.PhoneSelect, "Select Option"),

            new InstructionalButton(Control.PhoneCancel, "Go Back"),

            new InstructionalButton(Control.VehicleHandbrake, "Perform Drift", PadCheck.Keyboard)
        };

        // Register events
        myButtons[0].OnControlSelected += (btn) => {
            Debug.WriteLine("Select Option pressed.");
        };

        myButtons[1].OnControlSelected += (btn) => {
            Debug.WriteLine("Go Back pressed. Cleaning up buttons.");

            StopDemo();
        };

    }

    private void StartDemo()
    {
        isDemoActive = true;
        ScaleformUI.Main.InstructionalButtons.SetInstructionalButtons(myButtons);

    }

    private void StopDemo()
    {
        isDemoActive = false;
        ScaleformUI.Main.InstructionalButtons.ClearButtonList();

    }

    private async Task OnTick()
    {
        if (Game.IsControlJustPressed(0, Control.FrontendSocialClub))
        {
            if (!isDemoActive)
            {
                StartDemo();
            }

        }

        if (isDemoActive)
        {
            // The library handles drawing and input checks automatically in its internal update loop.
            // You only need to keep the list populated.
            await Task.FromResult(0);

        }

    }

}
```

--------------------------------

### Lua Example: Managing Instructional Buttons

Source: https://manups4e.github.io/ScaleformUI/Scaleforms/Instructionalbuttons

Shows how to manage instructional buttons and handle their press events in Lua. Buttons are created, events are assigned, and the list is managed via ScaleformUI methods.

```lua
local demoActive = false
local myButtons = {}

local function StartDemo()
    demoActive = true
      
    local selectBtn = InstructionalButton.New("Select Option", -1, 191, 191, -1)
    local backBtn = InstructionalButton.New("Go Back", -1, 194, 194, -1)
      
    selectBtn.OnControlSelected = function(btn)
        print("Select Option pressed.")

    end
      
    backBtn.OnControlSelected = function(btn)
        print("Go Back pressed. Stopping demo.")

        demoActive = false
        ScaleformUI.Scaleforms.InstructionalButtons:ClearButtonList()

    end
      
    myButtons = { selectBtn, backBtn }
    ScaleformUI.Scaleforms.InstructionalButtons:SetInstructionalButtons(myButtons)

end

RegisterCommand("testbuttons", function()
    if not demoActive then
        StartDemo()

    end

end, false)
```

--------------------------------

### C# Example: Creating and Adding Job Selection Cards

Source: https://manups4e.github.io/ScaleformUI/Scaleforms/MissionSelector

Demonstrates how to create JobSelectionCard objects with various MissionDetailsItems and add them to the mission selector. This is useful for populating the mission selection menu with available jobs.

```csharp
JobSelectionCard card3 = new JobSelectionCard("Test 4", "~y~Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat", "test", "panelbackground", 12, 15, JobSelectionCardIcon.BASE_JUMPING, HudColor.HUD_COLOUR_FREEMODE, 2, new List<MissionDetailsItem>()  
{
    new MissionDetailsItem("Left Label", "Right Label", (JobIcon)15, HudColor.HUD_COLOUR_FREEMODE), 
    new MissionDetailsItem("Left Label", "Right Label", (JobIcon)16, HudColor.HUD_COLOUR_GOLD), 
    new MissionDetailsItem("Left Label", "Right Label", (JobIcon)17, HudColor.HUD_COLOUR_PURPLE), 
    new MissionDetailsItem("Left Label", "Right Label", (JobIcon)18, HudColor.HUD_COLOUR_GREEN), 
    new MissionDetailsItem("Left Label", "Right Label", (JobIcon)19, HudColor.HUD_COLOUR_WHITE, true), 
});

ScaleformUI.Main.JobMissionSelection.AddCard(card3);

JobSelectionCard card4 = new JobSelectionCard("Test 5", "~y~Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat", "test", "panelbackground", 12, 15, JobSelectionCardIcon.BASE_JUMPING, HudColor.HUD_COLOUR_FREEMODE, 2, new List<MissionDetailsItem>()  
{
    new MissionDetailsItem("Left Label", "Right Label", (JobIcon)20, HudColor.HUD_COLOUR_FREEMODE), 
    new MissionDetailsItem("Left Label", "Right Label", (JobIcon)21, HudColor.HUD_COLOUR_GOLD), 
    new MissionDetailsItem("Left Label", "Right Label", (JobIcon)22, HudColor.HUD_COLOUR_PURPLE), 
    new MissionDetailsItem("Left Label", "Right Label", (JobIcon)23, HudColor.HUD_COLOUR_GREEN), 
    new MissionDetailsItem("Left Label", "Right Label", (JobIcon)24, HudColor.HUD_COLOUR_WHITE, true), 
});

ScaleformUI.Main.JobMissionSelection.AddCard(card4);

JobSelectionCard card5 = new JobSelectionCard("Test 6", "~y~Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat", "test", "panelbackground", 12, 15, JobSelectionCardIcon.BASE_JUMPING, HudColor.HUD_COLOUR_FREEMODE, 2, new List<MissionDetailsItem>()  
{
    new MissionDetailsItem("Left Label", "Right Label", 0, HudColor.HUD_COLOUR_FREEMODE), 
    new MissionDetailsItem("Left Label", "Right Label", (JobIcon)1, HudColor.HUD_COLOUR_GOLD), 
    new MissionDetailsItem("Left Label", "Right Label", (JobIcon)2, HudColor.HUD_COLOUR_PURPLE), 
    new MissionDetailsItem("Left Label", "Right Label", (JobIcon)3, HudColor.HUD_COLOUR_GREEN), 
    new MissionDetailsItem("Left Label", "Right Label", (JobIcon)4, HudColor.HUD_COLOUR_WHITE, true), 
});

ScaleformUI.Main.JobMissionSelection.AddCard(card5);
```

--------------------------------

### Lua Example: Load, Message, and Typing

Source: https://manups4e.github.io/ScaleformUI/Scaleforms/MultiplayerChat

Demonstrates loading the multiplayer chat, adding messages, and handling input to toggle typing mode in Lua. Ensure to call chat:Load() and chat:Update() within a loop.

```lua
local chat = MultiplayerChat.New()

Citizen.CreateThread(function()
    -- Load the scaleform  
    chat:Load()

    while true do
        Citizen.Wait(0)

        -- Render the chat scaleform every frame  
        chat:Update()

        -- Press T to start typing  
        if IsControlJustPressed(0, 245) then -- INPUT_MP_TEXT_CHAT_ALL  

            if not chat:IsTyping() then  

                chat:StartTyping(ChatScope.Global, "All")  

            end  

        end  

        -- Press ESC to close chat if typing  
        if chat:IsTyping() and IsControlJustPressed(0, 200) then -- INPUT_FRONTEND_PAUSE_ALTERNATE  

            chat:AbortText()

            chat:Close()

        end  

        -- Example key press (E) to add a test message  
        if IsControlJustPressed(0, 38) then -- INPUT_CONTEXT  

            chat:AddMessage("System", "Welcome to the server!", ChatScope.Global, false, HudColours.HUD_COLOUR_GOLD)

        end
    end
end)
```

--------------------------------

### Lua Scaleform Wide Screen Example

Source: https://manups4e.github.io/ScaleformUI/Scaleforms/ScaleformWideScreen

Demonstrates loading a Scaleform Wide Screen, calling a function on it, and rendering it fullscreen in Lua.

```lua
local myScaleform = nil

Citizen.CreateThread(function()
    myScaleform = Scaleform.RequestWidescreen("MP_BIG_MESSAGE_FREEMODE")
      
    while not myScaleform:IsLoaded() do
        Citizen.Wait(0)
    end

    -- Call a function on the scaleform
    myScaleform:CallFunction("SHOW_CENTERED_MP_MESSAGE", "TEST TITLE", "Test Subtitle", 100, true)
  
    while true do
        Citizen.Wait(0)
        -- Render the scaleform fullscreen
        myScaleform:Render2D()
    end
end)

```

--------------------------------

### C# Example: Enabling and Showing Player Votes

Source: https://manups4e.github.io/ScaleformUI/Scaleforms/MissionSelector

Illustrates how to enable the mission selector and display player vote information. This is typically done after setting up cards and buttons to make the selector visible and interactive.

```csharp
ScaleformUI.Main.JobMissionSelection.Enabled = true;

await Delay(1000);
ScaleformUI.Main.JobMissionSelection.ShowPlayerVote(2, "PlayerName", HudColor.HUD_COLOUR_GREEN, true, true);
```

--------------------------------

### C# Example: Configuring and Handling Job Selection Buttons

Source: https://manups4e.github.io/ScaleformUI/Scaleforms/MissionSelector

Shows how to define a list of JobSelectionButton objects, set their properties like 'Selectable', and attach event handlers for button presses. This is used to create interactive elements within the mission selector.

```csharp
ScaleformUI.Main.JobMissionSelection.Buttons = new List<JobSelectionButton>()
{
    new JobSelectionButton("Test1", "description test", new List<MissionDetailsItem>()) {Selectable = false },
    new JobSelectionButton("Test2", "description test", new List<MissionDetailsItem>()) {Selectable = false },
    new JobSelectionButton("Test3", "description test", new List<MissionDetailsItem>()) {Selectable = true },
};

ScaleformUI.Main.JobMissionSelection.Buttons[0].OnButtonPressed += () =>
{
    Screen.ShowSubtitle($"Button Pressed => {ScaleformUI.Main.JobMissionSelection.Buttons[0].Text}");
};
```

--------------------------------

### Start Countdown Lua Implementation

Source: https://manups4e.github.io/ScaleformUI/Scaleforms/Countdown

Initiates the countdown with optional parameters for number, HUD color, and audio cues. Default values are provided for convenience.

```lua
:Start(number, hudColour, countdownAudioName, countdownAudioRef, goAudioName, goAudioRef)  
---
Starts the countdown  

---
@param number number? - The number to start the countdown from  

---
@param hudColour number? - The hud colour to use for the countdown  

---
@param countdownAudioName string? - The audio name to play for each number  

---
@param countdownAudioRef string? - The audio ref to play for each number  

---
@param goAudioName string? - The audio name to play when the countdown is finished  

---
@param goAudioRef string? - The audio ref to play when the countdown is finished  

---
@return promise  

-- consider that:  

  if number == nil then number = 3 end  

  if hudColour == nil then hudColour = 18 end  

  if countdownAudioName == nil then countdownAudioName = "321" end  

  if countdownAudioRef == nil then countdownAudioRef = "Car_Club_Races_Pursuit_Series_Sounds" end  

  if goAudioName == nil then goAudioName = "Go" end  

  if goAudioRef == nil then goAudioRef = "Car_Club_Races_Pursuit_Series_Sounds" end  
  
  

```

--------------------------------

### SettingsItem Constructors

Source: https://manups4e.github.io/ScaleformUI/PauseMenu/SettingsItems/settingsitem

Demonstrates how to instantiate a SettingsItem using C# and Lua.

```APIDOC
## SettingsItem Constructors

### C#
```csharp
public SettingsItem(string label, string rightLabel)
```

### Lua
```lua
SettingsItem.New(label, rightLabel)
```
```

--------------------------------

### Set and Get Menu Alignment (C#)

Source: https://manups4e.github.io/ScaleformUI/UIMenu/Parameters

Use this property to set or get the alignment of the menu on the screen.

```csharp
MenuAlignment MenuAlignment { get; set; } 

menu.MenuAlignment
```

--------------------------------

### Set and Get Subtitle Color (C#)

Source: https://manups4e.github.io/ScaleformUI/UIMenu/Parameters

Use this property to set or get the color of the menu's subtitle.

```csharp
HudColour SubtitleColor { get; set; } 

menu.SubtitleColor
```

--------------------------------

### UIMenuStatsItem Event Handlers

Source: https://manups4e.github.io/ScaleformUI/UIMenu/Items/uimenustatsitem

Provides example function signatures for handling stat changed and stat selected events.

```lua
OnStatsChanged = function(menu, item, newindex)
end,

OnStatsSelected = function(menu, item, newindex)
end
```

--------------------------------

### Set and Get Counter Color (C#)

Source: https://manups4e.github.io/ScaleformUI/UIMenu/Parameters

Use this property to set or get the color of the item counter displayed alongside the subtitle.

```csharp
SColor CounterColor { get; set; } 

menu.CounterColor
```

--------------------------------

### Start Typing in Chat (Lua)

Source: https://manups4e.github.io/ScaleformUI/Scaleforms/MultiplayerChat

Activates the chat interface for typing. Allows specifying scope type and scope text.

```lua
MultiplayerChat:StartTyping(scopeType, scopeText)

```

--------------------------------

### Create and Draw Marker Manually in Lua

Source: https://manups4e.github.io/ScaleformUI/hud/Markers

Example of creating a marker and drawing it manually within a thread. This snippet demonstrates manual rendering via a loop.

```lua
Citizen.CreateThread(function()

    local markerPos = vector3(-1037.0, -2737.0, 20.0)

    local markerColor = { R = 0, G = 255, B = 255, A = 150 }

      

    local myMarker = Marker.New(

        1, -- VerticalCylinder

        markerPos,   

        vector3(1.5, 1.5, 1.0),   

        50.0,   

        markerColor,   

        true,   

        false,   

        false,   

        false,

        true

    )

  

    while true do

        Citizen.Wait(0)

        myMarker:Draw()

  

        if myMarker.IsInMarker then

            BeginTextCommandDisplayHelp("STRING")

            AddTextComponentSubstringPlayerName("Press ~INPUT_CONTEXT~ to interact.")

            EndTextCommandDisplayHelp(0, false, true, -1)

  

            if IsControlJustPressed(0, 51) then

                print("Player interacted with the marker.")

            end

        end

    end

end)

```

--------------------------------

### Set and Get Description Font (C#)

Source: https://manups4e.github.io/ScaleformUI/UIMenu/Parameters

Use this property to set or get the font used for item descriptions within the menu.

```csharp
ItemFont DescriptionFont { get; set; } 

menu.DescriptionFont
```

--------------------------------

### Create InstructionalButton with Split Gamepad/Keyboard Lists (C#)

Source: https://manups4e.github.io/ScaleformUI/Scaleforms/Instructionalbuttons

Construct an InstructionalButton with lists of controls for gamepad and keyboard.

```csharp
public InstructionalButton(List<Control> gamepadControls, List<Control> keyboardControls, string text)
```

--------------------------------

### Create InstructionalButton (Lua)

Source: https://manups4e.github.io/ScaleformUI/Scaleforms/Instructionalbuttons

Construct an InstructionalButton in Lua with text, pad check, and control specifications.

```lua
InstructionalButton.New(text, padcheck, gamepadControls, keyboardControls, inputGroup)
```

--------------------------------

### Set and Get Menu Title (C#)

Source: https://manups4e.github.io/ScaleformUI/UIMenu/Parameters

Use this property to set or get the title displayed on the menu banner. It can be set during menu construction.

```csharp
string Title {get;set;}

menu.Title
```

--------------------------------

### Constructor

Source: https://manups4e.github.io/ScaleformUI/RadioMenu

Initializes a new instance of the UIRadioMenu class.

```APIDOC
## Constructor

### C#
```csharp
public UIRadioMenu()
```

### Lua
```lua
UIRadioMenu.New()
```
```

--------------------------------

### Set and Get Menu Subtitle (C#)

Source: https://manups4e.github.io/ScaleformUI/UIMenu/Parameters

Use this property to set or get the subtitle, which appears after the banner and is accompanied by the item count. It can be set during menu construction.

```csharp
string Subtitle {get;set;} 

menu.Subtitle
```

--------------------------------

### Initialize Radio Menu

Source: https://manups4e.github.io/ScaleformUI/RadioMenu

Creates a new instance of the UIRadioMenu.

```csharp
public UIRadioMenu()

```

```csharp
UIRadioMenu.New()

```

--------------------------------

### Create InstructionalButton with Split Gamepad/Keyboard Controls (C#)

Source: https://manups4e.github.io/ScaleformUI/Scaleforms/Instructionalbuttons

Construct an InstructionalButton specifying separate controls for gamepad and keyboard.

```csharp
public InstructionalButton(Control gamepadControl, Control keyboardControl, string text)
```

--------------------------------

### Populate Settings Column (C#)

Source: https://manups4e.github.io/ScaleformUI/Tutorials/HowTo-LobbyMenu

Adds interactive menu items, such as a 'Start Match' button and a 'Friendly Fire' checkbox, to the settings column.

```C#
// 1. Populate Settings Column

UIMenuItem startItem = new UIMenuItem("Start Match", "Start the match immediately.");

UIMenuCheckboxItem friendlyFire = new UIMenuCheckboxItem("Friendly Fire", true, "Toggle friendly fire.");

settingsCol.AddSettings(startItem);

settingsCol.AddSettings(friendlyFire);


```

--------------------------------

### TabView Constructor (Lua)

Source: https://manups4e.github.io/ScaleformUI/PauseMenu/TabView

Shows how to create a TabView instance using Lua.

```lua
TabView.New(title, subtitle, sideTop, sideMid, sideBot)

```

--------------------------------

### Title Property

Source: https://manups4e.github.io/ScaleformUI/UIMenu/Side%20Panels/uimissiondetailspanel

Gets or sets the title of the panel.

```APIDOC
## Title Property

### Description
Gets or sets the panel title.

### Property
`string Title { get; set; }`
```

--------------------------------

### Set Color (C#)

Source: https://manups4e.github.io/ScaleformUI/RadialMenu/segmentitem

Gets or sets the color of the SegmentItem.

```csharp
public SColor Color {get; set;}
```

--------------------------------

### Set Description (C#)

Source: https://manups4e.github.io/ScaleformUI/RadialMenu/segmentitem

Gets or sets the description for the SegmentItem.

```csharp
public string Description {get; set;}
```

--------------------------------

### Lua Example: Creating and Managing the Mission Selector Menu

Source: https://manups4e.github.io/ScaleformUI/Scaleforms/MissionSelector

Provides a Lua function to create and toggle the visibility of the mission selector. It includes setting up the Dui, runtime textures, title, max votes, and initializing the cards array.

```lua
local MissionSelectorVisible = false
function CreateMissionSelectorMenu()
    MissionSelectorVisible = not MissionSelectorVisible
    if not MissionSelectorVisible then
        ScaleformUI.Scaleforms.JobMissionSelector:Enabled(false)
        return
    end
    local txd = CreateRuntimeTxd("test")
    local _paneldui = CreateDui("https://i.imgur.com/mH0Y65C.gif", 288, 160)
    CreateRuntimeTextureFromDuiHandle(txd, "panelbackground", GetDuiHandle(_paneldui))
    ScaleformUI.Scaleforms.JobMissionSelector:SetTitle("MISSION SELECTOR")
    ScaleformUI.Scaleforms.JobMissionSelector.MaxVotes = 3
    ScaleformUI.Scaleforms.JobMissionSelector:SetVotes(0, "VOTED")
    ScaleformUI.Scaleforms.JobMissionSelector.Cards = {}
end
```

--------------------------------

### Set Label (C#)

Source: https://manups4e.github.io/ScaleformUI/RadialMenu/segmentitem

Gets or sets the label for the SegmentItem.

```csharp
public string Label {get; set;}
```

--------------------------------

### UIMenuProgressItem Constructors

Source: https://manups4e.github.io/ScaleformUI/UIMenu/Items/uimenuprogressitem

Provides the different ways to instantiate a UIMenuProgressItem, allowing for customization of text, maximum value, starting index, description, and colors.

```APIDOC
## Constructors

### `UIMenuProgressItem(string text, int maxCount, int startIndex)`

Initializes a new instance of the `UIMenuProgressItem` class with the specified text, maximum count, and starting index.

### `UIMenuProgressItem(string text, int maxCount, int startIndex, string description, bool heritage = false)`

Initializes a new instance with additional parameters for description and heritage.

### `UIMenuProgressItem(string text, int maxCount, int startIndex, string description, SColor sliderColor)`

Initializes a new instance with a specified slider color.
```

--------------------------------

### Show Warning with Interactive Buttons in C#

Source: https://manups4e.github.io/ScaleformUI/Tutorials/Scaleform-Messages

Illustrates how to display a warning screen with interactive buttons in C#, allowing users to respond via keyboard or gamepad. Includes an example of listening for button press events.

```C#
List<InstructionalButton> buttons = new List<InstructionalButton>()
{
    new InstructionalButton(Control.FrontendDown, "Accept only with Keyboard", PadCheck.Keyboard),
    new InstructionalButton(Control.FrontendY, "Cancel only with GamePad", PadCheck.Controller),
    new InstructionalButton(Control.FrontendX, Control.Detonate, "Changes button depending on input type")
};

ScaleformUI.Main.Warning.ShowWarningWithButtons(
    "ALERT",
    "Do you want to proceed?",
    "Press a button",
    buttons,
    "System Warning"
);

// Listen to the button press
ScaleformUI.Main.Warning.OnButtonPressed += (button) =>
{
    Debug.WriteLine($"You pressed a Button => {button.Text}");
    ScaleformUI.Main.Warning.Dispose();
};
```

--------------------------------

### Accessing Checkbox Style

Source: https://manups4e.github.io/ScaleformUI/UIMenu/Items/uimenucheckboxitem

Shows how to get the current style of the UIMenuCheckboxItem.

```csharp
UIMenuCheckboxStyle Style { get; }

local style = item.CheckBoxStyle
```

--------------------------------

### Create a Radio Menu in C#

Source: https://manups4e.github.io/ScaleformUI/Tutorials/Radio-Menus

Instantiate a UIRadioMenu and configure its animation properties like duration and direction.

```csharp
using ScaleformUI.Radio;

// Create a new Radio Menu
UIRadioMenu menu = new UIRadioMenu();

// Configure the animation settings
menu.AnimationDuration = 1f;
menu.AnimDirection = AnimationDirection.ZoomOut;
```

--------------------------------

### SettingsCheckboxItem Properties

Source: https://manups4e.github.io/ScaleformUI/PauseMenu/SettingsItems/settingscheckboxitem

Properties to get or set the state and style of the checkbox.

```APIDOC
## Properties

### IsChecked
- **Type**: `bool`
- **Description**: Gets or sets the checkbox state.

### CheckBoxStyle
- **Type**: `UIMenuCheckboxStyle`
- **Description**: Gets or sets the checkbox style.
```

--------------------------------

### Initialize and Populate Mission Selector

Source: https://manups4e.github.io/ScaleformUI/Scaleforms/MissionSelector

Demonstrates how to initialize the Mission Selector UI, set its properties, create and add mission cards with details, and display player votes.

```C#
if (ScaleformUI.Main.JobMissionSelection.Enabled)  

{

    ScaleformUI.Main.JobMissionSelection.Enabled = false;

    return;

}



long txd = API.CreateRuntimeTxd("test");

long _paneldui = API.CreateDui("https://i.imgur.com/mH0Y65C.gif", 288, 160);

API.CreateRuntimeTextureFromDuiHandle(txd, "panelbackground", API.GetDuiHandle(_paneldui));



ScaleformUI.Main.JobMissionSelection.SetTitle("MISSION SELECTOR");

ScaleformUI.Main.JobMissionSelection.MaxVotes = 3;

ScaleformUI.Main.JobMissionSelection.SetVotes(0, "VOTES");

ScaleformUI.Main.JobMissionSelection.Cards = new List<JobSelectionCard>();



JobSelectionCard card = new JobSelectionCard("Test 1", "~y~Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat", "test", "panelbackground", 12, 15, JobSelectionCardIcon.BASE_JUMPING, HudColor.HUD_COLOUR_FREEMODE, 2, new List<MissionDetailsItem>()  

{

    new MissionDetailsItem("Left Label", "Right Label", 0, HudColor.HUD_COLOUR_FREEMODE),

    new MissionDetailsItem("Left Label", "Right Label", (JobIcon)1, HudColor.HUD_COLOUR_GOLD),

    new MissionDetailsItem("Left Label", "Right Label", (JobIcon)2, HudColor.HUD_COLOUR_PURPLE),

    new MissionDetailsItem("Left Label", "Right Label", (JobIcon)3, HudColor.HUD_COLOUR_GREEN),

    new MissionDetailsItem("Left Label", "Right Label", (JobIcon)4, HudColor.HUD_COLOUR_WHITE, true),

});

ScaleformUI.Main.JobMissionSelection.AddCard(card);



JobSelectionCard card1 = new JobSelectionCard("Test 2", "~y~Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat", "test", "panelbackground", 12, 15, JobSelectionCardIcon.BASE_JUMPING, HudColor.HUD_COLOUR_FREEMODE, 2, new List<MissionDetailsItem>()  

{

    new MissionDetailsItem("Left Label", "Right Label", (JobIcon)5, HudColor.HUD_COLOUR_FREEMODE),

    new MissionDetailsItem("Left Label", "Right Label", (JobIcon)6, HudColor.HUD_COLOUR_GOLD),

    new MissionDetailsItem("Left Label", "Right Label", (JobIcon)7, HudColor.HUD_COLOUR_PURPLE),

    new MissionDetailsItem("Left Label", "Right Label", (JobIcon)8, HudColor.HUD_COLOUR_GREEN),

    new MissionDetailsItem("Left Label", "Right Label", (JobIcon)9, HudColor.HUD_COLOUR_WHITE, true),

});

ScaleformUI.Main.JobMissionSelection.AddCard(card1);



JobSelectionCard card2 = new JobSelectionCard("Test 3", "~y~Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat", "test", "panelbackground", 12, 15, JobSelectionCardIcon.BASE_JUMPING, HudColor.HUD_COLOUR_FREEMODE, 2, new List<MissionDetailsItem>()  

{

    new MissionDetailsItem("Left Label", "Right Label", (JobIcon)10, HudColor.HUD_COLOUR_FREEMODE),

    new MissionDetailsItem("Left Label", "Right Label", (JobIcon)11, HudColor.HUD_COLOUR_GOLD),

    new MissionDetailsItem("Left Label", "Right Label", (JobIcon)12, HudColor.HUD_COLOUR_PURPLE),

    new MissionDetailsItem("Left Label", "Right Label", (JobIcon)13, HudColor.HUD_COLOUR_GREEN),

    new MissionDetailsItem("Left Label", "Right Label", (JobIcon)14, HudColor.HUD_COLOUR_WHITE, true),

});

ScaleformUI.Main.JobMissionSelection.AddCard(card2);


```

--------------------------------

### Add Color Panel to UIMenuItem (Lua)

Source: https://manups4e.github.io/ScaleformUI/Tutorials/Side-Attached-Panels

Shows how to attach a Color Panel to a UIMenuItem using Lua. Includes examples for standard and custom palettes, along with event handling for color selection.

```lua
-- Standard Palettes
local listPanelItem1 = UIMenuItem.New("Change Color", "Select a color")
local colorPanel = UIMenuColorPanel.New("Color Panel Example", 1, 0)

-- Custom Palette
local colorPanel2 = UIMenuColorPanel.New("Custom Palette Example", 1, 0,
    { SColor.FromRandomValues(), SColor.FromRandomValues(), SColor.FromRandomValues() })

exampleMenu:AddItem(listPanelItem1)
listPanelItem1:AddPanel(colorPanel)
listPanelItem1:AddPanel(colorPanel2)

-- Event Handling
colorPanel.OnColorPanelChanged = function(menu, item, newindex)
    local message = "ColorPanel index => " .. newindex + 1
    ScaleformUI.Notifications:ShowSubtitle(message)
end
```

--------------------------------

### Create InstructionalButton with Multiple Controls (C#)

Source: https://manups4e.github.io/ScaleformUI/Scaleforms/Instructionalbuttons

Construct an InstructionalButton with a list of controls, text, and an optional pad filter.

```csharp
public InstructionalButton(List<Control> controls, string text, PadCheck padFilter = PadCheck.Any)
```

--------------------------------

### CurrentSelection Property

Source: https://manups4e.github.io/ScaleformUI/UIMenu/Panels/uimenucolorpanel

Gets or sets the current color selection index for the UIMenuColorPanel.

```APIDOC
## Parameters

### CurrentSelection

Gets or Sets the panel current color selection.

```
int CurrentSelection { get; set; }
```

**Usage:**
```
colorPanel:CurrentSelection(new_value)
```
```

--------------------------------

### Current Selection

Source: https://manups4e.github.io/ScaleformUI/RadioMenu

Gets or sets the current selected item in the menu by its index.

```APIDOC
## Current Selection

### Description
Gets or Sets the current selected item in the menu.

### C#
```csharp
public int CurrentSelection {get; set;}
```

### Lua
```lua
function UIRadioMenu:CurrentSelection(index)
```
```

--------------------------------

### Set Texture Height (C#)

Source: https://manups4e.github.io/ScaleformUI/RadialMenu/segmentitem

Gets or sets the height of the texture for the SegmentItem.

```csharp
public int TextureHeight {get; set;}
```

--------------------------------

### Set Up Lobby Menu Columns (C#)

Source: https://manups4e.github.io/ScaleformUI/Tutorials/HowTo-LobbyMenu

Creates and assigns the three main columns (Settings, Players, Details) to the lobby menu. Each column is initialized with a title and a specified width.

```C#
// Create the columns

SettingsListColumn settingsCol = new SettingsListColumn("SETTINGS", 16);

PlayerListColumn playersCol = new PlayerListColumn("PLAYERS", 16);

MissionDetailsPanel detailsCol = new MissionDetailsPanel("DETAILS");

  

// Assign the columns to the lobby menu

lobbyMenu.SetupLeftColumn(settingsCol);

lobbyMenu.SetupCenterColumn(playersCol);

lobbyMenu.SetupRightColumn(detailsCol);


```

--------------------------------

### Set Texture Width (C#)

Source: https://manups4e.github.io/ScaleformUI/RadialMenu/segmentitem

Gets or sets the width of the texture for the SegmentItem.

```csharp
public int TextureWidth {get; set;}
```

--------------------------------

### Set Texture Name (C#)

Source: https://manups4e.github.io/ScaleformUI/RadialMenu/segmentitem

Gets or sets the texture name for the SegmentItem.

```csharp
public string TextureName {get; set;}
```

--------------------------------

### UIMenuItem Constructors

Source: https://manups4e.github.io/ScaleformUI/UIMenu/Items/uimenuitem

Demonstrates the various ways to construct a UIMenuItem with different combinations of text, description, and colors.

```csharp
public UIMenuItem(string text);

public UIMenuItem(string text, string description);

public UIMenuItem(string text, uint descriptionHash);

public UIMenuItem(string text, string description, HudColor mainColor, HudColor highlightColor);

public UIMenuItem(string text, uint descriptionHash, HudColor mainColor, HudColor highlightColor);

public UIMenuItem(string text, string description, HudColor color, HudColor highlightColor, HudColor textColor, HudColor highlightedTextColor);

public UIMenuItem(string text, uint descriptionHash, HudColor color, HudColor highlightColor, HudColor textColor, HudColor highlightedTextColor);
```

--------------------------------

### SliderColor Property

Source: https://manups4e.github.io/ScaleformUI/UIMenu/Items/uimenuslideritem

Documentation for the `SliderColor` property, which allows getting or setting the color of the slider.

```APIDOC
## SliderColor Property

### Description
Gets or sets the slider color after initialization or at runtime.

### Property Signature
`HudColor SliderColor { get; set; }`

### Usage Example
```lua
sliderItem:SliderColor(color)
```
```

--------------------------------

### Set Up Lobby Menu Columns (Lua)

Source: https://manups4e.github.io/ScaleformUI/Tutorials/HowTo-LobbyMenu

Creates and assigns the three main columns (Settings, Players, Details) to the lobby menu. Each column is initialized with a title and a specified width.

```Lua
-- Create the columns

local settingsCol = SettingsListColumn.New("SETTINGS", 16)

local playersCol = PlayerListColumn.New("PLAYERS", 16)

local detailsCol = MissionDetailsPanel.New("DETAILS")

  

-- Assign the columns to the lobby menu

lobbyMenu:SetupLeftColumn(settingsCol)

lobbyMenu:SetupCenterColumn(playersCol)

lobbyMenu:SetupRightColumn(detailsCol)


```

--------------------------------

### Setting Checked State

Source: https://manups4e.github.io/ScaleformUI/UIMenu/Items/uimenucheckboxitem

Demonstrates how to get and set the checked state (true/false) of a UIMenuCheckboxItem.

```csharp
public bool Checked {get;set;}

item.Checked = true;
```

--------------------------------

### UIMenuListItem Constructors

Source: https://manups4e.github.io/ScaleformUI/UIMenu/Items/uimenulistitem

Demonstrates the different ways to construct a UIMenuListItem, including options for text, items, index, description, and colors.

```csharp
UIMenuListItem(string text, List<dynamic> items, int index)

UIMenuListItem(string text, List<dynamic> items, int index, string description)

UIMenuListItem(string text, List<dynamic> items, int index, string description, HudColor mainColor, HudColor higlightColor)
```

--------------------------------

### C# Example of UIMenuDynamicListItem Usage

Source: https://manups4e.github.io/ScaleformUI/UIMenu/Items/uimenudynamiclistitem

Demonstrates how to create and use a UIMenuDynamicListItem in C#. The callback function dynamically adjusts a float value based on left/right input and returns it formatted to three decimal places.

```csharp
float dynamicvalue = 0f;

dynamicItem = new UIMenuDynamicListItem("Dynamic List Item", "Try pressing ~INPUT_FRONTEND_LEFT~ or ~INPUT_FRONTEND_RIGHT~", dynamicvalue.ToString("F3"), async (sender, direction) =>
{
	if (direction == UIMenuDynamicListItem.ChangeDirection.Left) dynamicvalue -= 0.01f;
	else dynamicvalue += 0.01f;
	return dynamicvalue.ToString("F3");
});
```

--------------------------------

### Set Current Selection

Source: https://manups4e.github.io/ScaleformUI/RadioMenu

Gets or sets the index of the currently selected item in the menu.

```csharp
public int CurrentSelection {get; set;}

```

```lua
function UIRadioMenu:CurrentSelection(index)

```

--------------------------------

### AddInstructionalButton Method

Source: https://manups4e.github.io/ScaleformUI/Scaleforms/Instructionalbuttons

Adds a single instructional button to the current list. Use this to dynamically add buttons.

```lua
ScaleformUI.Scaleforms.InstructionalButtons:AddInstructionalButton(button)
```

--------------------------------

### Set Texture Dictionary (C#)

Source: https://manups4e.github.io/ScaleformUI/RadialMenu/segmentitem

Gets or sets the texture dictionary name for the SegmentItem.

```csharp
public string TextureDict {get; set;}
```

--------------------------------

### Show Simple Warning Screens in C#

Source: https://manups4e.github.io/ScaleformUI/Tutorials/Scaleform-Messages

Demonstrates how to display a simple warning screen in C#, including showing a warning, updating its content, and disposing of it.

```C#
// Show a warning
ScaleformUI.Main.Warning.ShowWarning(
    "ALERT",
    "Connection lost",
    "Please wait while we reconnect...",
    "Error Code: 0x12345"
);

// You can update the warning while it's active
ScaleformUI.Main.Warning.UpdateWarning("ALERT", "Connection lost", "Reconnecting in 5...", "Error Code: 0x12345");

// Dispose when done
ScaleformUI.Main.Warning.Dispose();
```

--------------------------------

### ShowAdvancedNotification Basic Usage

Source: https://manups4e.github.io/ScaleformUI/hud/AdvancedNotification

A simplified example of calling ShowAdvancedNotification with essential parameters for displaying a notification.

```csharp
ShowAdvancedNotification(title, subtitle, text, iconSet, icon, bgColor, flashColor, blink, type, sound)
```

--------------------------------

### Initialize Heritage and Details Windows (Lua)

Source: https://manups4e.github.io/ScaleformUI/Tutorials/Heritage-Details-Windows

Create and attach UIMenuHeritageWindow and UIMenuDetailsWindow to a UIMenu using Lua. The Heritage Window handles parent face blending, and the Details Window displays trait blending percentages.

```Lua
-- Create the target menu  
local windowMenu = UIMenu.New("Character Creator", "Customize your heritage")  

-- Initialize the Heritage Window (Default Dad Index, Default Mom Index)  
local heritageWindow = UIMenuHeritageWindow.New(0, 0)  

-- Initialize the Details Window  
local detailsWindow = UIMenuDetailsWindow.New(  
    "Parents resemblance", -- Title  
    "Dad:",                -- Left Stat Name  
    "Mom:",                -- Right Stat Name  
    true,                  -- Has Percentage Wheel?  
    {}                     -- Initial Stats  
)  

-- Add both windows to the Menu  
windowMenu:AddWindow(heritageWindow)  
windowMenu:AddWindow(detailsWindow)
```

--------------------------------

### Get Color Instance (C#)

Source: https://manups4e.github.io/ScaleformUI/UIMenu/Panels/uimenuvehiclecolourpickerpanel

Retrieves the SColor instance representing the currently selected value.

```csharp
public SColor Color {get;}
```

--------------------------------

### Create InstructionalButton with Single Control (C#)

Source: https://manups4e.github.io/ScaleformUI/Scaleforms/Instructionalbuttons

Construct an InstructionalButton with a single control, text, and an optional pad filter.

```csharp
public InstructionalButton(Control control, string text, PadCheck padFilter = PadCheck.Any)
```

--------------------------------

### Set Current Value (C#)

Source: https://manups4e.github.io/ScaleformUI/UIMenu/Panels/uimenuvehiclecolourpickerpanel

Gets or sets the current integer value of the color picker.

```csharp
public int Value {get;set;}
```

--------------------------------

### KeymapItem Constructors

Source: https://manups4e.github.io/ScaleformUI/PauseMenu/SubmenuTabItems/keymapitem

Constructors for creating a KeymapItem instance. You can initialize it with primary keyboard bindings, or with both primary and secondary keyboard and gamepad bindings.

```APIDOC
## KeymapItem Constructors

### C#

`public KeymapItem(string title, string primaryKeyboard);`

`public KeymapItem(string title, string primaryKeyboard, string secondaryKeyboard);`

### Lua

`KeymapItem.New(title, primaryKeyboard, secondaryKeyboard, primaryGamepad, secondaryGamepad)`
```

--------------------------------

### UIMenuDetailsWindow.New

Source: https://manups4e.github.io/ScaleformUI/UIMenu/Windows/uimenudetailswindow

Documentation for the static New method of UIMenuDetailsWindow, likely used for creating new instances.

```APIDOC
## Static Method

### UIMenuDetailsWindow.New(...)

Creates a new instance of UIMenuDetailsWindow. The specific parameters are not detailed in the source.
```

--------------------------------

### CurrentValue Property

Source: https://manups4e.github.io/ScaleformUI/UIMenu/Items/uimenuslideritem

Documentation for the `Value` property, which allows getting or setting the current value or position of the slider.

```APIDOC
## CurrentValue Property

### Description
Gets or sets the current value or position of the slider.

### Property Signature
`int Value { get; set; }`

### Usage Example
```lua
sliderItem:Index(Index)
```
```

--------------------------------

### Get Color Instance (Lua)

Source: https://manups4e.github.io/ScaleformUI/UIMenu/Panels/uimenuvehiclecolourpickerpanel

Retrieves the SColor instance of the current selected value using Lua.

```lua
panel:Color()
```

--------------------------------

### C# UIMenu Constructor Overloads

Source: https://manups4e.github.io/ScaleformUI/UIMenu

Demonstrates various overloads for the UIMenu constructor in C#.

```csharp
public UIMenu(string title, string subtitle, bool glare = false, bool alternativeTitle = false, float fadingTime, MenuAlignment menuAlignment)
  
public UIMenu(string title, string subtitle, PointF offset, bool glare = false, bool alternativeTitle = false, float fadingTime, MenuAlignment menuAlignment)
  
public UIMenu(string title, string subtitle, PointF offset, KeyValuePair<string, string> customBanner, bool glare = false, bool alternativeTitle = false, float fadingTime, MenuAlignment menuAlignment)
  
public UIMenu(string title, string subtitle, PointF offset, string spriteLibrary, string spriteName, bool glare = false, bool alternativeTitle = false, float fadingTime, MenuAlignment menuAlignment)
  
public UIMenu(string title, string subtitle, string description, PointF offset, string spriteLibrary, string spriteName, bool glare = false, bool alternativeTitle = false, float fadingTime, MenuAlignment menuAlignment)
```

--------------------------------

### SettingsProgressItem Constructors

Source: https://manups4e.github.io/ScaleformUI/PauseMenu/SettingsItems/settingsprogressitem

Initializes a new instance of the SettingsProgressItem class.

```APIDOC
## SettingsProgressItem Constructors

### C#
```csharp
public SettingsProgressItem(string label, int max, int startIndex, bool masked, SColor barColor)
```

### Lua
```lua
SettingsProgressItem.New(label, max, startIndex, masked, barColor)
```
```

--------------------------------

### Get InstructionalButton ID (C#)

Source: https://manups4e.github.io/ScaleformUI/Scaleforms/Instructionalbuttons

Retrieves the internal string identifier for the instructional button's icon.

```csharp
public string GetButtonId()
```

--------------------------------

### Get/Set Current Segment (C#)

Source: https://manups4e.github.io/ScaleformUI/RadialMenu

Gets or sets the index of the currently highlighted segment in the radial menu.

```C#
public int CurrentSegment {get;set;}
```

--------------------------------

### Handle PickerRollout Event (C# Lambda)

Source: https://manups4e.github.io/ScaleformUI/UIMenu/Panels/uimenuvehiclecolourpickerpanel

Example of handling the PickerRollout event using a C# lambda expression.

```csharp
// not an error, same delegate, different name  
VehicleColorPickerHoverEvent(int index, SColor color);
panel.OnColorRollOut += (index, color) =>  
{
    // code here
}
```

--------------------------------

### Create InstructionalButton with InputGroup (C#)

Source: https://manups4e.github.io/ScaleformUI/Scaleforms/Instructionalbuttons

Construct an InstructionalButton using an InputGroup for automatic control handling.

```csharp
public InstructionalButton(InputGroup control, string text, PadCheck padFilter = PadCheck.Any)
```

--------------------------------

### SettingsSeparatorItem Constructors

Source: https://manups4e.github.io/ScaleformUI/PauseMenu/SettingsItems/settingsseparatoritem

Provides information on how to instantiate a SettingsSeparatorItem, with options for a labeled or empty separator.

```APIDOC
## SettingsSeparatorItem Constructors

### Description
Instantiates a new SettingsSeparatorItem. Can be created with an optional label for a labeled separator or without a label for an empty separator.

### C#
```csharp
public SettingsSeparatorItem(string label);
public SettingsSeparatorItem();
```

### Lua
```lua
SettingsSeparatorItem.New(label, isJumpable)
```
```
Tokens:
Raw