682 lines
21 KiB
Lua
682 lines
21 KiB
Lua
--[[
|
|
StyledStrike's VGUI theme utilities
|
|
|
|
A collection of functions to create common
|
|
UI panels and to apply a custom theme to them.
|
|
]]
|
|
|
|
StyledTheme = StyledTheme or {}
|
|
|
|
--[[
|
|
Setup color constants
|
|
]]
|
|
do
|
|
StyledTheme.colors = StyledTheme.colors or {}
|
|
|
|
local colors = StyledTheme.colors or {}
|
|
|
|
colors.accent = Color( 56, 113, 179 )
|
|
colors.panelBackground = Color( 46, 46, 46, 240 )
|
|
colors.panelDisabledBackground = Color( 90, 90, 90, 255 )
|
|
colors.scrollBackground = Color( 0, 0, 0, 200 )
|
|
|
|
colors.labelText = Color( 255, 255, 255, 255 )
|
|
colors.labelTextDisabled = Color( 180, 180, 180, 255 )
|
|
|
|
colors.buttonHover = Color( 150, 150, 150, 50 )
|
|
colors.buttonPress = colors.accent
|
|
colors.buttonBorder = Color( 32, 32, 32, 255 )
|
|
colors.buttonText = Color( 255, 255, 255, 255 )
|
|
colors.buttonTextDisabled = Color( 180, 180, 180, 255 )
|
|
|
|
colors.entryBackground = Color( 20, 20, 20, 255 )
|
|
colors.entryBorder = Color( 80, 80, 80, 255 )
|
|
colors.entryHighlight = colors.accent
|
|
colors.entryPlaceholder = Color( 150, 150, 150, 255 )
|
|
colors.entryText = Color( 255, 255, 255, 255 )
|
|
end
|
|
|
|
--[[
|
|
Setup dimensions
|
|
]]
|
|
StyledTheme.dimensions = StyledTheme.dimensions or {}
|
|
|
|
hook.Add( "StyledTheme_OnResolutionChange", "StyledTheme.UpdateDimensions", function()
|
|
local dimensions = StyledTheme.dimensions
|
|
local ScaleSize = StyledTheme.ScaleSize
|
|
|
|
dimensions.framePadding = ScaleSize( 10 )
|
|
dimensions.frameButtonSize = ScaleSize( 36 )
|
|
|
|
dimensions.buttonHeight = ScaleSize( 40 )
|
|
dimensions.headerHeight = ScaleSize( 32 )
|
|
|
|
dimensions.scrollBarWidth = ScaleSize( 16 )
|
|
dimensions.scrollPadding = ScaleSize( 8 )
|
|
|
|
dimensions.formPadding = ScaleSize( 20 )
|
|
dimensions.formSeparator = ScaleSize( 6 )
|
|
dimensions.formLabelWidth = ScaleSize( 300 )
|
|
|
|
dimensions.menuPadding = ScaleSize( 6 )
|
|
dimensions.indicatorSize = ScaleSize( 20 )
|
|
end )
|
|
|
|
--[[
|
|
Setup fonts
|
|
]]
|
|
StyledTheme.BASE_FONT_NAME = "Roboto"
|
|
StyledTheme.fonts = StyledTheme.fonts or {}
|
|
|
|
function StyledTheme.RegisterFont( name, screenSize, data )
|
|
data = data or {}
|
|
|
|
data.screenSize = screenSize
|
|
data.font = data.font or StyledTheme.BASE_FONT_NAME
|
|
data.extended = true
|
|
|
|
StyledTheme.fonts[name] = data
|
|
StyledTheme.forceUpdateResolution = true
|
|
end
|
|
|
|
StyledTheme.RegisterFont( "StyledTheme_Small", 0.018, {
|
|
weight = 500,
|
|
} )
|
|
|
|
StyledTheme.RegisterFont( "StyledTheme_Tiny", 0.013, {
|
|
weight = 500,
|
|
} )
|
|
|
|
hook.Add( "StyledTheme_OnResolutionChange", "StyledTheme.UpdateFonts", function( _, screenH )
|
|
for name, data in pairs( StyledTheme.fonts ) do
|
|
data.size = math.floor( screenH * data.screenSize )
|
|
surface.CreateFont( name, data )
|
|
end
|
|
end )
|
|
|
|
--[[
|
|
Watch for changes in screen resolution
|
|
]]
|
|
do
|
|
local screenW, screenH = ScrW(), ScrH()
|
|
local Floor = math.floor
|
|
|
|
--- Scales the given size (in pixels) from a 1080p resolution to
|
|
--- the resolution currently being used by the game.
|
|
function StyledTheme.ScaleSize( size )
|
|
return Floor( ( size / 1080 ) * screenH )
|
|
end
|
|
|
|
local function UpdateResolution()
|
|
screenW, screenH = ScrW(), ScrH()
|
|
StyledTheme.forceUpdateResolution = false
|
|
hook.Run( "StyledTheme_OnResolutionChange", screenW, screenH )
|
|
end
|
|
|
|
-- Only update resolution on gamemode initialization.
|
|
hook.Add( "Initialize", "StyledTheme.UpdateResolution", UpdateResolution )
|
|
|
|
local ScrW, ScrH = ScrW, ScrH
|
|
|
|
timer.Create( "StyledTheme.CheckResolution", 2, 0, function()
|
|
if ScrW() ~= screenW or ScrH() ~= screenH or StyledTheme.forceUpdateResolution then
|
|
UpdateResolution()
|
|
end
|
|
end )
|
|
end
|
|
|
|
--[[
|
|
Misc. utility functions
|
|
]]
|
|
do
|
|
--- Gets a localized language string, with the first character being in uppercase.
|
|
function StyledTheme.GetUpperLanguagePhrase( text )
|
|
text = language.GetPhrase( text )
|
|
return text:sub( 1, 1 ):upper() .. text:sub( 2 )
|
|
end
|
|
|
|
local SetDrawColor = surface.SetDrawColor
|
|
local DrawRect = surface.DrawRect
|
|
|
|
--- Draw box, using the specified background color.
|
|
--- It allows overriding the alpha while keeping the supplied color table intact.
|
|
function StyledTheme.DrawRect( x, y, w, h, color, alpha )
|
|
alpha = alpha or 1
|
|
|
|
SetDrawColor( color.r, color.g, color.b, color.a * alpha )
|
|
DrawRect( x, y, w, h )
|
|
end
|
|
|
|
local SetMaterial = surface.SetMaterial
|
|
local MAT_BLUR = Material( "pp/blurscreen" )
|
|
|
|
--- Blur the background of a panel.
|
|
function StyledTheme.BlurPanel( panel, alpha, density )
|
|
SetDrawColor( 255, 255, 255, alpha or panel:GetAlpha() )
|
|
SetMaterial( MAT_BLUR )
|
|
|
|
MAT_BLUR:SetFloat( "$blur", density or 4 )
|
|
MAT_BLUR:Recompute()
|
|
|
|
render.UpdateScreenEffectTexture()
|
|
|
|
local x, y = panel:LocalToScreen( 0, 0 )
|
|
surface.DrawTexturedRect( -x, -y, ScrW(), ScrH() )
|
|
end
|
|
|
|
local cache = {}
|
|
|
|
-- Get a material given a path to a material or .png file.
|
|
function StyledTheme.GetMaterial( path )
|
|
if cache[path] then
|
|
return cache[path]
|
|
end
|
|
|
|
cache[path] = Material( path, "smooth ignorez" )
|
|
|
|
return cache[path]
|
|
end
|
|
|
|
local GetMaterial = StyledTheme.GetMaterial
|
|
local DrawTexturedRect = surface.DrawTexturedRect
|
|
local COLOR_WHITE = Color( 255, 255, 255, 255 )
|
|
|
|
--- Draw a icon, using the specified image file path and color.
|
|
--- It allows overriding the alpha while keeping the supplied color table intact.
|
|
function StyledTheme.DrawIcon( path, x, y, w, h, alpha, color )
|
|
color = color or COLOR_WHITE
|
|
alpha = alpha or 1
|
|
|
|
SetMaterial( GetMaterial( path ) )
|
|
SetDrawColor( color.r, color.g, color.b, 255 * alpha )
|
|
DrawTexturedRect( x, y, w, h )
|
|
end
|
|
end
|
|
|
|
--[[
|
|
Utility function to apply the theme to existing VGUI panels
|
|
]]
|
|
do
|
|
local ClassFunctions = {}
|
|
|
|
function StyledTheme.Apply( panel, classOverride )
|
|
local funcs = ClassFunctions[classOverride or panel.ClassName]
|
|
if not funcs then return end
|
|
|
|
if funcs.Prepare then
|
|
funcs.Prepare( panel )
|
|
end
|
|
|
|
if funcs.Paint then
|
|
panel.Paint = funcs.Paint
|
|
end
|
|
|
|
if funcs.UpdateColours then
|
|
panel.UpdateColours = funcs.UpdateColours
|
|
end
|
|
|
|
if funcs.Close then
|
|
panel.Close = funcs.Close
|
|
end
|
|
end
|
|
|
|
local colors = StyledTheme.colors
|
|
local dimensions = StyledTheme.dimensions
|
|
local DrawRect = StyledTheme.DrawRect
|
|
|
|
ClassFunctions["DLabel"] = {
|
|
Prepare = function( self )
|
|
self:SetColor( colors.labelText )
|
|
self:SetFont( "StyledTheme_Small" )
|
|
end
|
|
}
|
|
|
|
ClassFunctions["DPanel"] = {
|
|
Paint = function( self, w, h )
|
|
DrawRect( 0, 0, w, h, self:GetBackgroundColor() or colors.panelBackground )
|
|
end
|
|
}
|
|
|
|
local function CustomMenuAdd( self, class )
|
|
local pnl = self:OriginalAdd( class )
|
|
|
|
if class == "DButton" then
|
|
StyledTheme.Apply( pnl )
|
|
|
|
timer.Simple( 0, function()
|
|
if not IsValid( pnl ) then return end
|
|
|
|
pnl:SetPaintBackground( true )
|
|
pnl:SizeToContentsX( StyledTheme.ScaleSize( 20 ) )
|
|
pnl:DockMargin( 0, 0, dimensions.menuPadding, 0 )
|
|
end )
|
|
end
|
|
|
|
return pnl
|
|
end
|
|
|
|
ClassFunctions["DMenuBar"] = {
|
|
Prepare = function( self )
|
|
self:SetTall( dimensions.buttonHeight )
|
|
self:DockMargin( 0, 0, 0, 0 )
|
|
self:DockPadding( dimensions.menuPadding, dimensions.menuPadding, dimensions.menuPadding, dimensions.menuPadding )
|
|
|
|
self.OriginalAdd = self.Add
|
|
self.Add = CustomMenuAdd
|
|
end,
|
|
Paint = function( self, w, h )
|
|
DrawRect( 0, 0, w, h, self:GetBackgroundColor() or colors.accent )
|
|
end
|
|
}
|
|
|
|
local Lerp = Lerp
|
|
local FrameTime = FrameTime
|
|
|
|
ClassFunctions["DButton"] = {
|
|
Prepare = function( self )
|
|
self:SetFont( "StyledTheme_Small" )
|
|
self:SetTall( dimensions.buttonHeight )
|
|
self.animHover = 0
|
|
self.animPress = 0
|
|
end,
|
|
|
|
Paint = function( self, w, h )
|
|
local dt = FrameTime() * 10
|
|
local enabled = self:IsEnabled()
|
|
|
|
self.animHover = Lerp( dt, self.animHover, ( enabled and self.Hovered ) and 1 or 0 )
|
|
self.animPress = Lerp( dt, self.animPress, ( enabled and ( self:IsDown() or self.m_bSelected ) ) and 1 or 0 )
|
|
|
|
DrawRect( 0, 0, w, h, ( self.isToggle and self.isChecked ) and colors.buttonPress or colors.buttonBorder )
|
|
DrawRect( 1, 1, w - 2, h - 2, enabled and colors.panelBackground or colors.panelDisabledBackground )
|
|
DrawRect( 1, 1, w - 2, h - 2, colors.buttonHover, self.animHover )
|
|
DrawRect( 1, 1, w - 2, h - 2, colors.buttonPress, self.animPress )
|
|
end,
|
|
|
|
UpdateColours = function( self )
|
|
if self:IsEnabled() then
|
|
self:SetTextStyleColor( colors.buttonText )
|
|
else
|
|
self:SetTextStyleColor( colors.buttonTextDisabled )
|
|
end
|
|
end
|
|
}
|
|
|
|
ClassFunctions["DBinder"] = ClassFunctions["DButton"]
|
|
|
|
ClassFunctions["DTextEntry"] = {
|
|
Prepare = function( self )
|
|
self:SetFont( "StyledTheme_Small" )
|
|
self:SetTall( dimensions.buttonHeight )
|
|
self:SetDrawBorder( false )
|
|
self:SetPaintBackground( false )
|
|
|
|
self:SetTextColor( colors.entryText )
|
|
self:SetCursorColor( colors.entryText )
|
|
self:SetHighlightColor( colors.entryHighlight )
|
|
self:SetPlaceholderColor( colors.entryPlaceholder )
|
|
end,
|
|
|
|
Paint = function( self, w, h )
|
|
local enabled = self:IsEnabled()
|
|
|
|
DrawRect( 0, 0, w, h, ( self:IsEditing() and enabled ) and colors.entryHighlight or colors.entryBorder )
|
|
DrawRect( 1, 1, w - 2, h - 2, enabled and colors.entryBackground or colors.panelDisabledBackground )
|
|
|
|
derma.SkinHook( "Paint", "TextEntry", self, w, h )
|
|
end
|
|
}
|
|
|
|
ClassFunctions["DComboBox"] = {
|
|
Prepare = function( self )
|
|
self:SetFont( "StyledTheme_Small" )
|
|
self:SetTall( dimensions.buttonHeight )
|
|
self:SetTextColor( colors.entryText )
|
|
self.animHover = 0
|
|
end,
|
|
|
|
Paint = function( self, w, h )
|
|
local dt = FrameTime() * 10
|
|
local enabled = self:IsEnabled()
|
|
|
|
self.animHover = Lerp( dt, self.animHover, ( enabled and self.Hovered ) and 1 or 0 )
|
|
|
|
DrawRect( 0, 0, w, h, ( self:IsMenuOpen() and enabled ) and colors.entryHighlight or colors.buttonBorder )
|
|
DrawRect( 1, 1, w - 2, h - 2, enabled and colors.panelBackground or colors.panelDisabledBackground )
|
|
DrawRect( 1, 1, w - 2, h - 2, colors.buttonHover, self.animHover )
|
|
end
|
|
}
|
|
|
|
ClassFunctions["DNumSlider"] = {
|
|
Prepare = function( self )
|
|
StyledTheme.Apply( self.TextArea )
|
|
StyledTheme.Apply( self.Label )
|
|
end
|
|
}
|
|
|
|
ClassFunctions["DScrollPanel"] = {
|
|
Prepare = function( self )
|
|
StyledTheme.Apply( self.VBar )
|
|
|
|
local padding = dimensions.scrollPadding
|
|
self.pnlCanvas:DockPadding( padding, padding, padding, padding )
|
|
self:SetPaintBackground( true )
|
|
end,
|
|
|
|
Paint = function( self, w, h )
|
|
if self:GetPaintBackground() then
|
|
DrawRect( 0, 0, w, h, colors.scrollBackground )
|
|
end
|
|
end
|
|
}
|
|
|
|
local Clamp = math.Clamp
|
|
|
|
local function AddScroll( self, delta )
|
|
local oldScroll = self.animTargetScroll or self:GetScroll()
|
|
local newScroll = Clamp( oldScroll + delta * 40, 0, self.CanvasSize )
|
|
|
|
if oldScroll == newScroll then
|
|
return false
|
|
end
|
|
|
|
self:Stop()
|
|
self.animTargetScroll = newScroll
|
|
|
|
local anim = self:NewAnimation( 0.4, 0, 0.25, function( _, pnl )
|
|
pnl.animTargetScroll = nil
|
|
end )
|
|
|
|
anim.StartPos = oldScroll
|
|
anim.TargetPos = newScroll
|
|
|
|
anim.Think = function( a, pnl, fraction )
|
|
pnl:SetScroll( Lerp( fraction, a.StartPos, a.TargetPos ) )
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
local function DrawGrip( self, w, h )
|
|
local dt = FrameTime() * 10
|
|
|
|
self.animHover = Lerp( dt, self.animHover, self.Hovered and 1 or 0 )
|
|
self.animPress = Lerp( dt, self.animPress, self.Depressed and 1 or 0 )
|
|
|
|
DrawRect( 0, 0, w, h, colors.buttonBorder )
|
|
DrawRect( 1, 1, w - 2, h - 2, colors.panelBackground )
|
|
DrawRect( 1, 1, w - 2, h - 2, colors.buttonHover, self.animHover )
|
|
DrawRect( 1, 1, w - 2, h - 2, colors.buttonPress, self.animPress )
|
|
end
|
|
|
|
ClassFunctions["DVScrollBar"] = {
|
|
Prepare = function( self )
|
|
self:SetWide( dimensions.scrollBarWidth )
|
|
self:SetHideButtons( true )
|
|
self.AddScroll = AddScroll
|
|
|
|
self.btnGrip.animHover = 0
|
|
self.btnGrip.animPress = 0
|
|
self.btnGrip.Paint = DrawGrip
|
|
end,
|
|
|
|
Paint = function( _, w, h )
|
|
DrawRect( 0, 0, w, h, colors.scrollBackground )
|
|
end
|
|
}
|
|
|
|
local function FrameSlideAnim( anim, panel, fraction )
|
|
if not anim.StartPos then
|
|
anim.StartPos = Vector( panel.x, panel.y + anim.StartOffset, 0 )
|
|
anim.TargetPos = Vector( panel.x, panel.y + anim.EndOffset, 0 )
|
|
end
|
|
|
|
local pos = LerpVector( fraction, anim.StartPos, anim.TargetPos )
|
|
panel:SetPos( pos.x, pos.y )
|
|
panel:SetAlpha( 255 * Lerp( fraction, anim.StartAlpha, anim.EndAlpha ) )
|
|
end
|
|
|
|
local function FramePerformLayout( self, w )
|
|
local padding = dimensions.framePadding
|
|
local buttonSize = dimensions.frameButtonSize
|
|
|
|
self.btnClose:SetSize( buttonSize, buttonSize )
|
|
self.btnClose:SetPos( w - self.btnClose:GetWide() - padding, padding )
|
|
|
|
local iconMargin = 0
|
|
|
|
if IsValid( self.imgIcon ) then
|
|
local iconSize = buttonSize * 0.6
|
|
|
|
self.imgIcon:SetPos( padding, padding + ( buttonSize * 0.5 ) - ( iconSize * 0.5 ) )
|
|
self.imgIcon:SetSize( iconSize, iconSize )
|
|
|
|
iconMargin = iconSize + padding * 0.5
|
|
end
|
|
|
|
self.lblTitle:SetPos( padding + iconMargin, padding )
|
|
self.lblTitle:SetSize( w - ( padding * 2 ) - iconMargin, buttonSize )
|
|
end
|
|
|
|
ClassFunctions["DFrame"] = {
|
|
Prepare = function( self )
|
|
self._OriginalClose = self.Close
|
|
self.PerformLayout = FramePerformLayout
|
|
|
|
StyledTheme.Apply( self.btnClose )
|
|
StyledTheme.Apply( self.lblTitle )
|
|
|
|
local padding = dimensions.framePadding
|
|
local buttonSize = dimensions.frameButtonSize
|
|
|
|
self:DockPadding( padding, buttonSize + padding * 2, padding, padding )
|
|
self.btnClose:SetText( "X" )
|
|
|
|
if IsValid( self.btnMaxim ) then
|
|
self.btnMaxim:Remove()
|
|
end
|
|
|
|
if IsValid( self.btnMinim ) then
|
|
self.btnMinim:Remove()
|
|
end
|
|
|
|
local anim = self:NewAnimation( 0.4, 0, 0.25 )
|
|
anim.StartOffset = -80
|
|
anim.EndOffset = 0
|
|
anim.StartAlpha = 0
|
|
anim.EndAlpha = 1
|
|
anim.Think = FrameSlideAnim
|
|
end,
|
|
|
|
Close = function( self )
|
|
self:SetMouseInputEnabled( false )
|
|
self:SetKeyboardInputEnabled( false )
|
|
|
|
if self.OnStartClosing then
|
|
self.OnStartClosing()
|
|
end
|
|
|
|
local anim = self:NewAnimation( 0.2, 0, 0.5, function()
|
|
self:_OriginalClose()
|
|
end )
|
|
|
|
anim.StartOffset = 0
|
|
anim.EndOffset = -80
|
|
anim.StartAlpha = 1
|
|
anim.EndAlpha = 0
|
|
anim.Think = FrameSlideAnim
|
|
end,
|
|
|
|
Paint = function( self, w, h )
|
|
if self.m_bBackgroundBlur then
|
|
Derma_DrawBackgroundBlur( self, self.m_fCreateTime )
|
|
else
|
|
StyledTheme.BlurPanel( self )
|
|
end
|
|
|
|
DrawRect( 0, 0, w, h, colors.panelBackground, self:GetAlpha() / 255 )
|
|
end
|
|
}
|
|
end
|
|
|
|
--[[
|
|
Utility functions to create "form" panels.
|
|
]]
|
|
do
|
|
local colors = StyledTheme.colors
|
|
local dimensions = StyledTheme.dimensions
|
|
|
|
function StyledTheme.CreateFormHeader( parent, text, mtop, mbottom )
|
|
mtop = mtop or dimensions.formSeparator
|
|
mbottom = mbottom or dimensions.formSeparator
|
|
|
|
local panel = vgui.Create( "DPanel", parent )
|
|
panel:SetTall( dimensions.headerHeight )
|
|
panel:Dock( TOP )
|
|
panel:DockMargin( -dimensions.formPadding, mtop, -dimensions.formPadding, mbottom )
|
|
panel:SetBackgroundColor( colors.scrollBackground )
|
|
|
|
StyledTheme.Apply( panel )
|
|
|
|
local label = vgui.Create( "DLabel", panel )
|
|
label:SetText( text )
|
|
label:SetContentAlignment( 5 )
|
|
label:SizeToContents()
|
|
label:Dock( FILL )
|
|
|
|
StyledTheme.Apply( label )
|
|
|
|
return panel
|
|
end
|
|
|
|
function StyledTheme.CreateFormLabel( parent, text )
|
|
local label = vgui.Create( "DLabel", parent )
|
|
label:Dock( TOP )
|
|
label:DockMargin( 0, 0, 0, dimensions.formSeparator )
|
|
label:SetText( text )
|
|
label:SetTall( dimensions.buttonHeight )
|
|
|
|
StyledTheme.Apply( label )
|
|
|
|
return label
|
|
end
|
|
|
|
function StyledTheme.CreateFormButton( parent, label, callback )
|
|
local button = vgui.Create( "DButton", parent )
|
|
button:SetText( label )
|
|
button:Dock( TOP )
|
|
button:DockMargin( 0, 0, 0, dimensions.formSeparator )
|
|
button.DoClick = callback
|
|
|
|
StyledTheme.Apply( button )
|
|
|
|
return button
|
|
end
|
|
|
|
function StyledTheme.CreateFormToggle( parent, label, isChecked, callback )
|
|
local button = vgui.Create( "DButton", parent )
|
|
button:SetIcon( isChecked and "icon16/accept.png" or "icon16/cancel.png" )
|
|
button:SetText( label )
|
|
button:Dock( TOP )
|
|
button:DockMargin( 0, 0, 0, dimensions.formSeparator )
|
|
button.isToggle = true
|
|
button.isChecked = isChecked
|
|
|
|
StyledTheme.Apply( button )
|
|
|
|
button.SetChecked = function( s, value )
|
|
value = value == true
|
|
s.isChecked = value
|
|
button:SetIcon( value and "icon16/accept.png" or "icon16/cancel.png" )
|
|
callback( value )
|
|
end
|
|
|
|
button.DoClick = function( s )
|
|
s:SetChecked( not s.isChecked )
|
|
end
|
|
|
|
return button
|
|
end
|
|
|
|
function StyledTheme.CreateFormSlider( parent, label, default, min, max, decimals, callback )
|
|
local slider = vgui.Create( "DNumSlider", parent )
|
|
slider:SetText( label )
|
|
slider:SetMin( min )
|
|
slider:SetMax( max )
|
|
slider:SetValue( default )
|
|
slider:SetDecimals( decimals )
|
|
slider:Dock( TOP )
|
|
slider:DockMargin( 0, 0, 0, dimensions.formSeparator )
|
|
|
|
slider.PerformLayout = function( s )
|
|
s.Label:SetWide( dimensions.formLabelWidth )
|
|
end
|
|
|
|
StyledTheme.Apply( slider )
|
|
|
|
slider.OnValueChanged = function( _, value )
|
|
callback( decimals == 0 and math.floor( value ) or math.Round( value, decimals ) )
|
|
end
|
|
|
|
return slider
|
|
end
|
|
|
|
function StyledTheme.CreateFormCombo( parent, text, options, defaultIndex, callback )
|
|
local panel = vgui.Create( "DPanel", parent )
|
|
panel:SetTall( dimensions.buttonHeight )
|
|
panel:SetPaintBackground( false )
|
|
panel:Dock( TOP )
|
|
panel:DockMargin( 0, 0, 0, dimensions.formSeparator )
|
|
|
|
local label = vgui.Create( "DLabel", panel )
|
|
label:Dock( LEFT )
|
|
label:DockMargin( 0, 0, 0, 0 )
|
|
label:SetText( text )
|
|
label:SetWide( dimensions.formLabelWidth )
|
|
|
|
StyledTheme.Apply( label )
|
|
|
|
local combo = vgui.Create( "DComboBox", panel )
|
|
combo:Dock( FILL )
|
|
combo:SetSortItems( false )
|
|
|
|
for _, v in ipairs( options ) do
|
|
combo:AddChoice( v )
|
|
end
|
|
|
|
if defaultIndex then
|
|
combo:ChooseOptionID( defaultIndex )
|
|
end
|
|
|
|
StyledTheme.Apply( combo )
|
|
|
|
combo.OnSelect = function( _, index )
|
|
callback( index )
|
|
end
|
|
end
|
|
|
|
function StyledTheme.CreateFormBinder( parent, text, defaultKey )
|
|
local panel = vgui.Create( "DPanel", parent )
|
|
panel:SetTall( dimensions.buttonHeight )
|
|
panel:SetPaintBackground( false )
|
|
panel:Dock( TOP )
|
|
panel:DockMargin( 0, 0, 0, dimensions.formSeparator )
|
|
|
|
local label = vgui.Create( "DLabel", panel )
|
|
label:Dock( LEFT )
|
|
label:DockMargin( 0, 0, 0, 0 )
|
|
label:SetText( text )
|
|
label:SetWide( dimensions.formLabelWidth )
|
|
|
|
StyledTheme.Apply( label )
|
|
|
|
local binder = vgui.Create( "DBinder", panel )
|
|
binder:SetValue( defaultKey or KEY_NONE )
|
|
binder:Dock( FILL )
|
|
|
|
StyledTheme.Apply( binder )
|
|
|
|
return binder
|
|
end
|
|
end
|