cluaupp 0.1.0

package/runtime/TopbarPlus/Elements/Container.lua

@@ -0,0 +1,215 @@
+local hasBecomeOldTheme = false
+local previousInsetHeight = 0
+return function(Icon)
+	
+	-- Has to be included for the time being due to this bug mentioned here:
+	-- https://devforum.roblox.com/t/bug/2973508/7
+	local GuiService = game:GetService("GuiService")
+	local Players =  game:GetService("Players")
+	local UserInputService = game:GetService("UserInputService")
+	local container = {}
+	local Signal = require(script.Parent.Parent.Packages.GoodSignal)
+	local insetChanged = Signal.new()
+	local guiInset = GuiService:GetGuiInset()
+	local startInset = 0
+	local yDownOffset = 0
+	local ySizeOffset = 0
+	local checkCount = 0
+	local isConsoleScreen = false
+	local isUsingVR = false
+	local function checkInset(status)
+		local currentHeight = GuiService.TopbarInset.Height
+		local isOldTopbar = currentHeight <= 36
+		
+
+		-- These additional checks are needed to ensure *it is actually* the old topbar
+		-- and not a client which takes a really long time to load
+		-- There's unfortunately no APIs to do this a prettier way
+		isConsoleScreen = GuiService:IsTenFootInterface()
+		isUsingVR = UserInputService.VREnabled
+		Icon.isOldTopbar = isOldTopbar
+		checkCount += 1
+		if currentHeight == 0 and status == nil then
+			task.defer(function()
+				task.wait(8)
+				checkInset("ForceConvertToOld")
+			end)
+		elseif checkCount == 1 then
+			task.delay(5, function()
+				local localPlayer = Players.LocalPlayer
+				localPlayer:WaitForChild("PlayerGui")
+				if checkCount == 1 then
+					checkInset()
+				end
+			end)
+		end
+
+		-- Conver to old theme if verified
+		if Icon.isOldTopbar and not isConsoleScreen and not isUsingVR and hasBecomeOldTheme == false and (currentHeight ~= 0 or status == "ForceConvertToOld") then
+			hasBecomeOldTheme = true
+			task.defer(function()
+				-- If oldtopbar, apply the Classic theme
+				local themes = script.Parent.Parent.Features.Themes
+				local Classic = require(themes.Classic)
+				Icon.modifyBaseTheme(Classic)
+
+				-- Also configure the oldtopbar correctly
+				local function decideToHideTopbar()
+					if GuiService.MenuIsOpen then
+						Icon.setTopbarEnabled(false, true)
+					else
+						Icon.setTopbarEnabled()
+					end
+				end
+				GuiService:GetPropertyChangedSignal("MenuIsOpen"):Connect(decideToHideTopbar)
+				decideToHideTopbar()
+			end)
+		end
+
+		-- Modify the offsets slightly depending on device type
+		guiInset = GuiService:GetGuiInset()
+		startInset = if isOldTopbar then 12 else guiInset.Y - 50
+		yDownOffset = if isOldTopbar then 2 else 0 --if isOldTopbar then 2 else 0 
+		ySizeOffset = -2
+		if isConsoleScreen then
+			startInset = 10
+			yDownOffset = 0 ---9
+		end
+		if GuiService.TopbarInset.Height == 0 and not hasBecomeOldTheme then
+			yDownOffset += 13
+			ySizeOffset = 50
+		end
+
+		-- Now inform other areas of the change
+		insetChanged:Fire(guiInset)
+		local insetHeight = guiInset.Y
+		if insetHeight ~= previousInsetHeight then
+			previousInsetHeight = insetHeight
+			task.defer(function()
+				Icon.insetHeightChanged:Fire(insetHeight)
+			end)
+		end
+		
+	end
+	GuiService:GetPropertyChangedSignal("TopbarInset"):Connect(checkInset)
+	checkInset("FirstTime")
+
+	local screenGui = Instance.new("ScreenGui")
+	insetChanged:Connect(function()
+		screenGui:SetAttribute("StartInset", startInset)
+	end)
+	screenGui.Name = "TopbarStandard"
+	screenGui.Enabled = true
+	screenGui.DisplayOrder = Icon.baseDisplayOrder
+	screenGui.ZIndexBehavior = Enum.ZIndexBehavior.Sibling
+	screenGui.IgnoreGuiInset = true
+	screenGui.ResetOnSpawn = false
+	screenGui.ScreenInsets = Enum.ScreenInsets.TopbarSafeInsets
+	container[screenGui.Name] = screenGui
+	Icon.baseDisplayOrderChanged:Connect(function()
+		screenGui.DisplayOrder = Icon.baseDisplayOrder
+	end)
+
+	local holders = Instance.new("Frame")
+	holders.Name = "Holders"
+	holders.BackgroundTransparency = 1
+	insetChanged:Connect(function()
+		local holderY = if isUsingVR then 36 else 56
+		local holderSize = if isConsoleScreen then UDim2.new(1, 0, 0, holderY) else UDim2.new(1, 0, 1, ySizeOffset)
+		holders.Position = UDim2.new(0, 0, 0, yDownOffset)
+		holders.Size = holderSize
+	end)
+	holders.Visible = true
+	holders.ZIndex = 1
+	holders.Parent = screenGui
+	
+	local screenGuiCenter = screenGui:Clone()
+	local holdersCenter = screenGuiCenter.Holders
+	local function updateCenteredHoldersHeight()
+		holdersCenter.Size = UDim2.new(1, 0, 0, GuiService.TopbarInset.Height+ySizeOffset)
+	end
+	screenGuiCenter.Name = "TopbarCentered"
+	screenGuiCenter.DisplayOrder = Icon.baseDisplayOrder
+	screenGuiCenter.ScreenInsets = Enum.ScreenInsets.None
+	Icon.baseDisplayOrderChanged:Connect(function()
+		screenGuiCenter.DisplayOrder = Icon.baseDisplayOrder
+	end)
+	container[screenGuiCenter.Name] = screenGuiCenter
+	
+	insetChanged:Connect(updateCenteredHoldersHeight)
+	updateCenteredHoldersHeight()
+	
+	local screenGuiClipped = screenGui:Clone()
+	screenGuiClipped.Name = screenGuiClipped.Name.."Clipped"
+	screenGuiClipped.DisplayOrder = (Icon.baseDisplayOrder + 1)
+	Icon.baseDisplayOrderChanged:Connect(function()
+		screenGuiClipped.DisplayOrder = (Icon.baseDisplayOrder + 1)
+	end)
+	container[screenGuiClipped.Name] = screenGuiClipped
+	
+	local screenGuiCenterClipped = screenGuiCenter:Clone()
+	screenGuiCenterClipped.Name = screenGuiCenterClipped.Name.."Clipped"
+	screenGuiCenterClipped.DisplayOrder = (Icon.baseDisplayOrder + 1)
+	Icon.baseDisplayOrderChanged:Connect(function()
+		screenGuiCenterClipped.DisplayOrder = (Icon.baseDisplayOrder + 1)
+	end)
+	container[screenGuiCenterClipped.Name] = screenGuiCenterClipped
+	
+	local holderReduction = -24
+	local left = Instance.new("ScrollingFrame")
+	left:SetAttribute("IsAHolder", true)
+	left.Name = "Left"
+	insetChanged:Connect(function()
+		left.Position = UDim2.fromOffset(startInset, 0)
+	end)
+	left.Size = UDim2.new(1, holderReduction, 1, 0)
+	left.BackgroundTransparency = 1
+	left.Visible = true
+	left.ZIndex = 1
+	left.Active = false
+	left.ClipsDescendants = true
+	left.HorizontalScrollBarInset = Enum.ScrollBarInset.None
+	left.CanvasSize = UDim2.new(0, 0, 1, -1) -- This -1 prevents a dropdown scrolling appearance bug
+	left.AutomaticCanvasSize = Enum.AutomaticSize.X
+	left.ScrollingDirection = Enum.ScrollingDirection.X
+	left.ScrollBarThickness = 0
+	left.BorderSizePixel = 0
+	left.Selectable = false
+	left.ScrollingEnabled = false--true
+	left.ElasticBehavior = Enum.ElasticBehavior.Never
+	left.Parent = holders
+	
+	local UIListLayout = Instance.new("UIListLayout")
+	insetChanged:Connect(function()
+		UIListLayout.Padding = UDim.new(0, startInset)
+	end)
+	UIListLayout.FillDirection = Enum.FillDirection.Horizontal
+	UIListLayout.SortOrder = Enum.SortOrder.LayoutOrder
+	UIListLayout.VerticalAlignment = Enum.VerticalAlignment.Bottom
+	UIListLayout.HorizontalAlignment = Enum.HorizontalAlignment.Left
+	UIListLayout.Parent = left
+	
+	local center = left:Clone()
+	insetChanged:Connect(function()
+		center.UIListLayout.Padding = UDim.new(0, startInset)
+	end)
+	center.ScrollingEnabled = false
+	center.UIListLayout.HorizontalAlignment = Enum.HorizontalAlignment.Center
+	center.Name = "Center"
+	center.Parent = holdersCenter
+	
+	local right = left:Clone()
+	insetChanged:Connect(function()
+		right.UIListLayout.Padding = UDim.new(0, startInset)
+	end)
+	right.UIListLayout.HorizontalAlignment = Enum.HorizontalAlignment.Right
+	right.Name = "Right"
+	right.AnchorPoint = Vector2.new(1, 0)
+	right.Position = UDim2.new(1, -12, 0, 0)
+	right.Parent = holders
+
+	-- This is important so that all elements update instantly
+	insetChanged:Fire(guiInset)
+
+	return container
+end

package/runtime/TopbarPlus/Elements/Dropdown.lua

@@ -0,0 +1,315 @@
+local TweenService = game:GetService("TweenService")
+local RunService = game:GetService("RunService")
+local Themes = require(script.Parent.Parent.Features.Themes)
+local PADDING = 0 -- used to be 8
+return function(icon)
+	
+	local dropdown = Instance.new("Frame") -- Instance.new("CanvasGroup")
+	dropdown.Name = "Dropdown"
+	dropdown.AutomaticSize = Enum.AutomaticSize.X
+	dropdown.BackgroundTransparency = 1
+	dropdown.BorderSizePixel = 0
+	dropdown.AnchorPoint = Vector2.new(0.5, 0)
+	dropdown.Position = UDim2.new(0.5, 0, 1, 10)
+	dropdown.ZIndex = -2
+	dropdown.ClipsDescendants = true
+	dropdown.Parent = icon.widget
+
+	-- Account for PreferredTransparency which can be set by every player
+	local GuiService = game:GetService("GuiService")
+	icon:setBehaviour("Dropdown", "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(dropdown, "BackgroundTransparency")
+	end))
+
+	local UICorner = Instance.new("UICorner")
+	UICorner.Name = "DropdownCorner"
+	UICorner.CornerRadius = UDim.new(0, 10)
+	UICorner.Parent = dropdown
+
+	local dropdownScroller = Instance.new("ScrollingFrame")
+	dropdownScroller.Name = "DropdownScroller"
+	dropdownScroller.AutomaticSize = Enum.AutomaticSize.X
+	dropdownScroller.BackgroundTransparency = 1
+	dropdownScroller.BorderSizePixel = 0
+	dropdownScroller.AnchorPoint = Vector2.new(0, 0)
+	dropdownScroller.Position = UDim2.new(0, 0, 0, 0)
+	dropdownScroller.ZIndex = -1
+	dropdownScroller.ClipsDescendants = true
+	dropdownScroller.Visible = true
+	dropdownScroller.VerticalScrollBarInset = Enum.ScrollBarInset.None --ScrollBar
+	dropdownScroller.VerticalScrollBarPosition = Enum.VerticalScrollBarPosition.Right
+	dropdownScroller.Active = false
+	dropdownScroller.ScrollingEnabled = true
+	dropdownScroller.AutomaticCanvasSize = Enum.AutomaticSize.Y
+	dropdownScroller.ScrollBarThickness = 5
+	dropdownScroller.ScrollBarImageColor3 = Color3.fromRGB(255, 255, 255)
+	dropdownScroller.ScrollBarImageTransparency = 0.8
+	dropdownScroller.CanvasSize = UDim2.new(0, 0, 0, 0)
+	dropdownScroller.Selectable = false
+	dropdownScroller.Active = true
+	dropdownScroller.Parent = dropdown
+
+	local TweenDuration = Instance.new("NumberValue") -- this helps to change the speed to open / close in modifyTheme()
+	TweenDuration.Name = "DropdownSpeed"
+	TweenDuration.Value = 0.07
+	TweenDuration.Parent = dropdown
+
+	local dropdownPadding = Instance.new("UIPadding")
+	dropdownPadding.Name = "DropdownPadding"
+	dropdownPadding.PaddingTop = UDim.new(0, PADDING)
+	dropdownPadding.PaddingBottom = UDim.new(0, PADDING)
+	dropdownPadding.Parent = dropdownScroller
+
+	local dropdownList = Instance.new("UIListLayout")
+	dropdownList.Name = "DropdownList"
+	dropdownList.FillDirection = Enum.FillDirection.Vertical
+	dropdownList.SortOrder = Enum.SortOrder.LayoutOrder
+	dropdownList.HorizontalAlignment = Enum.HorizontalAlignment.Center
+	dropdownList.HorizontalFlex = Enum.UIFlexAlignment.SpaceEvenly
+	dropdownList.Parent = dropdownScroller
+
+	local dropdownJanitor = icon.dropdownJanitor
+	local Icon = require(icon.iconModule)
+	icon.dropdownChildAdded:Connect(function(childIcon)
+		local _, modificationUID = childIcon:modifyTheme({
+			{"Widget", "BorderSize", 0},
+			{"IconCorners", "CornerRadius", UDim.new(0, 10)},
+			{"Widget", "MinimumWidth", 190},
+			{"Widget", "MinimumHeight", 58},
+			{"IconLabel", "TextSize", 20},
+			{"IconOverlay", "Size", UDim2.new(1, 0, 1, 0)},
+			{"PaddingLeft", "Size", UDim2.fromOffset(25, 0)},
+			{"Notice", "Position", UDim2.new(1, -24, 0, 5)},
+			{"ContentsList", "HorizontalAlignment", Enum.HorizontalAlignment.Left},
+			{"Selection", "Size", UDim2.new(1, -PADDING, 1, -PADDING)},
+			{"Selection", "Position", UDim2.new(0, PADDING/2, 0, PADDING/2)},
+		})
+		task.defer(function()
+			childIcon.joinJanitor:add(function()
+				childIcon:removeModification(modificationUID)
+			end)
+		end)
+	end)
+	icon.dropdownSet:Connect(function(arrayOfIcons)
+		for i, otherIconUID in pairs(icon.dropdownIcons) do
+			local otherIcon = Icon.getIconByUID(otherIconUID)
+			otherIcon:destroy()
+		end
+		if type(arrayOfIcons) == "table" then
+			for i, otherIcon in pairs(arrayOfIcons) do
+				otherIcon:joinDropdown(icon)
+			end
+		end
+	end)
+
+	local function updateMaxIcons()
+		--icon:modifyTheme({"Dropdown", "Visible", icon.isSelected})
+		local maxIcons = dropdown:GetAttribute("MaxIcons")
+		if not maxIcons then return 0 end
+		local children = {}
+		for _, child in pairs(dropdownScroller:GetChildren()) do
+			if child:IsA("GuiObject") and child.Visible then
+				table.insert(children, child)
+			end
+		end
+
+		table.sort(children, function(a, b) return a.AbsolutePosition.Y < b.AbsolutePosition.Y end)
+		local totalHeight = 0
+		local maxIconsRoundedUp = math.ceil(maxIcons)
+		for i = 1, maxIconsRoundedUp do
+			local child = children[i]
+			if not child then break end
+			local height = child.AbsoluteSize.Y
+			local isReduced = i == maxIconsRoundedUp and maxIconsRoundedUp ~= maxIcons
+			if isReduced then
+				height *= (maxIcons - maxIconsRoundedUp + 1)
+			end
+			totalHeight += height
+		end
+		totalHeight += dropdownPadding.PaddingTop.Offset + dropdownPadding.PaddingBottom.Offset
+		return totalHeight
+	end
+	
+	local openTween = nil
+	local closeTween = nil
+	local currentSpeedMultiplier = nil
+	local currentTweenInfo = nil
+	local function getTweenInfo()
+		local speedMultiplier = Themes.getInstanceValue(dropdown, "MaxIcons") or 1
+		if currentSpeedMultiplier and currentSpeedMultiplier == speedMultiplier and currentTweenInfo then
+			return currentTweenInfo
+		end
+		local newTweenInfo = TweenInfo.new(
+			TweenDuration.Value * speedMultiplier,
+			Enum.EasingStyle.Exponential,
+			Enum.EasingDirection.Out
+		)
+		currentTweenInfo = newTweenInfo
+		currentSpeedMultiplier = speedMultiplier
+		return newTweenInfo
+	end
+	local function updateVisibility()
+		-- Update visibiliy of dropdown using tween transition
+		local tweenInfo = getTweenInfo()
+		
+		if openTween then
+			openTween:Cancel()
+			openTween = nil
+		end
+		if closeTween then
+			closeTween:Cancel()
+			closeTween = nil
+		end
+
+		if icon.isSelected then
+			local height = updateMaxIcons()
+			dropdown.Visible = true
+			dropdown.BackgroundTransparency = 0 -- no transparency so it looks solid
+			dropdown.Size = UDim2.new(0, dropdown.Size.X.Offset, 0, 0) -- reset height to 0 before tween
+
+			openTween = TweenService:Create(dropdown, tweenInfo, {Size = UDim2.new(0, dropdown.Size.X.Offset, 0, height)})
+			openTween:Play()
+			openTween.Completed:Connect(function()
+				openTween = nil
+			end)
+		else
+			local closeTweenInfo = TweenInfo.new(0)
+			closeTween = TweenService:Create(dropdown, closeTweenInfo, {Size = UDim2.new(0, dropdown.Size.X.Offset, 0, 0)})
+			closeTween:Play()
+			closeTween.Completed:Connect(function()
+				closeTween = nil
+			end)
+		end
+	end
+
+	dropdownJanitor:add(icon.toggled:Connect(updateVisibility))
+	updateVisibility()
+	--task.delay(0.2, updateVisibility)
+
+	local function updateChildSize()
+		local tweenInfo = getTweenInfo()
+		if not icon.isSelected then return end
+		if openTween then
+			openTween:Cancel()
+			openTween = nil
+		end
+		if closeTween then
+			closeTween:Cancel()
+			closeTween = nil
+		end
+		
+		RunService.Heartbeat:Wait()
+		
+		local height = updateMaxIcons()
+
+		openTween = TweenService:Create(dropdown, tweenInfo, {Size = UDim2.new(0, dropdown.Size.X.Offset, 0, height)})
+		openTween:Play()
+		openTween.Completed:Connect(function()	
+			openTween = nil
+		end)
+	end
+
+	dropdownJanitor:add(icon.toggled:Connect(updateVisibility))
+
+	-- Ensures canvas and size stay synced (original updateMaxIcons logic)
+	local updateCount = 0
+	local isUpdating = false
+
+	-- This updates the scrolling frame to only display a scroll
+	-- length equal to the distance produced by its MaxIcons
+	local function updateMaxIconsListener()
+		updateCount += 1
+		if isUpdating then return end
+		local myUpdateCount = updateCount
+		isUpdating = true
+		task.defer(function()
+			isUpdating = false
+			if updateCount ~= myUpdateCount then
+				updateMaxIconsListener()
+			end
+		end)
+		local maxIcons = dropdown:GetAttribute("MaxIcons")
+		if not maxIcons then return end
+
+		local orderedInstances = {}
+		for _, child in pairs(dropdownScroller:GetChildren()) do
+			if child:IsA("GuiObject") and child.Visible then
+				table.insert(orderedInstances, {child, child.AbsolutePosition.Y})
+			end
+		end
+		table.sort(orderedInstances, function(a, b) return a[2] < b[2] end)
+
+		local totalHeight = 0
+		local hasSetNextSelection = false
+		local maxIconsRoundedUp = math.ceil(maxIcons)
+		for i = 1, maxIconsRoundedUp do
+			local group = orderedInstances[i]
+			if not group then break end
+			local child = group[1]
+			local height = child.AbsoluteSize.Y
+			local isReduced = i == maxIconsRoundedUp and maxIconsRoundedUp ~= maxIcons
+			if isReduced then
+				height = height * (maxIcons - maxIconsRoundedUp + 1)
+			end
+			totalHeight += height
+			if isReduced then
+				continue
+			end
+			local iconUID = child:GetAttribute("WidgetUID")
+			local childIcon = iconUID and Icon.getIconByUID(iconUID)
+			if childIcon then
+				local nextSelection = nil
+				if not hasSetNextSelection then
+					hasSetNextSelection = true
+					nextSelection = icon:getInstance("ClickRegion")
+				end
+				childIcon:getInstance("ClickRegion").NextSelectionUp = nextSelection
+			end
+		end
+		totalHeight += dropdownPadding.PaddingTop.Offset + dropdownPadding.PaddingBottom.Offset
+
+		dropdownScroller.Size = UDim2.fromOffset(0, totalHeight)
+
+	end
+
+	dropdownJanitor:add(dropdownScroller:GetPropertyChangedSignal("AbsoluteCanvasSize"):Connect(updateMaxIconsListener))
+	dropdownJanitor:add(dropdownScroller.ChildAdded:Connect(updateMaxIconsListener))
+	dropdownJanitor:add(dropdownScroller.ChildRemoved:Connect(updateChildSize)) -- rezise the dropdown when icon delects or adds
+	dropdownJanitor:add(dropdownScroller.ChildRemoved:Connect(updateMaxIconsListener))
+	dropdownJanitor:add(dropdown:GetAttributeChangedSignal("MaxIcons"):Connect(updateMaxIconsListener))
+	dropdownJanitor:add(dropdown:GetAttributeChangedSignal("MaxIcons"):Connect(updateChildSize))
+	dropdownJanitor:add(icon.childThemeModified:Connect(updateMaxIconsListener))
+	updateMaxIconsListener()
+
+	-- Ensures each child listens to visibility changes
+	local function connectVisibilityListeners(child)
+		if child:IsA("GuiObject") then
+			child:GetPropertyChangedSignal("Visible"):Connect(updateChildSize)
+			child:GetPropertyChangedSignal("Size"):Connect(updateChildSize) -- -- update max icons when child size changes
+		end
+	end
+	
+	-- For existing children
+	for _, child in pairs(dropdownScroller:GetChildren()) do
+		connectVisibilityListeners(child)
+	end
+	-- For new children
+	dropdownScroller.ChildAdded:Connect(function(child)
+		RunService.Heartbeat:Wait()
+		connectVisibilityListeners(child)
+		updateChildSize()
+	end)
+
+	-- On start, hide dropdown (prevent it showing as opened)
+	dropdown.Visible = false
+
+	return dropdown
+end

package/runtime/TopbarPlus/Elements/Indicator.lua

@@ -0,0 +1,91 @@
+return function(icon, Icon)
+
+	local widget = icon.widget
+	local contents = icon:getInstance("Contents")
+	local indicator = Instance.new("Frame")
+	indicator.Name = "Indicator"
+	indicator.LayoutOrder = 9999999
+	indicator.ZIndex = 6
+	indicator.Size = UDim2.new(0, 42, 0, 42)
+	indicator.BorderColor3 = Color3.fromRGB(0, 0, 0)
+	indicator.BackgroundTransparency = 1
+	indicator.Position = UDim2.new(1, 0, 0.5, 0)
+	indicator.BorderSizePixel = 0
+	indicator.BackgroundColor3 = Color3.fromRGB(0, 0, 0)
+	indicator.Parent = contents
+
+	local indicatorButton = Instance.new("Frame")
+	indicatorButton.Name = "IndicatorButton"
+	indicatorButton.BorderColor3 = Color3.fromRGB(0, 0, 0)
+	indicatorButton.AnchorPoint = Vector2.new(0.5, 0.5)
+	indicatorButton.BorderSizePixel = 0
+	indicatorButton.BackgroundColor3 = Color3.fromRGB(0, 0, 0)
+	indicatorButton.Parent = indicator
+	
+	local GuiService = game:GetService("GuiService")
+	local GamepadService = game:GetService("GamepadService")
+	local ourClickRegion = icon:getInstance("ClickRegion")
+	local function selectionChanged()
+		local selectedClickRegion = GuiService.SelectedObject
+		if selectedClickRegion == ourClickRegion then
+			indicatorButton.BackgroundTransparency = 1
+			indicatorButton.Position = UDim2.new(0.5, -2, 0.5, 0)
+			indicatorButton.Size = UDim2.fromScale(1.2, 1.2)
+		else
+			indicatorButton.BackgroundTransparency = 0.75
+			indicatorButton.Position = UDim2.new(0.5, 2, 0.5, 0)
+			indicatorButton.Size = UDim2.fromScale(1, 1)
+		end
+	end
+	icon.janitor:add(GuiService:GetPropertyChangedSignal("SelectedObject"):Connect(selectionChanged))
+	selectionChanged()
+
+	local imageLabel = Instance.new("ImageLabel")
+	imageLabel.LayoutOrder = 2
+	imageLabel.ZIndex = 15
+	imageLabel.AnchorPoint = Vector2.new(0.5, 0.5)
+	imageLabel.Size = UDim2.new(0.5, 0, 0.5, 0)
+	imageLabel.BackgroundTransparency = 1
+	imageLabel.Position = UDim2.new(0.5, 0, 0.5, 0)
+	imageLabel.Image = "rbxasset://textures/ui/Controls/XboxController/DPadUp@2x.png"
+	imageLabel.Parent = indicatorButton
+
+	local UICorner = Instance.new("UICorner")
+	UICorner.CornerRadius = UDim.new(1, 0)
+	UICorner.Parent = indicatorButton
+
+	local UserInputService = game:GetService("UserInputService")
+	local function setIndicatorVisible(visibility)
+		if visibility == nil then
+			visibility = indicator.Visible
+		end
+		if GamepadService.GamepadCursorEnabled then
+			visibility = false
+		end
+		if visibility then
+			icon:modifyTheme({"PaddingRight", "Size", UDim2.new(0, 0, 1, 0)}, "IndicatorPadding")
+		elseif indicator.Visible then
+			icon:removeModification("IndicatorPadding")
+		end
+		icon:modifyTheme({"Indicator", "Visible", visibility})
+		icon.updateSize:Fire()
+	end
+	icon.janitor:add(GamepadService:GetPropertyChangedSignal("GamepadCursorEnabled"):Connect(setIndicatorVisible))
+	icon.indicatorSet:Connect(function(keyCode)
+		local visibility = false
+		if keyCode then
+			imageLabel.Image = UserInputService:GetImageForKeyCode(keyCode)
+			visibility = true
+		end
+		setIndicatorVisible(visibility)
+	end)
+
+	local function updateSize()
+		local ySize = widget.AbsoluteSize.Y*0.96
+		indicator.Size = UDim2.new(0, ySize, 0, ySize)
+	end
+	widget:GetPropertyChangedSignal("AbsoluteSize"):Connect(updateSize)
+	updateSize()
+
+	return indicator
+end