cluaupp 0.1.0

package/runtime/TopbarPlus/Elements/Widget.lua

@@ -0,0 +1,437 @@
+-- I named this 'Widget' instead of 'Icon' to make a clear difference between the icon *object* and
+-- the icon (aka Widget) instance.
+-- This contains the core components of the icon such as the button, image, label and notice. It's
+-- also responsible for handling the automatic resizing of the widget (based upon image visibility and text length)
+
+return function(icon, Icon)
+
+	local widget = Instance.new("Frame")
+	widget:SetAttribute("WidgetUID", icon.UID)
+	widget.Name = "Widget"
+	widget.BackgroundTransparency = 1
+	widget.Visible = true
+	widget.ZIndex = 20
+	widget.Active = false
+	widget.ClipsDescendants = true
+
+	local button = Instance.new("Frame")
+	button.Name = "IconButton"
+	button.Visible = true
+	button.ZIndex = 2
+	button.BorderSizePixel = 0
+	button.Parent = widget
+	button.ClipsDescendants = true
+	button.Active = false -- This is essential for mobile scrollers to work when dragging
+	icon.deselected:Connect(function()
+		button.ClipsDescendants = true
+		task.delay(0.2, function()
+			if icon.isSelected then
+				button.ClipsDescendants = false
+			end
+		end)
+	end)
+
+	-- Account for PreferredTransparency which can be set by every player
+	local GuiService = game:GetService("GuiService")
+	icon:setBehaviour("IconButton", "BackgroundTransparency", function(value)
+		local preference = GuiService.PreferredTransparency
+		local newValue = value * preference
+		if value == 1 then
+			return value
+		end
+		return newValue
+	end)
+	icon.janitor:add(GuiService:GetPropertyChangedSignal("PreferredTransparency"):Connect(function()
+		icon:refreshAppearance(button, "BackgroundTransparency")
+	end))
+
+	local iconCorner = Instance.new("UICorner")
+	iconCorner:SetAttribute("Collective", "IconCorners")
+	iconCorner.Name = "UICorner"
+	iconCorner.Parent = button
+
+	local menu = require(script.Parent.Menu)(icon)
+	local menuUIListLayout = menu.MenuUIListLayout
+	local menuGap = menu.MenuGap
+	menu.Parent = button
+
+	local iconSpot = Instance.new("Frame")
+	iconSpot.Name = "IconSpot"
+	iconSpot.BackgroundColor3 = Color3.fromRGB(225, 225, 225)
+	iconSpot.BackgroundTransparency = 0.9
+	iconSpot.Visible = true
+	iconSpot.AnchorPoint = Vector2.new(0, 0.5)
+	iconSpot.ZIndex = 5
+	iconSpot.Parent = menu
+
+	local iconSpotCorner = iconCorner:Clone()
+	iconSpotCorner.Parent = iconSpot
+
+	local overlay = iconSpot:Clone()
+	overlay.UICorner.Name = "OverlayUICorner"
+	overlay.Name = "IconOverlay"
+	overlay.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
+	overlay.ZIndex = iconSpot.ZIndex + 1
+	overlay.Size = UDim2.new(1, 0, 1, 0)
+	overlay.Position = UDim2.new(0, 0, 0, 0)
+	overlay.AnchorPoint = Vector2.new(0, 0)
+	overlay.Visible = false
+	overlay.Parent = iconSpot
+
+	local clickRegion = Instance.new("TextButton")
+	clickRegion:SetAttribute("CorrespondingIconUID", icon.UID)
+	clickRegion.Name = "ClickRegion"
+	clickRegion.BackgroundTransparency = 1
+	clickRegion.Visible = true
+	clickRegion.Text = ""
+	clickRegion.ZIndex = 20
+	clickRegion.Selectable = true
+	clickRegion.SelectionGroup = true
+	clickRegion.Parent = iconSpot
+	
+	local Gamepad = require(script.Parent.Parent.Features.Gamepad)
+	Gamepad.registerButton(clickRegion)
+
+	local clickRegionCorner = iconCorner:Clone()
+	clickRegionCorner.Parent = clickRegion
+
+	local contents = Instance.new("Frame")
+	contents.Name = "Contents"
+	contents.BackgroundTransparency = 1
+	contents.Size = UDim2.fromScale(1, 1)
+	contents.Parent = iconSpot
+
+	local contentsList = Instance.new("UIListLayout")
+	contentsList.Name = "ContentsList"
+	contentsList.FillDirection = Enum.FillDirection.Horizontal
+	contentsList.VerticalAlignment = Enum.VerticalAlignment.Center
+	contentsList.SortOrder = Enum.SortOrder.LayoutOrder
+	contentsList.VerticalFlex = Enum.UIFlexAlignment.SpaceEvenly
+	contentsList.Padding = UDim.new(0, 3)
+	contentsList.Parent = contents
+
+	local paddingLeft = Instance.new("Frame")
+	paddingLeft.Name = "PaddingLeft"
+	paddingLeft.LayoutOrder = 1
+	paddingLeft.ZIndex = 5
+	paddingLeft.BorderColor3 = Color3.fromRGB(0, 0, 0)
+	paddingLeft.BackgroundTransparency = 1
+	paddingLeft.BorderSizePixel = 0
+	paddingLeft.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
+	paddingLeft.Parent = contents
+
+	local paddingCenter = Instance.new("Frame")
+	paddingCenter.Name = "PaddingCenter"
+	paddingCenter.LayoutOrder = 3
+	paddingCenter.ZIndex = 5
+	paddingCenter.Size = UDim2.new(0, 0, 1, 0)
+	paddingCenter.BorderColor3 = Color3.fromRGB(0, 0, 0)
+	paddingCenter.BackgroundTransparency = 1
+	paddingCenter.BorderSizePixel = 0
+	paddingCenter.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
+	paddingCenter.Parent = contents
+
+	local paddingRight = Instance.new("Frame")
+	paddingRight.Name = "PaddingRight"
+	paddingRight.LayoutOrder = 5
+	paddingRight.ZIndex = 5
+	paddingRight.BorderColor3 = Color3.fromRGB(0, 0, 0)
+	paddingRight.BackgroundTransparency = 1
+	paddingRight.BorderSizePixel = 0
+	paddingRight.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
+	paddingRight.Parent = contents
+
+	local iconLabelContainer = Instance.new("Frame")
+	iconLabelContainer.Name = "IconLabelContainer"
+	iconLabelContainer.LayoutOrder = 4
+	iconLabelContainer.ZIndex = 3
+	iconLabelContainer.AnchorPoint = Vector2.new(0, 0.5)
+	iconLabelContainer.Size = UDim2.new(0, 0, 0.5, 0)
+	iconLabelContainer.BackgroundTransparency = 1
+	iconLabelContainer.Position = UDim2.new(0.5, 0, 0.5, 0)
+	iconLabelContainer.Parent = contents
+
+	local iconLabel = Instance.new("TextLabel")
+	local viewportX = workspace.CurrentCamera.ViewportSize.X+200
+	iconLabel.Name = "IconLabel"
+	iconLabel.LayoutOrder = 4
+	iconLabel.ZIndex = 15
+	iconLabel.AnchorPoint = Vector2.new(0, 0)
+	iconLabel.Size = UDim2.new(0, viewportX, 1, 0)
+	iconLabel.ClipsDescendants = false
+	iconLabel.BackgroundTransparency = 1
+	iconLabel.Position = UDim2.fromScale(0, 0)
+	iconLabel.RichText = true
+	iconLabel.TextColor3 = Color3.fromRGB(255, 255, 255)
+	iconLabel.TextXAlignment = Enum.TextXAlignment.Left
+	iconLabel.Text = ""
+	iconLabel.TextWrapped = true
+	iconLabel.TextWrap = true
+	iconLabel.TextScaled = false
+	iconLabel.Active = false
+	iconLabel.AutoLocalize = true
+	iconLabel.Parent = iconLabelContainer
+
+	local iconImage = Instance.new("ImageLabel")
+	iconImage.Name = "IconImage"
+	iconImage.LayoutOrder = 2
+	iconImage.ZIndex = 15
+	iconImage.AnchorPoint = Vector2.new(0, 0.5)
+	iconImage.Size = UDim2.new(0, 0, 0.5, 0)
+	iconImage.BackgroundTransparency = 1
+	iconImage.Position = UDim2.new(0, 11, 0.5, 0)
+	iconImage.ScaleType = Enum.ScaleType.Stretch
+	iconImage.Active = false
+	iconImage.Parent = contents
+
+	local iconImageCorner = iconCorner:Clone()
+	iconImageCorner:SetAttribute("Collective", nil)
+	iconImageCorner.CornerRadius = UDim.new(0, 0)
+	iconImageCorner.Name = "IconImageCorner"
+	iconImageCorner.Parent = iconImage
+
+	local TweenService = game:GetService("TweenService")
+	local resizingCount = 0
+	local function handleLabelAndImageChangesUnstaggered(forceUpdateString)
+
+		-- We defer changes by a frame to eliminate all but 1 requests which
+		-- could otherwise stack up to 20+ requests in a single frame
+		-- We then repeat again once to account for any final changes
+		-- Deferring is also essential because properties are set immediately
+		-- afterwards (therefore calculations will use the correct values)
+		task.defer(function()
+			local indicator = icon.indicator
+			local usingIndicator = indicator and indicator.Visible
+			local usingText = usingIndicator or iconLabel.Text ~= ""
+			local usingImage = iconImage.Image ~= "" and iconImage.Image ~= nil
+			local _alignment = Enum.HorizontalAlignment.Center
+			local NORMAL_BUTTON_SIZE = UDim2.fromScale(1, 1)
+			local buttonSize = NORMAL_BUTTON_SIZE
+			if usingImage and not usingText then
+				iconLabelContainer.Visible = false
+				iconImage.Visible = true
+				paddingLeft.Visible = false
+				paddingCenter.Visible = false
+				paddingRight.Visible = false
+			elseif not usingImage and usingText then
+				iconLabelContainer.Visible = true
+				iconImage.Visible = false
+				paddingLeft.Visible = true
+				paddingCenter.Visible = false
+				paddingRight.Visible = true
+			elseif usingImage and usingText then
+				iconLabelContainer.Visible = true
+				iconImage.Visible = true
+				paddingLeft.Visible = true
+				paddingCenter.Visible = not usingIndicator
+				paddingRight.Visible = not usingIndicator
+				_alignment = Enum.HorizontalAlignment.Left
+			end
+			button.Size = buttonSize
+
+			local function getItemWidth(item)
+				local targetWidth = item:GetAttribute("TargetWidth") or item.AbsoluteSize.X
+				return targetWidth
+			end
+			local contentsPadding = contentsList.Padding.Offset
+			local initialWidgetWidth = contentsPadding --0
+			local textWidth = iconLabel.TextBounds.X
+			iconLabelContainer.Size = UDim2.new(0, textWidth, iconLabel.Size.Y.Scale, 0)
+			for _, child in pairs(contents:GetChildren()) do
+				if child:IsA("GuiObject") and child.Visible == true then
+					local itemWidth = getItemWidth(child)
+					initialWidgetWidth += itemWidth + contentsPadding
+				end
+			end
+			local widgetMinimumWidth = widget:GetAttribute("MinimumWidth")
+			local widgetMinimumHeight = widget:GetAttribute("MinimumHeight")
+			local widgetBorderSize = widget:GetAttribute("BorderSize")
+			local widgetWidth = math.clamp(initialWidgetWidth, widgetMinimumWidth, viewportX)
+			local menuIcons = icon.menuIcons
+			local additionalWidth = 0
+			local hasMenu = #menuIcons > 0
+			local showMenu = hasMenu and icon.isSelected
+			if showMenu then
+				for _, frame in pairs(menu:GetChildren()) do
+					if frame ~= iconSpot and frame:IsA("GuiObject") and frame.Visible then
+						additionalWidth += getItemWidth(frame) + menuUIListLayout.Padding.Offset
+					end
+				end
+				if not iconSpot.Visible then
+					widgetWidth -= (getItemWidth(iconSpot) + menuUIListLayout.Padding.Offset*2 + widgetBorderSize)
+				end
+				additionalWidth -= (widgetBorderSize*0.5)
+				widgetWidth += additionalWidth - (widgetBorderSize*0.75)
+			end
+			menuGap.Visible = showMenu and iconSpot.Visible
+			local desiredWidth = widget:GetAttribute("DesiredWidth")
+			if desiredWidth and widgetWidth < desiredWidth then
+				widgetWidth = desiredWidth
+			end
+
+			icon.updateMenu:Fire()
+			local preWidth = math.max(widgetWidth-additionalWidth, widgetMinimumWidth)
+			local spotWidth = preWidth-(widgetBorderSize*2)
+			local menuWidth = menu:GetAttribute("MenuWidth")
+			local totalMenuWidth = menuWidth and menuWidth + spotWidth + menuUIListLayout.Padding.Offset + 10
+			if totalMenuWidth then
+				local maxWidth = menu:GetAttribute("MaxWidth")
+				if maxWidth then
+					totalMenuWidth = math.max(maxWidth, widgetMinimumWidth)
+				end
+				menu:SetAttribute("MenuCanvasWidth", widgetWidth)
+				if totalMenuWidth < widgetWidth then
+					widgetWidth = totalMenuWidth
+				end
+			end
+
+			local style = Enum.EasingStyle.Quint
+			local direction = Enum.EasingDirection.Out
+			local spotWidthMax = math.max(spotWidth, getItemWidth(iconSpot), iconSpot.AbsoluteSize.X)
+			local widgetWidthMax = math.max(widgetWidth, getItemWidth(widget), widget.AbsoluteSize.X)
+			local SPEED = 750
+			local spotTweenInfo = TweenInfo.new(spotWidthMax/SPEED, style, direction)
+			local widgetTweenInfo = TweenInfo.new(widgetWidthMax/SPEED, style, direction)
+			TweenService:Create(iconSpot, spotTweenInfo, {
+				Position = UDim2.new(0, widgetBorderSize, 0.5, 0),
+				Size = UDim2.new(0, spotWidth, 1, -widgetBorderSize*2),
+			}):Play()
+			TweenService:Create(clickRegion, spotTweenInfo, {
+				Size = UDim2.new(0, spotWidth, 1, 0),
+			}):Play()
+			local newWidgetSize = UDim2.fromOffset(widgetWidth, widgetMinimumHeight)
+			local updateInstantly = widget.Size.Y.Offset ~= widgetMinimumHeight
+			if updateInstantly then
+				widget.Size = newWidgetSize
+			end
+			widget:SetAttribute("TargetWidth", newWidgetSize.X.Offset)
+			local movingTween = TweenService:Create(widget, widgetTweenInfo, {
+				Size = newWidgetSize,
+			})
+			movingTween:Play()
+			resizingCount += 1
+			for i = 1, widgetTweenInfo.Time * 100 do
+				task.delay(i/100, function()
+					Icon.iconChanged:Fire(icon)
+				end)
+			end
+			task.delay(widgetTweenInfo.Time-0.2, function()
+				resizingCount -= 1
+				task.defer(function()
+					if resizingCount == 0 then
+						icon.resizingComplete:Fire()
+					end
+				end)
+			end)
+			icon:updateParent()
+		end)
+	end
+	local Utility = require(script.Parent.Parent.Utility)
+	local handleLabelAndImageChanges = Utility.createStagger(0.01, handleLabelAndImageChangesUnstaggered)
+	local firstTimeSettingFontFace = true
+	icon:setBehaviour("IconLabel", "Text", handleLabelAndImageChanges)
+	icon:setBehaviour("IconLabel", "FontFace", function(value)
+		local previousFontFace = iconLabel.FontFace
+		if previousFontFace == value then
+			return
+		end
+		task.spawn(function()
+			--[[
+			local fontLink = value.Family
+			if string.match(fontLink, "rbxassetid://") then
+				local ContentProvider = game:GetService("ContentProvider")
+				local assets = {fontLink}
+				ContentProvider:PreloadAsync(assets)
+			end--]]
+
+			-- Afaik there's no way to determine when a Font Family has
+			-- loaded (even with ContentProvider), so we just have to try
+			-- a few times and hope it loads within the refresh period
+			handleLabelAndImageChanges()
+			if firstTimeSettingFontFace then
+				firstTimeSettingFontFace = false
+				for i = 1, 10 do
+					task.wait(1)
+					handleLabelAndImageChanges()
+				end
+			end
+		end)
+	end)
+	local function updateBorderSize()
+		task.defer(function()
+			local borderOffset = widget:GetAttribute("BorderSize")
+			local alignment = icon.alignment
+			local alignmentOffset = (iconSpot.Visible == false and 0) or (alignment == "Right" and -borderOffset) or borderOffset
+			menu.Position = UDim2.new(0, alignmentOffset, 0, 0)
+			menuGap.Size = UDim2.fromOffset(borderOffset, 0)
+			menuUIListLayout.Padding = UDim.new(0, 0)
+			handleLabelAndImageChanges()
+		end)
+	end
+	icon:setBehaviour("Widget", "BorderSize", updateBorderSize)
+	icon:setBehaviour("IconSpot", "Visible", updateBorderSize)
+	icon.startMenuUpdate:Connect(handleLabelAndImageChanges)
+	icon.updateSize:Connect(handleLabelAndImageChanges)
+	icon:setBehaviour("ContentsList", "HorizontalAlignment", handleLabelAndImageChanges)
+	icon:setBehaviour("Widget", "Visible", handleLabelAndImageChanges)
+	icon:setBehaviour("Widget", "DesiredWidth", handleLabelAndImageChanges)
+	icon:setBehaviour("Widget", "MinimumWidth", handleLabelAndImageChanges)
+	icon:setBehaviour("Widget", "MinimumHeight", handleLabelAndImageChanges)
+	icon:setBehaviour("Indicator", "Visible", handleLabelAndImageChanges)
+	icon:setBehaviour("IconImageRatio", "AspectRatio", handleLabelAndImageChanges)
+	icon:setBehaviour("IconImage", "Image", function(value)
+		local textureId = (tonumber(value) and "http://www.roblox.com/asset/?id="..value) or value or ""
+		if iconImage.Image ~= textureId then
+			handleLabelAndImageChanges()
+		end
+		return textureId
+	end)
+	icon.alignmentChanged:Connect(function(newAlignment)
+		if newAlignment == "Center" then
+			newAlignment = "Left"
+		end
+		menuUIListLayout.HorizontalAlignment = Enum.HorizontalAlignment[newAlignment]
+		updateBorderSize()
+	end)
+
+	-- Localization support (refresh icon size whenever player changes language changes in-game)
+	local Players = game:GetService("Players")
+	local localPlayer = Players.LocalPlayer
+	local lastLocaleId = localPlayer.LocaleId
+	icon.janitor:add(localPlayer:GetPropertyChangedSignal("LocaleId"):Connect(function()
+		task.delay(0.2, function()
+			local newLocaleId = localPlayer.LocaleId
+			if newLocaleId ~= lastLocaleId then
+				lastLocaleId = newLocaleId
+				icon:refresh()
+				task.wait(0.5)
+				icon:refresh()
+			end
+		end)
+	end))
+	
+	local iconImageScale = Instance.new("NumberValue")
+	iconImageScale.Name = "IconImageScale"
+	iconImageScale.Parent = iconImage
+	iconImageScale:GetPropertyChangedSignal("Value"):Connect(function()
+		iconImage.Size = UDim2.new(iconImageScale.Value, 0, iconImageScale.Value, 0)
+	end)
+
+	local UIAspectRatioConstraint = Instance.new("UIAspectRatioConstraint")
+	UIAspectRatioConstraint.Name = "IconImageRatio"
+	UIAspectRatioConstraint.AspectType = Enum.AspectType.FitWithinMaxSize
+	UIAspectRatioConstraint.DominantAxis = Enum.DominantAxis.Height
+	UIAspectRatioConstraint.Parent = iconImage
+
+	local iconGradient = Instance.new("UIGradient")
+	iconGradient.Name = "IconGradient"
+	iconGradient.Enabled = true
+	iconGradient.Parent = button
+
+	local iconSpotGradient = Instance.new("UIGradient")
+	iconSpotGradient.Name = "IconSpotGradient"
+	iconSpotGradient.Enabled = true
+	iconSpotGradient.Parent = iconSpot
+
+	return widget
+end

package/runtime/TopbarPlus/Features/Gamepad.lua

@@ -0,0 +1,201 @@
+-- As the name suggests, this handles everything related to gamepads
+-- (i.e. Xbox or Playstation controllers) and their navigation
+-- I created a separate module for gamepads (and not touchpads or
+-- keyboards) because gamepads are greatly more unqiue and require
+-- additional tailored programming
+
+
+
+-- SERVICES
+local GamepadService = game:GetService("GamepadService")
+local UserInputService = game:GetService("UserInputService")
+local GuiService = game:GetService("GuiService")
+
+
+
+-- LOCAL
+local DEFAULT_HIGHLIGHT_KEY = Enum.KeyCode.DPadUp -- The default key to highlight the topbar icon
+local GAMEPAD_INPUT = Enum.PreferredInput.Gamepad
+local Gamepad = {}
+local Icon
+
+
+
+-- FUNCTIONS
+-- This is called upon the Icon initializing
+function Gamepad.start(incomingIcon)
+	
+	-- Public variables
+	Icon = incomingIcon
+	Icon.highlightKey = if Icon.highlightKey ~= nil then Icon.highlightKey else DEFAULT_HIGHLIGHT_KEY -- What controller key to highlight the topbar (or set to false to disable)
+	Icon.highlightIcon = false -- Change to a specific icon if you'd like to highlight a specific icon instead of the left-most
+	
+	-- We defer so the developer can make changes before the
+	-- gamepad controls are initialized
+	task.delay(1, function()
+		-- Some local utility
+		local iconsDict = Icon.iconsDictionary
+		local function getIconFromSelectedObject()
+			local clickRegion = GuiService.SelectedObject
+			local iconUID = clickRegion and clickRegion:GetAttribute("CorrespondingIconUID")
+			local icon = iconUID and iconsDict[iconUID]
+			return icon
+		end
+		
+		-- This enables users to instantly open up their last selected icon
+		local previousHighlightedIcon
+		local usedIndicatorOnce = DEFAULT_HIGHLIGHT_KEY ~= Icon.highlightKey
+		local usedBOnce = DEFAULT_HIGHLIGHT_KEY ~= Icon.highlightKey
+		local Selection = require(script.Parent.Parent.Elements.Selection)
+		local function updateSelectedObject()
+			local icon = getIconFromSelectedObject()
+			local isUsingGamepad = UserInputService.PreferredInput == GAMEPAD_INPUT
+			if icon then
+				if isUsingGamepad then
+					local clickRegion = icon:getInstance("ClickRegion")
+					local selection = icon.selection
+					if not selection then
+						selection = icon.janitor:add(Selection(Icon))
+						selection:SetAttribute("IgnoreVisibilityUpdater", true)
+						selection.Parent = icon.widget
+						icon.selection = selection
+						icon:refreshAppearance(selection) --icon:clipOutside(selection)
+					end
+					clickRegion.SelectionImageObject = selection.Selection
+				end
+				if previousHighlightedIcon and previousHighlightedIcon ~= icon then
+					previousHighlightedIcon:setIndicator()
+				end
+				local newIndicator = if isUsingGamepad and not usedBOnce and not icon.parentIconUID then Enum.KeyCode.ButtonB else nil
+				previousHighlightedIcon = icon
+				Icon.lastHighlightedIcon = icon
+				icon:setIndicator(newIndicator)
+			else
+				local newIndicator = if isUsingGamepad and not usedIndicatorOnce then Icon.highlightKey else nil
+				if not previousHighlightedIcon then
+					previousHighlightedIcon = Gamepad.getIconToHighlight()
+				end
+				if newIndicator == Icon.highlightKey then
+					-- We only display the highlightKey once to show
+					-- the user how to highlight the topbar icon
+					usedIndicatorOnce = true
+				else
+					--usedBOnce = true
+				end
+				if previousHighlightedIcon then
+					previousHighlightedIcon:setIndicator(newIndicator)
+				end
+			end
+		end
+		GuiService:GetPropertyChangedSignal("SelectedObject"):Connect(updateSelectedObject)
+
+		-- This listens for a gamepad being present/added/removed
+		local function preferredInputChanged()
+			local preferredInput = UserInputService.PreferredInput
+			local isUsingGamepad = preferredInput == GAMEPAD_INPUT
+
+			if not isUsingGamepad then
+				usedIndicatorOnce = false
+				usedBOnce = false
+			end
+			updateSelectedObject()
+		end
+		UserInputService:GetPropertyChangedSignal("PreferredInput"):Connect(preferredInputChanged)
+		preferredInputChanged()
+
+		-- This allows for easy highlighting of the topbar when the
+		-- when ``Icon.highlightKey`` (i.e. DPadUp) is pressed.
+		-- If you'd like to disable, do ``Icon.highlightKey = false``
+		UserInputService.InputBegan:Connect(function(input, touchingAnObject)
+			if input.UserInputType == Enum.UserInputType.MouseButton1 then
+				-- Sometimes the Roblox gamepad glitches when combined with a cursor
+				-- This fixes that by unhighlighting if the cursor is pressed down
+				-- (i.e. a mouse click)
+				local icon = getIconFromSelectedObject()
+				if icon then
+					GuiService.SelectedObject = nil
+				end
+				return
+			end
+			if input.KeyCode ~= Icon.highlightKey then
+				return
+			end
+			local iconToHighlight = Gamepad.getIconToHighlight()
+			if iconToHighlight then
+				if GamepadService.GamepadCursorEnabled then
+					task.wait(0.2)
+					GamepadService:DisableGamepadCursor()
+				end
+				local clickRegion = iconToHighlight:getInstance("ClickRegion")
+				GuiService.SelectedObject = clickRegion
+			end
+		end)
+	end)
+end
+
+function Gamepad.getIconToHighlight()
+	-- If an icon has already been selected, returns the last selected icon
+	-- Else if more than 0 icons, it selects the left-most icon
+	local iconsDict = Icon.iconsDictionary
+	local iconToHighlight = Icon.highlightIcon or Icon.lastHighlightedIcon
+	if not iconToHighlight then
+		local currentX
+		for _, icon in pairs(iconsDict) do
+			if icon.parentIconUID then
+				continue
+			end
+			local thisX = icon.widget.AbsolutePosition.X
+			if not currentX or thisX < currentX then
+				iconToHighlight = icon
+				currentX = iconToHighlight.widget.AbsolutePosition.X
+			end
+		end
+	end
+	return iconToHighlight
+end
+
+-- This called when the icon's ClickRegion is created
+function Gamepad.registerButton(buttonInstance)
+	-- This provides a basic level of support for controllers by making
+	-- the icons easy to highlight via the virtual cursor, then
+	-- when selected, focuses in on the selected icon and hops
+	-- between other nearby icons simply by toggling the joystick
+	local inputBegan = false
+	buttonInstance.InputBegan:Connect(function(input)
+		-- Two wait frames required to ensure inputBegan is detected within
+		-- UserInputService.InputBegan. We do this because object.InputBegan
+		-- does not return the correct input objects (unlike the service)
+		inputBegan = true
+		task.wait()
+		task.wait()
+		inputBegan = false
+	end)
+	local connection = UserInputService.InputBegan:Connect(function(input)
+		task.wait()
+		if input.KeyCode == Enum.KeyCode.ButtonA and inputBegan then
+			-- We focus on an icon when selected via the virtual cursor
+			task.wait(0.2)
+			GamepadService:DisableGamepadCursor()
+			GuiService.SelectedObject = buttonInstance
+			return
+		end
+		local isSelected = GuiService.SelectedObject == buttonInstance
+		local unselectKeyCodes = {"ButtonB", "ButtonSelect"}
+		local keyName = input.KeyCode.Name
+		if table.find(unselectKeyCodes, keyName) and isSelected then
+			-- We unfocus when back button is pressed, but ignore
+			-- if the virtual cursor is disabled otherwise it will be
+			-- impossible to select the topbar
+			if not(keyName == "ButtonSelect" and not GamepadService.GamepadCursorEnabled) then
+				GuiService.SelectedObject = nil
+			end
+		end
+	end)
+	buttonInstance.Destroying:Once(function()
+		connection:Disconnect()
+	end)
+end
+
+
+
+return Gamepad