Added base files

Src/KFClassicHUD/Classes/ClassicHUD.uc

@@ -0,0 +1,102 @@
+class ClassicHUD extends KFMutator;
+
+var KFPawn LastHitZed;
+var int LastHitHP;
+var KFPlayerController LastDamageDealer;
+var vector LastDamagePosition;
+var class<KFDamageType> LastDamageDMGType;
+
+struct RepInfoS
+{
+    var DamageReplicationInfo DRI;
+    var KFPlayerController KFPC;
+};
+var array<RepInfoS> DamageReplicationInfos;
+
+function PostBeginPlay()
+{
+    Super.PostBeginPlay();
+    WorldInfo.Game.HUDType = class'ClassicKFHUD';
+}
+
+function NetDamage(int OriginalDamage, out int Damage, Pawn Injured, Controller InstigatedBy, vector HitLocation, out vector Momentum, class<DamageType> DamageType, Actor DamageCauser)
+{
+    Super.NetDamage(OriginalDamage, Damage, Injured, InstigatedBy, HitLocation, Momentum, DamageType, DamageCauser);
+
+    if( LastDamageDealer!=None )
+    {
+        ClearTimer('CheckDamageDone');
+        CheckDamageDone();
+    }
+    
+    if( Damage>0 && InstigatedBy != None )
+    {
+        if( KFPawn_Monster(Injured) != None && KFPlayerController(InstigatedBy) != None )
+        {
+            LastDamageDealer = KFPlayerController(InstigatedBy);
+
+            LastHitZed = KFPawn(Injured);
+            LastHitHP = LastHitZed.Health;
+            LastDamagePosition = HitLocation;
+            LastDamageDMGType = class<KFDamageType>(DamageType);
+            SetTimer(0.1,false,'CheckDamageDone');
+        }
+    }
+}
+
+final function CheckDamageDone()
+{
+    local int Damage, i;
+
+    if( LastDamageDealer!=None && LastHitZed!=None && LastHitHP!=LastHitZed.Health )
+    {
+        Damage = LastHitHP-Max(LastHitZed.Health,0);
+        if( Damage>0 )
+        {
+            i = DamageReplicationInfos.Find('KFPC', LastDamageDealer);
+            if( i != INDEX_NONE )
+                DamageReplicationInfos[i].DRI.ClientNumberMsg(Damage,LastDamagePosition,LastDamageDMGType);
+        }
+    }
+    LastDamageDealer = None;
+}
+
+function NotifyLogin(Controller C)
+{
+	if( KFPlayerController(C) != None )
+		CreateReplicationInfo(KFPlayerController(C));
+		
+    Super.NotifyLogin(C);
+}
+
+function NotifyLogout(Controller C)
+{
+	if( KFPlayerController(C) != None )
+		DestroyReplicationInfo(KFPlayerController(C));
+	
+    Super.NotifyLogout(C);
+}
+
+function CreateReplicationInfo(KFPlayerController C)
+{
+    local RepInfoS Info;
+    
+    Info.DRI = Spawn(class'DamageReplicationInfo', C);
+    Info.KFPC = C;
+    
+    Info.DRI.KFPC = C;
+    
+    DamageReplicationInfos.AddItem(Info);
+}
+
+function DestroyReplicationInfo(KFPlayerController C)
+{
+    local int i;
+    
+    i = DamageReplicationInfos.Find('KFPC', C);
+    if( i != INDEX_NONE )
+    {
+        DamageReplicationInfos[i].DRI.Destroy();
+        DamageReplicationInfos.RemoveItem(DamageReplicationInfos[i]);
+    }
+}

Src/KFClassicHUD/Classes/ClassicStyle.uc

@@ -0,0 +1,408 @@
+Class ClassicStyle extends KF2Style;
+
+function RenderFramedWindow( KFGUI_FloatingWindow P )
+{
+    local int XS,YS,TitleHeight;
+    local float XL, YL, FontScale;
+    
+    XS = Canvas.ClipX-Canvas.OrgX;
+    YS = Canvas.ClipY-Canvas.OrgY;
+    TitleHeight = DefaultHeight;
+
+    if( P.bWindowFocused )
+        Canvas.SetDrawColor(105,105,105,255);
+    else Canvas.SetDrawColor(85,85,85,P.FrameOpacity);
+    
+    // Frame Header
+    Canvas.SetPos(0, 0);
+    Canvas.DrawTileStretched(TabTextures[`TAB_TOP],XS,TitleHeight,0,0,128,16);
+    
+    // Frame itself.
+    Canvas.SetPos(0, TitleHeight);
+    Canvas.DrawTileStretched(BorderTextures[`BOX_SMALL_SLIGHTTRANSPARENT],XS,YS-TitleHeight,0,0,128,128);
+    
+    // Title.
+    if( P.WindowTitle!="" )
+    {
+        Canvas.Font = PickFont(FontScale);
+        Canvas.TextSize(P.WindowTitle,XL,YL,FontScale,FontScale);
+        Canvas.SetDrawColor(250,250,250,255);
+        Canvas.SetPos((XS*0.5)-(XL*0.5),0);
+        Canvas.DrawText(P.WindowTitle,,FontScale,FontScale);
+    }
+}
+
+function RenderWindow( KFGUI_Page P )
+{
+    local int XS,YS;
+    
+    XS = Canvas.ClipX-Canvas.OrgX;
+    YS = Canvas.ClipY-Canvas.OrgY;
+
+    // Frame itself.
+    if( P.bWindowFocused )
+        Canvas.SetDrawColor(105,105,105,255);
+    else Canvas.SetDrawColor(85,85,85,P.FrameOpacity);
+    
+    Canvas.SetPos(0, 0);
+    Canvas.DrawTileStretched(BorderTextures[`BOX_SMALL_SLIGHTTRANSPARENT],XS,YS,0,0,128,128);
+}
+
+function RenderToolTip( KFGUI_Tooltip TT )
+{
+    local int i;
+    local float X,Y,XS,YS,TX,TY,TS,DefFontHeight;
+
+    Canvas.Font = PickFont(TS);
+
+    // First compute textbox size.
+    TY = DefaultHeight*TT.Lines.Length;
+    for( i=0; i<TT.Lines.Length; ++i )
+    {
+        if( TT.Lines[i]!="" )
+            Canvas.TextSize(TT.Lines[i],XS,YS);
+        TX = FMax(XS,TX);
+    }
+    TX*=TS;
+    
+    // Give some borders.
+    TX += TOOLTIP_BORDER*2;
+    TY += TOOLTIP_BORDER*2;
+
+    X = TT.CompPos[0];
+    Y = TT.CompPos[1]+24.f;
+
+    // Then check if too close to window edge, then move it to another pivot.
+    if( (X+TX)>TT.Owner.ScreenSize.X )
+        X = TT.Owner.ScreenSize.X-TX;
+    if( (Y+TY)>TT.Owner.ScreenSize.Y )
+        Y = TT.CompPos[1]-TY;
+    
+    if( TT.CurrentAlpha<255 )
+        TT.CurrentAlpha = Min(TT.CurrentAlpha+25,255);
+
+    // Reset clipping.
+    Canvas.SetOrigin(0,0);
+    Canvas.SetClip(TT.Owner.ScreenSize.X,TT.Owner.ScreenSize.Y);
+
+    // Draw frame.
+    Canvas.SetDrawColor(115,115,115,TT.CurrentAlpha);
+    Canvas.SetPos(X-2,Y-2);
+    DrawBoxHollow(X-2,Y-2,TX+4,TY+4,2);
+    Canvas.SetDrawColor(5,5,5,TT.CurrentAlpha);
+    Canvas.SetPos(X,Y);
+    DrawWhiteBox(TX,TY);
+    
+    DefFontHeight = DefaultHeight;
+
+    // Draw text.
+    Canvas.SetDrawColor(255,255,255,TT.CurrentAlpha);
+    X+=TOOLTIP_BORDER;
+    Y+=TOOLTIP_BORDER;
+    for( i=0; i<TT.Lines.Length; ++i )
+    {
+        Canvas.SetPos(X,Y);
+        Canvas.DrawText(TT.Lines[i],,TS,TS,TT.TextFontInfo);
+        Y+=DefFontHeight;
+    }
+}
+
+function RenderScrollBar( KFGUI_ScrollBarBase S )
+{
+    local float A;
+    local byte i;
+
+    if( S.bDisabled )
+        Canvas.SetDrawColor(5, 5, 5, 0);
+    else if( S.bFocused || S.bGrabbedScroller )
+        Canvas.SetDrawColor(15, 15, 15, 160);
+    else Canvas.SetDrawColor(15, 15, 15, 160);
+
+    Canvas.SetPos(0.f, 0.f);
+    Canvas.DrawTileStretched(BorderTextures[`BOX_INNERBORDER],S.CompPos[2],S.CompPos[3],0,0,128,128);
+    
+    if( S.bDisabled )
+        return;
+
+    if( S.bVertical )
+        i = 3;
+    else i = 2;
+    
+    S.SliderScale = FMax(S.PageStep * (S.CompPos[i] - 32.f) / (S.MaxRange + S.PageStep),S.CalcButtonScale);
+    
+    if( S.bGrabbedScroller )
+    {
+        // Track mouse.
+        if( S.bVertical )
+            A = S.Owner.MousePosition.Y - S.CompPos[1] - S.GrabbedOffset;
+        else A = S.Owner.MousePosition.X - S.CompPos[0] - S.GrabbedOffset;
+        
+        A /= ((S.CompPos[i]-S.SliderScale) / float(S.MaxRange));
+        S.SetValue(A);
+    }
+
+    A = float(S.CurrentScroll) / float(S.MaxRange);
+    S.ButtonOffset = A*(S.CompPos[i]-S.SliderScale);
+
+    if( S.bGrabbedScroller )
+        Canvas.SetDrawColor(125,125,125,200);
+    else if( S.bFocused )
+        Canvas.SetDrawColor(200,200,200,200);
+    else Canvas.SetDrawColor(255,255,255,200);
+
+    if( S.bVertical )
+    {
+        Canvas.SetPos(0.f, S.ButtonOffset);
+        Canvas.DrawTileStretched(ScrollTexture,S.CompPos[2],S.SliderScale,0,0,32,32);
+    }
+    else 
+    {
+        Canvas.SetPos(S.ButtonOffset, 0.f);
+        Canvas.DrawTileStretched(ScrollTexture,S.SliderScale,S.CompPos[3],0,0,32,32);
+    }
+}
+
+function RenderCheckbox( KFGUI_CheckBox C )
+{
+    local Texture CheckMark;
+    
+    DrawTileStretched(ItemBoxTextures[`ITEMBOX_DISABLED],0.f,0.f,C.CompPos[2],C.CompPos[3]);
+
+    if( C.bChecked )
+    {
+        if( C.bDisabled )
+            CheckMark = CheckBoxTextures[`CHECKMARK_DISABLED];
+        else if( C.bFocused )
+            CheckMark = CheckBoxTextures[`CHECKMARK_HIGHLIGHTED];
+        else CheckMark = CheckBoxTextures[`CHECKMARK_NORMAL];
+            
+        Canvas.SetDrawColor(255,255,255,255);
+        Canvas.SetPos(0.f,0.f);
+        Canvas.DrawTile(CheckMark,C.CompPos[2],C.CompPos[3],0,0,CheckMark.GetSurfaceWidth(),CheckMark.GetSurfaceHeight());
+    }
+}
+
+function RenderComboBox( KFGUI_ComboBox C )
+{
+    if( C.bDisabled )
+        Canvas.SetDrawColor(64,64,64,255);
+    else if( C.bPressedDown )
+        Canvas.SetDrawColor(220,220,220,255);
+    else if( C.bFocused )
+        Canvas.SetDrawColor(190,190,190,255);
+    
+    Canvas.SetPos(0.f,0.f);
+    Canvas.DrawTileStretched(BorderTextures[`BOX_INNERBORDER],C.CompPos[2],C.CompPos[3],0,0,128,128);
+    
+    DrawArrowBox(3, C.CompPos[2]-32, 0.5f, 32, 32);
+
+    if( C.SelectedIndex<C.Values.Length && C.Values[C.SelectedIndex]!="" )
+    {
+        Canvas.SetPos(C.BorderSize,(C.CompPos[3]-C.TextHeight)*0.5);
+        if( C.bDisabled )
+            Canvas.DrawColor = C.TextColor*0.5f;
+        else Canvas.DrawColor = C.TextColor;
+        Canvas.PushMaskRegion(Canvas.OrgX,Canvas.OrgY,Canvas.ClipX-C.BorderSize,Canvas.ClipY);
+        Canvas.DrawText(C.Values[C.SelectedIndex],,C.TextScale,C.TextScale,C.TextFontInfo);
+        Canvas.PopMaskRegion();
+    }
+}
+
+function RenderComboList( KFGUI_ComboSelector C )
+{
+    local float X,Y,YL,YP,Edge;
+    local int i;
+    local bool bCheckMouse;
+    
+    // Draw background.
+    Edge = C.Combo.BorderSize;
+    Canvas.SetPos(0.f, 0.f);
+    Canvas.DrawTileStretched(BorderTextures[`BOX_SMALL_SLIGHTTRANSPARENT],C.CompPos[2],C.CompPos[3],0,0,128,128);
+
+    // While rendering, figure out mouse focus row.
+    X = C.Owner.MousePosition.X - Canvas.OrgX;
+    Y = C.Owner.MousePosition.Y - Canvas.OrgY;
+    
+    bCheckMouse = (X>0.f && X<C.CompPos[2] && Y>0.f && Y<C.CompPos[3]);
+    
+    Canvas.Font = C.Combo.TextFont;
+    YL = C.Combo.TextHeight;
+
+    YP = Edge;
+    C.CurrentRow = -1;
+
+    Canvas.PushMaskRegion(Canvas.OrgX,Canvas.OrgY,Canvas.ClipX,Canvas.ClipY);
+    for( i=0; i<C.Combo.Values.Length; ++i )
+    {
+        if( bCheckMouse && Y>=YP && Y<=(YP+YL) )
+        {
+            bCheckMouse = false;
+            C.CurrentRow = i;
+            Canvas.SetPos(4.f,YP);
+            Canvas.SetDrawColor(128,48,48,255);
+            DrawWhiteBox(C.CompPos[2]-(Edge*2.f),YL);
+        }
+        Canvas.SetPos(Edge,YP);
+        
+        if( i==C.Combo.SelectedIndex )
+            Canvas.DrawColor = C.Combo.SelectedTextColor;
+        else Canvas.DrawColor = C.Combo.TextColor;
+
+        Canvas.DrawText(C.Combo.Values[i],,C.Combo.TextScale,C.Combo.TextScale,C.Combo.TextFontInfo);
+        
+        YP+=YL;
+    }
+    Canvas.PopMaskRegion();
+    if( C.OldRow!=C.CurrentRow )
+    {
+        C.OldRow = C.CurrentRow;
+        C.PlayMenuSound(MN_DropdownChange);
+    }
+}
+
+function RenderRightClickMenu( KFGUI_RightClickMenu C )
+{
+    local float X,Y,XL,YL,YP,Edge,TextScale;
+    local int i;
+    local bool bCheckMouse;
+    local string S;
+    
+    // Draw background.
+    Edge = C.EdgeSize;
+    DrawOutlinedBox(0.f,0.f,C.CompPos[2],C.CompPos[3],Edge,C.BoxColor,C.OutlineColor);
+
+    // While rendering, figure out mouse focus row.
+    X = C.Owner.MousePosition.X - Canvas.OrgX;
+    Y = C.Owner.MousePosition.Y - Canvas.OrgY;
+    
+    bCheckMouse = (X>0.f && X<C.CompPos[2] && Y>0.f && Y<C.CompPos[3]);
+    
+    PickFont(TextScale);
+
+    YP = Edge*2;
+    C.CurrentRow = -1;
+    
+    Canvas.PushMaskRegion(Canvas.OrgX,Canvas.OrgY,Canvas.ClipX,Canvas.ClipY);
+    for( i=0; i<C.ItemRows.Length; ++i )
+    {
+        if( C.ItemRows[i].bSplitter )
+            S = "-------";
+        else S = C.ItemRows[i].Text;
+        
+        Canvas.TextSize(S,XL,YL,TextScale,TextScale);
+        
+        if( bCheckMouse && Y>=YP && Y<=(YP+YL) )
+        {
+            bCheckMouse = false;
+            C.CurrentRow = i;
+            Canvas.SetPos(Edge,YP);
+            Canvas.SetDrawColor(128,0,0,255);
+            DrawWhiteBox(C.CompPos[2]-(Edge*2.f),YL);
+        }
+
+        Canvas.SetPos(Edge*6,YP);
+        if( C.ItemRows[i].bSplitter )
+            Canvas.SetDrawColor(255,255,255,255);
+        else
+        {
+            if( C.ItemRows[i].bDisabled )
+                Canvas.SetDrawColor(148,148,148,255);
+            else Canvas.SetDrawColor(248,248,248,255);
+        }
+        Canvas.DrawText(S,,TextScale,TextScale);
+        
+        YP+=YL;
+    }
+    Canvas.PopMaskRegion();
+    if( C.OldRow!=C.CurrentRow )
+    {
+        C.OldRow = C.CurrentRow;
+        C.PlayMenuSound(MN_FocusHover);
+    }
+}
+
+function RenderButton( KFGUI_Button B )
+{
+    local float XL,YL,TS,AX,AY,GamepadTexSize;
+    local Texture2D Mat, ButtonTex;
+    local bool bDrawOverride;
+
+    bDrawOverride = B.DrawOverride(Canvas, B);
+    if( !bDrawOverride )
+    {
+        if( B.bDisabled )
+            Mat = ButtonTextures[`BUTTON_DISABLED];
+        else if( B.bPressedDown )
+            Mat = ButtonTextures[`BUTTON_PRESSED];
+        else if( B.bFocused || B.bIsHighlighted )
+            Mat = ButtonTextures[`BUTTON_HIGHLIGHTED];
+        else Mat = ButtonTextures[`BUTTON_NORMAL];
+        
+        Canvas.SetPos(0.f,0.f);
+        Canvas.DrawTileStretched(Mat,B.CompPos[2],B.CompPos[3],0,0,32,32);
+
+        if( B.OverlayTexture.Texture!=None )
+        {
+            Canvas.SetPos(0.f,0.f);
+            Canvas.DrawTile(B.OverlayTexture.Texture,B.CompPos[2],B.CompPos[3],B.OverlayTexture.U,B.OverlayTexture.V,B.OverlayTexture.UL,B.OverlayTexture.VL);
+        }
+    }
+    
+    if( B.ButtonText!="" )
+    {
+        Canvas.Font = MainFont;
+        
+        GamepadTexSize = B.CompPos[3] / 1.25;
+        
+        TS = GetFontScaler();
+        TS *= B.FontScale;
+        
+        while( true )
+        {
+            Canvas.TextSize(B.ButtonText,XL,YL,TS,TS);
+            if( XL<(B.CompPos[2]*0.9) && YL<(B.CompPos[3]*0.9) )
+                break;
+                
+            TS -= 0.001;
+        }
+        
+        Canvas.SetPos((B.CompPos[2]-XL)*0.5,(B.CompPos[3]-YL)*0.5);
+        if( B.bDisabled )
+            Canvas.DrawColor = B.TextColor*0.5f;
+        else Canvas.DrawColor = B.TextColor;
+        Canvas.DrawText(B.ButtonText,,TS,TS,B.TextFontInfo);
+        
+        if( B.GetUsingGamepad() )
+        {
+            ButtonTex = Texture2D(DynamicLoadObject("UI_Controller."$B.GamepadButtonName$"_Asset", class'Texture2D'));
+            if( ButtonTex != None )
+            {
+                B.GetRealtivePos(AX, AY);
+                while( (Canvas.CurX-(GamepadTexSize*1.25))<AX )
+                {
+                    GamepadTexSize *= 0.95;
+                }
+                
+                switch(ButtonTex.Name)
+                {
+                    case 'XboxTypeS_A_Asset':
+                    case 'XboxTypeS_B_Asset':
+                    case 'XboxTypeS_X_Asset':
+                    case 'XboxTypeS_Y_Asset':
+                        Canvas.SetDrawColor(255, 255, 255, 145);
+                        break;
+                    default:
+                        Canvas.SetDrawColor(0, 0, 0, 145);
+                        break;
+                }
+                
+                Canvas.SetPos(Canvas.CurX-(GamepadTexSize*1.25),(B.CompPos[3]-GamepadTexSize)*0.5);
+                Canvas.DrawRect(GamepadTexSize,GamepadTexSize,ButtonTex);
+            }
+        }
+    }
+}
+
+defaultproperties
+{
+}

Src/KFClassicHUD/Classes/DamageReplicationInfo.uc

@@ -0,0 +1,13 @@
+class DamageReplicationInfo extends ReplicationInfo;
+
+var KFPlayerController KFPC;
+
+unreliable client function ClientNumberMsg( int Count, vector Pos, class<KFDamageType> Type )
+{
+    ClassicKFHUD(KFPC.MyHUD).AddNumberMsg(Count,Pos,Type);
+}
+
+defaultproperties
+{
+	bOnlyRelevantToOwner=True
+}

Src/KFClassicHUD/Classes/GUIStyleBase.uc

@@ -0,0 +1,865 @@
+Class GUIStyleBase extends Object
+    abstract;
+
+var Texture2D ItemTex;
+var array<Texture2D> BorderTextures, ArrowTextures, ButtonTextures, TabTextures, ItemBoxTextures, PerkBox, CheckBoxTextures, ProgressBarTextures, SliderTextures;
+var Texture2D ScrollTexture,FavoriteIcon,BankNoteIcon; 
+
+var SoundCue MenuDown, MenuDrag, MenuEdit, MenuFade, MenuClick, MenuHover, MenuUp;
+
+var() byte MaxFontScale;
+var float DefaultHeight; // Default font text size.
+var transient Canvas Canvas;
+var transient KF2GUIController Owner;
+var transient ClassicKFHUD HUDOwner;
+
+var Font MainFont, NumberFont, InfiniteFont;
+var Color BlurColor, BlurColor2;
+
+struct FColorInfo
+{
+    var name Code;
+    var Color Color;
+};
+var array<FColorInfo> ColorCodes;
+
+struct FTexturePreCache
+{
+    var string Path;
+    var Texture2D Tex;
+};
+var array<FTexturePreCache> PrecachedTextures;
+
+function InitStyle()
+{
+    local FColorInfo ColorInfo;
+    
+    ItemTex=Texture2D(DynamicLoadObject("UI_LevelChevrons_TEX.UI_LevelChevron_Icon_02",class'Texture2D'));
+    if( ItemTex==None )
+        ItemTex=Texture2D'EngineMaterials.DefaultWhiteGrid';
+        
+    NumberFont = Font(DynamicLoadObject("UI_Canvas_Fonts.Font_General", class'Font'));
+    
+    BlurColor = MakeColor(60, 60, 60, 220);
+    BlurColor2 = MakeColor(40, 40, 40, 140);
+    
+    ColorInfo.Code='Q';
+    ColorInfo.Color = MakeColor(0,140,0,255); // Dark Green
+    ColorCodes.AddItem(ColorInfo);
+    
+    ColorInfo.Code='E';
+    ColorInfo.Color = MakeColor(210,180,140,255); // Tan
+    ColorCodes.AddItem(ColorInfo);
+    
+    ColorInfo.Code='R';
+    ColorInfo.Color = MakeColor(128,0,0,255); // Dark Red
+    ColorCodes.AddItem(ColorInfo);
+    
+    ColorInfo.Code='T';
+    ColorInfo.Color = MakeColor(153,102,204,255); // Purple
+    ColorCodes.AddItem(ColorInfo);
+    
+    ColorInfo.Code='U';
+    ColorInfo.Color = MakeColor(128,128,128,255); // Dark Gray
+    ColorCodes.AddItem(ColorInfo);
+    
+    ColorInfo.Code='I';
+    ColorInfo.Color = MakeColor(255,170,0,255); // Orange
+    ColorCodes.AddItem(ColorInfo);
+    
+    ColorInfo.Code='O';
+    ColorInfo.Color = MakeColor(255,204,153,255); // Cream
+    ColorCodes.AddItem(ColorInfo);
+    
+    ColorInfo.Code='P';
+    ColorInfo.Color = MakeColor(209,216,168,255); // Olive
+    ColorCodes.AddItem(ColorInfo);
+    
+    ColorInfo.Code='A';
+    ColorInfo.Color = MakeColor(204,51,51,255); // Brick
+    ColorCodes.AddItem(ColorInfo);
+    
+    ColorInfo.Code='S';
+    ColorInfo.Color = MakeColor(153,102,51,255); // Brown
+    ColorCodes.AddItem(ColorInfo);
+    
+    ColorInfo.Code='D';
+    ColorInfo.Color = MakeColor(0,204,0,255); // Green
+    ColorCodes.AddItem(ColorInfo);
+    
+    ColorInfo.Code='F';
+    ColorInfo.Color = MakeColor(238,238,51,255); // Yellow
+    ColorCodes.AddItem(ColorInfo);
+    
+    ColorInfo.Code='G';
+    ColorInfo.Color = MakeColor(200,0,0,255); // Red
+    ColorCodes.AddItem(ColorInfo);
+    
+    ColorInfo.Code='H';
+    ColorInfo.Color = MakeColor(153,153,255,255); // Blue
+    ColorCodes.AddItem(ColorInfo);
+    
+    ColorInfo.Code='J';
+    ColorInfo.Color = MakeColor(192,192,192,255); // Silver
+    ColorCodes.AddItem(ColorInfo);
+    
+    ColorInfo.Code='K';
+    ColorInfo.Color = MakeColor(255,204,0,255); // Gold
+    ColorCodes.AddItem(ColorInfo);
+    
+    ColorInfo.Code='C';
+    ColorInfo.Color = MakeColor(255,255,255,255); // White
+    ColorCodes.AddItem(ColorInfo);
+    
+    ColorInfo.Code='V';
+    ColorInfo.Color = MakeColor(0,191,255,255); // Sky Blue
+    ColorCodes.AddItem(ColorInfo);
+    
+    ColorInfo.Code='B';
+    ColorInfo.Color = MakeColor(204,204,204,255); // Gray
+    ColorCodes.AddItem(ColorInfo);
+    
+    ColorInfo.Code='N';
+    ColorInfo.Color = MakeColor(0,128,255,255); // Dark Sky Blue
+    ColorCodes.AddItem(ColorInfo);
+    
+    ColorInfo.Code='M';
+    ColorInfo.Color = MakeColor(18,18,18,255); // Black
+    ColorCodes.AddItem(ColorInfo);
+}
+
+function RenderFramedWindow( KFGUI_FloatingWindow P );
+function RenderWindow( KFGUI_Page P );
+function RenderToolTip( KFGUI_Tooltip TT );
+function RenderButton( KFGUI_Button B );
+function RenderScrollBar( KFGUI_ScrollBarBase S );
+function RenderColumnHeader( KFGUI_ColumnTop C, float XPos, float Width, int Index, bool bFocus, bool bSort );
+function RenderRightClickMenu( KFGUI_RightClickMenu C );
+function RenderCheckbox( KFGUI_CheckBox C );
+function RenderComboBox( KFGUI_ComboBox C );
+function RenderComboList( KFGUI_ComboSelector C );
+
+function Font PickFont( out float Scaler, optional bool bNumbersOnly, optional bool bInfinite )
+{
+    Scaler = GetFontScaler();
+    
+    if( bNumbersOnly )
+        return NumberFont;
+    else if( bInfinite )
+        return InfiniteFont;
+    
+    return MainFont;
+}
+
+function PickDefaultFontSize( float YRes )
+{
+    local int XL,YL;
+    local string S;
+
+    S="ABC";
+    PickFont(YRes).GetStringHeightAndWidth(S,YL,XL);
+    
+    DefaultHeight=float(YL)*YRes;
+}
+final function float ScreenScale( float Size, optional float MaxRes=1920.f )
+{
+    return Size * ( HUDOwner.SizeX / MaxRes );
+}
+final function float GetFontScaler(optional float Scaler=0.375f, optional float Min=0.175f, optional float Max=0.375f)
+{
+    return FClamp((HUDOwner.SizeX / 1920.f) * Scaler, Min, Max);
+}
+final function DrawText( coerce string S )
+{
+    local float Scale;
+    
+    Canvas.Font=PickFont(Scale);
+    Canvas.DrawText(S,,Scale,Scale);
+}
+final function DrawCenteredText( coerce string S, float X, float Y, optional float Scale=1.f, optional bool bVertical, optional bool bUseOutline )
+{
+    local float XL,YL;
+
+    Canvas.TextSize(S,XL,YL);
+    if( bVertical )
+        Canvas.SetPos(X,Y-(YL*Scale*0.5));
+    else Canvas.SetPos(X-(XL*Scale*0.5),Y);
+    
+    if( bUseOutline )
+        DrawTextShadow(S, Canvas.CurX, Canvas.CurY, 1, Scale);
+    else Canvas.DrawText(S,,Scale,Scale);
+}
+final function string StripColorTags( coerce string S )
+{
+    local int Pos;
+    
+    Pos = InStr(S, "\\c");
+    while( Pos != INDEX_NONE )
+    {
+        S = Left(S,Pos) $ Mid(S,Pos+3);
+        Pos = InStr(S, "\\c");
+    }
+    
+    return S;
+}
+final function DrawColoredText( coerce string S, float X, float Y, optional float Scale=1.f, optional bool bUseOutline )
+{
+    local float XL,YL;
+    local int i, Index;
+    local array<string> SArray;
+    local string T, PrevT;
+    local Color TextColor;
+    
+    if( InStr(S, "\\c") == INDEX_NONE )
+    {
+        if( bUseOutline )
+            DrawTextShadow(S, X, Y, 1, Scale);
+        else 
+        {
+            Canvas.SetPos(X,Y);
+            Canvas.DrawText(S,,Scale,Scale);
+        }
+    }
+    else
+    {
+        SArray = SplitString(S, "\\c");
+
+        PrevT = Left(S,InStr(S, "\\c"));
+        if( Len(PrevT) > 0 )
+        {
+            Canvas.TextSize(PrevT,XL,YL,Scale,Scale);
+
+            if( bUseOutline )
+                DrawTextShadow(PrevT, X, Y, 1, Scale);
+            else 
+            {
+                Canvas.SetPos(X,Y);
+                Canvas.DrawText(PrevT,,Scale,Scale);
+            }
+        }
+        
+        for( i=0; i<SArray.Length; i++ )
+        {
+            T = SArray[i];
+            if( i>0 || Left(S, 2)~="\\c" )
+            {
+                Index = ColorCodes.Find('Code', name(Left(T, 1)));
+                if( Index != INDEX_NONE )
+                    TextColor = ColorCodes[Index].Color;
+                else TextColor = class'HUD'.default.WhiteColor;
+                
+                TextColor.A = Canvas.DrawColor.A;
+                
+                T = Mid(T, 1);
+            }
+            
+            Canvas.DrawColor = TextColor;
+            Canvas.TextSize(T,XL,YL,Scale,Scale);
+            
+            if( bUseOutline )
+                DrawTextShadow(T, X, Y, 1, Scale);
+            else 
+            {
+                Canvas.SetPos(X,Y);
+                Canvas.DrawText(T,,Scale,Scale);
+            }
+
+            X += XL;
+        }
+    }
+}
+final function DrawTextBlurry( coerce string S, float X, float Y, optional float Scale=1.f )
+{
+    local Color OldDrawColor;
+    
+    OldDrawColor = Canvas.DrawColor;
+    BlurColor.A = OldDrawColor.A * 0.85;
+    BlurColor2.A = OldDrawColor.A * 0.55;
+    
+    Canvas.DrawColor = BlurColor;
+    Canvas.SetPos(X + Owner.FontBlurX, Y + Owner.FontBlurY);
+    Canvas.DrawText(S,,Scale,Scale);
+    
+    Canvas.DrawColor = BlurColor2;
+    Canvas.SetPos(X + Owner.FontBlurX2, Y + Owner.FontBlurY2);
+    Canvas.DrawText(S,,Scale,Scale);
+    
+    Canvas.DrawColor = OldDrawColor;
+    Canvas.SetPos(X, Y);
+    Canvas.DrawText(S,,Scale,Scale);
+}
+final function DrawTextOutline( coerce string S, float X, float Y, int Size, Color OutlineColor, optional float Scale=1.f, optional FontRenderInfo FRI )
+{
+    local Color OldDrawColor;
+    local int XS, YS, Steps;
+    
+    OldDrawColor = Canvas.DrawColor;
+    OutlineColor.A = OldDrawColor.A;
+    
+    Size += 1;
+    Steps = (Size * 2) / 3;
+    if( Steps < 1 ) 
+    {
+        Steps = 1;
+    }
+    
+    Canvas.DrawColor = OutlineColor;
+    for (XS = -Size; XS <= Size; XS+=Steps)
+    {
+        for (YS = -Size; YS <= Size; YS+=Steps)
+        {
+            Canvas.SetPos(X + XS, Y + YS);
+            Canvas.DrawText(S,, Scale, Scale, FRI);
+        }
+    }
+    
+    Canvas.DrawColor = OldDrawColor;
+    Canvas.SetPos(X, Y);
+    Canvas.DrawText(S,, Scale, Scale, FRI);
+}
+final function DrawTextShadow( coerce string S, float X, float Y, float ShadowSize, optional float Scale=1.f )
+{
+    local Color OldDrawColor;
+    
+    OldDrawColor = Canvas.DrawColor;
+    
+    Canvas.SetPos(X + ShadowSize, Y + ShadowSize);
+    Canvas.SetDrawColor(0, 0, 0, OldDrawColor.A);
+    Canvas.DrawText(S,, Scale, Scale);
+    
+    Canvas.SetPos(X, Y);
+    Canvas.DrawColor = OldDrawColor;
+    Canvas.DrawText(S,, Scale, Scale);
+}
+final function DrawTexturedString( coerce string S, float X, float Y, optional float TextScaler=1.f, optional FontRenderInfo FRI, optional bool bUseOutline, optional bool bOnlyTexture )
+{
+    local Texture2D Mat;
+    local string D;
+    local float XL, YL;
+    local int i,j;
+    local Color OrgC;
+    
+    OrgC = Canvas.DrawColor;
+    
+    Mat = FindNextTexture(S);
+    while( Mat != None )
+    {
+        i = InStr(S,"<TEXTURE");
+        j = InStr(S,">");
+        
+        D = Left(S,i);
+        S = Mid(S,j+2);
+        
+        if( !bOnlyTexture )
+        {
+            Canvas.TextSize(StripColorTags(D),XL,YL,TextScaler,TextScaler);
+            DrawColoredText(D,X,Y,TextScaler,bUseOutline);
+            
+            X += XL;
+        }
+        else Canvas.TextSize("W",XL,YL,TextScaler,TextScaler);
+        
+        Canvas.DrawColor = class'HUD'.default.WhiteColor;
+        Canvas.DrawColor.A = OrgC.A;
+        
+        Canvas.SetPos(X,Y+(Owner.HUDOwner.ScaledBorderSize/2));
+        Canvas.DrawRect(YL-Owner.HUDOwner.ScaledBorderSize,YL-Owner.HUDOwner.ScaledBorderSize,Mat);
+        
+        X += YL-Owner.HUDOwner.ScaledBorderSize;
+        
+        Canvas.DrawColor = OrgC;
+        Mat = FindNextTexture(S);
+    }
+    
+    DrawColoredText(S,X,Y,TextScaler,bUseOutline);
+}
+final function Texture2D FindNextTexture(out string S)
+{
+    local int i, j;
+    local string Path;
+    local Texture2D Tex;
+    local FTexturePreCache Cache;
+
+    Path = S;
+    i = InStr(Path,"<Icon>");
+    if( i == INDEX_NONE )
+        return None;
+        
+    j = InStr(Path,"</Icon>");
+    S = Left(Path,i)$"<TEXTURE>"$Mid(Path, j+6);
+    Path = Mid(Path, i+6, j-(i+6));
+    
+    i = PrecachedTextures.Find('Path', Path);
+    if( i != INDEX_NONE )
+        return PrecachedTextures[i].Tex;
+    
+    Tex = Texture2D(FindObject(Path, class'Texture2D'));
+    if( Tex != None )
+    {
+        Cache.Path = Path;
+        Cache.Tex = Tex;
+        PrecachedTextures.AddItem(Cache);
+        
+        return Tex;
+    }
+
+    Cache.Path = Path;
+    Cache.Tex = Texture2D(DynamicLoadObject(Path, class'Texture2D'));
+    PrecachedTextures.AddItem(Cache);
+    
+    return Cache.Tex;
+}
+final function string StripTextureFromString(string S, optional bool bNoStringAdd)
+{
+    local int i, j;
+    
+    while( true )
+    {
+        i = InStr(S,"<Icon>");
+        if( i == INDEX_NONE )
+            break;
+            
+        j = InStr(S,"</Icon>");
+        S = Left(S,i)$(bNoStringAdd ? "" : "W")$Mid(S, j+Len("</Icon>"));
+    }
+
+    return StripColorTags(S);
+}
+final function string GetTimeString(int Seconds)
+{
+    local int Minutes, Hours;
+    local string Time;
+
+    if( Seconds > 3600 )
+    {
+        Hours = Seconds / 3600;
+        Seconds -= Hours * 3600;
+
+        Time = Hours$":";
+    }
+    Minutes = Seconds / 60;
+    Seconds -= Minutes * 60;
+
+    if( Minutes >= 10 )
+        Time = Time $ Minutes $ ":";
+    else Time = Time $ "0" $ Minutes $ ":";
+
+    if( Seconds >= 10 )
+        Time = Time $ Seconds;
+    else Time = Time $ "0" $ Seconds;
+
+    return Time;
+}
+
+final function DrawCornerTexNU( int SizeX, int SizeY, byte Dir ) // Draw non-uniform corner.
+{
+    switch( Dir )
+    {
+    case 0: // Up-left
+        Canvas.DrawTile(ItemTex,SizeX,SizeY,77,15,-66,58);
+        break;
+    case 1: // Up-right
+        Canvas.DrawTile(ItemTex,SizeX,SizeY,11,15,66,58);
+        break;
+    case 2: // Down-left
+        Canvas.DrawTile(ItemTex,SizeX,SizeY,77,73,-66,-58);
+        break;
+    default: // Down-right
+        Canvas.DrawTile(ItemTex,SizeX,SizeY,11,73,66,-58);
+    }
+}
+final function DrawCornerTex( int Size, byte Dir )
+{
+    switch( Dir )
+    {
+    case 0: // Up-left
+        Canvas.DrawTile(ItemTex,Size,Size,77,15,-66,58);
+        break;
+    case 1: // Up-right
+        Canvas.DrawTile(ItemTex,Size,Size,11,15,66,58);
+        break;
+    case 2: // Down-left
+        Canvas.DrawTile(ItemTex,Size,Size,77,73,-66,-58);
+        break;
+    default: // Down-right
+        Canvas.DrawTile(ItemTex,Size,Size,11,73,66,-58);
+    }
+}
+final function DrawWhiteBox( float XS, float YS, optional bool bClip )
+{
+    Canvas.DrawTile(ItemTex,XS,YS,19,45,1,1,,bClip);
+}
+
+final function DrawRectBox( float X, float Y, float XS, float YS, int Edge, optional byte Extrav )
+{
+    if( Extrav==2 )
+        Edge=Min(FMin(Edge,(XS)*0.5),YS);// Verify size.
+    else Edge=Min(FMin(Edge,(XS)*0.5),(YS)*0.5);// Verify size.
+    
+    Canvas.PreOptimizeDrawTiles(Extrav==0 ? 7 : 6, ItemTex);
+
+    // Top left
+    Canvas.SetPos(X,Y);
+    DrawCornerTex(Edge,0);
+    
+    if( Extrav<=1 )
+    {
+        if( Extrav==0 )
+        {
+            // Top right
+            Canvas.SetPos(X+XS-Edge,Y);
+            DrawCornerTex(Edge,1);
+            
+            // Bottom right
+            Canvas.SetPos(X+XS-Edge,Y+YS-Edge);
+            DrawCornerTex(Edge,3);
+            
+            // Fill
+            Canvas.SetPos(X+Edge,Y);
+            DrawWhiteBox(XS-Edge*2,YS);
+            Canvas.SetPos(X,Y+Edge);
+            DrawWhiteBox(Edge,YS-Edge*2);
+            Canvas.SetPos(X+XS-Edge,Y+Edge);
+            DrawWhiteBox(Edge,YS-Edge*2);
+        }
+        else if( Extrav==1 )
+        {
+            // Top right
+            Canvas.SetPos(X+XS,Y);
+            DrawCornerTex(Edge,3);
+            
+            // Bottom right
+            Canvas.SetPos(X+XS,Y+YS-Edge);
+            DrawCornerTex(Edge,1);
+
+            // Fill
+            Canvas.SetPos(X+Edge,Y);
+            DrawWhiteBox(XS-Edge,YS);
+            Canvas.SetPos(X,Y+Edge);
+            DrawWhiteBox(Edge,YS-Edge*2);
+        }
+        
+        // Bottom left
+        Canvas.SetPos(X,Y+YS-Edge);
+        DrawCornerTex(Edge,2);
+    }
+    else
+    {
+        // Top right
+        Canvas.SetPos(X+XS-Edge,Y);
+        DrawCornerTex(Edge,1);
+        
+        // Bottom right
+        Canvas.SetPos(X+XS-Edge,Y+YS);
+        DrawCornerTex(Edge,2);
+        
+        // Bottom left
+        Canvas.SetPos(X,Y+YS);
+        DrawCornerTex(Edge,3);
+        
+        // Fill
+        Canvas.SetPos(X,Y+Edge);
+        DrawWhiteBox(XS,YS-Edge);
+        Canvas.SetPos(X+Edge,Y);
+        DrawWhiteBox(XS-Edge*2,Edge);
+    }
+}
+
+final function DrawBoxHollow( float X, float Y, float Width, float Height, float Thickness )
+{
+    Canvas.PreOptimizeDrawTiles(4, ItemTex);
+
+    Canvas.SetPos(X + Thickness, Y);
+    DrawWhiteBox(Width - Thickness * 2, Thickness);
+
+    Canvas.SetPos(X + Thickness, Y+Height-Thickness);
+    DrawWhiteBox(Width - Thickness * 2, Thickness);
+
+    Canvas.SetPos(X, Y);
+    DrawWhiteBox(Thickness, Height);
+
+    Canvas.SetPos(X + Width - Thickness, Y);
+    DrawWhiteBox(Thickness, Height);
+}
+
+final function DrawOutlinedBox( float X, float Y, float Width, float Height, float Thickness, Color BoxColor, Color OutlineColor )
+{
+    Canvas.DrawColor = BoxColor;
+    Canvas.SetPos(X + Thickness, Y + Thickness);
+    DrawWhiteBox(Width - (Thickness*2), Height - (Thickness*2));
+    
+    Canvas.DrawColor = OutlineColor;
+    DrawBoxHollow(X, Y, Width, Height, Thickness);
+}
+
+final function DrawBoxCorners(float BorderSize, float X, float Y, float W, float H, optional bool TopLeft, optional bool TopRight, optional bool BottomLeft, optional bool BottomRight)
+{
+    // Top left
+    Canvas.SetPos(X,Y);
+    if( TopLeft )
+        DrawCornerTex(BorderSize,0);
+    else DrawWhiteBox(BorderSize, BorderSize);
+    
+    // Top right
+    Canvas.SetPos(X+W-BorderSize,Y);
+    if( TopRight )
+        DrawCornerTex(BorderSize,1);
+    else DrawWhiteBox(BorderSize, BorderSize);
+    
+    // Bottom left
+    Canvas.SetPos(X,Y+H-BorderSize);
+    if( BottomLeft )
+        DrawCornerTex(BorderSize,2);
+    else DrawWhiteBox(BorderSize, BorderSize);
+    
+    // Bottom right
+    Canvas.SetPos(X+W-BorderSize,Y+H-BorderSize);
+    if( BottomRight )
+        DrawCornerTex(BorderSize,3);
+    else DrawWhiteBox(BorderSize, BorderSize);
+}
+
+final function DrawRoundedBox( float BorderSize, float X, float Y, float W, float H, Color BoxColor )
+{
+    DrawRoundedBoxEx(BorderSize, X, Y, W, H, BoxColor, true, true, true, true);
+}
+
+final function DrawRoundedBoxEx( float BorderSize, float X, float Y, float W, float H, Color BoxColor, optional bool TopLeft, optional bool TopRight, optional bool BottomLeft, optional bool BottomRight )
+{
+    Canvas.DrawColor = BoxColor;
+
+    if( BorderSize <= 0 )
+    {
+        Canvas.SetPos(X, Y);
+        DrawWhiteBox(W, H);
+        return;
+    }
+    
+    Canvas.PreOptimizeDrawTiles(7, ItemTex);
+
+    BorderSize = Min(FMin(BorderSize,(W)*0.5),(H)*0.5);
+
+    Canvas.SetPos(X + BorderSize, Y);
+    DrawWhiteBox(W - BorderSize * 2, H);
+    
+    Canvas.SetPos(X, Y + BorderSize);
+    DrawWhiteBox(BorderSize, H - BorderSize * 2);
+    
+    Canvas.SetPos(X + W - BorderSize, Y + BorderSize);
+    DrawWhiteBox(BorderSize, H - BorderSize * 2);
+
+    DrawBoxCorners(BorderSize, X, Y, W, H, TopLeft, TopRight, BottomLeft, BottomRight);
+}
+
+final function DrawRoundedBoxHollow( float BorderSize, float X, float Y, float W, float H, Color BoxColor )
+{
+    DrawRoundedBoxHollowEx(BorderSize, X, Y, W, H, BoxColor, true, true, true, true);
+}
+
+final function DrawRoundedBoxHollowEx( float BorderSize, float X, float Y, float W, float H, Color BoxColor, optional bool TopLeft, optional bool TopRight, optional bool BottomLeft, optional bool BottomRight )
+{
+    Canvas.PreOptimizeDrawTiles(8, ItemTex);
+    
+    BorderSize = Min(FMin(BorderSize,(W)*0.5),(H)*0.5);
+
+    Canvas.DrawColor = BoxColor;
+
+    Canvas.SetPos(X + BorderSize, Y);
+    DrawWhiteBox(W - BorderSize * 2, BorderSize);
+    
+    Canvas.SetPos(X + BorderSize, Y+H-BorderSize);
+    DrawWhiteBox(W - BorderSize * 2, BorderSize);
+    
+    Canvas.SetPos(X, Y + BorderSize);
+    DrawWhiteBox(BorderSize, H - BorderSize * 2);    
+    
+    Canvas.SetPos(X + W - BorderSize, Y + BorderSize);
+    DrawWhiteBox(BorderSize, H - BorderSize * 2);
+
+    DrawBoxCorners(BorderSize, X, Y, W, H, TopLeft, TopRight, BottomLeft, BottomRight);
+}
+
+final function DrawRoundedBoxOutlined( float BorderSize, float X, float Y, float Width, float Height, Color BoxColor, Color OutlineColor )
+{
+    Canvas.DrawColor = BoxColor;
+    Canvas.SetPos(X + BorderSize, Y + BorderSize);
+    DrawWhiteBox(Width - (BorderSize*2), Height - (BorderSize*2));
+    
+    DrawRoundedBoxHollow(BorderSize, X, Y, Width, Height, OutlineColor);
+}
+
+final function DrawRoundedBoxOutlinedEx( float BorderSize, float X, float Y, float Width, float Height, Color BoxColor, Color OutlineColor, optional bool TopLeft, optional bool TopRight, optional bool BottomLeft, optional bool BottomRight )
+{
+    Canvas.DrawColor = BoxColor;
+    Canvas.SetPos(X + BorderSize, Y + BorderSize);
+    DrawWhiteBox(Width - (BorderSize*2), Height - (BorderSize*2));
+    
+    DrawRoundedBoxHollowEx(BorderSize, X, Y, Width, Height, OutlineColor, TopLeft, TopRight, BottomLeft, BottomRight);
+}
+
+final function DrawArrowBox( int Direction, float X, float Y, float Width, float Height )
+{
+    local Texture2D DirectionMat;
+    
+    switch( Direction )
+    {
+        case 0:
+            DirectionMat=ArrowTextures[`ARROW_UP];
+            break;
+        case 1:
+            DirectionMat=ArrowTextures[`ARROW_RIGHT];
+            break;
+        case 2:
+            DirectionMat=ArrowTextures[`ARROW_DOWN];
+            break;
+        case 3:
+            DirectionMat=ArrowTextures[`ARROW_LEFT];
+            break;
+        default:
+            DirectionMat=ArrowTextures[`ARROW_UP];
+            break;
+    }
+    
+    DrawTileStretched(ScrollTexture,X,Y,Width,Height);
+    DrawTileStretched(DirectionMat,X,Y,Width,Height);
+}
+
+final function DrawTileStretched( Texture Tex, float X, float Y, float XS, float YS )
+{
+    local float mW,mH,MidX,MidY,SmallTileW,SmallTileH,fX,fY;
+    local int OptimizeTiles;
+ 
+    if( Tex==None ) Tex = Texture2D'EngineMaterials.DefaultDiffuse';
+ 
+    // Get the size of the image
+    mW = Tex.GetSurfaceWidth();
+    mH = Tex.GetSurfaceHeight();
+ 
+    // Get the midpoints of the image
+    MidX = int(mW/2);
+    MidY = int(mH/2);
+ 
+    // Grab info about the scaled image
+    SmallTileW = XS - mW;
+    SmallTileH = YS - mH;
+    
+    // Optimized
+    OptimizeTiles = 4;
+    
+    if( mW<XS )
+        OptimizeTiles += 2;
+    if( mH<YS )
+        OptimizeTiles += 2;
+    if( (mH<YS) && (mW<XS) )
+        OptimizeTiles += 1;
+        
+    Canvas.PreOptimizeDrawTiles(OptimizeTiles, Tex);
+ 
+    // Draw the spans first
+    // Top and Bottom
+    if (mW<XS)
+    {
+        fX = MidX;
+ 
+        if (mH>YS)
+            fY = YS/2;
+        else
+            fY = MidY;
+ 
+        Canvas.SetPos(X+fX,Y);
+        Canvas.DrawTile(Tex,SmallTileW,fY,MidX,0,1,fY);
+        Canvas.SetPos(X+fX,Y+YS-fY);
+        Canvas.DrawTile(Tex,SmallTileW,fY,MidX,mH-fY,1,fY);
+    }
+    else
+        fX = XS / 2;
+ 
+    // Left and Right
+    if (mH<YS)
+    {
+        fY = MidY;
+ 
+        Canvas.SetPos(X,Y+fY);
+        Canvas.DrawTile(Tex,fX,SmallTileH,0,fY,fX,1);
+        Canvas.SetPos(X+XS-fX,Y+fY);
+        Canvas.DrawTile(Tex,fX,SmallTileH,mW-fX,fY,fX,1);
+    }
+    else
+        fY = YS / 2;
+ 
+    // Center
+    if ( (mH<YS) && (mW<XS) )
+    {
+        Canvas.SetPos(X+fX,Y+fY);
+        Canvas.DrawTile(Tex,SmallTileW,SmallTileH,fX,fY,1,1);
+    }
+ 
+    // Draw the 4 corners.
+    Canvas.SetPos(X,Y);
+    Canvas.DrawTile(Tex,fX,fY,0,0,fX,fY);
+    Canvas.SetPos(X+XS-fX,Y);
+    Canvas.DrawTile(Tex,fX,fY,mW-fX,0,fX,fY);
+    Canvas.SetPos(X,Y+YS-fY);
+    Canvas.DrawTile(Tex,fX,fY,0,mH-fY,fX,fY);
+    Canvas.SetPos(X+XS-fX,Y+YS-fY);
+    Canvas.DrawTile(Tex,fX,fY,mW-fX,mH-fY,fX,fY);
+}
+
+final function DrawTextJustified( byte Justification, float X1, float Y1, float X2, float Y2, coerce string S, optional float XS, optional float YS )
+{
+    local float XL, YL;
+    local float CurY, CurX;
+    
+    Canvas.TextSize(S, XL, YL, XS, YS);
+    
+    CurY = ((Y2-Y1) / 2) - (YL/2);
+
+    if( Justification == 0 )
+    {
+        CurX = 0;
+    }
+    else if( Justification == 1 )
+    {
+        if( XL > X2-X1 )
+            CurX = 0;
+        else CurX = ((X2-X1) / 2) - (XL/2);
+    }
+    else if( Justification == 2 )
+    {
+        CurX = (X2-X1) - XL;
+    }
+
+    Canvas.SetPos(CurX, CurY);
+    Canvas.DrawText(S,,XS, YS);
+}
+
+static final function float TimeFraction( float Start, float End, float Current )
+{
+    return FClamp((Current - Start) / (End - Start), 0.f, 1.f);
+}
+
+static final function string LTrim(coerce string S)
+{
+    while (Left(S, 1) == " ")
+        S = Right(S, Len(S) - 1);
+    return S;
+}
+
+static final function string RTrim(coerce string S)
+{
+    while (Right(S, 1) == " ")
+        S = Left(S, Len(S) - 1);
+    return S;
+}
+
+static final function string Trim(coerce string S)
+{
+    return LTrim(RTrim(S));
+}
+
+defaultproperties
+{
+    MainFont=Font'KFClassicMode_Assets.Font.KFMainFont'
+    NumberFont=Font'UI_Canvas_Fonts.Font_General'
+    InfiniteFont=Font'KFClassicMode_Assets.Font.KFInfiniteFont'
+}

Src/KFClassicHUD/Classes/KF1HUD_BossHealthBar.uc

@@ -0,0 +1,84 @@
+class KF1HUD_BossHealthBar extends KFGFxWidget_BossHealthBar;
+
+function TickHud(float DeltaTime)
+{
+    local ClassicKFHUD HUD;
+    
+    HUD = ClassicKFHUD(KFPC.MyHUD);
+    if(KFPC.bHideBossHealthBar != bLastHideValue)
+    {
+        bLastHideValue = KFPC.bHideBossHealthBar;
+
+        if(KFPC.bHideBossHealthBar && HUD.ScriptedPawn == none)
+            HUD.bDisplayImportantHealthBar = false;
+        else if(HUD.BossPawn != none || HUD.ScriptedPawn != none)
+            HUD.bDisplayImportantHealthBar = true;
+    }
+}
+
+function SetEscortPawn(KFPawn_Scripted NewPawn)
+{
+    local ClassicKFHUD HUD;
+    
+    HUD = ClassicKFHUD(KFPC.MyHUD);
+	if (NewPawn == none)
+		return;
+        
+    EscortPawn = NewPawn;
+    
+    HUD.bDisplayImportantHealthBar = true;
+    HUD.BossInfoIcon = Texture2D(DynamicLoadObject(NewPawn.GetIconPath(),class'Texture2D'));
+    HUD.ScriptedPawn = NewPawn;
+}
+
+function SetBossPawn(KFInterface_MonsterBoss NewBoss)
+{
+    BossPawn = NewBoss;
+    if(NewBoss == None || KFPC.bHideBossHealthBar)
+        return;
+
+    ClassicKFHUD(KFPC.MyHUD).BossInfoIcon = Texture2D(DynamicLoadObject(NewBoss.GetIconPath(),class'Texture2D'));
+    ClassicKFHUD(KFPC.MyHUD).BossPawn = NewBoss;
+}
+
+function UpdateBossShield(float NewShieldPercect)
+{
+    ClassicKFHUD(KFPC.MyHUD).BossShieldPct = NewShieldPercect;
+}
+
+function UpdateBossBattlePhase(int BattlePhase)
+{
+    ClassicKFHUD(KFPC.MyHUD).BossBattlePhaseColor = ClassicKFHUD(KFPC.MyHUD).BattlePhaseColors[Max(BattlePhase - 1, 0)];
+}
+
+function OnNamePlateHidden()
+{
+    local ClassicKFHUD HUD;
+    
+    HUD = ClassicKFHUD(KFPC.MyHUD);
+    if(KFPC.bHideBossHealthBar && HUD.ScriptedPawn == none)
+        return;
+
+    if(HUD.BossPawn != None)
+        HUD.bDisplayImportantHealthBar = true;
+	else  HUD.bDisplayImportantHealthBar = false;
+}
+
+simulated function Deactivate()
+{
+    local ClassicKFHUD HUD;
+    
+    HUD = ClassicKFHUD(KFPC.MyHUD);
+    
+    HUD.BossInfoIcon = None;
+    HUD.BossPawn = None;
+    HUD.BossShieldPct = 0.f;
+    HUD.BossBattlePhaseColor = HUD.default.BossBattlePhaseColor;
+    HUD.ScriptedPawn = None;
+    
+	HUD.bDisplayImportantHealthBar = false;
+}
+
+DefaultProperties
+{
+}

Src/KFClassicHUD/Classes/KF1HUD_ChatBoxWidget.uc

@@ -0,0 +1,13 @@
+class KF1HUD_ChatBoxWidget extends KFGFxHUD_ChatBoxWidget;
+
+function AddChatMessage(string NewMessage, string HexVal)
+{
+	Super.AddChatMessage(NewMessage, HexVal);
+    if( InStr(NewMessage, "<"$class'KFCommon_LocalizedStrings'.default.TeamString$">") != INDEX_NONE || InStr(NewMessage, "<"$class'KFCommon_LocalizedStrings'.default.AllString$">") != INDEX_NONE )
+        LocalPlayer(GetPC().Player).ViewportClient.ViewportConsole.OutputText(NewMessage);
+}
+
+defaultproperties
+{
+}
+

Src/KFClassicHUD/Classes/KF1HUD_MusicNotification.uc

@@ -0,0 +1,25 @@
+class KF1HUD_MusicNotification extends KFGFxWidget_MusicNotification;
+
+function ShowSongInfo(string SongInfoString)
+{
+	local KFGameEngine KFEngine;   
+    local ClassicKFHUD HUD;
+    local PopupMessage Msg;
+    
+    HUD = ClassicKFHUD(GetPC().MyHUD);
+	KFEngine = KFGameEngine(Class'Engine'.static.GetEngine());
+    
+	if(KFEngine != none && KFEngine.MusicVolumeMultiplier > 0)
+	{
+        Msg.Body = SongInfoString;
+        Msg.Image = Texture2D'UI_HUD.InGameHUD_SWF_IBC';
+        Msg.MsgPosition = PP_TOP_CENTER;
+        
+        HUD.AddPopupMessage(Msg);
+	}
+}
+
+DefaultProperties
+{
+    
+}

Src/KFClassicHUD/Classes/KF1HUD_PlayerStatus.uc

@@ -0,0 +1,14 @@
+class KF1HUD_PlayerStatus extends KFGFxHUD_PlayerStatus;
+
+function UpdateXP(int XPDelta, int XPPercent, bool bLevelUp, Class<KFPerk> PerkClass)
+{
+    if(!bLevelUp && MyPC.GetPerkLevelFromPerkList(PerkClass) < `MAX_PERK_LEVEL)
+        ClassicKFHUD(MyPC.MyHUD).NotifyXPEarned(XPDelta,PerkClass.default.PerkIcon,MakeColor(255, 255 * (KFPlayerReplicationInfo(MyPC.PlayerReplicationInfo).GetActivePerkLevel()/`MAX_PERK_LEVEL), 0, 255));
+    
+    Super.UpdateXP(XPDelta, XPPercent, bLevelUp, PerkClass);
+}
+
+DefaultProperties
+{
+    
+}

Src/KFClassicHUD/Classes/KF1HUD_WeaponSelectWidget.uc

@@ -0,0 +1,38 @@
+class KF1HUD_WeaponSelectWidget extends KFGFxHUD_WeaponSelectWidget;
+
+function SetSelectedWeapon(int GroupIndex, int SelectedIndex)
+{
+    local ClassicKFHUD HUD;
+    
+    HUD = ClassicKFHUD(GetPC().MyHUD);
+    if( !HUD.bDisplayInventory )
+    {
+        HUD.bDisplayInventory = true;
+        HUD.InventoryFadeStartTime = GetPC().WorldInfo.TimeSeconds;
+    }
+    else HUD.RefreshInventory();
+    
+    HUD.SelectedInventoryCategory = GroupIndex;
+    HUD.SelectedInventoryIndex = SelectedIndex;
+}
+
+function InitializeObject();
+function SetThowButton();
+simulated function RefreshWeaponSelect();
+simulated function UpdateWeaponGroupOnHUD( byte GroupIndex );
+simulated function SetWeaponGroupList(out array<KFWeapon> WeaponList, byte GroupIndex);
+simulated function SetWeaponList( GFxObject WeaponList, int GroupIndex );
+function Weapon GetSelectedWeapon();
+function UpdateIndex();
+function Hide();
+function SetWeaponCategories();
+function SendWeaponIndex( int GroupIndex, int SelectedIndex );
+function ShowOnlyHUDGroup( byte GroupIndex );
+function ShowAllHUDGroups();
+function FadeOut();
+function RefreshTimer();
+function SetWeaponSwitchStayOpen(bool bStayOpen);
+
+DefaultProperties
+{
+}

Src/KFClassicHUD/Classes/KF1_HUDWrapper.uc

@@ -0,0 +1,227 @@
+class KF1_HUDWrapper extends KFGFxMoviePlayer_HUD;
+
+event bool WidgetInitialized(name WidgetName, name WidgetPath, GFxObject Widget)
+{
+	local bool Ret;
+	
+    if( WidgetName == 'ObjectiveContainer' )
+        return false;
+    
+	Ret = Super.WidgetInitialized(WidgetName, WidgetPath, Widget);
+	
+	if( WaveInfoWidget != None )
+	{
+		WaveInfoWidget.SetVisible(false);
+	}
+	
+	if( MusicNotification != None )
+	{
+		MusicNotification.SetVisible(false);
+	}
+	
+	if( TraderCompassWidget != None )
+	{
+		TraderCompassWidget.SetVisible(false);
+	}	
+    
+    if( KeyboardWeaponSelectWidget != None )
+	{
+		KeyboardWeaponSelectWidget.SetVisible(false);
+	}   
+	
+	return Ret;
+}
+
+function TickHud(float DeltaTime)
+{
+	local ASDisplayInfo DI;
+	
+	Super.TickHud(DeltaTime);
+	
+	if( PlayerStatusContainer != None )
+	{
+		DI = PlayerStatusContainer.GetDisplayInfo();
+		if( DI.Visible )
+		{
+			DI.Visible = false;
+			PlayerStatusContainer.SetDisplayInfo(DI);
+		}
+	}
+	
+	if( PlayerBackpackContainer != None )
+	{
+		DI = PlayerBackpackContainer.GetDisplayInfo();
+		if( DI.Visible )
+		{
+			DI.Visible = false;
+			PlayerBackpackContainer.SetDisplayInfo(DI);
+		}
+	}
+	
+	if( WaveInfoWidget != None )
+	{
+		DI = WaveInfoWidget.GetDisplayInfo();
+		if( DI.Visible )
+		{
+			DI.Visible = false;
+			WaveInfoWidget.SetDisplayInfo(DI);
+		}
+	}
+	
+	if( TraderCompassWidget != None )
+	{
+		DI = TraderCompassWidget.GetDisplayInfo();
+		if( DI.Visible )
+		{
+			DI.Visible = false;
+			TraderCompassWidget.SetDisplayInfo(DI);
+		}
+	}	
+    
+    if( KeyboardWeaponSelectWidget != None )
+	{
+		DI = KeyboardWeaponSelectWidget.GetDisplayInfo();
+		if( DI.Visible )
+		{
+			DI.Visible = false;
+			KeyboardWeaponSelectWidget.SetDisplayInfo(DI);
+		}
+	}
+}
+
+function DisplayPriorityMessage(string InPrimaryMessageString, string InSecondaryMessageString, int LifeTime, optional KFLocalMessage_Priority.EGameMessageType MessageType)
+{
+    local KFGameReplicationInfo KFGRI;
+    local int ModifierIndex;
+    local FPriorityMessage PriorityMsg;
+    local KFWeeklyOutbreakInformation WeeklyInfo;
+    
+    KFGRI = KFGameReplicationInfo(class'WorldInfo'.static.GetWorldInfo().GRI);
+    
+    PriorityMsg.PrimaryText = InPrimaryMessageString;
+    PriorityMsg.SecondaryText = InSecondaryMessageString;
+    PriorityMsg.SecondaryAlign = PR_BOTTOM;
+    PriorityMsg.LifeTime = LifeTime;
+            
+    switch ( MessageType )
+    {
+        case GMT_WaveStartSpecial:
+            if( KFGRI.IsSpecialWave(ModifierIndex) )
+            {
+                PriorityMsg.SecondaryText = Localize("Zeds", SpecialWaveLocKey[ModifierIndex], "KFGame");
+                PriorityMsg.Icon = Texture2D(DynamicLoadObject(SpecialWaveIconPath[ModifierIndex], class'Texture2D'));
+            }
+            break;
+        case GMT_WaveStartWeekly:
+            if( KFGRI.IsWeeklyWave(ModifierIndex) )
+            {
+                WeeklyInfo = class'KFMission_LocalizedStrings'.static.GetWeeklyOutbreakInfoByIndex(ModifierIndex);
+                
+                PriorityMsg.SecondaryText = WeeklyInfo.FriendlyName;
+                PriorityMsg.Icon = Texture2D(DynamicLoadObject(WeeklyInfo.IconPath, class'Texture2D'));
+            }
+            break;
+        case GMT_WaveEnd:
+            PriorityMsg.Icon = Texture2D'DailyObjective_UI.KF2_Dailies_Icon_ZED';
+            break;
+        case GMT_WaveStart:
+            PriorityMsg.Icon = Texture2D'DailyObjective_UI.KF2_Dailies_Icon_ZED';
+            PriorityMsg.SecondaryIcon = Texture2D'UI_Widgets.MenuBarWidget_SWF_I11';
+            PriorityMsg.SecondaryText = GetExpandedWaveInfo();
+            break;
+        case GMT_WaveSBoss:
+            PriorityMsg.Icon = Texture2D'DailyObjective_UI.KF2_Dailies_Icon_ZED';
+            PriorityMsg.SecondaryText = class'KFGFxHUD_WaveInfo'.default.BossWaveString;
+            break;
+        case GMT_MatchWon:
+            PriorityMsg.Icon = Texture2D'UI_Award_Team.UI_Award_Team-Kills';
+            break;        
+        case GMT_MatchLost:
+            PriorityMsg.Icon = Texture2D'UI_Award_ZEDs.UI_Award_ZED_Kills';
+            break;
+        case GMT_LastPlayerStanding:
+            PriorityMsg.LifeTime *= 1.5f;
+            PriorityMsg.Icon = Texture2D'DailyObjective_UI.KF2_Dailies_Icon_ZED';
+            break;
+    }
+                    
+    ClassicKFHUD(KFPC.myHUD).ShowPriorityMessage(PriorityMsg);
+}
+
+function string GetExpandedWaveInfo()
+{
+	local KFGameReplicationInfo KFGRI;
+    local int Wave;
+    
+    KFGRI = KFGameReplicationInfo(KFPC.WorldInfo.GRI);
+    if( KFPC.WorldInfo.NetMode == NM_StandAlone )
+        Wave = KFGRI.WaveNum;
+    else Wave = KFGRI.WaveNum+1;
+
+    if (KFGRI.default.bEndlessMode)
+        return class'KFGFxHUD_WaveInfo'.default.WaveString@string(KFGRI.WaveNum+1);
+    else
+    {
+        if( Wave == KFGRI.GetFinalWaveNum() )
+            return class'KFGFxHUD_WaveInfo'.default.FinalWaveString;
+        else return class'KFGFxHUD_WaveInfo'.default.WaveString@Wave$"/"$KFGRI.GetFinalWaveNum();
+    }
+
+    return "";
+}
+
+function ShowKillMessage(PlayerReplicationInfo PRI1, PlayerReplicationInfo PRI2, optional bool bDeathMessage=false, optional Object OptionalObject)
+{
+    local bool bHumanDeath;
+    local string KilledName, KillerName;
+    local class<KFPawn_Monster> KFPM;
+
+    if(KFPC == none)
+        return;
+
+    KFPM = class<KFPawn_Monster>(OptionalObject);
+
+    if( KFGXHUDManager != none )
+    {
+        if(bDeathMessage)
+        {
+            if(KFPM != none)
+                KillerName=KFPM.static.GetLocalizedName();
+        }
+        else
+        {
+            if(KFPM != none)
+            {
+                KilledName=KFPM.static.GetLocalizedName();
+                bHumanDeath=false;
+            }
+            else if(PRI1 != none)
+                KillerName=PRI1.PlayerName;
+        }
+
+        if(PRI2 != none)
+        {
+            if(PRI2.GetTeamNum() == class'KFTeamInfo_Human'.default.TeamIndex)
+                bHumanDeath=true;
+            else bHumanDeath=false;
+            KilledName=PRI2.PlayerName;
+        }
+
+        ClassicKFHUD(KFPC.myHUD).ShowKillMessage(PRI1, PRI2, bHumanDeath, KilledName, KillerName);
+    }
+}
+
+DefaultProperties
+{
+    WidgetBindings.Remove((WidgetName="PlayerStatWidgetMC",WidgetClass=class'KFGFxHUD_PlayerStatus'))
+    WidgetBindings.Add((WidgetName="PlayerStatWidgetMC",WidgetClass=class'KF1HUD_PlayerStatus'))
+    
+    WidgetBindings.Remove((WidgetName="WeaponSelectContainer",WidgetClass=class'KFGFxHUD_WeaponSelectWidget'))
+    WidgetBindings.Add((WidgetName="WeaponSelectContainer",WidgetClass=class'KF1HUD_WeaponSelectWidget'))
+    
+    WidgetBindings.Remove((WidgetName="MusicNotification", WidgetClass=class'KFGFxWidget_MusicNotification'))
+    WidgetBindings.Add((WidgetName="MusicNotification", WidgetClass=class'KF1HUD_MusicNotification'))
+    
+    WidgetBindings.Remove((WidgetName="ChatBoxWidget", WidgetClass=class'KFGFxHUD_ChatBoxWidget'))
+    WidgetBindings.Add((WidgetName="ChatBoxWidget", WidgetClass=class'KF1HUD_ChatBoxWidget'))
+}

Src/KFClassicHUD/Classes/KF2GUIController.uc

@@ -0,0 +1,990 @@
+Class KF2GUIController extends Info
+    transient;
+
+var() class<GUIStyleBase> DefaultStyle;
+
+var PlayerController PlayerOwner;
+var ClassicKFHUD HUDOwner;
+var transient KF2GUIInput CustomInput;
+var transient PlayerInput BackupInput;
+var transient GameViewportClient ClientViewport;
+
+var delegate<Interaction.OnReceivedNativeInputKey> OldOnReceivedNativeInputKey;
+var delegate<Interaction.OnReceivedNativeInputAxis> OldOnReceivedNativeInputAxis;
+var delegate<Interaction.OnReceivedNativeInputChar> OldOnReceivedNativeInputChar;
+
+var delegate<GameViewportClient.HandleInputAxis> OldHandleInputAxis;
+
+var array<KFGUI_Page> ActiveMenus,PersistentMenus;
+var transient KFGUI_Base MouseFocus,InputFocus,KeyboardFocus;
+var IntPoint MousePosition,ScreenSize,OldMousePos,LastMousePos,LastClickPos[2];
+var transient float MousePauseTime,MenuTime,LastClickTimes[2];
+var transient GUIStyleBase CurrentStyle;
+
+var transient Console OrgConsole;
+var transient KFGUIConsoleHack HackConsole;
+
+var array<Texture2D> CursorTextures;
+var Color CursorColor;
+var int CurrentCursorIndex, CursorSize;
+
+var Texture DefaultPens[3];
+var byte CursorFade, FastCursorFade, CursorFlash;
+var int CursorStep, FastCursorStep;
+var int FontBlurX,FontBlurX2,FontBlurY,FontBlurY2,FastFontBlurX,FastFontBlurX2,FastFontBlurY,FastFontBlurY2;
+
+var bool bMouseWasIdle,bIsInMenuState,bAbsorbInput,bIsInvalid,bFinishedReplication,bHideCursor,bUsingGamepad,bForceEngineCursor,bNoInputReset;
+
+static function KF2GUIController GetGUIController( PlayerController PC )
+{
+    local KF2GUIController G;
+
+    if( PC.Player==None )
+    {
+        return None;
+    }
+        
+    foreach PC.ChildActors(class'KFClassicHUD.KF2GUIController',G)
+    {
+        if( !G.bIsInvalid )
+        {
+            break;
+        }
+    }
+    
+    if( G==None )
+    {
+        G = PC.Spawn(class'KFClassicHUD.KF2GUIController',PC);
+    }
+        
+    return G;
+}
+
+simulated function PostBeginPlay()
+{
+    PlayerOwner = PlayerController(Owner);
+    ClientViewport = LocalPlayer(PlayerOwner.Player).ViewportClient;
+    HUDOwner = ClassicKFHUD(PlayerOwner.myHUD);
+    
+    CurrentStyle = new (None) DefaultStyle;
+    CurrentStyle.InitStyle();
+    CurrentStyle.Owner = self;
+    
+    SetTimer(0.1, true, 'SetupFontBlur');
+    SetTimer(0.05, true, 'SetupFastFontBlur');
+    
+    SetTimer(0.25, true, 'SetupStyleTextures');
+    SetupStyleTextures();
+    
+    SetTimer(0.75, true, 'SetupCursorFlash');
+}
+
+simulated function SetupCursorFlash()
+{
+    if( CursorFlash == 255 )
+        CursorFlash = 0;
+    else CursorFlash = 255;
+}
+
+simulated function SetupStyleTextures()
+{
+    local ObjectReferencer RepObject;
+
+    RepObject = HUDOwner.RepObject;
+    if( RepObject != None )
+    {
+        CurrentStyle.MainFont = Font(RepObject.ReferencedObjects[104]);
+        CurrentStyle.InfiniteFont = Font(RepObject.ReferencedObjects[155]);
+        
+        CurrentStyle.BorderTextures[`BOX_INNERBORDER] = Texture2D(RepObject.ReferencedObjects[35]);
+        CurrentStyle.BorderTextures[`BOX_INNERBORDER_TRANSPARENT] = Texture2D(RepObject.ReferencedObjects[36]);
+        CurrentStyle.BorderTextures[`BOX_MEDIUM] = Texture2D(RepObject.ReferencedObjects[46]);
+        CurrentStyle.BorderTextures[`BOX_MEDIUM_SLIGHTTRANSPARENT] = Texture2D(RepObject.ReferencedObjects[47]);
+        CurrentStyle.BorderTextures[`BOX_MEDIUM_TRANSPARENT] = Texture2D(RepObject.ReferencedObjects[48]);
+        CurrentStyle.BorderTextures[`BOX_LARGE] = Texture2D(RepObject.ReferencedObjects[79]);
+        CurrentStyle.BorderTextures[`BOX_LARGE_SLIGHTTRANSPARENT] = Texture2D(RepObject.ReferencedObjects[80]);
+        CurrentStyle.BorderTextures[`BOX_LARGE_TRANSPARENT] = Texture2D(RepObject.ReferencedObjects[81]);
+        CurrentStyle.BorderTextures[`BOX_SMALL] = Texture2D(RepObject.ReferencedObjects[82]);
+        CurrentStyle.BorderTextures[`BOX_SMALL_SLIGHTTRANSPARENT] = Texture2D(RepObject.ReferencedObjects[83]);
+        CurrentStyle.BorderTextures[`BOX_SMALL_TRANSPARENT] = Texture2D(RepObject.ReferencedObjects[84]);
+        CurrentStyle.BorderTextures[`BOX_CORNER_8] = Texture2D(RepObject.ReferencedObjects[160]);
+        CurrentStyle.BorderTextures[`BOX_CORNER_16] = Texture2D(RepObject.ReferencedObjects[156]);
+        CurrentStyle.BorderTextures[`BOX_CORNER_32] = Texture2D(RepObject.ReferencedObjects[157]);
+        CurrentStyle.BorderTextures[`BOX_CORNER_64] = Texture2D(RepObject.ReferencedObjects[159]);
+        CurrentStyle.BorderTextures[`BOX_CORNER_512] = Texture2D(RepObject.ReferencedObjects[158]);
+        
+        CurrentStyle.ArrowTextures[`ARROW_DOWN] = Texture2D(RepObject.ReferencedObjects[10]);
+        CurrentStyle.ArrowTextures[`ARROW_LEFT] = Texture2D(RepObject.ReferencedObjects[45]);
+        CurrentStyle.ArrowTextures[`ARROW_RIGHT] = Texture2D(RepObject.ReferencedObjects[69]);
+        CurrentStyle.ArrowTextures[`ARROW_UP] = Texture2D(RepObject.ReferencedObjects[87]);
+        
+        CurrentStyle.ButtonTextures[`BUTTON_NORMAL] = Texture2D(RepObject.ReferencedObjects[3]);
+        CurrentStyle.ButtonTextures[`BUTTON_DISABLED] = Texture2D(RepObject.ReferencedObjects[4]);
+        CurrentStyle.ButtonTextures[`BUTTON_HIGHLIGHTED] = Texture2D(RepObject.ReferencedObjects[5]);
+        CurrentStyle.ButtonTextures[`BUTTON_PRESSED] = Texture2D(RepObject.ReferencedObjects[6]);
+        
+        CurrentStyle.TabTextures[`TAB_TOP] = Texture2D(RepObject.ReferencedObjects[76]);
+        CurrentStyle.TabTextures[`TAB_BOTTOM] = Texture2D(RepObject.ReferencedObjects[77]);
+        
+        CurrentStyle.ItemBoxTextures[`ITEMBOX_NORMAL] = Texture2D(RepObject.ReferencedObjects[40]);
+        CurrentStyle.ItemBoxTextures[`ITEMBOX_DISABLED] = Texture2D(RepObject.ReferencedObjects[41]);
+        CurrentStyle.ItemBoxTextures[`ITEMBOX_HIGHLIGHTED] = Texture2D(RepObject.ReferencedObjects[42]);
+        
+        CurrentStyle.ItemBoxTextures[`ITEMBOX_BAR_NORMAL] = Texture2D(RepObject.ReferencedObjects[37]);
+        CurrentStyle.ItemBoxTextures[`ITEMBOX_BAR_DISABLED] = Texture2D(RepObject.ReferencedObjects[38]);
+        CurrentStyle.ItemBoxTextures[`ITEMBOX_BAR_HIGHLIGHTED] = Texture2D(RepObject.ReferencedObjects[39]);
+        
+        CurrentStyle.CheckBoxTextures[`CHECKMARK_NORMAL] = Texture2D(RepObject.ReferencedObjects[7]);
+        CurrentStyle.CheckBoxTextures[`CHECKMARK_DISABLED] = Texture2D(RepObject.ReferencedObjects[8]);
+        CurrentStyle.CheckBoxTextures[`CHECKMARK_HIGHLIGHTED] = Texture2D(RepObject.ReferencedObjects[9]);
+        
+        CurrentStyle.PerkBox[`PERK_BOX_SELECTED] = Texture2D(RepObject.ReferencedObjects[60]);
+        CurrentStyle.PerkBox[`PERK_BOX_UNSELECTED] = Texture2D(RepObject.ReferencedObjects[61]);
+        
+        CurrentStyle.ScrollTexture = Texture2D(RepObject.ReferencedObjects[71]);
+        CurrentStyle.FavoriteIcon = Texture2D(RepObject.ReferencedObjects[105]);
+        CurrentStyle.BankNoteIcon = Texture2D(RepObject.ReferencedObjects[106]);
+        
+        CurrentStyle.ProgressBarTextures[`PROGRESS_BAR_NORMAL] = Texture2D(RepObject.ReferencedObjects[103]);
+        CurrentStyle.ProgressBarTextures[`PROGRESS_BAR_SELECTED] = Texture2D(RepObject.ReferencedObjects[68]);
+
+        CurrentStyle.SliderTextures[`SLIDER_NORMAL] = Texture2D(RepObject.ReferencedObjects[110]);
+        CurrentStyle.SliderTextures[`SLIDER_GRIP] = Texture2D(RepObject.ReferencedObjects[111]);
+        CurrentStyle.SliderTextures[`SLIDER_DISABLED] = Texture2D(RepObject.ReferencedObjects[112]);
+        
+        CurrentStyle.MenuDown = SoundCue(RepObject.ReferencedObjects[49]);
+        CurrentStyle.MenuDrag = SoundCue(RepObject.ReferencedObjects[50]);
+        CurrentStyle.MenuEdit = SoundCue(RepObject.ReferencedObjects[51]);
+        CurrentStyle.MenuFade = SoundCue(RepObject.ReferencedObjects[52]);
+        CurrentStyle.MenuClick = SoundCue(RepObject.ReferencedObjects[53]);
+        CurrentStyle.MenuHover = SoundCue(RepObject.ReferencedObjects[54]);
+        CurrentStyle.MenuUp = SoundCue(RepObject.ReferencedObjects[55]);
+        
+        DefaultPens[`PEN_WHITE] = Texture2D(RepObject.ReferencedObjects[108]);
+        DefaultPens[`PEN_BLACK] = Texture2D(RepObject.ReferencedObjects[107]);
+        DefaultPens[`PEN_GRAY] = Texture2D(RepObject.ReferencedObjects[109]);
+        
+        /*
+        CursorTextures[`CURSOR_DEFAULT] = Texture2D(RepObject.ReferencedObjects[119]);
+        CursorTextures[`CURSOR_RESIZEVERT] = Texture2D(RepObject.ReferencedObjects[120]);
+        CursorTextures[`CURSOR_RESIZEHORZ] = Texture2D(RepObject.ReferencedObjects[121]);
+        */
+        
+        bFinishedReplication = true;
+        ClearTimer('SetupStyleTextures');
+    }
+}
+
+simulated function SetupFastFontBlur()
+{
+    FastFontBlurX = RandRange(-8, 8);
+    FastFontBlurX2 = RandRange(-8, 8);
+    FastFontBlurY = RandRange(-8, 8);
+    FastFontBlurY2 = RandRange(-8, 8);
+}
+
+simulated function SetupFontBlur()
+{
+    FontBlurX = RandRange(-8, 8);
+    FontBlurX2 = RandRange(-8, 8);
+    FontBlurY = RandRange(-8, 8);
+    FontBlurY2 = RandRange(-8, 8);
+}
+
+simulated function Tick(float DT)
+{
+    Super.Tick(DT);
+    
+    DT /= WorldInfo.TimeDilation;
+    
+    CursorFade += 255 * DT * CursorStep;
+    if( CursorFade<=0 )
+    {
+        CursorFade = 0;
+        CursorStep = 1;
+    }
+    else if( CursorFade>=255 )
+    {
+        CursorFade = 255;
+        CursorStep = -1;
+    }
+
+    FastCursorFade += 8192 * DT * FastCursorStep;
+    if( FastCursorFade<=0 )
+    {
+        FastCursorFade = 0;
+        FastCursorStep = 1;
+    }
+    else if( FastCursorFade>=255 )
+    {
+        FastCursorFade = 255;
+        FastCursorStep = -1;
+    }
+}
+
+simulated function Destroyed()
+{
+    if( PlayerOwner!=None )
+        SetMenuState(false);
+}
+
+simulated function HandleDrawMenu()
+{
+    if( HackConsole==None )
+    {
+        HackConsole = new(ClientViewport)class'KFClassicHUD.KFGUIConsoleHack';
+        HackConsole.OutputObject = Self;
+    }
+    if( HackConsole!=ClientViewport.ViewportConsole )
+    {
+        OrgConsole = ClientViewport.ViewportConsole;
+        ClientViewport.ViewportConsole = HackConsole;
+        
+        // Make sure nothing overrides these settings while menu is being open.
+        // PlayerOwner.PlayerInput = CustomInput;
+    }
+}
+simulated function RenderMenu( Canvas C )
+{
+    local int i;
+    local float OrgX,OrgY,ClipX,ClipY;
+    
+    if( !bFinishedReplication || KFPlayerController(PlayerOwner).MyGFxManager.bMenusActive )
+        return;
+
+    ClientViewport.ViewportConsole = OrgConsole;
+
+    ScreenSize.X = C.SizeX;
+    ScreenSize.Y = C.SizeY;
+    CurrentStyle.Canvas = C;
+    CurrentStyle.PickDefaultFontSize(C.SizeY);
+    
+    HUDOwner.Canvas = C;
+    HUDOwner.RenderKFHUD(KFPawn_Human(PlayerOwner.Pawn));
+    
+    OrgX = C.OrgX;
+    OrgY = C.OrgY;
+    ClipX = C.ClipX;
+    ClipY = C.ClipY;
+    
+    for( i=(HUDOwner.HUDWidgets.Length-1); i>=0; --i )
+    {
+        HUDOwner.HUDWidgets[i].InputPos[0] = 0.f;
+        HUDOwner.HUDWidgets[i].InputPos[1] = 0.f;
+        HUDOwner.HUDWidgets[i].InputPos[2] = ScreenSize.X;
+        HUDOwner.HUDWidgets[i].InputPos[3] = ScreenSize.Y;
+        HUDOwner.HUDWidgets[i].Canvas = C;
+        HUDOwner.HUDWidgets[i].PreDraw();
+    }
+    
+    C.SetOrigin(OrgX,OrgY);
+    C.SetClip(ClipX,ClipY);
+
+    if( bIsInMenuState )
+    {
+        for( i=(ActiveMenus.Length-1); i>=0; --i )
+        {
+            ActiveMenus[i].bWindowFocused = (i==0);
+            ActiveMenus[i].InputPos[0] = 0.f;
+            ActiveMenus[i].InputPos[1] = 0.f;
+            ActiveMenus[i].InputPos[2] = ScreenSize.X;
+            ActiveMenus[i].InputPos[3] = ScreenSize.Y;
+            ActiveMenus[i].Canvas = C;
+            ActiveMenus[i].PreDraw();
+        }
+        if( InputFocus!=None && InputFocus.bFocusedPostDrawItem )
+        {
+            InputFocus.InputPos[0] = 0.f;
+            InputFocus.InputPos[1] = 0.f;
+            InputFocus.InputPos[2] = ScreenSize.X;
+            InputFocus.InputPos[3] = ScreenSize.Y;
+            InputFocus.Canvas = C;
+            InputFocus.PreDraw();
+        }
+        C.SetOrigin(OrgX,OrgY);
+        C.SetClip(ClipX,ClipY);
+
+        if (!bHideCursor)
+        {
+            DrawCursor(C, MousePosition.X, MousePosition.Y);
+        }
+    }
+    
+    if( OrgConsole!=None )
+        OrgConsole.PostRender_Console(C);
+    OrgConsole = None;
+}
+
+simulated function DrawCursor(Canvas C, float PosX, float PosY)
+{
+    C.SetPos(PosX, PosY);
+    C.DrawColor = CursorColor;
+    C.DrawTile(CursorTextures[CurrentCursorIndex], CurrentStyle.ScreenScale(CursorSize), CurrentStyle.ScreenScale(CursorSize), 0.f, 0.f, CursorTextures[CurrentCursorIndex].SizeX, CursorTextures[CurrentCursorIndex].SizeY,, true);
+}
+
+simulated final function InventoryChanged(optional KFWeapon Wep, optional bool bRemove)
+{
+    local int i;
+    
+    for( i=(ActiveMenus.Length-1); i>=0; --i )
+    {
+        ActiveMenus[i].InventoryChanged(Wep,bRemove);
+    }
+}
+
+simulated final function SetMenuState( bool bActive )
+{
+    if( PlayerOwner.PlayerInput==None )
+    {
+        NotifyLevelChange();
+        bActive = false;
+    }
+
+    if( bIsInMenuState==bActive )
+        return;
+    bIsInMenuState = bActive;
+    bHideCursor = !bActive;
+
+    if( bActive )
+    {
+        if( CustomInput==None )
+        {
+            CustomInput = new (KFPlayerController(PlayerOwner)) class'KFClassicHUD.KF2GUIInput';
+            CustomInput.ControllerOwner = Self;
+            CustomInput.OnReceivedNativeInputKey = ReceivedInputKey;
+            CustomInput.BaseInput = PlayerOwner.PlayerInput;
+            BackupInput = PlayerOwner.PlayerInput;
+            PlayerOwner.Interactions.AddItem(CustomInput);
+        }
+        
+        OldOnReceivedNativeInputKey = BackupInput.OnReceivedNativeInputKey;
+        OldOnReceivedNativeInputAxis = BackupInput.OnReceivedNativeInputAxis;
+        OldOnReceivedNativeInputChar = BackupInput.OnReceivedNativeInputChar;
+        
+        BackupInput.OnReceivedNativeInputKey = ReceivedInputKey;
+        BackupInput.OnReceivedNativeInputAxis = ReceivedInputAxis;
+        BackupInput.OnReceivedNativeInputChar = ReceivedInputChar;
+        
+        OldHandleInputAxis = ClientViewport.HandleInputAxis;
+        ClientViewport.HandleInputAxis = ReceivedInputAxis;
+        
+        PlayerOwner.PlayerInput = CustomInput;
+
+        if( LastMousePos != default.LastMousePos )
+            ClientViewport.SetMouse(LastMousePos.X,LastMousePos.Y);
+    }
+    else
+    {
+        LastMousePos = MousePosition;
+        
+        ClientViewport.HandleInputAxis = None;
+        
+        if( BackupInput!=None )
+        {
+            PlayerOwner.PlayerInput = BackupInput;
+            BackupInput.OnReceivedNativeInputKey = OldOnReceivedNativeInputKey;
+            BackupInput.OnReceivedNativeInputAxis = OldOnReceivedNativeInputAxis;
+            BackupInput.OnReceivedNativeInputChar = OldOnReceivedNativeInputChar;
+            
+            ClientViewport.HandleInputAxis = OldHandleInputAxis;
+        }
+        LastClickTimes[0] = 0;
+        LastClickTimes[1] = 0;
+    }
+    
+    if( !bNoInputReset )
+    {
+        PlayerOwner.PlayerInput.ResetInput();
+    }
+}
+
+simulated function NotifyLevelChange()
+{
+    local int i;
+
+    if( bIsInvalid )
+        return;
+    bIsInvalid = true;
+
+    if( InputFocus!=None )
+    {
+        InputFocus.LostInputFocus();
+        InputFocus = None;
+    }
+
+    for( i=(ActiveMenus.Length-1); i>=0; --i )
+        ActiveMenus[i].NotifyLevelChange();
+    for( i=(PersistentMenus.Length-1); i>=0; --i )
+        PersistentMenus[i].NotifyLevelChange();
+
+    SetMenuState(false);
+}
+
+simulated function MenuInput(float DeltaTime)
+{
+    local int i;
+    local vector2D V;
+
+    if( PlayerOwner.PlayerInput==None )
+    {
+        NotifyLevelChange();
+        return;
+    }
+    if( InputFocus!=None )
+        InputFocus.MenuTick(DeltaTime);
+    for( i=0; i<ActiveMenus.Length; ++i )
+        ActiveMenus[i].MenuTick(DeltaTime);
+    
+    // Check idle.
+    if( Abs(MousePosition.X-OldMousePos.X)>5.f || Abs(MousePosition.Y-OldMousePos.Y)>5.f || (bMouseWasIdle && MousePauseTime<0.5f) )
+    {
+        if( bMouseWasIdle )
+        {
+            bMouseWasIdle = false;
+            if( InputFocus!=None )
+                InputFocus.InputMouseMoved();
+        }
+        OldMousePos = MousePosition;
+        MousePauseTime = 0.f;
+    }
+    else if( !bMouseWasIdle && (MousePauseTime+=DeltaTime)>0.5f )
+    {
+        bMouseWasIdle = true;
+        if( MouseFocus!=None )
+            MouseFocus.NotifyMousePaused();
+    }
+
+    if( ActiveMenus.Length>0 )
+        MenuTime+=DeltaTime;
+        
+    V = ClientViewport.GetMousePosition();
+    
+    MousePosition.X = Clamp(V.X, 0, ScreenSize.X); 
+    MousePosition.Y = Clamp(V.Y, 0, ScreenSize.Y); 
+    
+    MouseMove();
+}
+
+simulated function MouseMove()
+{
+    local int i;
+    local KFGUI_Base F;
+
+    // Capture mouse for GUI
+    if( InputFocus!=None && InputFocus.bCanFocus )
+    {
+        if( InputFocus.CaptureMouse() )
+        {
+            F = InputFocus.GetMouseFocus();
+            if( F!=MouseFocus )
+            {
+                MousePauseTime = 0;
+                if( MouseFocus!=None )
+                    MouseFocus.MouseLeave();
+                MouseFocus = F;
+                F.MouseEnter();
+            }
+        }
+        else i = ActiveMenus.Length;
+    }
+    else
+    {
+        for( i=0; i<ActiveMenus.Length; ++i )
+        {
+            if( ActiveMenus[i].CaptureMouse() )
+            {
+                F = ActiveMenus[i].GetMouseFocus();
+                if( F!=MouseFocus )
+                {
+                    MousePauseTime = 0;
+                    if( MouseFocus!=None )
+                        MouseFocus.MouseLeave();
+                    MouseFocus = F;
+                    F.MouseEnter();
+                }
+                break;
+            }
+            else if( ActiveMenus[i].bOnlyThisFocus ) // Discard any other menus after this one.
+            {
+                i = ActiveMenus.Length;
+                break;
+            }
+        }
+    }
+    if( MouseFocus!=None && i==ActiveMenus.Length ) // Hovering over nothing.
+    {
+        MousePauseTime = 0;
+        if( MouseFocus!=None )
+            MouseFocus.MouseLeave();
+        MouseFocus = None;
+    }
+}
+
+simulated final function int GetFreeIndex( bool bNewAlwaysTop ) // Find first allowed top index of the stack.
+{
+    local int i;
+    
+    for( i=0; i<ActiveMenus.Length; ++i )
+        if( bNewAlwaysTop || !ActiveMenus[i].bAlwaysTop )
+        {
+            ActiveMenus.Insert(i,1);
+            return i;
+        }
+    i = ActiveMenus.Length;
+    ActiveMenus.Length = i+1;
+    return i;
+}
+simulated function KFGUI_Base InitializeHUDWidget( class<KFGUI_Base> GUIClass )
+{
+    local KFGUI_Base Widget;
+    
+    if( GUIClass==None )
+        return None;
+        
+    Widget = New(None) GUIClass;
+
+    if( Widget==None )
+        return None;
+        
+    HUDOwner.HUDWidgets.AddItem(Widget);
+        
+    Widget.Owner = Self;
+    Widget.HUDOwner = HUDOwner;
+    Widget.InitMenu();
+    Widget.ShowMenu();
+    Widget.bIsHUDWidget = true;
+    
+    return Widget;
+}
+simulated function KFGUI_Page OpenMenu( class<KFGUI_Page> MenuClass )
+{
+    local int i;
+    local KFGUI_Page M;
+    
+    if( MenuClass==None )
+        return None;
+
+    if( KeyboardFocus!=None )
+        GrabInputFocus(None);
+    if( InputFocus!=None )
+    {
+        InputFocus.LostInputFocus();
+        InputFocus = None;
+    }
+
+    // Enable mouse on UI if disabled.
+    SetMenuState(true);
+    
+    // Check if should use pre-excisting menu.
+    if( MenuClass.Default.bUnique )
+    {
+        for( i=0; i<ActiveMenus.Length; ++i )
+            if( ActiveMenus[i].Class==MenuClass )
+            {
+                if( i>0 && ActiveMenus[i].BringPageToFront() ) // Sort it upfront.
+                {
+                    M = ActiveMenus[i];
+                    ActiveMenus.Remove(i,1);
+                    i = GetFreeIndex(M.bAlwaysTop);
+                    ActiveMenus[i] = M;
+                }
+                return M;
+            }
+        
+        if( MenuClass.Default.bPersistant )
+        {
+            for( i=0; i<PersistentMenus.Length; ++i )
+                if( PersistentMenus[i].Class==MenuClass )
+                {
+                    M = PersistentMenus[i];
+                    PersistentMenus.Remove(i,1);
+                    i = GetFreeIndex(M.bAlwaysTop);
+                    ActiveMenus[i] = M;
+                    M.ShowMenu();
+                    return M;
+                }
+        }
+    }
+    M = New(None)MenuClass;
+
+    if( M==None ) // Probably abstract class.
+        return None;
+    
+    i = GetFreeIndex(M.bAlwaysTop);
+    ActiveMenus[i] = M;
+    M.Owner = Self;
+    M.InitMenu();
+    M.ShowMenu();
+    return M;
+}
+simulated function CloseMenu( class<KFGUI_Page> MenuClass, optional bool bCloseAll )
+{
+    local int i, j;
+    local KFGUI_Page M;
+
+    if( !bCloseAll && MenuClass==None )
+        return;
+    
+    if( KeyboardFocus!=None )
+        GrabInputFocus(None);
+    if( InputFocus!=None )
+    {
+        InputFocus.LostInputFocus();
+        InputFocus = None;
+    }
+    for( i=(ActiveMenus.Length-1); i>=0; --i )
+    {
+        if( bCloseAll || ActiveMenus[i].Class==MenuClass )
+        {
+            M = ActiveMenus[i];
+            ActiveMenus.Remove(i,1);
+            M.CloseMenu();
+            
+            for( j=0; j<M.TimerNames.Length; j++ )
+            {
+                M.ClearTimer(M.TimerNames[j]);
+            }
+            
+            // Cache menu.
+            if( M.bPersistant && M.bUnique )
+                PersistentMenus[PersistentMenus.Length] = M;
+        }
+    }
+    if( ActiveMenus.Length==0 )
+    {
+        SetMenuState(false);
+    }
+}
+simulated function PopCloseMenu( KFGUI_Base Item )
+{
+    local int i;
+    local KFGUI_Page M;
+
+    if( Item==None )
+        return;
+        
+    if( Item.bIsHUDWidget )
+    {
+        HUDOwner.HUDWidgets.RemoveItem(Item);
+        Item.CloseMenu();
+        return;
+    }
+    
+    if( KeyboardFocus!=None )
+        GrabInputFocus(None);
+    if( InputFocus!=None )
+    {
+        InputFocus.LostInputFocus();
+        InputFocus = None;
+    }
+    for( i=(ActiveMenus.Length-1); i>=0; --i )
+        if( ActiveMenus[i]==Item )
+        {
+            M = ActiveMenus[i];
+            ActiveMenus.Remove(i,1);
+            M.CloseMenu();
+            
+            // Cache menu.
+            if( M.bPersistant && M.bUnique )
+                PersistentMenus[PersistentMenus.Length] = M;
+            break;
+        }
+    if( ActiveMenus.Length==0 )
+        SetMenuState(false);
+}
+simulated function BringMenuToFront( KFGUI_Page Page )
+{
+    local int i;
+    
+    if( ActiveMenus[0].bAlwaysTop && !Page.bAlwaysTop )
+        return; // Can't override this menu.
+
+    // Try to remove from current position at stack.
+    for( i=(ActiveMenus.Length-1); i>=0; --i )
+        if( ActiveMenus[i]==Page )
+        {
+            ActiveMenus.Remove(i,1);
+            break;
+        }
+    if( i==-1 )
+        return; // Page isn't open.
+    
+    // Put on front of stack.
+    ActiveMenus.Insert(0,1);
+    ActiveMenus[0] = Page;
+}
+simulated final function bool MenuIsOpen( optional class<KFGUI_Page> MenuClass )
+{
+    local int i;
+    
+    for( i=(ActiveMenus.Length-1); i>=0; --i )
+        if( MenuClass==None || ActiveMenus[i].Class==MenuClass )
+            return true;
+    return false;
+}
+simulated final function GrabInputFocus( KFGUI_Base Comp, optional bool bForce )
+{
+    if( Comp==KeyboardFocus && !bForce )
+        return;
+
+    if( KeyboardFocus!=None )
+        KeyboardFocus.LostKeyFocus();
+
+    if( Comp==None )
+    {
+        OnInputKey = InternalInputKey;
+        OnReceivedInputChar = InternalReceivedInputChar;
+    }
+    else if( KeyboardFocus==None )
+    {
+        OnInputKey = Comp.NotifyInputKey;
+        OnReceivedInputChar = Comp.NotifyInputChar;
+        OnReceivedInputAxis = Comp.NotifyInputAxis;
+    }
+    KeyboardFocus = Comp;
+}
+
+simulated final function GUI_InputMouse( bool bPressed, bool bRight )
+{
+    local byte i;
+
+    MousePauseTime = 0;
+    
+    if( bPressed )
+    {
+        if( KeyboardFocus!=None && KeyboardFocus!=MouseFocus )
+        {
+            GrabInputFocus(None);
+            LastClickTimes[0] = 0;
+            LastClickTimes[1] = 0;
+        }
+        if( MouseFocus!=None )
+        {
+            if( MouseFocus!=InputFocus && !MouseFocus.bClickable && !MouseFocus.IsTopMenu() && MouseFocus.BringPageToFront() )
+            {
+                BringMenuToFront(MouseFocus.GetPageTop());
+                LastClickTimes[0] = 0;
+                LastClickTimes[1] = 0;
+            }
+            else
+            {
+                i = byte(bRight);
+                if( (MenuTime-LastClickTimes[i])<0.2 && Abs(LastClickPos[i].X-MousePosition.X)<5 && Abs(LastClickPos[i].Y-MousePosition.Y)<5 )
+                {
+                    LastClickTimes[i] = 0;
+                    MouseFocus.DoubleMouseClick(bRight);
+                }
+                else
+                {
+                    MouseFocus.MouseClick(bRight);
+                    LastClickTimes[i] = MenuTime;
+                    LastClickPos[i] = MousePosition;
+                }
+            }
+        }
+        else if( InputFocus!=None )
+        {
+            InputFocus.LostInputFocus();
+            InputFocus = None;
+            LastClickTimes[0] = 0;
+            LastClickTimes[1] = 0;
+        }
+    }
+    else
+    {
+        if( InputFocus!=None )
+            InputFocus.MouseRelease(bRight);
+        else if( MouseFocus!=None )
+            MouseFocus.MouseRelease(bRight);
+    }
+}
+simulated final function bool CheckMouse( name Key, EInputEvent Event )
+{
+    if ( Event == IE_Pressed )
+    {
+        switch( Key )
+        {
+        case 'XboxTypeS_A':
+        case 'LeftMouseButton':
+            GUI_InputMouse(true,false);
+            return true;
+        case 'XboxTypeS_B':
+        case 'RightMouseButton':
+            GUI_InputMouse(true,true);
+            return true;
+        }
+    }
+    else if ( Event == IE_Released )
+    {
+        switch( Key )
+        {
+        case 'XboxTypeS_A':
+        case 'LeftMouseButton':
+            GUI_InputMouse(false,false);
+            return true;
+        case 'XboxTypeS_B':
+        case 'RightMouseButton':
+            GUI_InputMouse(false,true);
+            return true;
+        }
+    }
+    return false;
+}
+simulated function bool ReceivedInputKey( int ControllerId, name Key, EInputEvent Event, optional float AmountDepressed=1.f, optional bool bGamepad )
+{
+    local KFPlayerInput KFInput;
+    local KeyBind BoundKey;
+    
+    if( !bIsInMenuState )
+        return false;
+        
+    bUsingGamepad = bGamepad;
+        
+    KFInput = KFPlayerInput(BackupInput);
+    if( KFInput == None )
+    {
+        KFInput = KFPlayerInput(PlayerOwner.PlayerInput);
+    }
+        
+    if( KeyboardFocus == None )
+    {
+        if( KFInput != None )
+        {    
+            KFInput.GetKeyBindFromCommand(BoundKey, "GBA_VoiceChat", false);    
+            if( string(Key) ~= KFInput.GetBindDisplayName(BoundKey) )
+            {
+                if( Event == IE_Pressed )
+                {
+                    KFInput.StartVoiceChat(true);
+                }
+                else if( Event == IE_Released )
+                {
+                    KFInput.StopVoiceChat();
+                }
+                
+                return true;
+            }
+        }
+    }
+
+    if( !CheckMouse(Key,Event) && !OnInputKey(ControllerId,Key,Event,AmountDepressed,bGamepad) )
+    {
+        if( bGamepad )
+        {
+            if( ActiveMenus[0].ReceievedControllerInput(ControllerId, Key, Event) )
+                return true;
+        }
+    
+        switch( Key )
+        {
+        case 'XboxTypeS_Start':
+        case 'Escape':
+            if( Event==IE_Pressed )
+                ActiveMenus[0].UserPressedEsc(); // Pop top menu if possible. // IE_Released
+            return true;
+        case 'XboxTypeS_DPad_Up':
+        case 'XboxTypeS_DPad_Down':
+        case 'XboxTypeS_DPad_Left':
+        case 'XboxTypeS_DPad_Right':
+        case 'MouseScrollDown':
+        case 'MouseScrollUp':
+            if( Event==IE_Pressed && MouseFocus!=None )
+                MouseFocus.ScrollMouseWheel(Key=='MouseScrollUp' || Key=='XboxTypeS_DPad_Up' || Key=='XboxTypeS_DPad_Left');
+            return true;
+        }
+        
+        return bAbsorbInput;
+    }
+    
+    return true;
+}
+simulated function bool ReceivedInputAxis( int ControllerId, name Key, float Delta, float DeltaTime, bool bGamepad )
+{
+    local Vector2D V;
+    local KFPlayerInput KFInput;
+    local float GamepadSensitivity,OldMouseX,OldMouseY,MoveDelta,MoveDeltaInvert;
+    
+    if( !bIsInMenuState )
+        return false;
+        
+    if( bGamepad  )
+    {
+        if( Abs(Delta) > 0.2f )
+        {
+            bUsingGamepad = true;
+            
+            V = ClientViewport.GetMousePosition();
+            OldMouseX = V.X;
+            OldMouseY = V.Y;
+            
+            KFInput = KFPlayerInput(BackupInput);
+            GamepadSensitivity = KFInput.GamepadSensitivityScale * 10;
+            MoveDelta = Delta * (KFInput.bInvertController ? -GamepadSensitivity : GamepadSensitivity);
+            MoveDeltaInvert = Delta * (KFInput.bInvertController ? GamepadSensitivity : -GamepadSensitivity);
+            
+            switch(Key)
+            {
+                case 'XboxTypeS_LeftX':
+                case 'XboxTypeS_RightX':
+                    if( Delta < 0 )
+                        V.X = Clamp(V.X - MoveDeltaInvert, 0, ScreenSize.X);
+                    else V.X = Clamp(V.X + MoveDelta, 0, ScreenSize.X);
+                    break;
+                case 'XboxTypeS_LeftY':
+                    if( Delta < 0 )
+                        V.Y = Clamp(V.Y + MoveDeltaInvert, 0, ScreenSize.Y);
+                    else V.Y = Clamp(V.Y - MoveDelta, 0, ScreenSize.Y);
+                    break;
+                case 'XboxTypeS_RightY':
+                    if( Delta < 0 )
+                        V.Y = Clamp(V.Y - MoveDeltaInvert, 0, ScreenSize.Y);
+                    else V.Y = Clamp(V.Y + MoveDelta, 0, ScreenSize.Y);
+                    break;
+            }
+            
+            if( OldMouseX != V.X || OldMouseY != V.Y )
+                ClientViewport.SetMouse(V.X, V.Y);
+        }
+    }
+    return OnReceivedInputAxis(ControllerId, Key, Delta, DeltaTime, bGamepad);
+}
+simulated function bool ReceivedInputChar( int ControllerId, string Unicode )
+{
+    if( !bIsInMenuState )
+        return false;
+    return OnReceivedInputChar(ControllerId,Unicode);
+}
+
+simulated Delegate bool OnInputKey( int ControllerId, name Key, EInputEvent Event, optional float AmountDepressed=1.f, optional bool bGamepad )
+{
+    return false;
+}
+simulated Delegate bool OnReceivedInputAxis( int ControllerId, name Key, float Delta, float DeltaTime, bool bGamepad )
+{
+    return false;
+}
+simulated Delegate bool OnReceivedInputChar( int ControllerId, string Unicode )
+{
+    return false;
+}
+simulated Delegate bool InternalInputKey( int ControllerId, name Key, EInputEvent Event, optional float AmountDepressed=1.f, optional bool bGamepad )
+{
+    return false;
+}
+simulated Delegate bool InternalReceivedInputChar( int ControllerId, string Unicode )
+{
+    return false;
+}
+
+defaultproperties
+{
+    CursorSize=24
+    CursorColor=(R=255,G=255,B=255,A=255)
+    CursorTextures[`CURSOR_DEFAULT]=Texture2D'UI_Managers.LoaderManager_SWF_I13'
+    CurrentCursorIndex=`CURSOR_DEFAULT
+    
+    DefaultStyle=class'ClassicStyle'
+    bAbsorbInput=false
+    bAlwaysTick=true
+    bHideCursor=true
+}

Src/KFClassicHUD/Classes/KF2GUIInput.uc

@@ -0,0 +1,62 @@
+// Input while in a menu.
+class KF2GUIInput extends KFPlayerInput;
+
+var KF2GUIController ControllerOwner;
+var PlayerInput BaseInput;
+
+function DrawHUD( HUD H )
+{
+    //ControllerOwner.RenderMenu(H.Canvas);
+}
+function PostRender( Canvas Canvas )
+{
+    if( ControllerOwner.bIsInMenuState )
+        ControllerOwner.HandleDrawMenu();
+        //ControllerOwner.RenderMenu(Canvas);
+}
+
+// Postprocess the player's input.
+function PlayerInput( float DeltaTime )
+{
+    // Do not move.
+    ControllerOwner.MenuInput(DeltaTime);
+    
+    if( !ControllerOwner.bAbsorbInput )
+    {
+        aMouseX = 0;
+        aMouseY = 0;
+        aBaseX = BaseInput.aBaseX;
+        aBaseY = BaseInput.aBaseY;
+        aBaseZ = BaseInput.aBaseZ;
+        aForward = BaseInput.aForward;
+        aTurn = BaseInput.aTurn;
+        aStrafe = BaseInput.aStrafe;
+        aUp = BaseInput.aUp;
+        aLookUp = BaseInput.aLookUp;
+        Super.PlayerInput(DeltaTime);
+    }
+    else
+    {
+        aMouseX = 0;
+        aMouseY = 0;
+        aBaseX = 0;
+        aBaseY = 0;
+        aBaseZ = 0;
+        aForward = 0;
+        aTurn = 0;
+        aStrafe = 0;
+        aUp = 0;
+        aLookUp = 0;
+    }
+}
+
+function PreClientTravel( string PendingURL, ETravelType TravelType, bool bIsSeamlessTravel)
+{
+    `Log("PreClientTravel"@PendingURL@TravelType@bIsSeamlessTravel);
+    ControllerOwner.BackupInput.PreClientTravel(PendingURL,TravelType,bIsSeamlessTravel); // Let original mod do stuff too!
+    ControllerOwner.NotifyLevelChange(); // Close menu NOW!
+}
+
+defaultproperties
+{
+}

Src/KFClassicHUD/Classes/KF2Style.uc

@@ -0,0 +1,452 @@
+Class KF2Style extends GUIStyleBase;
+
+var Texture2D LoadedTex[2];
+const TOOLTIP_BORDER=4;
+
+function InitStyle()
+{
+    local byte i;
+
+    Super.InitStyle();
+    
+    LoadedTex[0] = Texture2D(DynamicLoadObject("EditorMaterials.CASC_ModuleEnable",class'Texture2D'));
+    LoadedTex[1] = Texture2D(DynamicLoadObject("EditorMaterials.Tick",class'Texture2D'));
+    for( i=0; i<ArrayCount(LoadedTex); ++i )
+    {
+        if( LoadedTex[i]==None )
+            LoadedTex[i] = Texture2D'EngineMaterials.DefaultWhiteGrid';
+    }
+}
+function RenderFramedWindow( KFGUI_FloatingWindow P )
+{
+    local int XS,YS,CornerSlope,TitleHeight;
+    
+    XS = Canvas.ClipX-Canvas.OrgX;
+    YS = Canvas.ClipY-Canvas.OrgY;
+    CornerSlope = DefaultHeight*0.4;
+    TitleHeight = DefaultHeight;
+
+    // Frame Header
+    if( P.bWindowFocused )
+        Canvas.SetDrawColor(220,2,2,255);
+    else Canvas.SetDrawColor(100,1,1,P.FrameOpacity);
+    Canvas.SetPos(0,0);
+    DrawCornerTex(CornerSlope,0);
+    Canvas.SetPos(0,TitleHeight);
+    DrawCornerTex(CornerSlope,3);
+    Canvas.SetPos(XS-CornerSlope,0);
+    DrawCornerTex(CornerSlope,1);
+    Canvas.SetPos(XS-CornerSlope,TitleHeight);
+    DrawCornerTex(CornerSlope,2);
+    
+    // Header filling
+    Canvas.SetPos(0,CornerSlope);
+    DrawWhiteBox(XS,TitleHeight-CornerSlope);
+    Canvas.SetPos(CornerSlope,0);
+    DrawWhiteBox(XS-(CornerSlope*2),CornerSlope);
+    
+    // Frame itself.
+    if( P.bWindowFocused )
+        Canvas.SetDrawColor(32,6,6,255);
+    else Canvas.SetDrawColor(16,2,2,P.FrameOpacity);
+    Canvas.SetPos(0,TitleHeight);
+    DrawCornerTex(CornerSlope,0);
+    Canvas.SetPos(XS-CornerSlope,TitleHeight);
+    DrawCornerTex(CornerSlope,1);
+    Canvas.SetPos(0,YS-CornerSlope);
+    DrawCornerTex(CornerSlope,2);
+    Canvas.SetPos(XS-CornerSlope,YS-CornerSlope);
+    DrawCornerTex(CornerSlope,3);
+    
+    // Filling
+    Canvas.SetPos(CornerSlope,TitleHeight);
+    DrawWhiteBox(XS-(CornerSlope*2),YS-TitleHeight);
+    Canvas.SetPos(0,TitleHeight+CornerSlope);
+    DrawWhiteBox(CornerSlope,YS-(CornerSlope*2)-TitleHeight);
+    Canvas.SetPos(XS-CornerSlope,TitleHeight+CornerSlope);
+    DrawWhiteBox(CornerSlope,YS-(CornerSlope*2)-TitleHeight);
+    
+    // Title.
+    if( P.WindowTitle!="" )
+    {
+        Canvas.SetDrawColor(250,250,250,P.FrameOpacity);
+        Canvas.SetPos(CornerSlope,0);
+        DrawText(P.WindowTitle);
+    }
+}
+function RenderWindow( KFGUI_Page P )
+{
+    local int XS,YS,CornerSlope;
+    
+    XS = Canvas.ClipX-Canvas.OrgX;
+    YS = Canvas.ClipY-Canvas.OrgY;
+    CornerSlope = DefaultHeight*0.4;
+
+    // Frame itself.
+    if( P.bWindowFocused )
+        Canvas.SetDrawColor(64,64,64,255);
+    else Canvas.SetDrawColor(32,32,32,P.FrameOpacity);
+    Canvas.SetPos(0,0);
+    DrawCornerTex(CornerSlope,0);
+    Canvas.SetPos(XS-CornerSlope,0);
+    DrawCornerTex(CornerSlope,1);
+    Canvas.SetPos(0,YS-CornerSlope);
+    DrawCornerTex(CornerSlope,2);
+    Canvas.SetPos(XS-CornerSlope,YS-CornerSlope);
+    DrawCornerTex(CornerSlope,3);
+    
+    // Filling
+    Canvas.SetPos(CornerSlope,0);
+    DrawWhiteBox(XS-(CornerSlope*2),YS);
+    Canvas.SetPos(0,CornerSlope);
+    DrawWhiteBox(CornerSlope,YS-(CornerSlope*2));
+    Canvas.SetPos(XS-CornerSlope,CornerSlope);
+    DrawWhiteBox(CornerSlope,YS-(CornerSlope*2));
+}
+function RenderToolTip( KFGUI_Tooltip TT )
+{
+    local int i;
+    local float X,Y,XS,YS,TX,TY,TS,DefFontHeight;
+
+    Canvas.Font = PickFont(TS);
+
+    // First compute textbox size.
+    TY = DefaultHeight*TT.Lines.Length;
+    for( i=0; i<TT.Lines.Length; ++i )
+    {
+        if( TT.Lines[i]!="" )
+            Canvas.TextSize(TT.Lines[i],XS,YS);
+        TX = FMax(XS,TX);
+    }
+    TX*=TS;
+    
+    // Give some borders.
+    TX += TOOLTIP_BORDER*2;
+    TY += TOOLTIP_BORDER*2;
+
+    X = TT.CompPos[0];
+    Y = TT.CompPos[1]+24.f;
+
+    // Then check if too close to window edge, then move it to another pivot.
+    if( (X+TX)>TT.Owner.ScreenSize.X )
+        X = TT.Owner.ScreenSize.X-TX;
+    if( (Y+TY)>TT.Owner.ScreenSize.Y )
+        Y = TT.CompPos[1]-TY;
+    
+    if( TT.CurrentAlpha<255 )
+        TT.CurrentAlpha = Min(TT.CurrentAlpha+25,255);
+
+    // Reset clipping.
+    Canvas.SetOrigin(0,0);
+    Canvas.SetClip(TT.Owner.ScreenSize.X,TT.Owner.ScreenSize.Y);
+
+    // Draw frame.
+    Canvas.SetDrawColor(200,200,80,TT.CurrentAlpha);
+    Canvas.SetPos(X-2,Y-2);
+    DrawBoxHollow(X-2,Y-2,TX+4,TY+4,2);
+    Canvas.SetDrawColor(80,10,80,TT.CurrentAlpha);
+    Canvas.SetPos(X,Y);
+    DrawWhiteBox(TX,TY);
+    
+    DefFontHeight = DefaultHeight;
+
+    // Draw text.
+    Canvas.SetDrawColor(255,255,255,TT.CurrentAlpha);
+    X+=TOOLTIP_BORDER;
+    Y+=TOOLTIP_BORDER;
+    for( i=0; i<TT.Lines.Length; ++i )
+    {
+        Canvas.SetPos(X,Y);
+        Canvas.DrawText(TT.Lines[i],,TS,TS,TT.TextFontInfo);
+        Y+=DefFontHeight;
+    }
+}
+function RenderScrollBar( KFGUI_ScrollBarBase S )
+{
+    local float A;
+    local byte i;
+
+    if( S.bDisabled )
+        Canvas.SetDrawColor(5, 5, 5, 0);
+    else if( S.bFocused || S.bGrabbedScroller )
+        Canvas.SetDrawColor(15, 15, 15, 160);
+    else Canvas.SetDrawColor(15, 15, 15, 160);
+
+    DrawRectBox (0.f, 0.f, S.CompPos[2], S.CompPos[3], 4);
+    
+    if( S.bDisabled )
+        return;
+
+    if( S.bVertical )
+        i = 3;
+    else i = 2;
+    
+    S.SliderScale = FMax(S.PageStep * (S.CompPos[i] - 32.f) / (S.MaxRange + S.PageStep),S.CalcButtonScale);
+    
+    if( S.bGrabbedScroller )
+    {
+        // Track mouse.
+        if( S.bVertical )
+            A = S.Owner.MousePosition.Y - S.CompPos[1] - S.GrabbedOffset;
+        else A = S.Owner.MousePosition.X - S.CompPos[0] - S.GrabbedOffset;
+        
+        A /= ((S.CompPos[i]-S.SliderScale) / float(S.MaxRange));
+        S.SetValue(A);
+    }
+
+    A = float(S.CurrentScroll) / float(S.MaxRange);
+    S.ButtonOffset = A*(S.CompPos[i]-S.SliderScale);
+
+    if( S.bGrabbedScroller )
+        Canvas.SetDrawColor(255,0,0,200);
+    else if( S.bFocused )
+        Canvas.SetDrawColor(200,0,0,200);
+    else Canvas.SetDrawColor(150,0,0,200);
+
+    if( S.bVertical )
+        DrawRectBox (0.f, S.ButtonOffset, S.CompPos[2], S.SliderScale, 4);
+    else DrawRectBox (S.ButtonOffset, 0.f, S.SliderScale, S.CompPos[3], 4);
+}
+function RenderColumnHeader( KFGUI_ColumnTop C, float XPos, float Width, int Index, bool bFocus, bool bSort )
+{
+    local int XS;
+
+    if( bSort )
+    {
+        if( bFocus )
+            Canvas.SetDrawColor(175,240,8,255);
+        else Canvas.SetDrawColor(128,200,56,255);
+    }
+    else if( bFocus )
+        Canvas.SetDrawColor(220,220,8,255);
+    else Canvas.SetDrawColor(220,86,56,255);
+
+    XS = DefaultHeight*0.125;
+    Canvas.SetPos(XPos,0.f);
+    DrawCornerTexNU(XS,C.CompPos[3],0);
+    Canvas.SetPos(XPos+XS,0.f);
+    DrawWhiteBox(Width-(XS*2),C.CompPos[3]);
+    Canvas.SetPos(XPos+Width-(XS*2),0.f);
+    DrawCornerTexNU(XS,C.CompPos[3],1);
+    
+    Canvas.SetDrawColor(250,250,250,255);
+    Canvas.SetPos(XPos+XS,(C.CompPos[3]-C.ListOwner.TextHeight)*0.5f);
+    C.ListOwner.DrawStrClipped(C.ListOwner.Columns[Index].Text);
+}
+function RenderCheckbox( KFGUI_CheckBox C )
+{
+    if( C.bDisabled )
+        Canvas.SetDrawColor(86,86,86,255);
+    else if( C.bPressedDown )
+        Canvas.SetDrawColor(128,255,128,255);
+    else if( C.bFocused )
+        Canvas.SetDrawColor(150,200,128,255);
+    else Canvas.SetDrawColor(128,186,128,255);
+    
+    Canvas.SetPos(0.f,0.f);
+    Canvas.DrawTileStretched(LoadedTex[0],C.CompPos[2],C.CompPos[3],0,0,LoadedTex[0].GetSurfaceWidth(),LoadedTex[0].GetSurfaceHeight());
+
+    if( C.bChecked )
+    {
+        if( C.bDisabled )
+            Canvas.SetDrawColor(128,128,128,255);
+        else Canvas.SetDrawColor(255,255,255,255);
+        Canvas.SetPos(0.f,0.f);
+        Canvas.DrawTile(LoadedTex[1],C.CompPos[2],C.CompPos[3],0,0,LoadedTex[1].GetSurfaceWidth(),LoadedTex[1].GetSurfaceHeight());
+    }
+}
+function RenderComboBox( KFGUI_ComboBox C )
+{
+    if( C.bDisabled )
+        Canvas.SetDrawColor(64,4,4,255);
+    else if( C.bPressedDown )
+        Canvas.SetDrawColor(220,56,56,255);
+    else if( C.bFocused )
+        Canvas.SetDrawColor(190,48,48,255);
+    else Canvas.SetDrawColor(186,4,4,255);
+    
+    Canvas.SetPos(0.f,0.f);
+    DrawWhiteBox(C.CompPos[2],C.CompPos[3]);
+
+    if( C.SelectedIndex<C.Values.Length && C.Values[C.SelectedIndex]!="" )
+    {
+        Canvas.SetPos(C.BorderSize,(C.CompPos[3]-C.TextHeight)*0.5);
+        if( C.bDisabled )
+            Canvas.DrawColor = C.TextColor*0.5f;
+        else Canvas.DrawColor = C.TextColor;
+        Canvas.PushMaskRegion(Canvas.OrgX,Canvas.OrgY,Canvas.ClipX-C.BorderSize,Canvas.ClipY);
+        Canvas.DrawText(C.Values[C.SelectedIndex],,C.TextScale,C.TextScale,C.TextFontInfo);
+        Canvas.PopMaskRegion();
+    }
+}
+function RenderComboList( KFGUI_ComboSelector C )
+{
+    local float X,Y,YL,YP,Edge;
+    local int i;
+    local bool bCheckMouse;
+    
+    // Draw background.
+    Edge = C.Combo.BorderSize;
+    Canvas.SetPos(0.f,0.f);
+    Canvas.SetDrawColor(128,4,4,255);
+    DrawWhiteBox(C.CompPos[2],C.CompPos[3]);
+    Canvas.SetPos(Edge,Edge);
+    Canvas.SetDrawColor(64,4,4,255);
+    DrawWhiteBox(C.CompPos[2]-(Edge*2.f),C.CompPos[3]-(Edge*2.f));
+
+    // While rendering, figure out mouse focus row.
+    X = C.Owner.MousePosition.X - Canvas.OrgX;
+    Y = C.Owner.MousePosition.Y - Canvas.OrgY;
+    
+    bCheckMouse = (X>0.f && X<C.CompPos[2] && Y>0.f && Y<C.CompPos[3]);
+    
+    Canvas.Font = C.Combo.TextFont;
+    YL = C.Combo.TextHeight;
+
+    YP = Edge;
+    C.CurrentRow = -1;
+
+    Canvas.PushMaskRegion(Canvas.OrgX,Canvas.OrgY,Canvas.ClipX,Canvas.ClipY);
+    for( i=0; i<C.Combo.Values.Length; ++i )
+    {
+        if( bCheckMouse && Y>=YP && Y<=(YP+YL) )
+        {
+            bCheckMouse = false;
+            C.CurrentRow = i;
+            Canvas.SetPos(4.f,YP);
+            Canvas.SetDrawColor(128,48,48,255);
+            DrawWhiteBox(C.CompPos[2]-(Edge*2.f),YL);
+        }
+        Canvas.SetPos(Edge,YP);
+        
+        if( i==C.Combo.SelectedIndex )
+            Canvas.DrawColor = C.Combo.SelectedTextColor;
+        else Canvas.DrawColor = C.Combo.TextColor;
+
+        Canvas.DrawText(C.Combo.Values[i],,C.Combo.TextScale,C.Combo.TextScale,C.Combo.TextFontInfo);
+        
+        YP+=YL;
+    }
+    Canvas.PopMaskRegion();
+    if( C.OldRow!=C.CurrentRow )
+    {
+        C.OldRow = C.CurrentRow;
+        C.PlayMenuSound(MN_DropdownChange);
+    }
+}
+function RenderRightClickMenu( KFGUI_RightClickMenu C )
+{
+    local float X,Y,YP,Edge,TextScale,TexDefHieght;
+    local int i;
+    local bool bCheckMouse;
+    
+    // Draw background.
+    Edge = C.EdgeSize;
+    Canvas.SetDrawColor(148,4,4,255);
+    DrawBoxHollow(0.f,0.f,C.CompPos[2],C.CompPos[3],Edge);
+    Canvas.SetPos(Edge,Edge);
+    Canvas.SetDrawColor(64,4,4,200);
+    DrawWhiteBox(C.CompPos[2]-(Edge*2.f),C.CompPos[3]-(Edge*2.f));
+
+    // While rendering, figure out mouse focus row.
+    X = C.Owner.MousePosition.X - Canvas.OrgX;
+    Y = C.Owner.MousePosition.Y - Canvas.OrgY;
+    
+    bCheckMouse = (X>0.f && X<C.CompPos[2] && Y>0.f && Y<C.CompPos[3]);
+    
+    Canvas.Font = PickFont(TextScale);
+
+    YP = Edge;
+    C.CurrentRow = -1;
+
+    TexDefHieght = DefaultHeight;
+
+    Canvas.PushMaskRegion(Canvas.OrgX,Canvas.OrgY,Canvas.ClipX,Canvas.ClipY);
+    for( i=0; i<C.ItemRows.Length; ++i )
+    {
+        if( bCheckMouse && Y>=YP && Y<=(YP+TexDefHieght) )
+        {
+            bCheckMouse = false;
+            C.CurrentRow = i;
+            Canvas.SetPos(4.f,YP);
+            Canvas.SetDrawColor(128,48,48,255);
+            DrawWhiteBox(C.CompPos[2]-(Edge*2.f),TexDefHieght);
+        }
+
+        Canvas.SetPos(Edge,YP);
+        if( C.ItemRows[i].bSplitter )
+        {
+            Canvas.SetDrawColor(0,0,0,255);
+            Canvas.DrawText("-------",,TextScale,TextScale);
+        }
+        else
+        {
+            if( C.ItemRows[i].bDisabled )
+                Canvas.SetDrawColor(148,148,148,255);
+            else Canvas.SetDrawColor(248,248,248,255);
+            Canvas.DrawText(C.ItemRows[i].Text,,TextScale,TextScale);
+        }
+        
+        YP+=TexDefHieght;
+    }
+    Canvas.PopMaskRegion();
+    if( C.OldRow!=C.CurrentRow )
+    {
+        C.OldRow = C.CurrentRow;
+        C.PlayMenuSound(MN_DropdownChange);
+    }
+}
+function RenderButton( KFGUI_Button B )
+{
+    local float XL,YL,TS;
+    local byte i;
+
+    if( B.bDisabled )
+        Canvas.SetDrawColor(32,0,0,255);
+    else if( B.bPressedDown )
+        Canvas.SetDrawColor(255,64,64,255);
+    else if( B.bFocused )
+        Canvas.SetDrawColor(180,45,45,255);
+    else Canvas.SetDrawColor(164,8,8,255);
+    
+    if( B.bIsHighlighted )
+    {
+        Canvas.DrawColor.R = Min(Canvas.DrawColor.R+25,255);
+        Canvas.DrawColor.G = Min(Canvas.DrawColor.G+25,255);
+        Canvas.DrawColor.B = Min(Canvas.DrawColor.B+25,255);
+    }
+
+    Canvas.SetPos(0.f,0.f);
+    if( B.ExtravDir==255 )
+        DrawWhiteBox(B.CompPos[2],B.CompPos[3]);
+    else DrawRectBox(0,0,B.CompPos[2],B.CompPos[3],Min(B.CompPos[2],B.CompPos[3])*0.2,B.ExtravDir);
+
+    if( B.OverlayTexture.Texture!=None )
+    {
+        Canvas.SetPos(0.f,0.f);
+        Canvas.DrawTile(B.OverlayTexture.Texture,B.CompPos[2],B.CompPos[3],B.OverlayTexture.U,B.OverlayTexture.V,B.OverlayTexture.UL,B.OverlayTexture.VL);
+    }
+    if( B.ButtonText!="" )
+    {
+        // Chose the best font to fit this button.
+        i = Min(B.FontScale,MaxFontScale);
+        while( true )
+        {
+            Canvas.Font = PickFont(TS);
+            Canvas.TextSize(B.ButtonText,XL,YL,TS,TS);
+            if( i==0 || (XL<(B.CompPos[2]*0.95) && YL<(B.CompPos[3]*0.95)) )
+                break;
+            --i;
+        }
+        Canvas.SetPos((B.CompPos[2]-XL)*0.5,(B.CompPos[3]-YL)*0.5);
+        if( B.bDisabled )
+            Canvas.DrawColor = B.TextColor*0.5f;
+        else Canvas.DrawColor = B.TextColor;
+        Canvas.DrawText(B.ButtonText,,TS,TS,B.TextFontInfo);
+    }
+}
+
+defaultproperties
+{
+    MaxFontScale=5
+}

Src/KFClassicHUD/Classes/KFColorHelper.uc

@@ -0,0 +1,120 @@
+//All code here was done by Mr Evil.
+class KFColorHelper extends Object
+    transient;
+
+struct HSVColour
+{
+    var() float H, S, V, A;
+
+    structdefaultproperties
+    {
+        A=1.0
+    }
+};
+
+static final function HSVColour RGBToHSV(const LinearColor RGB)
+{
+    local float Max;
+    local float Min;
+    local float Chroma;
+    local HSVColour HSV;
+
+    Min = FMin(FMin(RGB.R, RGB.G), RGB.B);
+    Max = FMax(FMax(RGB.R, RGB.G), RGB.B);
+    Chroma = Max - Min;
+
+    //If Chroma is 0, then S is 0 by definition, and H is undefined but 0 by convention.
+    if(Chroma != 0)
+    {
+        if(RGB.R == Max)
+        {
+            HSV.H = (RGB.G - RGB.B) / Chroma;
+
+            if(HSV.H < 0.0)
+            {
+                HSV.H += 6.0;
+            }
+        }
+        else if(RGB.G == Max)
+        {
+            HSV.H = ((RGB.B - RGB.R) / Chroma) + 2.0;
+        }
+        else //RGB.B == Max
+        {
+            HSV.H = ((RGB.R - RGB.G) / Chroma) + 4.0;
+        }
+
+        HSV.H *= 60.0;
+        HSV.S = Chroma / Max;
+    }
+
+    HSV.V = Max;
+    HSV.A = RGB.A;
+
+    return HSV;
+}
+
+static final function LinearColor HSVToRGB(const HSVColour HSV)
+{
+    local float Min;
+    local float Chroma;
+    local float Hdash;
+    local float X;
+    local LinearColor RGB;
+
+    Chroma = HSV.S * HSV.V;
+    Hdash = HSV.H / 60.0;
+    X = Chroma * (1.0 - Abs((Hdash % 2.0) - 1.0));
+
+    if(Hdash < 1.0)
+    {
+        RGB.R = Chroma;
+        RGB.G = X;
+    }
+    else if(Hdash < 2.0)
+    {
+        RGB.R = X;
+        RGB.G = Chroma;
+    }
+    else if(Hdash < 3.0)
+    {
+        RGB.G = Chroma;
+        RGB.B = X;
+    }
+    else if(Hdash < 4.0)
+    {
+        RGB.G= X;
+        RGB.B = Chroma;
+    }
+    else if(Hdash < 5.0)
+    {
+        RGB.R = X;
+        RGB.B = Chroma;
+    }
+    else if(Hdash < 6.0)
+    {
+        RGB.R = Chroma;
+        RGB.B = X;
+    }
+
+    Min = HSV.V - Chroma;
+
+    RGB.R += Min;
+    RGB.G += Min;
+    RGB.B += Min;
+    RGB.A = HSV.A;
+    
+    return RGB;
+}
+
+static final function Color LinearColorToColor(const LinearColor RGB)
+{
+    local Color TrueRGB;
+    
+    TrueRGB.R = RGB.R * 255;
+    TrueRGB.G = RGB.G * 255;
+    TrueRGB.B = RGB.B * 255;
+    TrueRGB.A = RGB.A * 255;
+    
+    return TrueRGB;
+}

Src/KFClassicHUD/Classes/KFGUIConsoleHack.uc

@@ -0,0 +1,9 @@
+// Ugly hack to draw ontop of flash UI!
+Class KFGUIConsoleHack extends Console;
+
+var KF2GUIController OutputObject;
+
+function PostRender_Console(Canvas Canvas)
+{
+    OutputObject.RenderMenu(Canvas);
+}

Src/KFClassicHUD/Classes/KFGUI_Base.uc

@@ -0,0 +1,344 @@
+// Menu system written by Marco.
+Class KFGUI_Base extends Object
+    abstract;
+
+var KF2GUIController Owner;
+var ClassicKFHUD HUDOwner;
+var KFGUI_Base ParentComponent; // Parent component if any.
+var transient Canvas Canvas;
+
+enum EMenuSound
+{
+    MN_Focus,
+    MN_LostFocus,
+    MN_FocusHover,
+    MN_ClickButton,
+    MN_ClickCheckboxOn,
+    MN_ClickCheckboxOff,
+    MN_Dropdown,
+    MN_DropdownChange,
+};
+
+var() float XPosition,YPosition,XSize,YSize;
+var() name ID; // Just for internal purposes, you can give the components unique ID values.
+var() int IDValue; // Integer ID value.
+var transient float CompPos[4],InputPos[4];
+
+var transient KFGUI_Base MouseArea; // Next in recurse line of the mouse pointer focus area.
+
+var() bool bDisabled,bClickable,bCanFocus;
+var bool bFocusedPostDrawItem; // If this component has been given input focus, should it receive draw menu call after everything else been drawn?
+var transient bool bFocused,bTextureInit,bVisible;
+var bool bIsHUDWidget,bEnableInputs,bNoLookInputs;
+var array<name> TimerNames;
+
+function InitMenu(); // Menu was initialized for the first time.
+function ShowMenu(); // Menu was opened.
+function PreDraw()
+{
+    if( !bVisible )
+        return;
+        
+    ComputeCoords();
+    Canvas.SetDrawColor(255,255,255);
+    Canvas.SetOrigin(CompPos[0],CompPos[1]);
+    Canvas.SetClip(CompPos[0]+CompPos[2],CompPos[1]+CompPos[3]);
+    DrawMenu();
+}
+function DrawMenu(); // Draw menu now.
+function CloseMenu(); // Menu was closed.
+function InventoryChanged(optional KFWeapon Wep, optional bool bRemove); // Called when a players inventory is changed.
+function MenuTick( float DeltaTime );
+
+final function SetTimer(float InRate, optional bool inbLoop, optional Name inTimerFunc='Timer')
+{
+    if( InRate <= 0.f )
+    {
+        ClearTimer(inTimerFunc);
+        return;
+    }
+    
+    if( TimerNames.Find(inTimerFunc) == INDEX_NONE )
+    {
+        TimerNames.AddItem(inTimerFunc);
+    }
+    
+    `TimerHelper.SetTimer( InRate, inbLoop, inTimerFunc, self );
+}
+final function ClearTimer(optional Name inTimerFunc='Timer')
+{
+    if( TimerNames.Find(inTimerFunc) != INDEX_NONE )
+    {
+        TimerNames.RemoveItem(inTimerFunc);
+    }
+        
+    `TimerHelper.ClearTimer( inTimerFunc, self );
+}
+function Timer();
+
+function MouseEnter()
+{
+    bFocused = true;
+    OnFocus(Self,True);
+}
+function MouseLeave()
+{
+    bFocused = false;
+    OnFocus(Self,False);
+}
+function MouseClick( bool bRight );
+function MouseRelease( bool bRight );
+function DoubleMouseClick( bool bRight ) // User rapidly double clicked this component.
+{
+    MouseClick(bRight);
+}
+
+function ScrollMouseWheel( bool bUp );
+
+function bool ReceievedControllerInput(int ControllerId, name Key, EInputEvent Event)
+{
+    return false;
+}
+
+final function PlayerController GetPlayer()
+{
+    return Owner.PlayerOwner;
+}
+
+function SetDisabled( bool bDisable )
+{
+    bDisabled = bDisable;
+}
+
+Delegate OnFocus( KFGUI_Base Sender, bool bBecame );
+
+final function ComputeCoords()
+{
+    CompPos[0] = XPosition*InputPos[2]+InputPos[0];
+    CompPos[1] = YPosition*InputPos[3]+InputPos[1];
+    CompPos[2] = XSize*InputPos[2];
+    CompPos[3] = YSize*InputPos[3];
+}
+
+function bool CaptureMouse()
+{
+    return bVisible && ( Owner.MousePosition.X>=CompPos[0] && Owner.MousePosition.Y>=CompPos[1] && Owner.MousePosition.X<=(CompPos[0]+CompPos[2]) && Owner.MousePosition.Y<=(CompPos[1]+CompPos[3]) );
+}
+
+final function KFGUI_Base GetMouseFocus()
+{
+    local KFGUI_Base M;
+    
+    for( M=Self; M.MouseArea!=None; M=M.MouseArea )
+    {}
+    return M;
+}
+
+function SetVisibility(bool Visible)
+{
+    bVisible = Visible;
+}
+
+function DoClose()
+{
+    local int i;
+    
+    for( i=0; i<TimerNames.Length; i++ )
+    {
+        ClearTimer(TimerNames[i]);
+    }
+    
+    if( ParentComponent!=None )
+        ParentComponent.DoClose();
+    else Owner.PopCloseMenu(Self);
+}
+
+function byte GetCursorStyle()
+{
+    return (bClickable ? `PEN_BLACK : `PEN_WHITE);
+}
+
+function UserPressedEsc() // user pressed escape while this menu was active.
+{
+    if( ParentComponent!=None )
+        ParentComponent.UserPressedEsc();
+    else DoClose();
+}
+function bool BringPageToFront()
+{
+    if( ParentComponent!=None )
+        return ParentComponent.BringPageToFront();
+    return true; // Allow user to bring this page to front.
+}
+final function bool IsTopMenu()
+{
+    return (Owner.ActiveMenus.Length>0 && GetPageTop()==Owner.ActiveMenus[0]);
+}
+final function KFGUI_Page GetPageTop()
+{
+    local KFGUI_Base M;
+    
+    for( M=Self; M.ParentComponent!=None; M=M.ParentComponent )
+    {}
+    return KFGUI_Page(M);
+}
+function KFGUI_Base FindComponentID( name InID )
+{
+    if( ID==InID )
+        return Self;
+    return None;
+}
+function FindAllComponentID( name InID, out array<KFGUI_Base> Res )
+{
+    if( ID==InID )
+        Res[Res.Length] = Self;
+}
+function RemoveComponent( KFGUI_Base B );
+
+function GetInputFocus()
+{
+    if( Owner.InputFocus!=None )
+        Owner.InputFocus.LostInputFocus();
+    Owner.InputFocus = Self;
+}
+function DropInputFocus()
+{
+    if( Owner.InputFocus==Self )
+    {
+        Owner.InputFocus.LostInputFocus();
+        Owner.InputFocus = None;
+    }
+}
+function LostInputFocus();
+
+// Obtain keyboard focus.
+final function GrabKeyFocus()
+{
+    Owner.GrabInputFocus(Self);
+}
+final function ReleaseKeyFocus()
+{
+    if( Owner.KeyboardFocus==Self )
+        Owner.GrabInputFocus(None);
+}
+function LostKeyFocus();
+
+function bool NotifyInputKey( int ControllerId, name Key, EInputEvent Event, float AmountDepressed, bool bGamepad )
+{
+    if( bIsHUDWidget && bEnableInputs )
+    {
+        switch( Key )
+        {
+        case 'XboxTypeS_Start':
+        case 'Escape':
+            if( Event==IE_Pressed )
+                UserPressedEsc();
+            return true;
+        case 'XboxTypeS_DPad_Up':
+        case 'XboxTypeS_DPad_Down':
+        case 'XboxTypeS_DPad_Left':
+        case 'XboxTypeS_DPad_Right':
+        case 'MouseScrollDown':
+        case 'MouseScrollUp':
+        case 'MouseScrollDown':
+        case 'MouseScrollUp':
+            if( Event==IE_Pressed )
+                ScrollMouseWheel(Key=='MouseScrollUp' || Key=='XboxTypeS_DPad_Up' || Key=='XboxTypeS_DPad_Left');
+            return true;
+        }
+    }
+    
+    return false;
+}
+function bool NotifyInputAxis( int ControllerId, name Key, float Delta, float DeltaTime, bool bGamepad )
+{
+    return false;
+}
+function bool NotifyInputChar( int ControllerId, string Unicode )
+{
+    return false;
+}
+
+// While on input focus mode, notify that mouse just moved over the threshold.
+function InputMouseMoved();
+
+// Notify any focused menu element that mouse has been idle over it.
+function NotifyMousePaused();
+
+final function GetActualPos( out float X, out float Y )
+{
+    X = ((XPosition+X)*InputPos[2]) + InputPos[0];
+    Y = ((YPosition+Y)*InputPos[3]) + InputPos[1];
+}
+final function GetRealtivePos( out float X, out float Y )
+{
+    X = X / CompPos[2];
+    Y = Y / CompPos[2];
+}
+
+simulated final function PlayMenuSound( EMenuSound Slot )
+{
+    local SoundCue S;
+    local KFGameEngine Engine;
+    
+    Engine = KFGameEngine(class'Engine'.static.GetEngine());
+    
+    switch( Slot )
+    {
+    case MN_FocusHover:
+    case MN_Focus:
+        S = Owner.CurrentStyle.MenuHover;
+        break;
+    case MN_LostFocus:
+        S = Owner.CurrentStyle.MenuFade;
+        break;
+    case MN_ClickButton:
+    case MN_ClickCheckboxOff:
+        S = Owner.CurrentStyle.MenuClick;
+        break;
+    case MN_Dropdown:
+        S = Owner.CurrentStyle.MenuDown;
+        break;
+    case MN_DropdownChange:
+        S = Owner.CurrentStyle.MenuEdit;
+        break;
+    }
+    
+    if( S!=None )
+    {
+        S.VolumeMultiplier = (Engine.SFxVolumeMultiplier/100.f) * (Engine.MasterVolumeMultiplier/100.f);
+        GetPlayer().PlaySound(S,true,,false);
+    }
+}
+
+// Pre level change notification.
+function NotifyLevelChange();
+
+final function SetPosition( float X, float Y, float XS, float YS )
+{
+    XPosition = X;
+    YPosition = Y;
+    XSize = XS;
+    YSize = YS;
+}
+
+static final function string MakeSortStr( int Value )
+{
+    local string S;
+    local int i;
+    
+    // Prefix with zeroes to properly sort this string.
+    S = string(Value);
+    i = Len(S);
+    if( i<10 )
+        return Mid("0000000000",i)$S;
+    return S;
+}
+
+defaultproperties
+{
+    XSize=1
+    YSize=1
+    bCanFocus=true
+    bVisible=true
+}

Src/KFClassicHUD/Classes/KFGUI_Button.uc

@@ -0,0 +1,41 @@
+Class KFGUI_Button extends KFGUI_Clickable;
+
+var() Canvas.CanvasIcon OverlayTexture;
+var() string ButtonText,GamepadButtonName;
+var() color TextColor;
+var() Canvas.FontRenderInfo TextFontInfo;
+var() byte FontScale,ExtravDir;
+var bool bIsHighlighted;
+
+function DrawMenu()
+{
+    Owner.CurrentStyle.RenderButton(Self);
+}
+
+function bool GetUsingGamepad()
+{
+    return Owner.bUsingGamepad && GamepadButtonName != "";
+}
+
+function HandleMouseClick( bool bRight )
+{
+    if( bRight )
+        OnClickRight(Self);
+    else OnClickLeft(Self);
+}
+
+Delegate OnClickLeft( KFGUI_Button Sender );
+Delegate OnClickRight( KFGUI_Button Sender );
+
+Delegate bool DrawOverride(Canvas C, KFGUI_Button B)
+{
+    return false;
+}
+
+defaultproperties
+{
+    ButtonText="Button!"
+    TextColor=(R=0,G=0,B=0,A=255)
+    TextFontInfo=(bClipText=true,bEnableShadow=true)
+    FontScale=1
+}

Src/KFClassicHUD/Classes/KFGUI_CategoryButton.uc

@@ -0,0 +1,80 @@
+class KFGUI_CategoryButton extends KFGUI_Button;
+
+var transient bool bOpened;
+var Texture2D Icon;
+var Color IconColor;
+
+function DrawMenu()
+{
+    local float XL,YL,TS,TextX,TextY;
+    local Texture2D Mat;
+    local bool bDrawOverride;
+    
+    bDrawOverride = DrawOverride(Canvas, Self);
+    if( !bDrawOverride )
+    {
+        if( bDisabled )
+            Mat = Owner.CurrentStyle.ButtonTextures[`BUTTON_DISABLED];
+        else if( bPressedDown )
+            Mat = Owner.CurrentStyle.ButtonTextures[`BUTTON_PRESSED];
+        else if( bFocused || bIsHighlighted )
+            Mat = Owner.CurrentStyle.ButtonTextures[`BUTTON_NORMAL];
+        else Mat = Owner.CurrentStyle.ButtonTextures[`BUTTON_HIGHLIGHTED];
+        
+        Canvas.SetPos(0.f,0.f);
+        Canvas.DrawTileStretched(Mat,CompPos[2],CompPos[3],0,0,32,32);
+
+        if( OverlayTexture.Texture!=None )
+        {
+            Canvas.SetPos(0.f,0.f);
+            Canvas.DrawTile(OverlayTexture.Texture,CompPos[2],CompPos[3],OverlayTexture.U,OverlayTexture.V,OverlayTexture.UL,OverlayTexture.VL);
+        }
+    }
+    
+    if( ButtonText!="" )
+    {
+        Canvas.Font = Owner.CurrentStyle.MainFont;
+        
+        TS = Owner.CurrentStyle.GetFontScaler();
+        TS *= FontScale;
+        
+        while( true )
+        {
+            Canvas.TextSize(ButtonText,XL,YL,TS,TS);
+            if( XL<(CompPos[2]*0.9) && YL<(CompPos[3]*0.9) )
+                break;
+                
+            TS -= 0.001;
+        }
+        
+        TextX = (CompPos[2]-XL)*0.5;
+        TextY = (CompPos[3]-YL)*0.5;
+        
+        Canvas.SetPos(TextX, TextY);
+        if( bDisabled )
+            Canvas.DrawColor = TextColor*0.5f;
+        else Canvas.DrawColor = TextColor;
+        Canvas.DrawText(ButtonText,,TS,TS,TextFontInfo);
+        
+        if( Icon != None )
+        {
+            Canvas.DrawColor = IconColor;
+            
+            Canvas.SetPos(TextX-CompPos[3], 0.f);
+            Canvas.DrawRect(CompPos[3], CompPos[3], Icon);
+            
+            Canvas.SetPos(TextX+XL, 0.f);
+            Canvas.DrawRect(CompPos[3], CompPos[3], Icon);
+        }
+    }
+    
+    Canvas.DrawColor = class'HUD'.default.WhiteColor;
+    Canvas.SetPos(0.f,0.f);
+    Canvas.DrawRect(CompPos[3], CompPos[3], bOpened ? Owner.CurrentStyle.ArrowTextures[`ARROW_DOWN] : Owner.CurrentStyle.ArrowTextures[`ARROW_RIGHT]);
+    Canvas.SetPos(CompPos[2]-CompPos[3], 0.f);
+    Canvas.DrawRect(CompPos[3], CompPos[3], bOpened ? Owner.CurrentStyle.ArrowTextures[`ARROW_DOWN] : Owner.CurrentStyle.ArrowTextures[`ARROW_LEFT]);
+}
+
+defaultproperties
+{
+}

Src/KFClassicHUD/Classes/KFGUI_CategoryList.uc

@@ -0,0 +1,89 @@
+class KFGUI_CategoryList extends KFGUI_ComponentList;
+
+// Broken, does not work correctly when closing a menu and re-opening it if a category is open
+struct FCategoryItems
+{
+    var name ID;
+    var KFGUI_Base Item;
+};
+var array<FCategoryItems> CategoryItems;
+
+function AddCategory(name CatID, string CatName, optional Texture2D IconMat, optional Color IconClr, optional float XS=1.f, optional float YS=1.f)
+{
+    local KFGUI_CategoryButton B;
+    
+    B = KFGUI_CategoryButton(AddListComponent(class'KFGUI_CategoryButton', XS, YS));
+    B.ButtonText = CatName;
+    B.ID = CatID;
+    B.Icon = IconMat;
+    B.IconColor = IconClr;
+    B.OnClickLeft = SelectedCategory;
+    B.OnClickRight = SelectedCategory;
+}
+
+function KFGUI_Base AddItemToCategory(name CatID, class<KFGUI_Base> Item)
+{
+    local FCategoryItems CatItem;
+    local KFGUI_Base G;
+    
+    G = CreateComponent(Item);
+    G.ID = CatID;
+    G.Owner = Owner;
+    G.ParentComponent = Self;
+    
+    CatItem.ID = CatID;
+    CatItem.Item = G;
+    CategoryItems.AddItem(CatItem);
+    
+    return G;
+}
+
+function SelectedCategory(KFGUI_Button Sender)
+{
+    local int i, j, Index;
+    local KFGUI_CategoryButton CatB;
+    
+    CatB = KFGUI_CategoryButton(Sender);
+    if( CatB == None )
+        return;
+    
+    Index = ItemComponents.Find(Sender);
+    if( Index != INDEX_NONE )
+    {
+        if( !CatB.bOpened )
+        {
+            CatB.bOpened = true;
+            j = Index+1;
+            for( i=0; i<CategoryItems.Length; i++ )
+            {
+                if( CategoryItems[i].ID == CatB.ID )
+                    AddItemAtIndex(j++, CategoryItems[i].Item);
+            }
+        }
+        else
+        {
+            CatB.bOpened = false;
+            for( i=0; i<CategoryItems.Length; i++ )
+            {
+                if( CategoryItems[i].ID == CatB.ID )
+                    ItemComponents.RemoveItem(CategoryItems[i].Item);
+            }
+        }
+    }
+}
+
+function EmptyList()
+{
+    local int i;
+    
+    for( i=0; i<ItemComponents.Length; i++ )
+    {
+        if( KFGUI_CategoryButton(ItemComponents[i]) == None )
+            ItemComponents.Remove(i, 1);
+    }
+    CategoryItems.Length = 0;
+}
+
+defaultproperties
+{
+}

Src/KFClassicHUD/Classes/KFGUI_CheckBox.uc

@@ -0,0 +1,30 @@
+Class KFGUI_CheckBox extends KFGUI_EditControl;
+
+var() Texture CheckMark,CheckDisabled,CheckIdle,CheckFocus,CheckClicked;
+var() bool bForceUniform,bChecked;
+
+function UpdateSizes()
+{
+    Super.UpdateSizes();
+    if( bForceUniform )
+        XSize = (YSize*InputPos[3]) / InputPos[2];
+}
+
+function DrawMenu()
+{
+    Owner.CurrentStyle.RenderCheckbox(Self);
+}
+
+function HandleMouseClick( bool bRight )
+{
+    bChecked = !bChecked;
+    OnCheckChange(Self);
+}
+
+Delegate OnCheckChange( KFGUI_CheckBox Sender );
+
+defaultproperties
+{
+    bForceUniform=true
+    LableWidth=0.85
+}

Src/KFClassicHUD/Classes/KFGUI_Clickable.uc

@@ -0,0 +1,95 @@
+Class KFGUI_Clickable extends KFGUI_Base
+    abstract;
+
+var() int IntIndex; // More user variables.
+var() string ToolTip;
+
+var KFGUI_Tooltip ToolTipItem;
+
+var byte PressedDown[2];
+var bool bPressedDown;
+
+var bool bHoverSound;
+
+function InitMenu()
+{
+    Super.InitMenu();
+    bClickable = !bDisabled;
+}
+function MouseClick( bool bRight )
+{
+    if( !bDisabled )
+    {
+        PressedDown[byte(bRight)] = 1;
+        bPressedDown = true;
+    }
+}
+function MouseRelease( bool bRight )
+{
+    if( !bDisabled && PressedDown[byte(bRight)]==1 )
+    {
+        PlayMenuSound(MN_ClickButton);
+        PressedDown[byte(bRight)] = 0;
+        bPressedDown = (PressedDown[0]!=0 || PressedDown[1]!=0);
+        HandleMouseClick(bRight);
+    }
+}
+function MouseLeave()
+{
+    Super.MouseLeave();
+    PressedDown[0] = 0;
+    PressedDown[1] = 0;
+    bPressedDown = false;
+}
+function MouseEnter()
+{
+    Super.MouseEnter();
+    if( !bDisabled && bHoverSound )
+        PlayMenuSound(MN_FocusHover);
+}
+
+function SetDisabled( bool bDisable )
+{
+    Super.SetDisabled(bDisable);
+    bClickable = !bDisable;
+    PressedDown[0] = 0;
+    PressedDown[1] = 0;
+    bPressedDown = false;
+}
+
+function NotifyMousePaused()
+{
+    if( Owner.InputFocus==None && ToolTip!="" )
+    {
+        if( ToolTipItem==None )
+        {
+            ToolTipItem = New(None)Class'KFGUI_Tooltip';
+            ToolTipItem.Owner = Owner;
+            ToolTipItem.ParentComponent = Self;
+            ToolTipItem.InitMenu();
+            ToolTipItem.SetText(ToolTip);
+        }
+        ToolTipItem.ShowMenu();
+        ToolTipItem.CompPos[0] = Owner.MousePosition.X;
+        ToolTipItem.CompPos[1] = Owner.MousePosition.Y;
+        ToolTipItem.GetInputFocus();
+    }
+}
+final function ChangeToolTip( string S )
+{
+    if( ToolTipItem!=None )
+        ToolTipItem.SetText(S);
+    else ToolTip = S;
+}
+function SetVisibility(bool Visible)
+{
+    Super.SetVisibility(Visible);
+    SetDisabled(!Visible);
+}
+
+function HandleMouseClick( bool bRight );
+
+defaultproperties
+{
+    bHoverSound=true
+}

Src/KFClassicHUD/Classes/KFGUI_ColorSlider.uc

@@ -0,0 +1,122 @@
+class KFGUI_ColorSlider extends KFGUI_MultiComponent;
+
+var KFGUI_Slider RSlider,GSlider,BSlider,ASlider;
+var KFGUI_TextLable TextLable,RedLabel,GreenLabel,BlueLabel,AlphaLabel,RedValue,GreenValue,BlueValue,AlphaValue;
+var KFGUI_ComponentList SettingsBox;
+
+var Color DefaultColor;
+var string CaptionText;
+
+function InitMenu()
+{
+    Super.InitMenu();
+    
+    SettingsBox = KFGUI_ComponentList(FindComponentID('SettingsBox'));
+    
+    TextLable = KFGUI_TextLable(FindComponentID('CaptionText'));
+    TextLable.SetText(CaptionText);
+    
+    RSlider = AddSlider("Red:",'ColorSliderR',0,255,RedLabel,RedValue);
+    GSlider = AddSlider("Green:",'ColorSliderG',0,255,GreenLabel,GreenValue);
+    BSlider = AddSlider("Blue:",'ColorSliderB',0,255,BlueLabel,BlueValue);
+    ASlider = AddSlider("Alpha:",'ColorSliderA',0,255,AlphaLabel,AlphaValue);
+    
+    SetDefaultColor(DefaultColor);
+}
+
+function SetDefaultColor(Color Def)
+{
+    RSlider.SetValue(Def.R);
+    RSlider.UpdateListVis();
+    
+    GSlider.SetValue(Def.G);
+    GSlider.UpdateListVis();
+    
+    BSlider.SetValue(Def.B);
+    BSlider.UpdateListVis();
+    
+    ASlider.SetValue(Def.A);
+    ASlider.UpdateListVis();
+}
+
+final function KFGUI_Slider AddSlider( string Cap, name IDN, int MinValue, int MaxValue, out KFGUI_TextLable Label, out KFGUI_TextLable ColorValueLabel )
+{
+    local KFGUI_Slider SL;
+    local KFGUI_MultiComponent MC;
+    
+    MC = KFGUI_MultiComponent(SettingsBox.AddListComponent(class'KFGUI_MultiComponent'));
+    MC.InitMenu();
+    Label = new(MC) class'KFGUI_TextLable';
+    Label.SetText(Cap);
+    Label.XSize = 0.45;
+    Label.FontScale = 1;
+    MC.AddComponent(Label);    
+    ColorValueLabel = new(MC) class'KFGUI_TextLable';
+    ColorValueLabel.XPosition = 0.95;
+    ColorValueLabel.XSize = 0.1;
+    ColorValueLabel.FontScale = 1;
+    MC.AddComponent(ColorValueLabel);
+    SL = new(MC) class'KFGUI_Slider';
+    SL.XPosition = 0.575;
+    SL.XSize = 0.35;
+    SL.MinValue = MinValue;
+    SL.MaxValue = MaxValue;
+    SL.ID = IDN;
+    SL.OnValueChanged = OnValueChanged;
+    MC.AddComponent(SL);
+    return SL;
+}
+
+function OnValueChanged(KFGUI_Slider Sender, int Value)
+{
+    switch(Sender.ID)
+    {
+        case 'ColorSliderR':
+            RedValue.SetText(string(Value));
+            TextLable.TextColor.R = Value;
+            break;
+        case 'ColorSliderG':
+            GreenValue.SetText(string(Value));
+            TextLable.TextColor.G = Value;
+            break;
+        case 'ColorSliderB':
+            BlueValue.SetText(string(Value));
+            TextLable.TextColor.B = Value;
+            break;
+        case 'ColorSliderA':
+            AlphaValue.SetText(string(Value));
+            TextLable.TextColor.A = Value;
+            break;
+    }
+    
+    OnColorSliderValueChanged(self, Sender, Value);
+}
+
+delegate OnColorSliderValueChanged(KFGUI_ColorSlider Sender, KFGUI_Slider Slider, int Value);
+
+function DrawMenu()
+{
+    Owner.CurrentStyle.DrawTileStretched(Owner.CurrentStyle.BorderTextures[`BOX_SMALL],0,0,CompPos[2],CompPos[3]);
+}
+
+defaultproperties
+{
+    Begin Object Class=KFGUI_ComponentList Name=ClientSettingsBox
+        XPosition=0.05
+        YPosition=0.1
+        XSize=0.95
+        YSize=0.95
+        ID="SettingsBox"
+        ListItemsPerPage=4
+    End Object
+    Components.Add(ClientSettingsBox)
+    
+    Begin Object Class=KFGUI_TextLable Name=CaptionLabel
+        XSize=1
+        YSize=0.125
+        AlignX=1
+        AlignY=1
+        ID="CaptionText"
+    End Object
+    Components.Add(CaptionLabel)
+}

Src/KFClassicHUD/Classes/KFGUI_ColumnList.uc

@@ -0,0 +1,445 @@
+// Columned list box (only for text lines).
+Class KFGUI_ColumnList extends KFGUI_List;
+
+struct FColumnItem
+{
+    var() string Text;
+    var() float Width;
+    var() bool bOnlyTextures;
+    
+    var transient bool bHidden;
+    var transient int X,XSize;
+};
+var() array<FColumnItem> Columns;
+var() class<KFGUI_ListItem> ListItemClass;
+var() float FontSize;
+var() color FocusedLineColor,SelectedLineColor;
+var() float EdgeSize;
+var KFGUI_ColumnTop ColumnComp;
+var Canvas.FontRenderInfo LineFontInfo;
+
+var int SelectedRowIndex;
+var int LastSortedColumn;
+
+var transient float TextHeight,ScalerSize,TextScaler;
+var transient int OldItemsPerFrame;
+
+var KFGUI_ListItem FirstItem,UnusedItem;
+
+var transient bool bListSizeDirty;
+var bool bLastSortedReverse;
+var() bool bShouldSortList; // Should sort any new items added to the list instantly.
+var() bool bCanSortColumn; // Allow user to sort columns.
+
+delegate OnSelectedRow( KFGUI_ListItem Item, int Row, bool bRight, bool bDblClick );
+
+function KFGUI_ListItem AddLine( string Value, optional int iValue, optional string SortValue, optional int Index=-1 )
+{
+    local KFGUI_ListItem N,O;
+    local int i;
+    
+    // Allocate list item object.
+    if( UnusedItem!=None )
+    {
+        N = UnusedItem;
+        UnusedItem = N.Next;
+        N.Next = None;
+    }
+    else N = new (None) ListItemClass;
+    
+    // Setup column text value.
+    N.SetValue(Value,iValue,SortValue);
+
+    // Insert into list.
+    if( bShouldSortList && Index==-1 )
+    {
+        N.Temp = N.GetSortStr(LastSortedColumn);
+        
+        if( ListCount==0 ) // No sorting needed yet.
+        {
+            N.Next = FirstItem;
+            FirstItem = N;
+        }
+        else if( bLastSortedReverse )
+        {
+            if( FirstItem.Temp<N.Temp )
+            {
+                N.Next = FirstItem;
+                FirstItem = N;
+            }
+            else
+            {
+                for( O=FirstItem; O!=None; O=O.Next )
+                {
+                    if( O.Next==None || O.Next.Temp<N.Temp )
+                    {
+                        N.Next = O.Next;
+                        O.Next = N;
+                        break;
+                    }
+                }
+            }
+        }
+        else if( FirstItem.Temp>N.Temp )
+        {
+            N.Next = FirstItem;
+            FirstItem = N;
+        }
+        else
+        {
+            for( O=FirstItem; O!=None; O=O.Next )
+            {
+                if( O.Next==None || O.Next.Temp>N.Temp )
+                {
+                    N.Next = O.Next;
+                    O.Next = N;
+                    break;
+                }
+            }
+        }
+    }
+    else if( Index==-1 || Index>ListCount )
+        Index = ListCount;
+    if( Index==0 )
+    {
+        N.Next = FirstItem;
+        FirstItem = N;
+    }
+    else
+    {
+        i = 0;
+        for( O=FirstItem; O!=None; O=O.Next )
+        {
+            if( (++i)==Index )
+            {
+                N.Next = O.Next;
+                O.Next = N;
+                break;
+            }
+        }
+    }
+    UpdateListSize();
+    
+    return N;
+}
+final function RemoveLine( KFGUI_ListItem I )
+{
+    local KFGUI_ListItem N;
+    
+    if( I.Index==-1 )
+        return;
+    
+    // Update selected row info.
+    if( SelectedRowIndex==I.Index )
+        SelectedRowIndex = -1;
+    else if( SelectedRowIndex>I.Index )
+        --SelectedRowIndex;
+
+    // Remove from list.
+    if( FirstItem==I )
+        FirstItem = I.Next;
+    else
+    {
+        for( N=FirstItem; N!=None; N=N.Next )
+            if( N.Next==I )
+            {
+                N.Next = I.Next;
+                break;
+            }
+    }
+    
+    // Add to unused list.
+    I.Next = UnusedItem;
+    UnusedItem = I;
+    I.Index = -1;
+
+    UpdateListSize();
+}
+final function EmptyList()
+{
+    local KFGUI_ListItem N,I;
+
+    for( I=FirstItem; I!=None; I=N )
+    {
+        N = I.Next;
+        
+        // Add to unused list.
+        I.Next = UnusedItem;
+        UnusedItem = I;
+        I.Index = -1;
+    }
+
+    FirstItem = None;
+    UpdateListSize();
+}
+
+final function KFGUI_ListItem GetFromIndex( int Index )
+{
+    local KFGUI_ListItem N;
+
+    if( Index<0 || Index>=ListCount )
+        return None;
+    for( N=FirstItem; N!=None; N=N.Next )
+        if( (Index--)==0 )
+            return N;
+    return None;
+}
+
+function SortColumn( int Column, optional bool bReverse )
+{
+    local array<KFGUI_ListItem> List;
+    local KFGUI_ListItem Sel,N,P;
+    local int i;
+    
+    if( !bCanSortColumn || Column<0 || Column>=Columns.Length )
+        return;
+
+    LastSortedColumn = Column;
+    bLastSortedReverse = bReverse;
+    bShouldSortList = true;
+
+    // Allocate memory space first.
+    List.Length = ListCount;
+    List.Length = 0;
+    
+    // Grab current selected line.
+    Sel = GetFromIndex(SelectedRowIndex);
+    SelectedRowIndex = -1;
+    
+    // Slow, sort it all.
+    for( N=FirstItem; N!=None; N=N.Next )
+    {
+        N.Temp = N.GetSortStr(Column);
+
+        if( bReverse )
+        {
+            for( i=0; i<List.Length; ++i )
+                if( List[i].Temp<N.Temp )
+                    break;
+        }
+        else
+        {
+            for( i=0; i<List.Length; ++i )
+                if( List[i].Temp>N.Temp )
+                    break;
+        }
+        List.Insert(i,1);
+        List[i] = N;
+    }
+    
+    // Rebuild list.
+    FirstItem = None;
+    P = None;
+    for( i=0; i<List.Length; ++i )
+    {
+        N = List[i];
+        if( Sel==N )
+            SelectedRowIndex = i;
+        N.Index = i;
+        N.Next = None;
+        if( P==None )
+            FirstItem = N;
+        else P.Next = N;
+        P = N;
+    }
+}
+
+function ChangeListSize( int NewSize );
+
+final function UpdateListSize()
+{
+    local KFGUI_ListItem N;
+    
+    ListCount = 0;
+    for( N=FirstItem; N!=None; N=N.Next )
+        N.Index = ListCount++;
+    bListSizeDirty = true;
+}
+
+function InitMenu()
+{
+    ListCount = 0;
+    Super.InitMenu();
+    ColumnComp = KFGUI_ColumnTop(FindComponentID('Columns'));
+}
+
+final function DrawStrClipped( string S, optional bool bOnlyTextures )
+{
+    Canvas.PushMaskRegion(Canvas.OrgX,Canvas.OrgY,Canvas.ClipX,Canvas.ClipY);
+    Owner.CurrentStyle.DrawTexturedString(S,Canvas.CurX,Canvas.CurY,TextScaler,LineFontInfo,false,bOnlyTextures);
+    Canvas.PopMaskRegion();
+}
+
+function DrawMenu()
+{
+    local int i,n,j;
+    local float Y,TextY,XOffset;
+    local KFGUI_ListItem C;
+    local bool bCheckMouse;
+
+    Canvas.SetDrawColor(250,250,250,255);
+    Canvas.SetPos(0.f,0.f);
+    Canvas.DrawTileStretched(Owner.CurrentStyle.BorderTextures[`BOX_SMALL_SLIGHTTRANSPARENT],CompPos[2],CompPos[3],0,0,128,128);
+    
+    // Mouse focused item check.
+    bCheckMouse = bClickable && bFocused;
+    FocusMouseItem = -1;
+    if( bCheckMouse )
+        MouseYHit = Owner.MousePosition.Y - CompPos[1];
+
+    n = ScrollBar.CurrentScroll;
+    i = 0;
+    for( C=FirstItem; C!=None; C=C.Next )
+        if( (i++)==n )
+            break;
+    Y = 0.f;
+    TextY = (ItemHeight-TextHeight)*0.5f;
+    XOffset = TextY*0.75;
+    Canvas.SetDrawColor(250,250,250,255);
+
+    for( i=0; (i<ListItemsPerPage && C!=None); ++i )
+    {
+        // Check for mouse hit.
+        if( bCheckMouse && FocusMouseItem==-1 )
+        {
+            if( MouseYHit<ItemHeight )
+                FocusMouseItem = n;
+            else MouseYHit-=ItemHeight;
+        }
+        
+        // Draw selection background.
+        if( SelectedRowIndex==n ) // Selected
+        {
+            Canvas.SetPos(EdgeSize,Y);
+            Canvas.DrawColor = SelectedLineColor;
+            Owner.CurrentStyle.DrawWhiteBox(CompPos[2]-(EdgeSize*2),ItemHeight);
+            Canvas.SetDrawColor(250,250,250,255);
+        }
+        else if( FocusMouseItem==n ) // Focused
+        {
+            Canvas.SetPos(EdgeSize,Y);
+            Canvas.DrawColor = FocusedLineColor;
+            Owner.CurrentStyle.DrawWhiteBox(CompPos[2]-(EdgeSize*2),ItemHeight);
+            Canvas.SetDrawColor(250,250,250,255);
+        }
+        
+        // Draw columns of text
+        for( j=0; j<Columns.Length; ++j )
+            if( !Columns[j].bHidden )
+            {
+                //Canvas.SetClip(Columns[j].X+Columns[j].XSize+EdgeSize,YClip);
+                Canvas.SetPos(Columns[j].X+XOffset+EdgeSize,TextY);
+                DrawStrClipped(C.GetDisplayStr(j), Columns[j].bOnlyTextures);
+            }
+        Y+=ItemHeight;
+        TextY+=ItemHeight;
+        ++n;
+        C = C.Next;
+    }
+}
+
+function PreDraw()
+{
+    local byte j;
+    local float XS,SpaceX;
+    
+    if( !bVisible )
+        return;
+
+    ComputeCoords();
+    
+    // Check font to use.
+    Canvas.Font = Owner.CurrentStyle.PickFont(TextScaler);
+    TextScaler *= FontSize;
+    Canvas.TextSize("ABC",XS,TextHeight,TextScaler,TextScaler);
+    
+    for( j=0; j<4; ++j )
+    {
+        ScrollBar.InputPos[j] = CompPos[j];
+        ColumnComp.InputPos[j] = CompPos[j];
+    }
+    
+    // Setup positioning.
+    // First compute the width scrollbar.
+    if( OldXSize!=InputPos[2] )
+    {
+        OldXSize = InputPos[2];
+        ScalerSize = ScrollBar.GetWidth();
+        ScrollBar.XPosition = 1.f - ScalerSize;
+        ColumnComp.XSize = ScrollBar.XPosition;
+    }
+    SpaceX = ScalerSize*CompPos[2];
+    CompPos[2] -= SpaceX;
+    ScrollBar.InputPos[3] = CompPos[3];
+
+    // Draw columns.
+    ColumnComp.YSize = (TextHeight*1.05) / CompPos[3];
+    ColumnComp.Canvas = Canvas;
+    ColumnComp.PreDraw();
+    
+    // Move down to give space for columns.
+    CompPos[1] += ColumnComp.CompPos[3];
+    CompPos[3] -= ColumnComp.CompPos[3];
+
+    // Compute how many rows fit in with this setting.
+    ItemHeight = TextHeight*1.025;
+    ListItemsPerPage = CompPos[3]/ItemHeight;
+    ItemHeight = CompPos[3]/ListItemsPerPage;
+    if( OldItemsPerFrame!=ListItemsPerPage || bListSizeDirty )
+    {
+        if( SelectedRowIndex>=ListCount )
+            SelectedRowIndex = -1;
+        OldItemsPerFrame = ListItemsPerPage;
+        bListSizeDirty = false;
+        UpdateListVis();
+    }
+
+    // Draw vertical scrollbar
+    ScrollBar.Canvas = Canvas;
+    ScrollBar.PreDraw();
+    
+    // Draw self.
+    Canvas.SetOrigin(CompPos[0],CompPos[1]);
+    Canvas.SetClip(CompPos[0]+CompPos[2],CompPos[1]+CompPos[3]);
+    DrawMenu();
+    
+    // Reset scaling to allow mouse to capture input.
+    CompPos[1] -= ColumnComp.CompPos[3];
+    CompPos[2] += SpaceX;
+    CompPos[3] += ColumnComp.CompPos[3];
+}
+function InternalClickedItem( int Index, bool bRight, int MouseX, int MouseY )
+{
+    SelectedRowIndex = Index;
+    OnSelectedRow(GetFromIndex(Index),Index,bRight,false);
+}
+function InternalDblClickedItem( int Index, bool bRight, int MouseX, int MouseY )
+{
+    SelectedRowIndex = Index;
+    OnSelectedRow(GetFromIndex(Index),Index,bRight,true);
+}
+
+defaultproperties
+{
+    ListItemClass=class'KFGUI_ListItem'
+    OnClickedItem=InternalClickedItem
+    OnDblClickedItem=InternalDblClickedItem
+    SelectedRowIndex=-1
+    FontSize=1.f
+    EdgeSize=5.f
+    bClickable=true
+    FocusedLineColor=(R=64,G=3,B=48,A=255)
+    SelectedLineColor=(R=84,G=26,B=128,A=255)
+    bCanSortColumn=true
+
+    Begin Object Class=KFGUI_ColumnTop Name=ColumnComps
+        XPosition=0
+        YPosition=0
+        XSize=1
+        YSize=0.04
+        ID="Columns"
+    End Object
+    Components.Add(ColumnComps)
+    
+    LineFontInfo=(bClipText=true,bEnableShadow=false)
+}

Src/KFClassicHUD/Classes/KFGUI_ColumnTop.uc

@@ -0,0 +1,206 @@
+// Do not use this on your own, it is used by ColumnList
+Class KFGUI_ColumnTop extends KFGUI_Base;
+
+var() float ColumnMinSize; // Minimum pixels width allowed.
+var KFGUI_ColumnList ListOwner;
+
+var transient int PrevSortedColumn,MouseColumn,ScalingColumn;
+var transient byte PressedDown[2];
+var transient bool bPressedDown,bScaleColumn,bMouseScaler;
+
+function InitMenu()
+{
+    Super.InitMenu();
+    ListOwner = KFGUI_ColumnList(ParentComponent);
+}
+
+function DrawMenu()
+{
+    local int i,j;
+    local float X,XS,MouseX,GrabWidth,MinSize,Wd;
+    local bool bCheckMouse;
+
+    bClickable = ListOwner.bClickable;
+    MinSize = ColumnMinSize / CompPos[2];
+    
+    // Scale column
+    if( bScaleColumn )
+    {
+        MouseX = Owner.MousePosition.X - CompPos[0];
+        for( i=0; i<ScalingColumn; ++i )
+            MouseX-=(ListOwner.Columns[i].Width * CompPos[2]);
+
+        ListOwner.Columns[ScalingColumn].Width = MouseX / CompPos[2];
+        
+        // Make sure no column is scrolled off screen.
+        X = 0;
+        for( i=0; i<(ListOwner.Columns.Length-1); ++i )
+        {
+            if( ListOwner.Columns[i].Width<MinSize )
+                ListOwner.Columns[i].Width = MinSize;
+            X+=ListOwner.Columns[i].Width;
+            if( X>=(1.f-MinSize) )
+            {
+                MouseX = X-(1.f-MinSize); // Grab overshoot.
+
+                // Then push back!
+                for( j=i; j>=0; --j )
+                {
+                    if( (ListOwner.Columns[j].Width-MouseX)>MinSize ) // This column has enough space to retract.
+                    {
+                        ListOwner.Columns[j].Width-=MouseX;
+                        MouseX = 0;
+                        break;
+                    }
+                    else if( ListOwner.Columns[j].Width>MinSize ) // This column has limited space to retract.
+                    {
+                        MouseX-=(ListOwner.Columns[j].Width-MinSize);
+                        ListOwner.Columns[j].Width = MinSize;
+                    }
+                }
+                X = (1.f-MinSize); // Continue at maximum size.
+            }
+        }
+    }
+    
+    // Init mouse check.
+    MouseColumn = -1;
+    bCheckMouse = (bClickable && bFocused);
+    if( bCheckMouse )
+    {
+        GrabWidth = CompPos[3]*0.175;
+        MouseX = Owner.MousePosition.X - CompPos[0] - GrabWidth;
+        GrabWidth *= -2.f;
+    }
+
+    // Draw the columns and compute the scalings.
+    X = 0;
+    j = (ListOwner.bShouldSortList ? ListOwner.LastSortedColumn : -1);
+    for( i=0; i<ListOwner.Columns.Length; ++i )
+    {
+        if( ListOwner.Columns[i].Width<MinSize )
+            ListOwner.Columns[i].Width = MinSize;
+
+        Wd = ListOwner.Columns[i].Width * CompPos[2];
+        if( i==(ListOwner.Columns.Length-1) ) // Final column, give infinitive width.
+        {
+            Wd = (CompPos[2]-X);
+        }
+        if( Wd<=0 ) // Impossible.
+        {
+            ListOwner.Columns[i].bHidden = true;
+            continue;
+        }
+
+        ListOwner.Columns[i].X = X;
+        ListOwner.Columns[i].XSize = Wd;
+        
+        if( bCheckMouse && (MouseX-=Wd)<=0.f )
+        {
+            MouseColumn = i;
+            bCheckMouse = false;
+            bMouseScaler = (MouseX>=GrabWidth) && ((i+1)<ListOwner.Columns.Length);
+        }
+
+        if( X>=CompPos[2] )
+            ListOwner.Columns[i].bHidden = true;
+        else
+        {
+            ListOwner.Columns[i].bHidden = false;
+            //Canvas.SetClip(X+Wd,CompPos[1]+CompPos[3]);
+            
+            // Draw column.
+            if( i==j )
+            {
+                if( MouseColumn==i && !bMouseScaler )
+                    Canvas.SetDrawColor(175,240,8,255);
+                else Canvas.SetDrawColor(128,200,56,255);
+            }
+            else if( MouseColumn==i && !bMouseScaler )
+                Canvas.SetDrawColor(220,220,8,255);
+
+            XS = Owner.CurrentStyle.DefaultHeight*0.5;
+            Canvas.SetPos(X,0.f);
+            Canvas.DrawTileStretched(Owner.CurrentStyle.TabTextures[`TAB_TOP],Min(Wd,CompPos[2]-X),CompPos[3],0,0,128,16);
+            
+            Canvas.SetDrawColor(250,250,250,255);
+            Canvas.SetPos(X+XS,(CompPos[3]-ListOwner.TextHeight)*0.5f);
+            ListOwner.DrawStrClipped(ListOwner.Columns[i].Text);
+        }
+        X+=Wd;
+    }
+}
+
+function MouseClick( bool bRight )
+{
+    if( !ListOwner.bDisabled && bClickable )
+    {
+        PressedDown[byte(bRight)] = 1;
+        bPressedDown = true;
+        
+        if( !bRight && bMouseScaler )
+        {
+            PlayMenuSound(MN_ClickButton);
+            bScaleColumn = true;
+            ScalingColumn = MouseColumn;
+            GetInputFocus();
+        }
+    }
+}
+function MouseRelease( bool bRight )
+{
+    if( bScaleColumn && !bRight )
+    {
+        bScaleColumn = false;
+        DropInputFocus();
+        return;
+    }
+    if( !bDisabled && bClickable && PressedDown[byte(bRight)]==1 )
+    {
+        PlayMenuSound(MN_ClickButton);
+        PressedDown[byte(bRight)] = 0;
+        bPressedDown = (PressedDown[0]!=0 || PressedDown[1]!=0);
+        
+        if( MouseColumn>=0 )
+        {
+            ListOwner.SortColumn(MouseColumn,(PrevSortedColumn==MouseColumn));
+            if( PrevSortedColumn==MouseColumn )
+                PrevSortedColumn = -1;
+            else PrevSortedColumn = MouseColumn;
+        }
+    }
+}
+function byte GetCursorStyle()
+{
+    if( bClickable )
+        return (bMouseScaler ? 2 : 1);
+    return 0;
+}
+function MouseLeave()
+{
+    Super.MouseLeave();
+    if( !bScaleColumn )
+    {
+        PressedDown[0] = 0;
+        PressedDown[1] = 0;
+        bPressedDown = false;
+    }
+}
+function MouseEnter()
+{
+    Super.MouseEnter();
+}
+
+function LostInputFocus()
+{
+    bScaleColumn = false;
+    PressedDown[0] = 0;
+    PressedDown[1] = 0;
+    bPressedDown = false;
+}
+
+defaultproperties
+{
+    bClickable=true
+    ColumnMinSize=8
+}

Src/KFClassicHUD/Classes/KFGUI_ComboBox.uc

@@ -0,0 +1,64 @@
+Class KFGUI_ComboBox extends KFGUI_EditControl;
+
+var KFGUI_ComboSelector Selection;
+
+var float BorderSize;
+var() array<string> Values;
+var() int SelectedIndex;
+var() color SelectedTextColor,TextColor;
+var() bool bButtonStretched;
+
+function UpdateSizes()
+{
+    // Update height.
+    if( bScaleByFontSize )
+        YSize = (TextHeight + (BorderSize*2)) / InputPos[3];
+}
+
+function DrawMenu()
+{
+    Owner.CurrentStyle.RenderComboBox(Self);
+}
+
+function HandleMouseClick( bool bRight )
+{
+    PlayMenuSound(MN_Dropdown);
+    if( Selection==None )
+    {
+        Selection = New(None)Class'KFGUI_ComboSelector';
+        Selection.Owner = Owner;
+        Selection.Combo = Self;
+        Selection.InitMenu();
+    }
+    Selection.XPosition = CompPos[0] / Owner.ScreenSize.X;
+    Selection.YPosition = (CompPos[1]+CompPos[3]) / Owner.ScreenSize.Y;
+    Selection.XSize = CompPos[2] / Owner.ScreenSize.X;
+    Selection.YSize = (TextHeight / Owner.ScreenSize.Y) * Values.Length + ((BorderSize*2) / Owner.ScreenSize.Y);
+    if( (Selection.YPosition+Selection.YSize)>1.f )
+        Selection.YPosition-=((Selection.YPosition+Selection.YSize)-1.f);
+    Selection.GetInputFocus();
+}
+final function string GetCurrent()
+{
+    if( SelectedIndex<Values.Length )
+        return Values[SelectedIndex];
+    return "";
+}
+final function bool SetValue( string S )
+{
+    local int i;
+    
+    i = Values.Find(S);
+    if( i==-1 )
+        return false;
+    SelectedIndex = i;
+    return true;
+}
+Delegate OnComboChanged( KFGUI_ComboBox Sender );
+
+defaultproperties
+{
+    SelectedTextColor=(R=255,G=128,B=128,A=255)
+    TextColor=(R=255,G=255,B=255,A=255)
+    BorderSize=4
+}

Src/KFClassicHUD/Classes/KFGUI_ComboSelector.uc

@@ -0,0 +1,27 @@
+Class KFGUI_ComboSelector extends KFGUI_Clickable;
+
+var KFGUI_ComboBox Combo;
+var int CurrentRow,OldRow;
+
+function DrawMenu()
+{
+    Owner.CurrentStyle.RenderComboList(Self);
+}
+
+function HandleMouseClick( bool bRight )
+{
+    PlayMenuSound(MN_ClickButton);
+    DropInputFocus();
+    if( CurrentRow>=0 )
+    {
+        Combo.SelectedIndex = CurrentRow;
+        Combo.OnComboChanged(Combo);
+    }
+}
+
+defaultproperties
+{
+    CurrentRow=-1
+    OldRow=-1
+    bFocusedPostDrawItem=true
+}

Src/KFClassicHUD/Classes/KFGUI_ComponentList.uc

@@ -0,0 +1,222 @@
+// List box with components as items.
+Class KFGUI_ComponentList extends KFGUI_List;
+
+var int VisRange[2];
+var() int NumColumns;
+var array<KFGUI_Base> ItemComponents;
+
+// REMEMBER to call InitMenu() on the newly created component after values are init!!!
+final function KFGUI_Base AddListComponent( class<KFGUI_Base> CompClass, optional float XS=1.f, optional float YS=1.f )
+{
+    return AddComponentAtIndex(ItemComponents.Length, CompClass, XS, YS);
+}
+
+final function KFGUI_Base CreateComponent(class<KFGUI_Base> CompClass, optional float XS=1.f, optional float YS=1.f)
+{
+    local KFGUI_Base G;
+    
+    G = new(Self)CompClass;
+    if( G==None )
+        return None;
+        
+    G.XPosition = (1.f - XS) * 0.5f;
+    G.YPosition = (1.f - YS) * 0.5f;
+    G.XSize = XS;
+    G.YSize = YS;
+        
+    return G;
+}
+
+final function AddItem( KFGUI_Base Item )
+{
+    AddItemAtIndex(ItemComponents.Length, Item);
+}
+
+final function AddItemAtIndex( int i, KFGUI_Base Item )
+{
+    ItemComponents.InsertItem(i, Item);
+}
+
+final function KFGUI_Base AddComponentAtIndex( int i, class<KFGUI_Base> CompClass, optional float XS=1.f, optional float YS=1.f )
+{
+    local KFGUI_Base G;
+    
+    G = CreateComponent(CompClass, XS, YS);
+    G.Owner = Owner;
+    G.ParentComponent = Self;
+    ItemComponents.InsertItem(i, G);
+    
+    return G;
+}
+
+function EmptyList()
+{
+    ItemComponents.Length = 0;
+}
+
+function InitMenu()
+{
+    Super.InitMenu();
+    ListCount = 0;
+    NumColumns = Max(NumColumns,1);
+}
+
+function DrawMenu()
+{
+    if( bDrawBackground )
+    {
+        Canvas.SetDrawColor(250,250,250,255);
+        Canvas.SetPos(0.f,0.f);
+        Canvas.DrawTileStretched(Owner.CurrentStyle.BorderTextures[`BOX_INNERBORDER],CompPos[2],CompPos[3],0,0,128,128);
+    }
+}
+
+function PreDraw()
+{
+    local int i;
+    local byte j;
+    
+    if( !bVisible )
+        return;
+
+    ComputeCoords();
+    
+    // Update list size
+    i = ItemComponents.Length / NumColumns;
+    if( i!=NumColumns )
+    {
+        ListCount = i;
+        UpdateListVis();
+    }
+    
+    if( !ScrollBar.bDisabled && !ScrollBar.bHideScrollbar )
+    {
+        // First draw scrollbar to allow it to resize itself.
+        for( j=0; j<4; ++j )
+            ScrollBar.InputPos[j] = CompPos[j];
+        if( OldXSize!=InputPos[2] )
+        {
+            OldXSize = InputPos[2];
+        }
+        ScrollBar.Canvas = Canvas;
+        ScrollBar.PreDraw();
+        
+        // Then downscale our selves to give room for scrollbar.
+        CompPos[2] -= ScrollBar.CompPos[2];
+        Canvas.SetOrigin(CompPos[0],CompPos[1]);
+        Canvas.SetClip(CompPos[0]+CompPos[2],CompPos[1]+CompPos[3]);
+        DrawMenu();
+        PreDrawListItems();
+        CompPos[2] += ScrollBar.CompPos[2];
+    }
+    else
+    {
+        Canvas.SetOrigin(CompPos[0],CompPos[1]);
+        Canvas.SetClip(CompPos[0]+CompPos[2],CompPos[1]+CompPos[3]);
+        DrawMenu();
+        PreDrawListItems();
+    }
+}
+
+function PreDrawListItems()
+{
+    local int i,XNum,r;
+    local float XS,YS;
+    
+    XNum = 0;
+    r = 0;
+    XS = CompPos[2] / NumColumns;
+    YS = CompPos[3] / ListItemsPerPage;
+    VisRange[0] = (ScrollBar.CurrentScroll*NumColumns);
+    VisRange[1] = ItemComponents.Length;
+    for( i=VisRange[0]; i<VisRange[1]; ++i )
+    {
+        ItemComponents[i].Canvas = Canvas;
+        ItemComponents[i].InputPos[0] = CompPos[0]+XS*XNum;
+        ItemComponents[i].InputPos[1] = CompPos[1]+YS*r;
+        ItemComponents[i].InputPos[2] = XS;
+        ItemComponents[i].InputPos[3] = YS;
+        ItemComponents[i].PreDraw();
+
+        if( ++XNum==NumColumns )
+        {
+            XNum = 0;
+            if( ++r==ListItemsPerPage )
+            {
+                VisRange[1] = i+1;
+                break;
+            }
+        }
+    }
+}
+
+function ChangeListSize( int NewSize );
+
+function MouseClick( bool bRight );
+function MouseRelease( bool bRight );
+function MouseLeave()
+{
+    Super(KFGUI_Base).MouseLeave();
+}
+function MouseEnter()
+{
+    Super(KFGUI_Base).MouseEnter();
+}
+
+function bool CaptureMouse()
+{
+    local int i;
+    
+    if( ItemComponents.Length > 0 )
+    {
+        for( i=VisRange[1] - 1; i>=VisRange[0] && i<ItemComponents.Length; i-- )
+        {
+            if( ItemComponents[i].CaptureMouse() )
+            {
+                MouseArea = ItemComponents[i];
+                return true;
+            }
+        }
+    }
+    
+    return Super.CaptureMouse();
+}
+function CloseMenu()
+{
+    local int i;
+    
+    for( i=0; i<ItemComponents.Length; ++i )
+        ItemComponents[i].CloseMenu();
+    Super.CloseMenu();
+}
+function NotifyLevelChange()
+{
+    local int i;
+    
+    for( i=0; i<ItemComponents.Length; ++i )
+        ItemComponents[i].NotifyLevelChange();
+    Super.NotifyLevelChange();
+}
+function InventoryChanged(optional KFWeapon Wep, optional bool bRemove)
+{
+    local int i;
+    
+    for( i=0; i<ItemComponents.Length; ++i )
+        ItemComponents[i].InventoryChanged(Wep,bRemove);
+}
+function MenuTick( float DeltaTime )
+{
+    local int i;
+
+    Super.MenuTick(DeltaTime);
+    for( i=0; i<ItemComponents.Length; ++i )
+        ItemComponents[i].MenuTick(DeltaTime);
+}
+
+defaultproperties
+{
+    ListCount=0
+    NumColumns=1
+    bClickable=true
+    bDrawBackground=false
+}

Src/KFClassicHUD/Classes/KFGUI_EditBox.uc

@@ -0,0 +1,428 @@
+Class KFGUI_EditBox extends KFGUI_Clickable;
+
+var enum eTextCase
+{
+    TXTC_None,
+    TXTC_Upper,
+    TXTC_Lower,
+} TextCase;
+
+var Color FontColor;
+
+var string TextStr,AllowedCharSet;
+var bool bDrawBackground,bNoClearOnEnter,bMaskText,bIntOnly,bFloatOnly,bIncludeSign,bConvertSpaces,bCtrl,bAllSelected,bForceShowCaret;
+var int MaxWidth;
+var bool bReadOnly,bAlwaysNotify;
+var int CaretPos,FirstVis,LastSizeX,LastCaret,LastLength;
+var float TextScale;
+
+function InitMenu()
+{
+    Super.InitMenu();
+
+    if ( bIntOnly || bFloatOnly )
+    {
+        AllowedCharSet = "0123456789";
+
+        if (bFloatOnly)
+            AllowedCharSet $= ".";
+    }
+
+    bAllSelected = true;
+}
+
+function SetText(string NewText, optional bool bIgnoreDelegate)
+{
+    local bool bChanged;
+
+    bChanged = bAlwaysNotify || TextStr != NewText;
+    TextStr = NewText;
+    CaretPos = Len(TextStr);
+
+    if (bChanged && !bIgnoreDelegate)
+        TextChanged();
+
+    bAllSelected=true;
+}
+
+function bool NotifyInputChar(int Key, string Unicode)
+{
+    local string Temp,S;
+
+    if (bReadOnly)
+        return false;
+
+    if( UniCode!="" )
+        S = Unicode;
+    else S = Chr(Key);
+    
+    if( Asc(S) == 13 || Asc(S) == 8 || Asc(S) == 27 )
+        return false;
+        
+    if( bCtrl )
+        return false;
+
+    if(bAllSelected)
+    {
+        TextStr="";
+        CaretPos=0;
+        bAllSelected=false;
+    }
+
+    if ( (AllowedCharSet=="") || ( (bIncludeSign) && ( (S=="-") || (S=="+") ) && (TextStr=="") ) || (InStr(AllowedCharSet,S)>=0) )
+    {
+        if ( (MaxWidth==0) || (Len(TextStr)<MaxWidth) )
+        {
+            if ( (bConvertSpaces) && ((S==" ") || (S=="?") || (S=="\\")) )
+                S = "_";
+
+            if ( (TextStr=="") || ( CaretPos==Len(TextStr) ) )
+            {
+                TextStr = TextStr$S;
+                CaretPos=Len(TextStr);
+            }
+            else
+            {
+                Temp = Left(TextStr,CaretPos)$S$Mid(TextStr,CaretPos);
+                TextStr = Temp;
+                CaretPos++;
+            }
+
+            TextChanged();
+            return true;
+        }
+    }
+
+    return false;
+}
+
+function SetInputText(string S)
+{
+    switch(TextCase)
+    {
+        case TXTC_Upper:
+            S = Caps(S);
+            break;
+        case TXTC_Lower:
+            S = Locs(S);
+            break;
+    }
+    
+    TextStr = S;
+    TextChanged();
+}
+
+function AppendInputText(string Text)
+{
+    local int Character;
+
+    while (Len(Text) > 0)
+    {
+        Character = Asc(Left(Text, 1));
+        Text = Mid(Text, 1);
+
+        if (Character >= 0x20 && Character < 0x100)
+        {
+            SetInputText(Left(TextStr, CaretPos) $ Chr(Character) $ Right(TextStr, Len(TextStr) - CaretPos));
+            CaretPos += 1;
+        }
+    }
+}
+
+function bool ProcessControlKey(name Key, EInputEvent Event)
+{
+    if (Key == 'LeftControl' || Key == 'RightControl')
+    {
+        if (Event == IE_Released)
+        {
+            bCtrl = false;
+        }
+        else if (Event == IE_Pressed)
+        {
+            bCtrl = true;
+        }
+
+        return true;
+    }
+    else if (bCtrl && Event == IE_Pressed && GetPlayer() != None)
+    {
+        if (Key == 'V')
+        {
+            // paste
+            AppendInputText(GetPlayer().PasteFromClipboard());
+            return true;
+        }
+        else if (Key == 'C')
+        {
+            // copy
+            GetPlayer().CopyToClipboard(TextStr);
+            return true;
+        }
+        else if (Key == 'X')
+        {
+            // cut
+            if (TextStr != "")
+            {
+                GetPlayer().CopyToClipboard(TextStr);
+                SetInputText("");
+                CaretPos = 0;
+            }
+            return true;
+        }
+    }
+
+    return false;
+}
+
+function bool NotifyInputKey(int ControllerId, name Key, EInputEvent Event, float AmountDepressed, bool bGamepad)
+{
+    local string Temp;
+    
+    if( bReadOnly )
+    {
+        return false;
+    }
+    
+    if (ProcessControlKey(Key, Event))
+    {
+        return false;
+    }
+    else if( Key == 'Escape' && Event == IE_Pressed )
+    {
+        if( TextStr!="" )
+        {
+            SetInputText("");
+            CaretPos = 0;
+            return true;
+        }
+        else
+        {
+            if( ParentComponent != None )
+            {
+                ParentComponent.UserPressedEsc();
+                return true;
+            }
+        }
+    }
+    else if( Key=='Enter' && Event == IE_Released )
+    {
+        if( TextStr!="" )
+        {
+            Temp = TextStr;
+            OnTextFinished(self, Temp);
+            if( !bNoClearOnEnter )
+            {
+                SetInputText("");
+                CaretPos = 0;
+            }
+        }
+
+        return true;
+    }
+    else if ( Key=='Home' )
+    {
+        CaretPos = 0;
+        return true;
+    }
+    else if ( Key=='End' )
+    {
+        CaretPos = Len(TextStr);
+        return true;
+    }
+    else if( Event == IE_Pressed || Event == IE_Repeat )
+    {
+        if( Key=='Backspace' || Key=='Delete' )
+        {
+            if( bAllSelected )
+            {
+                SetInputText("");
+                CaretPos = 0;
+            }
+            else if( CaretPos>0 )
+            {
+                SetInputText(Left(TextStr,CaretPos-1) $ Right(TextStr, Len(TextStr) - CaretPos));
+                CaretPos -= 1;
+            }
+
+            return true;
+        }
+        else if ( Key=='Left' )
+        {
+            CaretPos = Max(0, CaretPos - 1);
+            return true;
+        }
+        else if ( Key=='Right' )
+        {
+            CaretPos = Min(Len(TextStr), CaretPos + 1);
+            return true;
+        }
+    }
+
+    return true;
+}
+
+function string ConvertIllegal(string InputStr)
+{
+    local int i, Max;
+    local string Retval;
+    local string C;
+
+    i = 0;
+    Max = Len(InputStr);
+    while ( i < Max )
+    {
+        C = Mid(InputStr,i,1);
+        if ( AllowedCharSet != "" && InStr(AllowedCharSet,C) < 0 )
+        {
+            C = "";
+        }
+        if ( bConvertSpaces &&
+            ((C == " ") || (C =="?") || (C=="\\") ))
+        {
+            C = "_";
+        }
+        Retval = Retval $ C;
+        i++;
+    }
+
+    if (MaxWidth > 0)
+        return Left(Retval,MaxWidth);
+
+    return Retval;
+}
+
+function string GetText()
+{
+    return TextStr;
+}
+
+function TextChanged()
+{
+    OnChange(Self);
+}
+
+function DrawMenu()
+{
+    local string Storage,FinalDraw,TmpString;
+    local int MaskIndex,StorageLength;
+    local float XL,YL,BoxWidth,FontScale,CursorY,BorderSize;
+    local FontRenderInfo FRI;
+    
+    Super.DrawMenu();
+    
+    if( bDrawBackground )
+    {
+        Canvas.SetDrawColor(250,250,250,255);
+        Canvas.SetPos(0.f,0.f);
+        Canvas.DrawTileStretched(Owner.CurrentStyle.BorderTextures[`BOX_SMALL],CompPos[2],CompPos[3],0,0,Owner.CurrentStyle.BorderTextures[`BOX_SMALL].GetSurfaceWidth(),Owner.CurrentStyle.BorderTextures[`BOX_SMALL].GetSurfaceHeight());
+    }
+    
+    BorderSize = Owner.CurrentStyle.ScreenScale(4.f);
+    
+    FRI.bClipText = true;
+    FRI.bEnableShadow = true;
+
+    Storage = TextStr;
+
+    if ( bMaskText && Len(Storage)>0 )
+    {
+        StorageLength = Len(Storage);
+        
+        Storage = "";
+        for(MaskIndex=1; MaskIndex <= StorageLength; MaskIndex++ )
+        {
+            Storage $= "*";
+        }
+    }
+    
+    Canvas.Font = Owner.CurrentStyle.PickFont(FontScale);
+    FontScale *= TextScale;
+
+    BoxWidth=CompPos[2]*0.9875;
+    
+    if ( (Len(Storage) != LastLength) || (CaretPos!=LastCaret) )
+    {
+        if (CaretPos<=FirstVis)
+            FirstVis = Max(0,CaretPos-1);
+        else
+        {
+            FinalDraw = Mid(Storage, FirstVis, CaretPos-FirstVis);
+            Canvas.TextSize(FinalDraw, XL, YL, FontScale, FontScale);
+
+            while ( (XL>=BoxWidth) && (FirstVis<Len(Storage)) )
+            {
+                FirstVis++;
+                FinalDraw = Mid(Storage, FirstVis, CaretPos-FirstVis);
+                Canvas.TextSize(FinalDraw, XL, YL, FontScale, FontScale);
+            }
+        }
+    }
+    LastLength = Len(Storage);
+
+    if (bReadOnly)
+    {
+        FirstVis = 0;
+    }
+
+    FinalDraw = Mid(Storage, FirstVis, Len(Storage)-FirstVis);
+
+    if (!bReadOnly && (Owner.KeyboardFocus == self || bForceShowCaret))
+    {
+        if ( (FirstVis==CaretPos) || (Len(FinalDraw)==0) )
+        {
+            Canvas.TextSize("W", XL, YL, FontScale, FontScale);
+            XL = BorderSize;
+            bAllSelected=false;
+        }
+        else
+        {
+            TmpString = Mid(FinalDraw, 0, CaretPos-FirstVis);
+            Canvas.TextSize(TmpString, XL, YL, FontScale, FontScale);
+        }
+
+        CursorY = (CompPos[3]/2) - ((YL-Owner.HUDOwner.ScaledBorderSize)/2);
+
+        if(bAllSelected)
+        {
+            Canvas.SetDrawColor(255,255,255,195);
+            Canvas.SetPos(BorderSize, CursorY);
+            Canvas.DrawTile( Owner.DefaultPens[`PEN_WHITE], XL, YL-Owner.HUDOwner.ScaledBorderSize, 0, 0, Owner.DefaultPens[`PEN_WHITE].GetSurfaceWidth(), Owner.DefaultPens[`PEN_WHITE].GetSurfaceHeight() );
+        }
+        else
+        {
+            Canvas.SetDrawColor(255,255,255,Owner.CursorFlash);
+            Canvas.SetPos(XL + (Len(FinalDraw) == 0 ? 0 : 3), CursorY);
+            Canvas.DrawTile( Owner.DefaultPens[`PEN_WHITE], 3, YL-Owner.HUDOwner.ScaledBorderSize, 0, 0, Owner.DefaultPens[`PEN_WHITE].GetSurfaceWidth(), Owner.DefaultPens[`PEN_WHITE].GetSurfaceHeight() );
+        }
+    }
+    
+    Canvas.DrawColor = FontColor;
+    Canvas.SetPos(BorderSize, (CompPos[3]/2) - (YL/2));
+    Canvas.DrawText(FinalDraw,,FontScale,FontScale,FRI);
+}
+
+function HandleMouseClick( bool bRight )
+{
+    if( Owner.KeyboardFocus != self )
+    {
+        GrabKeyFocus();
+    }
+        
+    CaretPos = Len(TextStr);
+    bAllSelected = !bAllSelected;
+}
+
+Delegate OnChange(KFGUI_EditBox Sender);
+Delegate OnTextFinished(KFGUI_EditBox Sender, string S);
+
+defaultproperties
+{
+    FontColor=(R=255,G=255,B=255,A=255)
+    MaxWidth=768
+    TextScale=1
+    TextCase=TXTC_None
+    LastCaret=-1
+    LastLength=-1
+    
+    YSize=0.06
+}

Src/KFClassicHUD/Classes/KFGUI_EditControl.uc

@@ -0,0 +1,102 @@
+Class KFGUI_EditControl extends KFGUI_Clickable;
+
+var export editinline KFGUI_TextLable TextLable;
+var transient float TextHeight,TextScale;
+var transient Font TextFont;
+var Canvas.FontRenderInfo TextFontInfo;
+
+var(Lable) float LableWidth;
+var(Lable) string LableString;
+var(Lable) color LableColor; // Label text color.
+var(Lable) byte FontScale;
+var(Lable) bool bScaleByFontSize; // Scale this component height by font height.
+
+function InitMenu()
+{
+    if( LableString=="" )
+        TextLable = None;
+    else
+    {
+        TextLable.SetText(LableString);
+        TextLable.FontScale = FontScale;
+        TextLable.XPosition = XPosition;
+        TextLable.YPosition = YPosition;
+        TextLable.XSize = (XSize*LableWidth*0.975);
+        TextLable.YSize = YSize;
+        TextLable.Owner = Owner;
+        TextLable.TextColor = LableColor;
+        TextLable.ParentComponent = Self;
+        TextLable.InitMenu();
+        XPosition+=(XSize*LableWidth);
+        XSize*=(1.f-LableWidth);
+    }
+    Super.InitMenu();
+    bClickable = !bDisabled;
+}
+
+function UpdateSizes()
+{
+    // Update height.
+    if( bScaleByFontSize )
+        YSize = ((TextHeight*1.05) + 6) / InputPos[3];
+}
+
+function PreDraw()
+{
+    local float XS;
+    local byte i;
+
+    Canvas.Font = Owner.CurrentStyle.PickFont(TextScale);
+    
+    TextScale *= FontScale;
+    TextFont = Canvas.Font;
+    
+    Canvas.TextSize("ABC",XS,TextHeight,TextScale,TextScale);
+    
+    UpdateSizes();
+
+    Super.PreDraw();
+    if( TextLable!=None )
+    {
+        TextLable.YSize = YSize;
+        TextLable.Canvas = Canvas;
+        for( i=0; i<4; ++i )
+            TextLable.InputPos[i] = InputPos[i];
+        TextLable.PreDraw();
+    }
+}
+
+final function DrawClippedText( string S, float TScale, float MaxX )
+{
+    local int i,l;
+    local float X,XL,YL;
+    
+    l = Len(S);
+    for( i=0; i<l; ++i )
+    {
+        Canvas.TextSize(Mid(S,i,1),XL,YL,TScale,TScale);
+        if( (Canvas.CurX+X+XL)>MaxX )
+        {
+            --i;
+            break;
+        }
+        X+=XL;
+    }
+    Canvas.DrawText(Left(S,i),,TScale,TScale,TextFontInfo);
+}
+
+defaultproperties
+{
+    LableColor=(R=255,G=255,B=255,A=255)
+    FontScale=1
+    LableWidth=0.5
+    bScaleByFontSize=true
+    TextFontInfo=(bClipText=true,bEnableShadow=true)
+
+    Begin Object Class=KFGUI_TextLable Name=MyBoxLableText
+        AlignX=0
+        AlignY=1
+        TextFontInfo=(bClipText=true,bEnableShadow=true)
+    End Object
+    TextLable=MyBoxLableText
+}

Src/KFClassicHUD/Classes/KFGUI_FloatingWindow.uc

@@ -0,0 +1,107 @@
+Class KFGUI_FloatingWindow extends KFGUI_Page
+    abstract;
+
+var() string WindowTitle; // Title of this window.
+var float DragOffset[2], OpenAnimSpeed;
+var KFGUI_FloatingWindowHeader HeaderComp;
+var bool bDragWindow,bUseAnimation;
+
+var float WindowFadeInTime;
+var transient float OpenStartTime,OpenEndTime;
+
+function InitMenu()
+{
+    Super.InitMenu();
+    HeaderComp = new (Self) class'KFGUI_FloatingWindowHeader';
+    AddComponent(HeaderComp);
+}
+function ShowMenu()
+{
+    Super.ShowMenu();
+    
+    OpenStartTime = GetPlayer().WorldInfo.RealTimeSeconds;
+    OpenEndTime = GetPlayer().WorldInfo.RealTimeSeconds + OpenAnimSpeed;
+}
+function DrawMenu()
+{
+    local float TempSize;
+    
+    if( bUseAnimation )
+    {
+        TempSize = `TimeSinceEx(GetPlayer(), OpenStartTime);
+        if ( WindowFadeInTime - TempSize > 0 && FrameOpacity != default.FrameOpacity )
+            FrameOpacity = (1.f - ((WindowFadeInTime - TempSize) / WindowFadeInTime)) * default.FrameOpacity;
+    }
+    
+    Owner.CurrentStyle.RenderFramedWindow(Self);
+    
+    if( HeaderComp!=None )
+    {
+        HeaderComp.CompPos[3] = Owner.CurrentStyle.DefaultHeight;
+        HeaderComp.YSize = HeaderComp.CompPos[3] / CompPos[3]; // Keep header height fit the window height.
+    }
+}
+function SetWindowDrag( bool bDrag )
+{
+    bDragWindow = bDrag;
+    if( bDrag )
+    {
+        DragOffset[0] = Owner.MousePosition.X-CompPos[0];
+        DragOffset[1] = Owner.MousePosition.Y-CompPos[1];
+    }
+}
+function bool CaptureMouse()
+{
+    local int i;
+    
+    if( bDragWindow && HeaderComp!=None ) // Always keep focus on window frame now!
+    {
+        MouseArea = HeaderComp;
+        return true;
+    }
+    
+    for( i=0; i<Components.Length; i++ )
+    {
+        if( Components[i].CaptureMouse() )
+        {
+            MouseArea = Components[i];
+            return true;
+        }
+    }
+    
+    MouseArea = None;
+    
+    return Super(KFGUI_Base).CaptureMouse();
+}
+function PreDraw()
+{
+    local float Frac, CenterX, CenterY;
+    
+    if( bUseAnimation )
+    {
+        Frac = Owner.CurrentStyle.TimeFraction(OpenStartTime, OpenEndTime, GetPlayer().WorldInfo.RealTimeSeconds);
+        XSize = Lerp(default.XSize*0.75, default.XSize, Frac);
+        YSize = Lerp(default.YSize*0.75, default.YSize, Frac);
+        
+        CenterX = (default.XPosition + default.XSize * 0.5) - ((default.XSize*0.75)/2);
+        CenterY = (default.YPosition + default.YSize * 0.5) - ((default.YSize*0.75)/2);
+        
+        XPosition = Lerp(CenterX, default.XPosition, Frac);
+        YPosition = Lerp(CenterY, default.YPosition, Frac);
+        
+        if( bDragWindow )
+        {
+            XPosition = FClamp(Owner.MousePosition.X-DragOffset[0],0,InputPos[2]-CompPos[2]) / InputPos[2];
+            YPosition = FClamp(Owner.MousePosition.Y-DragOffset[1],0,InputPos[3]-CompPos[3]) / InputPos[3];
+        }
+    }
+    
+    Super.PreDraw();
+}
+
+defaultproperties
+{
+    bUseAnimation=true
+    OpenAnimSpeed=0.05f
+    WindowFadeInTime=0.2f
+}

Src/KFClassicHUD/Classes/KFGUI_FloatingWindowHeader.uc

@@ -0,0 +1,23 @@
+Class KFGUI_FloatingWindowHeader extends KFGUI_Base;
+
+var bool bDragWindow;
+
+function PreDraw()
+{
+    ComputeCoords();
+}
+function MouseClick( bool bRight )
+{
+    if( !bRight )
+        KFGUI_FloatingWindow(ParentComponent).SetWindowDrag(true);
+}
+function MouseRelease( bool bRight )
+{
+    if( !bRight )
+        KFGUI_FloatingWindow(ParentComponent).SetWindowDrag(false);
+}
+
+defaultproperties
+{
+    bClickable=true
+}

Src/KFClassicHUD/Classes/KFGUI_Frame.uc

@@ -0,0 +1,128 @@
+Class KFGUI_Frame extends KFGUI_FloatingWindow;
+ 
+var() float EdgeSize[4]; // Pixels wide for edges (left, top, right, bottom).
+var() float HeaderSize[2]; // Pixels wide for edges (left, top).
+var() Texture FrameTex;
+var() bool bDrawHeader,bHeaderCenter,bUseLegacyDrawTile,bDrawBackground;
+var() float FontScale;
+ 
+function InitMenu()
+{
+    Super(KFGUI_Page).InitMenu();
+}
+
+function DrawMenu()
+{
+    local float TempSize;
+    
+    if( bUseAnimation )
+    {
+        TempSize = `TimeSinceEx(GetPlayer(), OpenStartTime);
+        if ( WindowFadeInTime - TempSize > 0 && FrameOpacity != default.FrameOpacity )
+            FrameOpacity = (1.f - ((WindowFadeInTime - TempSize) / WindowFadeInTime)) * default.FrameOpacity;
+    }
+    
+    if( bDrawBackground )
+    {
+        OnDrawFrame(Canvas, CompPos[2], CompPos[3]);
+    }
+}
+
+delegate OnDrawFrame(Canvas C, float W, Float H)
+{
+    local float T,XL,YL,HeaderH;
+    local FontRenderInfo FRI;
+    
+    if( FrameTex == None )
+    {
+        return;
+    }
+    
+    C.SetDrawColor(255,255,255,FrameOpacity);
+    if( bUseLegacyDrawTile )
+    {
+        Owner.CurrentStyle.DrawTileStretched(FrameTex,0,0,W,H);
+    }
+    else 
+    {
+        Canvas.SetPos(0.f, 0.f);
+        Canvas.DrawTileStretched(FrameTex,W,H,0,0,FrameTex.GetSurfaceWidth(),FrameTex.GetSurfaceHeight());
+    }
+   
+    if( bDrawHeader && WindowTitle!="" )
+    {
+        FRI.bClipText = true;
+        FRI.bEnableShadow = true;
+    
+        C.Font = Owner.CurrentStyle.MainFont;
+        T = Owner.CurrentStyle.ScreenScale(FontScale);
+        
+        C.SetDrawColor(250,250,250,FrameOpacity);
+        C.TextSize(WindowTitle, XL, YL, T, T);
+        
+        HeaderH = EdgeSize[1]-HeaderSize[1];
+        if( bHeaderCenter )
+            C.SetPos((W/2) - (XL/2),(HeaderH/2) - (YL/2));
+        else C.SetPos(HeaderSize[0],(HeaderH/2) - (YL/2));
+        
+        C.DrawText(WindowTitle,,T,T,FRI);
+    }
+}
+ 
+function PreDraw()
+{
+    local int i;
+    local byte j;
+    local float Frac, CenterX, CenterY;
+    
+    if( !bVisible )
+        return;
+        
+    if( bUseAnimation )
+    {
+        Frac = Owner.CurrentStyle.TimeFraction(OpenStartTime, OpenEndTime, GetPlayer().WorldInfo.RealTimeSeconds);
+        XSize = Lerp(default.XSize*0.75, default.XSize, Frac);
+        YSize = Lerp(default.YSize*0.75, default.YSize, Frac);
+        
+        CenterX = (default.XPosition + default.XSize * 0.5) - ((default.XSize*0.75)/2);
+        CenterY = (default.YPosition + default.YSize * 0.5) - ((default.YSize*0.75)/2);
+        
+        XPosition = Lerp(CenterX, default.XPosition, Frac);
+        YPosition = Lerp(CenterY, default.YPosition, Frac);
+    }
+ 
+    ComputeCoords();
+    Canvas.SetDrawColor(255,255,255);
+    Canvas.SetOrigin(CompPos[0],CompPos[1]);
+    Canvas.SetClip(CompPos[0]+CompPos[2],CompPos[1]+CompPos[3]);
+    DrawMenu();
+    
+    for( i=0; i<Components.Length; ++i )
+    {
+        Components[i].Canvas = Canvas;
+        for( j=0; j<4; ++j )
+        {
+            Components[i].InputPos[j] = CompPos[j]+EdgeSize[j];
+        }
+        Components[i].PreDraw();
+    }
+}
+
+defaultproperties
+{
+    bUseAnimation=false
+    bDrawHeader=true
+    bUseLegacyDrawTile=true
+    bDrawBackground=true
+    
+    FontScale=0.35f
+    FrameOpacity=255
+    
+    HeaderSize(0)=26.f
+    HeaderSize(1)=8.f
+   
+    EdgeSize(0)=20
+    EdgeSize(1)=35
+    EdgeSize(2)=-40
+    EdgeSize(3)=-50
+}

Src/KFClassicHUD/Classes/KFGUI_Image.uc

@@ -0,0 +1,143 @@
+Class KFGUI_Image extends KFGUI_Base;
+
+var enum eImageStyle
+{
+    ISTY_Normal,
+    ISTY_Stretched
+} ImageStyle;
+
+var enum eScaleStyle
+{
+    ISTY_Height,
+    ISTY_Width
+} ScaleStyle;
+
+var Color ImageColor;
+var Texture Image;
+var bool bAlignCenter, bForceUniformSize;
+var int X1,Y1,X2,Y2;
+var float ImageScale;
+
+function DrawMenu()
+{
+    local float X, Y, XL, YL;
+    
+    if( Image == None )
+        return;
+        
+    DrawBackground(Canvas, CompPos[2], CompPos[3]);
+    
+    Canvas.DrawColor = ImageColor;
+    
+    switch (ImageStyle)
+    {
+        case ISTY_Normal:
+            if( X1 != -1 )
+                X = X1;
+            else X = 0;
+
+            if( Y1 != -1 )
+                Y = Y1;
+            else Y = 0;
+            
+            if( bForceUniformSize )
+            {
+                if( ScaleStyle == ISTY_Height )
+                {
+                    YL = CompPos[3];
+                    XL = YL;
+                }
+                else
+                {
+                    XL = CompPos[2];
+                    YL = XL;
+                }
+            }
+            else
+            {
+                if( Y2 == -1 )
+                    YL = FMin(CompPos[3], Image.GetSurfaceHeight());
+                else YL = (Y2-Y1);
+
+                if( X2 == -1 )
+                    XL = FMin(CompPos[2], Image.GetSurfaceWidth());
+                else XL = (X2-X1);
+            }
+            
+            if( bAlignCenter )
+            {
+                Canvas.SetPos((CompPos[2]/2) - (XL/2), (CompPos[3]/2) - (YL/2));
+                Canvas.DrawTile(Image, XL, YL, X, Y, Image.GetSurfaceWidth(), Image.GetSurfaceHeight());
+            }
+            else
+            {
+                Canvas.SetPos(0.f, 0.f);
+                Canvas.DrawTile(Image, XL, YL, X, Y, Image.GetSurfaceWidth(), Image.GetSurfaceHeight());
+            }
+                
+            break;
+        case ISTY_Stretched:
+            if ( X1 < 0 && X2 < 0 && Y1 < 0 && Y2 < 0 ) 
+                Owner.CurrentStyle.DrawTileStretched(Image, 0.f, 0.f, CompPos[2], CompPos[3]);
+            else
+            {
+                if ( X1 != -1 )
+                    X = X1;
+                else X = 0;
+
+                if( Y1 != -1 )
+                    Y = Y1;
+                else Y = 0;
+                
+                if( bForceUniformSize )
+                {
+                    if( ScaleStyle == ISTY_Height )
+                    {
+                        YL = CompPos[3];
+                        XL = YL;
+                    }
+                    else
+                    {
+                        XL = CompPos[2];
+                        YL = XL;
+                    }
+                }
+                else
+                {
+                    if( Y2 == -1 )
+                        YL = FMin(CompPos[3], Image.GetSurfaceHeight());
+                    else YL = (Y2-Y1);
+
+                    if( X2 == -1 )
+                        XL = FMin(CompPos[2], Image.GetSurfaceWidth());
+                    else XL = (X2-X1);
+                }
+
+                if( bAlignCenter )
+                {
+                    Canvas.SetPos((CompPos[2]/2) - (XL/2), (CompPos[3]/2) - (YL/2));
+                    Canvas.DrawTile(Image, CompPos[2], CompPos[3], X, Y, Image.GetSurfaceWidth(), Image.GetSurfaceHeight());
+                }
+                else
+                {
+                    Canvas.SetPos(0.f, 0.f);
+                    Canvas.DrawTile(Image, CompPos[2], CompPos[3], X, Y, Image.GetSurfaceWidth(), Image.GetSurfaceHeight());
+                }
+                    
+                break;
+            }
+            break;
+    }
+}
+
+delegate DrawBackground(Canvas C, float W, Float H);
+
+defaultproperties
+{
+    ImageColor=(R=255,G=255,B=255,A=255)
+    ImageStyle=ISTY_Normal
+    X1=-1
+    X2=-1
+    Y1=-1
+    Y2=-1
+}

Src/KFClassicHUD/Classes/KFGUI_List.uc

@@ -0,0 +1,219 @@
+// List box with custom render code for the items.
+Class KFGUI_List extends KFGUI_MultiComponent;
+
+var() bool bDrawBackground, bHideScrollbar, bUseFocusSound;
+var() protectedwrite int ListCount;
+var() int ListItemsPerPage;
+var() color BackgroundColor;
+var KFGUI_ScrollBarV ScrollBar;
+
+var transient float OldXSize,ItemHeight,MouseYHit;
+var transient int FocusMouseItem,LastFocusItem;
+
+var byte PressedDown[2];
+var bool bPressedDown;
+
+delegate OnDrawItem( Canvas C, int Index, float YOffset, float Height, float Width, bool bFocus );
+
+// Requires bClickable=true to receive this event.
+delegate OnClickedItem( int Index, bool bRight, int MouseX, int MouseY );
+delegate OnDblClickedItem( int Index, bool bRight, int MouseX, int MouseY );
+
+function InitMenu()
+{
+    Super.InitMenu();
+    ScrollBar = KFGUI_ScrollBarV(FindComponentID('Scrollbar'));
+    ScrollBar.bHideScrollbar = bHideScrollbar;
+    UpdateListVis();
+}
+
+function DrawMenu()
+{
+    local int i,n;
+    local float Y;
+    local bool bCheckMouse;
+
+    if( bDrawBackground )
+    {
+        Canvas.DrawColor = BackgroundColor;
+        Canvas.SetPos(0.f,0.f);
+        Canvas.DrawTileStretched(Owner.CurrentStyle.BorderTextures[`BOX_INNERBORDER],CompPos[2],CompPos[3],0,0,128,128);
+    }
+
+    // Mouse focused item check.
+    bCheckMouse = bClickable && bFocused;
+    FocusMouseItem = -1;
+    if( bCheckMouse )
+        MouseYHit = Owner.MousePosition.Y - CompPos[1];
+
+    n = ScrollBar.CurrentScroll;
+    ItemHeight = CompPos[3] / ListItemsPerPage;
+    Y = 0.f;
+    for( i=0; i<ListItemsPerPage; ++i )
+    {
+        if( n>=ListCount )
+            break;
+        if( bCheckMouse && FocusMouseItem==-1 )
+        {
+            if( MouseYHit<ItemHeight )
+                FocusMouseItem = n;
+            else MouseYHit-=ItemHeight;
+        }
+        OnDrawItem(Canvas,n,Y,ItemHeight,CompPos[2],(FocusMouseItem==n));
+        Y+=ItemHeight;
+        ++n;
+    }
+    if( LastFocusItem!=FocusMouseItem )
+    {
+        LastFocusItem = FocusMouseItem;
+        if( bUseFocusSound )
+        {
+            PlayMenuSound(MN_FocusHover);
+        }
+    }
+}
+
+function PreDraw()
+{
+    local int i;
+    local byte j;
+    
+    if( !bVisible )
+        return;
+
+    ComputeCoords();
+    
+    if( !ScrollBar.bDisabled && !ScrollBar.bHideScrollbar )
+    {
+        // First draw scrollbar to allow it to resize itself.
+        for( j=0; j<4; ++j )
+            ScrollBar.InputPos[j] = CompPos[j];
+        if( OldXSize!=InputPos[2] )
+        {
+            OldXSize = InputPos[2];
+            ScrollBar.XPosition = 1.f - ScrollBar.GetWidth();
+        }
+        ScrollBar.Canvas = Canvas;
+        ScrollBar.PreDraw();
+        
+        // Then downscale our selves to give room for scrollbar.
+        CompPos[2] -= ScrollBar.CompPos[2];
+        Canvas.SetOrigin(CompPos[0],CompPos[1]);
+        Canvas.SetClip(CompPos[0]+CompPos[2],CompPos[1]+CompPos[3]);
+        DrawMenu();
+        CompPos[2] += ScrollBar.CompPos[2];
+    }
+    else
+    {
+        Canvas.SetOrigin(CompPos[0],CompPos[1]);
+        Canvas.SetClip(CompPos[0]+CompPos[2],CompPos[1]+CompPos[3]);
+        DrawMenu();
+    }
+    
+    // Then draw rest of components.
+    for( i=0; i<Components.Length; ++i )
+    {
+        if( Components[i]!=ScrollBar )
+        {
+            Components[i].Canvas = Canvas;
+            for( j=0; j<4; ++j )
+                Components[i].InputPos[j] = CompPos[j];
+            Components[i].PreDraw();
+        }
+    }
+}
+function UpdateListVis()
+{
+    if( ListCount<=ListItemsPerPage )
+    {
+        ScrollBar.UpdateScrollSize(0,1,1,1);
+        ScrollBar.SetDisabled(true);
+    }
+    else
+    {
+        ScrollBar.UpdateScrollSize(ScrollBar.CurrentScroll,(ListCount-ListItemsPerPage),1,ListItemsPerPage);
+        ScrollBar.SetDisabled(false);
+    }
+}
+function ChangeListSize( int NewSize )
+{
+    if( ListCount==NewSize )
+        return;
+    ListCount = NewSize;
+    UpdateListVis();
+}
+final function int GetListSize()
+{
+    return ListCount;
+}
+
+function DoubleMouseClick( bool bRight )
+{
+    if( !bDisabled && bClickable )
+    {
+        PressedDown[byte(bRight)] = 0;
+        bPressedDown = (PressedDown[0]!=0 || PressedDown[1]!=0);
+        OnDblClickedItem(FocusMouseItem,bRight,Owner.MousePosition.X-CompPos[0],MouseYHit);
+    }
+}
+function MouseClick( bool bRight )
+{
+    if( !bDisabled && bClickable )
+    {
+        PressedDown[byte(bRight)] = 1;
+        bPressedDown = true;
+    }
+}
+function MouseRelease( bool bRight )
+{
+    if( !bDisabled && bClickable && PressedDown[byte(bRight)]==1 )
+    {
+        PressedDown[byte(bRight)] = 0;
+        bPressedDown = (PressedDown[0]!=0 || PressedDown[1]!=0);
+        OnClickedItem(FocusMouseItem,bRight,Owner.MousePosition.X-CompPos[0],MouseYHit);
+    }
+}
+function MouseLeave()
+{
+    Super.MouseLeave();
+    PressedDown[0] = 0;
+    PressedDown[1] = 0;
+    bPressedDown = false;
+}
+function MouseEnter()
+{
+    Super.MouseEnter();
+    LastFocusItem = -1;
+}
+
+function ScrollMouseWheel( bool bUp )
+{
+    if( !ScrollBar.bDisabled )
+        ScrollBar.ScrollMouseWheel(bUp);
+}
+
+function NotifyMousePaused()
+{
+    if( Owner.InputFocus==None && FocusMouseItem>=0 )
+        OnMouseRest(FocusMouseItem);
+}
+
+Delegate OnMouseRest( int Item );
+
+defaultproperties
+{
+    ListItemsPerPage=7
+    ListCount=1
+    BackgroundColor=(R=0,G=0,B=0,A=75)
+    bDrawBackground=false
+    bUseFocusSound=false
+
+    Begin Object Class=KFGUI_ScrollBarV Name=ListScroller
+        XPosition=0.96
+        YPosition=0
+        XSize=0.04
+        YSize=1.05
+        ID="Scrollbar"
+    End Object
+    Components.Add(ListScroller)
+}

Src/KFClassicHUD/Classes/KFGUI_ListHorz.uc

@@ -0,0 +1,225 @@
+Class KFGUI_ListHorz extends KFGUI_MultiComponent;
+
+var() bool bDrawBackground, bHideScrollbar, bUseFocusSound;
+var() protected int ListCount;
+var() int ListItemsPerPage;
+var() float ButtonScale;
+var() color BackgroundColor;
+var KFGUI_ScrollBarH ScrollBar;
+
+var transient float OldYSize,ItemWidth,MouseXHit;
+var transient int FocusMouseItem,LastFocusItem;
+
+var byte PressedDown[2];
+var bool bPressedDown;
+
+delegate OnDrawItem( Canvas C, int Index, float XOffset, float Height, float Width, bool bFocus );
+
+// Requires bClickable=true to receive this event.
+delegate OnClickedItem( int Index, bool bRight, int MouseX, int MouseY );
+delegate OnDblClickedItem( int Index, bool bRight, int MouseX, int MouseY );
+
+function InitMenu()
+{
+    Super.InitMenu();
+    ScrollBar = KFGUI_ScrollBarH(FindComponentID('Scrollbar'));
+    ScrollBar.bHideScrollbar = bHideScrollbar;
+    ScrollBar.ButtonScale = ButtonScale <= 0.f ? 1.f : ButtonScale;
+    UpdateListVis();
+}
+
+function DrawMenu()
+{
+    local int i,n;
+    local float X;
+    local bool bCheckMouse;
+
+    if( bDrawBackground )
+    {
+        //Canvas.DrawColor = BackgroundColor;
+        Canvas.SetDrawColor(250,250,250,255);
+        Canvas.SetPos(0.f,0.f);
+        Canvas.DrawTileStretched(Owner.CurrentStyle.BorderTextures[`BOX_INNERBORDER],CompPos[2],CompPos[3],0,0,128,128);
+    }
+
+    // Mouse focused item check.
+    bCheckMouse = bClickable && bFocused;
+    FocusMouseItem = -1;
+    if( bCheckMouse )
+        MouseXHit = Owner.MousePosition.X - CompPos[0];
+
+    n = ScrollBar.CurrentScroll;
+    ItemWidth = CompPos[2] / ListItemsPerPage;
+    X = 0.f;
+    for( i=0; i<ListItemsPerPage; ++i )
+    {
+        if( n>=ListCount )
+            break;
+        if( bCheckMouse && FocusMouseItem==-1 )
+        {
+            if( MouseXHit<ItemWidth )
+                FocusMouseItem = n;
+            else MouseXHit-=ItemWidth;
+        }
+        OnDrawItem(Canvas,n,X,CompPos[3],ItemWidth,(FocusMouseItem==n));
+        X+=ItemWidth;
+        ++n;
+    }
+    if( LastFocusItem!=FocusMouseItem )
+    {
+        LastFocusItem = FocusMouseItem;
+        if( bUseFocusSound )
+        {
+            PlayMenuSound(MN_FocusHover);
+        }
+    }
+}
+
+function PreDraw()
+{
+    local int i;
+    local byte j;
+    
+    if( !bVisible )
+        return;
+
+    ComputeCoords();
+    
+    if( !ScrollBar.bDisabled && !ScrollBar.bHideScrollbar )
+    {
+        // First draw scrollbar to allow it to resize itself.
+        for( j=0; j<4; ++j )
+            ScrollBar.InputPos[j] = CompPos[j];
+        if( OldYSize!=InputPos[3] )
+        {
+            OldYSize = InputPos[3];
+            ScrollBar.YPosition = 1.f - ScrollBar.GetWidth();
+        }
+        ScrollBar.Canvas = Canvas;
+        ScrollBar.PreDraw();
+        
+        // Then downscale our selves to give room for scrollbar.
+        CompPos[3] -= ScrollBar.CompPos[3]*1.15f;
+        Canvas.SetOrigin(CompPos[0],CompPos[1]);
+        Canvas.SetClip(CompPos[0]+CompPos[2],CompPos[1]+CompPos[3]);
+        DrawMenu();
+        CompPos[3] += ScrollBar.CompPos[3]*1.15f;
+    }
+    else
+    {
+        Canvas.SetOrigin(CompPos[0],CompPos[1]);
+        Canvas.SetClip(CompPos[0]+CompPos[2],CompPos[1]+CompPos[3]);
+        DrawMenu();
+    }
+    
+    // Then draw rest of components.
+    for( i=0; i<Components.Length; ++i )
+    {
+        if( Components[i]!=ScrollBar )
+        {
+            Components[i].Canvas = Canvas;
+            for( j=0; j<4; ++j )
+                Components[i].InputPos[j] = CompPos[j];
+            Components[i].PreDraw();
+        }
+    }
+}
+function UpdateListVis()
+{
+    if( ListCount<=ListItemsPerPage )
+    {
+        ScrollBar.UpdateScrollSize(0,1,1,1);
+        ScrollBar.SetDisabled(true);
+    }
+    else
+    {
+        ScrollBar.UpdateScrollSize(ScrollBar.CurrentScroll,(ListCount-ListItemsPerPage),1,ListItemsPerPage);
+        ScrollBar.SetDisabled(false);
+    }
+}
+function ChangeListSize( int NewSize )
+{
+    if( ListCount==NewSize )
+        return;
+    ListCount = NewSize;
+    UpdateListVis();
+}
+final function int GetListSize()
+{
+    return ListCount;
+}
+
+function DoubleMouseClick( bool bRight )
+{
+    if( !bDisabled && bClickable )
+    {
+        PlayMenuSound(MN_ClickButton);
+        PressedDown[byte(bRight)] = 0;
+        bPressedDown = (PressedDown[0]!=0 || PressedDown[1]!=0);
+        OnDblClickedItem(FocusMouseItem,bRight,MouseXHit,Owner.MousePosition.Y-CompPos[1]);
+    }
+}
+function MouseClick( bool bRight )
+{
+    if( !bDisabled && bClickable )
+    {
+        PressedDown[byte(bRight)] = 1;
+        bPressedDown = true;
+    }
+}
+function MouseRelease( bool bRight )
+{
+    if( !bDisabled && bClickable && PressedDown[byte(bRight)]==1 )
+    {
+        PlayMenuSound(MN_ClickButton);
+        PressedDown[byte(bRight)] = 0;
+        bPressedDown = (PressedDown[0]!=0 || PressedDown[1]!=0);
+        OnClickedItem(FocusMouseItem,bRight,MouseXHit,Owner.MousePosition.Y-CompPos[1]);
+    }
+}
+function MouseLeave()
+{
+    Super.MouseLeave();
+    PressedDown[0] = 0;
+    PressedDown[1] = 0;
+    bPressedDown = false;
+}
+function MouseEnter()
+{
+    Super.MouseEnter();
+    LastFocusItem = -1;
+    if( !bDisabled && bClickable && bUseFocusSound )
+        PlayMenuSound(MN_FocusHover);
+}
+
+function ScrollMouseWheel( bool bUp )
+{
+    if( !ScrollBar.bDisabled )
+        ScrollBar.ScrollMouseWheel(bUp);
+}
+
+function NotifyMousePaused()
+{
+    if( Owner.InputFocus==None && FocusMouseItem>=0 )
+        OnMouseRest(FocusMouseItem);
+}
+
+Delegate OnMouseRest( int Item );
+
+defaultproperties
+{
+    ListItemsPerPage=7
+    ListCount=1
+    BackgroundColor=(R=0,G=0,B=0,A=75)
+    bDrawBackground=false
+    bUseFocusSound=false
+
+    Begin Object Class=KFGUI_ScrollBarH Name=ListScroller
+        XPosition=0
+        YPosition=0.96
+        XSize=1
+        YSize=0.04
+        ID="Scrollbar"
+    End Object
+    Components.Add(ListScroller)
+}

Src/KFClassicHUD/Classes/KFGUI_ListItem.uc

@@ -0,0 +1,44 @@
+Class KFGUI_ListItem extends Object
+    transient;
+
+var KFGUI_ListItem Next;
+var array<string> Columns,SortColumns;
+var int Index,Value;
+
+var transient string Temp; // Cache sorting key.
+
+function SetValue( string S, int i, string SortStr )
+{
+    ParseStringIntoArray(S,Columns,"\n",false);
+    if( SortStr=="" )
+        SortColumns.Length = 0;
+    else ParseStringIntoArray(Caps(SortStr),SortColumns,"\n",false);
+    Value = i;
+}
+
+// Return string to draw on HUD.
+function string GetDisplayStr( int Column )
+{
+    if( Column<Columns.Length )
+        return Columns[Column];
+    return "";
+}
+
+// Return string to compare string with.
+function string GetSortStr( int Column )
+{
+    if( SortColumns.Length>0 )
+    {
+        if( Column<SortColumns.Length )
+            return SortColumns[Column];
+    }
+    if( Column<Columns.Length )
+        return Caps(Columns[Column]);
+    return "";
+}
+
+// Clear
+function Clear()
+{
+    Columns.Length = 0;
+}

Src/KFClassicHUD/Classes/KFGUI_MultiComponent.uc

@@ -0,0 +1,147 @@
+Class KFGUI_MultiComponent extends KFGUI_Base;
+
+var() export editinline array<KFGUI_Base> Components;
+
+function InitMenu()
+{
+    local int i;
+    
+    for( i=0; i<Components.Length; ++i )
+    {
+        Components[i].Owner = Owner;
+        Components[i].ParentComponent = Self;
+        Components[i].InitMenu();
+    }
+}
+function ShowMenu()
+{
+    local int i;
+    
+    for( i=0; i<Components.Length; ++i )
+        Components[i].ShowMenu();
+}
+function PreDraw()
+{
+    local int i;
+    local byte j;
+    
+    if( !bVisible )
+        return;
+
+    ComputeCoords();
+    Canvas.SetDrawColor(255,255,255);
+    Canvas.SetOrigin(CompPos[0],CompPos[1]);
+    Canvas.SetClip(CompPos[0]+CompPos[2],CompPos[1]+CompPos[3]);
+    DrawMenu();
+    for( i=0; i<Components.Length; ++i )
+    {
+        Components[i].Canvas = Canvas;
+        for( j=0; j<4; ++j )
+            Components[i].InputPos[j] = CompPos[j];
+        Components[i].PreDraw();
+    }
+}
+function InventoryChanged(optional KFWeapon Wep, optional bool bRemove)
+{
+    local int i;
+    
+    for( i=0; i<Components.Length; ++i )
+        Components[i].InventoryChanged(Wep,bRemove);
+}
+function MenuTick( float DeltaTime )
+{
+    local int i;
+
+    Super.MenuTick(DeltaTime);
+    for( i=0; i<Components.Length; ++i )
+        Components[i].MenuTick(DeltaTime);
+}
+
+function AddComponent( KFGUI_Base C )
+{
+    Components[Components.Length] = C;
+    C.Owner = Owner;
+    C.ParentComponent = Self;
+    C.InitMenu();
+}
+
+function CloseMenu()
+{
+    local int i;
+    
+    for( i=0; i<Components.Length; ++i )
+        Components[i].CloseMenu();
+}
+function bool CaptureMouse()
+{
+    local int i;
+    
+    for( i=Components.Length - 1; i>=0; i-- )
+    {
+        if( Components[i].CaptureMouse() )
+        {
+            MouseArea = Components[i];
+            return true;
+        }
+    }
+    MouseArea = None;
+    return Super.CaptureMouse(); // check with frame itself.
+}
+function bool ReceievedControllerInput(int ControllerId, name Key, EInputEvent Event)
+{
+    local int i;
+    
+    for( i=Components.Length - 1; i>=0; i-- )
+    {
+        if( Components[i].ReceievedControllerInput(ControllerId, Key, Event) )
+        {
+            return true;
+        }
+    }
+    
+    return Super.ReceievedControllerInput(ControllerId, Key, Event);
+}
+function KFGUI_Base FindComponentID( name InID )
+{
+    local int i;
+    local KFGUI_Base Result;
+
+    if( ID==InID )
+        Result = Self;
+    else
+    {
+        for( i=0; i<Components.Length && Result==None; ++i )
+            Result = Components[i].FindComponentID(InID);
+    }
+    return Result;
+}
+function FindAllComponentID( name InID, out array<KFGUI_Base> Res )
+{
+    local int i;
+
+    if( ID==InID )
+        Res[Res.Length] = Self;
+    for( i=0; i<Components.Length; ++i )
+        Components[i].FindAllComponentID(InID,Res);
+}
+function RemoveComponent( KFGUI_Base B )
+{
+    local int i;
+    
+    for( i=0; i<Components.Length; ++i )
+        if( Components[i]==B )
+        {
+            Components.Remove(i,1);
+            B.CloseMenu();
+            return;
+        }
+    for( i=0; i<Components.Length; ++i )
+        Components[i].RemoveComponent(B);
+}
+function NotifyLevelChange()
+{
+    local int i;
+    
+    for( i=0; i<Components.Length; ++i )
+        Components[i].NotifyLevelChange();
+}

Src/KFClassicHUD/Classes/KFGUI_Page.uc

@@ -0,0 +1,26 @@
+Class KFGUI_Page extends KFGUI_MultiComponent
+    abstract;
+
+var() byte FrameOpacity; // Transperancy of the frame.
+var() bool bPersistant, // Reuse the same menu object throughout the level.
+            bUnique, // If calling OpenMenu multiple times with same menu class, only open one instance of it.
+            bAlwaysTop, // This menu should stay always on top.
+            bOnlyThisFocus, // Only this menu should stay focused.
+            bNoBackground; // Don't draw the background.
+
+var bool bWindowFocused; // This page is currently focused.
+
+function DrawMenu()
+{
+    if( !bNoBackground )
+    {
+        Owner.CurrentStyle.RenderWindow(Self);
+    }
+}
+
+defaultproperties
+{
+    bUnique=true
+    bPersistant=true
+    FrameOpacity=175
+}

Src/KFClassicHUD/Classes/KFGUI_ProgressBar.uc

@@ -0,0 +1,134 @@
+class KFGUI_ProgressBar extends KFGUI_Base;
+
+var Texture BarBack;
+var Texture BarTop;
+var Color BarColor;
+var float Low;
+var float High;
+var float Value;
+
+var float CaptionWidth;
+var byte CaptionAlign;
+var byte ValueRightAlign;
+var string Caption;
+
+var float GraphicMargin;
+var float ValueRightWidth;
+var bool bShowLow;
+var bool bShowHigh;
+var bool bShowValue;
+var int NumDecimals;
+
+var byte BorderSize;
+
+function DrawMenu()
+{
+    local float Left, Top, Width, Height;
+    local float W, Sc;
+    local string S;
+    
+    Super.DrawMenu();
+
+    Left = 0.f;
+    Top = 0.f;
+    Width = CompPos[2];
+    Height = CompPos[3];
+    
+    // Select the right font in the Canvas
+    Canvas.Font = Owner.CurrentStyle.PickFont(Sc); 
+    
+    if (CaptionWidth > 0.0 && Width > 0 && Len(Caption) > 0)
+    {
+        W = CaptionWidth;
+
+        if( W < 1.0 )
+        {
+            W *= Width;
+        }
+
+        if( W > Width )
+        {
+            W = Width;
+        }
+
+        // Draw the label
+        Owner.CurrentStyle.DrawTextJustified(CaptionAlign, Left, Top, Left + W, Top + Height, Caption, Sc, Sc);
+        Left += W;
+        Width -= W;
+    }
+
+    if ( (bShowHigh || bShowValue) && ValueRightWidth > 0.0 && Width > 0.0)
+    {
+        W = ValueRightWidth;
+
+        if( W < 1.0 )
+        {
+            W *= Width;
+        }
+
+        if( W > Width )
+        {
+            W = Width;
+        }
+
+        if( bShowValue && bShowHigh )
+        {
+            S = int(Value)$"/"$int(High);
+        }
+        else if (bShowValue)
+        {
+            S = string(int(Value));
+        }
+        else 
+        {
+            S = string(int(High));
+        }
+
+        Owner.CurrentStyle.DrawTextJustified(ValueRightAlign, Left + Width - W, Top, Left + Width, Top + Height, S, Sc, Sc);
+
+        Width -= W;
+    }
+    
+    if (Width > GraphicMargin)
+    {
+        Width -= GraphicMargin;
+        Left += GraphicMargin / 2;
+    }
+
+    Canvas.SetDrawColor(255, 255, 255, 255);
+    if( Width > 0.0 && BarBack != None )
+    {
+        Owner.CurrentStyle.DrawTileStretched(BarBack, Left, Top, Width, Height);
+    }
+
+    if( Width > 0.0 && BarTop != None && Value > Low )
+    {
+        Canvas.DrawColor = BarColor;
+        Owner.CurrentStyle.DrawTileStretched(BarTop, Left + BorderSize, Top + BorderSize, (Width - (BorderSize * 2)) * (Value/High), Height - (BorderSize * 2));
+    }
+}
+
+function SetValue(float val)
+{
+    Value=val;
+}
+
+function float GetValue()
+{
+    return Value;
+}
+
+defaultproperties
+{
+    BarColor=(R=255,G=255,B=255,A=255)
+    Low=0.f
+    High=100.f
+    Value=0.f
+    bShowLow=false
+    bShowHigh=false
+    bShowValue=true
+    CaptionWidth=0.45
+    ValueRightWidth=0.2
+    ValueRightAlign=0
+    NumDecimals=0
+}

Src/KFClassicHUD/Classes/KFGUI_RightClickMenu.uc

@@ -0,0 +1,163 @@
+Class KFGUI_RightClickMenu extends KFGUI_Clickable;
+
+struct FRowItem
+{
+    var string Text,ToolTip;
+    var bool bSplitter,bDisabled;
+};
+var array<FRowItem> ItemRows;
+var int CurrentRow,OldRow;
+var int EdgeSize;
+var int OldSizeX;
+var transient bool bDrawToolTip;
+var Color BoxColor,OutlineColor;
+
+function OpenMenu( KFGUI_Base Menu )
+{
+    Owner = Menu.Owner;
+    InitMenu();
+    PlayMenuSound(MN_Dropdown);
+    GetInputFocus();
+    OldSizeX = 0;
+}
+final function ComputeSize()
+{
+    local float XS,YS,XL,YL,Scalar;
+    local int i;
+    local string S;
+    
+    if( OldSizeX == Owner.ScreenSize.X )
+        return;
+ 
+    if( ItemRows.Length==0 )
+    {
+        YS = 0;
+        XS = 50;
+    }
+    else
+    {
+        Canvas.Font = Owner.CurrentStyle.PickFont(Scalar);
+        for( i=0; i<ItemRows.Length; ++i )
+        {
+            if( ItemRows[i].bSplitter )
+                S = "----";
+            else S = ItemRows[i].Text;
+            
+            Canvas.TextSize(S,XL,YL,Scalar,Scalar);
+            
+            XS = FMax(XS,XL);
+            YS += YL;
+        }
+    }
+    XSize = (XS+(EdgeSize*12)) / Owner.ScreenSize.X;
+    YSize = (YS+(EdgeSize*4)) / Owner.ScreenSize.Y;
+    
+    ComputePosition();
+    
+    OldSizeX = Owner.ScreenSize.X;
+}
+function ComputePosition()
+{
+    XPosition = float(Owner.MousePosition.X+4) / Owner.ScreenSize.X;
+    YPosition = float(Owner.MousePosition.Y+4) / Owner.ScreenSize.Y;
+    if( (XPosition+XSize)>1.f )
+        YPosition = (float(Owner.MousePosition.X) / Owner.ScreenSize.X) - XSize; // Move to left side of mouse pointer.
+    if( (YPosition+YSize)>1.f )
+        YPosition-=((YPosition+YSize)-1.f); // Move up until fit on screen.
+}
+final function AddRow( string Text, bool bDisable, optional string AltToolTip )
+{
+    local int i;
+    
+    i = ItemRows.Length;
+    ItemRows.Length = i+1;
+    if( Text=="-" )
+        ItemRows[i].bSplitter = true;
+    else
+    {
+        ItemRows[i].Text = Text;
+        ItemRows[i].ToolTip = AltToolTip;
+        ItemRows[i].bDisabled = bDisable;
+    }
+}
+function PreDraw()
+{
+    ComputeSize();
+    Super.PreDraw();
+}
+function DrawMenu()
+{   
+    Owner.CurrentStyle.RenderRightClickMenu(Self);
+    
+    if( bDrawToolTip )
+    {
+        if( OldRow != CurrentRow )
+            bDrawToolTip = false;
+        DrawToolTip();
+    }
+}
+function DrawToolTip()
+{
+    local float X,Y,XL,YL,BoxW,BoxH,TextX,TextY,Scalar,CursorSize;
+    local string S;
+    
+    Canvas.Reset();
+    Canvas.SetClip(float(Owner.ScreenSize.X), float(Owner.ScreenSize.Y));
+    
+    S = ItemRows[CurrentRow].ToolTip;
+    Canvas.Font = Owner.CurrentStyle.PickFont(Scalar);
+    Canvas.TextSize(S,XL,YL,Scalar,Scalar);
+    
+    CursorSize = Owner.CurrentStyle.ScreenScale(Owner.CursorSize);
+    X = Owner.MousePosition.X+CursorSize;
+    Y = Owner.MousePosition.Y+CursorSize;
+    BoxW = XL * 1.05f;
+    BoxH = YL * 1.25f;
+    
+    while( (X + BoxW) > Canvas.ClipX )
+    {
+        X -= 0.01;
+    }
+        
+    Owner.CurrentStyle.DrawOutlinedBox(X, Y, BoxW, BoxH, EdgeSize, MakeColor(5,5,5,255), MakeColor(115,115,115,255));
+    
+    TextX = X + (BoxW/2) - (XL/2) - (EdgeSize/2);
+    TextY = Y + (BoxH/2) - (YL/2) - (EdgeSize/2);
+    
+    Canvas.DrawColor = class'HUD'.default.WhiteColor;
+    Canvas.SetPos(TextX, TextY);
+    Canvas.DrawText(S,,Scalar,Scalar);
+}
+function HandleMouseClick( bool bRight )
+{
+    if( CurrentRow>=0 && (ItemRows[CurrentRow].bSplitter || ItemRows[CurrentRow].bDisabled) )
+        return;
+    OnSelectedItem(CurrentRow);
+    PlayMenuSound(MN_ClickButton);
+    DropInputFocus();
+}
+function LostInputFocus()
+{
+    OnBecameHidden(Self);
+    OldRow = -1;
+    CurrentRow = -1;
+}
+function NotifyMousePaused()
+{
+    if(CurrentRow != -1 && ItemRows[CurrentRow].ToolTip != "")
+        bDrawToolTip = true;
+}
+
+Delegate OnSelectedItem( int Index );
+Delegate OnBecameHidden( KFGUI_RightClickMenu M );
+
+defaultproperties
+{
+    CurrentRow=-1
+    OldRow=-1
+    bFocusedPostDrawItem=true
+    bHoverSound=false
+    EdgeSize=2
+    BoxColor=(R=5,G=5,B=5,A=200)
+    OutlineColor=(R=115,G=115,B=115,A=255)
+}

Src/KFClassicHUD/Classes/KFGUI_ScrollBarBase.uc

@@ -0,0 +1,123 @@
+Class KFGUI_ScrollBarBase extends KFGUI_Clickable
+    abstract;
+
+var() int MinRange,MaxRange,ScrollStride,PageStep;
+var() float ButtonScale; // Button width (scaled by default font height).
+var int CurrentScroll;
+
+// In-runtime values.
+var transient float CalcButtonScale;
+var transient int SliderScale,ButtonOffset,GrabbedOffset;
+var transient bool bGrabbedScroller;
+
+var bool bVertical, bHideScrollbar;
+
+final function UpdateScrollSize( int Current, int MxRange, int Stride, int StepStride, optional int MnRange )
+{
+    MaxRange = MxRange;
+    MinRange = MnRange;
+    ScrollStride = Stride;
+    PageStep = StepStride;
+    SetValue(Current);
+}
+final function AddValue( int V )
+{
+    SetValue(CurrentScroll+V);
+}
+final function SetValue( int V )
+{
+    CurrentScroll = Clamp((V / ScrollStride) * ScrollStride,MinRange,MaxRange);
+    OnScrollChange(Self,CurrentScroll);
+}
+final function int GetValue()
+{
+    return CurrentScroll;
+}
+Delegate OnScrollChange( KFGUI_ScrollBarBase Sender, int Value );
+
+// Get UI width.
+function float GetWidth()
+{
+    CalcButtonScale = ButtonScale*Owner.CurrentStyle.DefaultHeight;
+    return CalcButtonScale / (bVertical ? InputPos[2] : InputPos[3]);
+}
+function PreDraw()
+{
+    // Auto scale to match width to screen size.
+    if( bVertical )
+        XSize = GetWidth();
+    else YSize = GetWidth();
+    Super.PreDraw();
+}
+function DrawMenu()
+{
+    if( !bHideScrollbar )
+    {
+        Owner.CurrentStyle.RenderScrollBar(Self);
+    }
+}
+function MouseClick( bool bRight )
+{
+    if( bRight || bDisabled )
+        return;
+    bPressedDown = true;
+    PlayMenuSound(MN_ClickButton);
+    
+    if( bVertical )
+    {
+        if( Owner.MousePosition.Y>=(CompPos[1]+ButtonOffset) && Owner.MousePosition.Y<=(CompPos[1]+ButtonOffset+SliderScale) ) // Grabbed scrollbar!
+        {
+            GrabbedOffset = Owner.MousePosition.Y - (CompPos[1]+ButtonOffset);
+            bGrabbedScroller = true;
+            GetInputFocus();
+        }
+        else if( Owner.MousePosition.Y<(CompPos[1]+ButtonOffset) ) // Page up.
+            AddValue(-PageStep);
+        else AddValue(PageStep);
+    }
+    else
+    {
+        if( Owner.MousePosition.X>=(CompPos[0]+ButtonOffset) && Owner.MousePosition.X<=(CompPos[0]+ButtonOffset+SliderScale) ) // Grabbed scrollbar!
+        {
+            GrabbedOffset = Owner.MousePosition.X - (CompPos[0]+ButtonOffset);
+            bGrabbedScroller = true;
+            GetInputFocus();
+        }
+        else if( Owner.MousePosition.X<(CompPos[0]+ButtonOffset) ) // Page left.
+            AddValue(-PageStep);
+        else AddValue(PageStep);
+    }
+}
+function MouseRelease( bool bRight )
+{
+    if( !bRight )
+        DropInputFocus();
+}
+
+function LostInputFocus()
+{
+    bGrabbedScroller = false;
+    bPressedDown = false;
+}
+
+function ScrollMouseWheel( bool bUp )
+{
+    if( bDisabled )
+        return;
+    if( bUp )
+        AddValue(-ScrollStride);
+    else AddValue(ScrollStride);
+}
+
+function SetVisibility(bool Visible)
+{
+    bHideScrollbar = Visible;
+}
+
+defaultproperties
+{
+    MaxRange=100
+    ScrollStride=1
+    PageStep=10
+    ButtonScale=1
+}

Src/KFClassicHUD/Classes/KFGUI_ScrollBarH.uc

@@ -0,0 +1,6 @@
+Class KFGUI_ScrollBarH extends KFGUI_ScrollBarBase;
+
+defaultproperties
+{
+    bVertical=false
+}

Src/KFClassicHUD/Classes/KFGUI_ScrollBarV.uc

@@ -0,0 +1,6 @@
+Class KFGUI_ScrollBarV extends KFGUI_ScrollBarBase;
+
+defaultproperties
+{
+    bVertical=true
+}

Src/KFClassicHUD/Classes/KFGUI_Slider.uc

@@ -0,0 +1,52 @@
+class KFGUI_Slider extends KFGUI_MultiComponent;
+
+var KFGUI_ScrollBarH ScrollBar;
+
+var int MinValue,MaxValue;
+var transient int CurrentValue;
+
+delegate OnValueChanged(KFGUI_Slider Sender, int Value);
+
+function InitMenu()
+{
+    Super.InitMenu();
+    ScrollBar = KFGUI_ScrollBarH(FindComponentID('Scrollbar'));
+    ScrollBar.OnScrollChange = ValueChanged;
+}
+
+function int GetValue()
+{
+    return CurrentValue;
+}
+
+function SetValue(int Value)
+{
+    CurrentValue = Clamp(Value, MinValue, MaxValue);
+    OnValueChanged(self, CurrentValue);
+}
+
+function ValueChanged(KFGUI_ScrollBarBase Sender, int Value)
+{
+    SetValue(Value);
+}
+
+function UpdateListVis()
+{
+    ScrollBar.UpdateScrollSize(CurrentValue,MaxValue,1,1,MinValue);
+}
+
+function ScrollMouseWheel( bool bUp )
+{
+    if( !ScrollBar.bDisabled )
+        ScrollBar.ScrollMouseWheel(bUp);
+}
+
+defaultproperties
+{
+    Begin Object Class=KFGUI_ScrollBarH Name=SliderScroll
+        XSize=1
+        YSize=0.5
+        ID="Scrollbar"
+    End Object
+    Components.Add(SliderScroll)
+}

Src/KFClassicHUD/Classes/KFGUI_SwitchMenuBar.uc

@@ -0,0 +1,165 @@
+// Same as SwitchComponent, but with buttons.
+Class KFGUI_SwitchMenuBar extends KFGUI_MultiComponent;
+
+var array<KFGUI_Base> SubPages;
+var() byte ButtonPosition; // 0 = top, 1 = bottom, 2 = left, 3 = right
+var() float BorderWidth,ButtonAxisSize; // Width for buttons.
+var() float PagePadding; // Padding for pages
+
+var int NumButtons,CurrentPageNum,PageComponentIndex;
+var array<KFGUI_Button> PageButtons;
+
+function ShowMenu()
+{
+    GrabKeyFocus();
+    Super.ShowMenu();
+}
+
+function CloseMenu()
+{
+    ReleaseKeyFocus();
+    Super.CloseMenu();
+}
+
+// Remember to call InitMenu() on the newly created page after.
+final function KFGUI_Base AddPage( class<KFGUI_Base> PageClass, string Caption, string Hint, optional out KFGUI_Button Button )
+{
+    local KFGUI_Base P;
+    local KFGUI_Button B;
+    
+    // Add page.
+    P = new (Self) PageClass;
+    P.Owner = Owner;
+    P.ParentComponent = Self;
+    SubPages.AddItem(P);
+
+    // Add page switch button.
+    B = new (Self) class'KFGUI_Button';
+    B.ButtonText = Caption;
+    B.ToolTip = Hint;
+    B.OnClickLeft = PageSwitched;
+    B.OnClickRight = PageSwitched;
+    B.IDValue = NumButtons;
+    
+    if( ButtonPosition<2 )
+    {
+        B.XPosition = NumButtons*ButtonAxisSize;
+        B.XSize = ButtonAxisSize*0.99;
+
+        if( ButtonPosition==0 )
+            B.YPosition = 0.f;
+        else B.YPosition = YSize-BorderWidth*0.99;
+        B.YSize = BorderWidth*0.99;
+        
+        if( NumButtons>0 )
+            PageButtons[PageButtons.Length-1].ExtravDir = 1;
+    }
+    else
+    {
+        if( ButtonPosition==2 )
+            B.XPosition = 0.f;
+        else B.XPosition = XSize-BorderWidth*0.99;
+        B.XSize = BorderWidth*0.99;
+        
+        B.YPosition = NumButtons*ButtonAxisSize;
+        B.YSize = ButtonAxisSize*0.99;
+        if( NumButtons>0 )
+            PageButtons[PageButtons.Length-1].ExtravDir = 2;
+    }
+
+    ++NumButtons;
+    PageButtons.AddItem(B);
+    AddComponent(B);
+    Button = B;
+    return P;
+}
+
+function PageSwitched( KFGUI_Button Sender )
+{
+    SelectPage(Sender.IDValue);
+}
+
+final function SelectPage( int Index )
+{
+    PlayMenuSound(MN_LostFocus);
+    
+    if( CurrentPageNum>=0 )
+    {
+        PageButtons[CurrentPageNum].bIsHighlighted = false;
+        SubPages[CurrentPageNum].CloseMenu();
+        Components.Remove(PageComponentIndex,1);
+        PageComponentIndex = -1;
+    }
+    CurrentPageNum = (Index>=0 && Index<SubPages.Length) ? Index : -1;
+    if( CurrentPageNum>=0 )
+    {
+        PageButtons[CurrentPageNum].bIsHighlighted = true;
+        SubPages[CurrentPageNum].ShowMenu();
+        PageComponentIndex = Components.Length;
+        Components.AddItem(SubPages[CurrentPageNum]);
+    }
+}
+
+function PreDraw()
+{
+    local int i;
+    local byte j;
+    
+    if( !bVisible )
+        return;
+
+    if( CurrentPageNum==-1 && NumButtons>0 )
+        SelectPage(0);
+    ComputeCoords();
+    Canvas.SetOrigin(CompPos[0],CompPos[1]);
+    Canvas.SetClip(CompPos[0]+CompPos[2],CompPos[1]+CompPos[3]);
+    DrawMenu();
+    for( i=0; i<Components.Length; ++i )
+    {
+        Components[i].Canvas = Canvas;
+        for( j=0; j<4; ++j )
+            Components[i].InputPos[j] = CompPos[j];
+        if( i==PageComponentIndex )
+        {
+            switch( ButtonPosition )
+            {
+            case 0:
+                Components[i].InputPos[1] += (InputPos[3]*BorderWidth*PagePadding);
+            case 1:
+                Components[i].InputPos[3] -= (InputPos[3]*BorderWidth*PagePadding);
+                break;
+            case 2:
+                Components[i].InputPos[0] += (InputPos[2]*BorderWidth*PagePadding);
+            default:
+                Components[i].InputPos[2] -= (InputPos[2]*BorderWidth*PagePadding);
+            }
+        }
+        Components[i].PreDraw();
+    }
+}
+
+function bool ReceievedControllerInput(int ControllerId, name Key, EInputEvent Event)
+{
+    switch(Key)
+    {
+        case 'XboxTypeS_LeftShoulder':
+            if( Event == IE_Pressed )
+                SelectPage(Clamp(CurrentPageNum - 1, 0, NumButtons));
+            return true;
+        case 'XboxTypeS_RightShoulder':
+            if( Event == IE_Pressed )
+                SelectPage(Clamp(CurrentPageNum + 1, 0, NumButtons));
+            return true;
+    }
+    
+    return false;
+}
+
+defaultproperties
+{
+    PagePadding=1.0
+    BorderWidth=0.05
+    ButtonAxisSize=0.08
+    CurrentPageNum=-1
+    PageComponentIndex=-1
+}

Src/KFClassicHUD/Classes/KFGUI_TextField.uc

@@ -0,0 +1,490 @@
+Class KFGUI_TextField extends KFGUI_MultiComponent;
+
+enum ETextFieldStyles
+{
+    TEXT_FIELD_NONE,
+    TEXT_FIELD_HSV,
+    TEXT_FIELD_SCAN,
+    TEXT_FIELD_FLASH
+};
+struct FTextPart
+{
+    var string S;
+    var ETextFieldStyles TextType;
+    var Color C;
+    var float X;
+    
+    structdefaultproperties
+    {
+        TextType=TEXT_FIELD_NONE
+    }
+};
+struct FTextLineInfo
+{
+    var array<FTextPart> Text;
+    var float Y;
+};
+var KFGUI_ScrollBarV ScrollBar;
+
+var() string LineSplitter;
+var() protected string Text;
+var() Color TextColor;
+var() Canvas.FontRenderInfo TextFontInfo;
+var() float FontScale,MessageDisplayTime,MessageFadeInTime,MessageFadeOutTime;
+var() bool bNoReset,bFadeInOut,bUseOutlineText;
+var() int MaxHistory, OutlineSize;
+var protected transient array<FTextLineInfo> Lines,OrgLines;
+var transient float MaxHeight,ScrollWidth,OldSize[2],InitFontScale,TextHeight,FadeStartTime;
+var transient Font InitFont;
+var transient bool bShowScrollbar,bTextParsed;
+
+function SetText( string S )
+{
+    if( Text==S )
+        return;
+    Text = S;
+    OldSize[0] = -1; // Force to refresh.
+    Lines.Length = 0;
+    OrgLines.Length = 0;
+    bTextParsed = false;
+}
+function AddText( string S, optional bool bIgnoreSpam )
+{
+    Text $= S;
+    OldSize[0] = -1;
+    Lines.Length = 0;
+    OrgLines.Length = 0;
+    bTextParsed = false;
+}
+final function string GetText()
+{
+    return Text;
+}
+
+final function ParseTextLines()
+{
+    local array<string> SA;
+    local int i,j,z;
+    local string S;
+    local color C;
+    local ETextFieldStyles TextType;
+
+    ParseStringIntoArray(Text,SA,LineSplitter,false);
+    Lines.Length = SA.Length;
+    C.A = 0;
+    TextType = TEXT_FIELD_NONE;
+    for( i=0; i<SA.Length; ++i )
+    {
+        Lines[i].Text.Length = 0;
+        
+        S = SA[i];
+        if( S=="" )
+            continue;
+        
+        z = 0;
+        while( true )
+        {
+            j = InStr(S,"#{");
+            if( j>0 )
+            {
+                Lines[i].Text.Length = z+1;
+                Lines[i].Text[z].S = Left(S,j);
+                Lines[i].Text[z].C = C;
+                Lines[i].Text[z].TextType = TextType;
+                ++z;
+            }
+            else if( j==-1 )
+                break;
+
+            S = Mid(S,j+2);
+            if( Left(S,4)=="DEF}" )
+            {
+                C.A = 0;
+                S = Mid(S,4);
+                TextType = TEXT_FIELD_NONE;
+            }
+            else if( Left(S,4)=="HSV}" )
+            {
+                C.A = 0;
+                S = Mid(S,4);
+                TextType = TEXT_FIELD_HSV;
+            }
+            else if( Left(S,6)=="FLASH}" )
+            {
+                C.A = 0;
+                S = Mid(S,6);
+                TextType = TEXT_FIELD_FLASH;
+            }
+            else if( Left(S,7)=="CFLASH=" )
+            {
+                C.A = 0;
+                S = Mid(S,7);
+                TextType = TEXT_FIELD_FLASH;
+                
+                C.R = GrabHexValue(Mid(S,0,2));
+                C.G = GrabHexValue(Mid(S,2,2));
+                C.B = GrabHexValue(Mid(S,4,2));
+                S = Mid(S,7);
+                C.A = 255;
+            }
+            else
+            {
+                C.R = GrabHexValue(Mid(S,0,2));
+                C.G = GrabHexValue(Mid(S,2,2));
+                C.B = GrabHexValue(Mid(S,4,2));
+                S = Mid(S,7);
+                C.A = 255;
+                TextType = TEXT_FIELD_NONE;
+            }
+        }
+        Lines[i].Text.Length = z+1;
+        Lines[i].Text[z].S = S;
+        Lines[i].Text[z].C = C;
+        Lines[i].Text[z].TextType = TextType;
+    }
+    OrgLines = Lines; // Create a backup.
+}
+final function byte GrabHexValue( string S )
+{
+    local byte n;
+    
+    n = (HexToInt(Asc(Left(S,1)))<<4) | HexToInt(Asc(Right(S,1)));
+    S = Mid(S,2);
+    return n;
+}
+final function byte HexToInt( byte n )
+{
+    if( n>=48 && n<=57 ) // '0' - '9'
+        return n-48;
+    if( n>=65 && n<=70 ) // 'A' - 'F'
+        return n-55; // 'A' - 10
+    if( n>=97 && n<=102 ) // 'a' - 'f'
+        return n-87; // 'a' - 10
+    return 0;
+}
+
+function InitSize()
+{
+    local byte i;
+    local float XS;
+    local int MaxScrollRange;
+
+    if( Canvas == None )
+        return;
+    
+    OldSize[0] = CompPos[2];
+    OldSize[1] = CompPos[3];
+    if( !bTextParsed )
+    {
+        ParseTextLines();
+        bTextParsed = true;
+    }
+    else Lines = OrgLines;
+
+    InitFont = Owner.CurrentStyle.PickFont(InitFontScale);
+    InitFontScale *= FontScale;
+    
+    // Compute Y-offsets of each line.
+    Canvas.Font = InitFont;
+    Canvas.TextSize("ABC",XS,TextHeight,InitFontScale,InitFontScale);
+
+    ParseLines(CompPos[2] / InitFontScale);
+    MaxHeight = (Lines.Length * TextHeight);
+    bShowScrollbar = (MaxHeight>=CompPos[3]);
+    bClickable = bShowScrollbar;
+    bCanFocus = bShowScrollbar;
+    
+    if( bShowScrollbar )
+    {
+        if( ScrollBar==None )
+        {
+            ScrollBar = new(Self) class'KFGUI_ScrollBarV';
+            ScrollBar.SetPosition(0.9,0.0,0.1,1.0);
+            ScrollBar.Owner = Owner;
+            ScrollBar.ParentComponent = Self;
+            ScrollBar.InitMenu();
+            ScrollBar.SetVisibility(bVisible);
+        }
+        
+        // Compute scrollbar size and X-position.
+        for( i=0; i<4; ++i )
+            ScrollBar.InputPos[i] = CompPos[i];
+        ScrollWidth = ScrollBar.GetWidth();
+        ScrollBar.XPosition = 1.f - ScrollWidth;
+        ScrollWidth *= CompPos[2];
+
+        ScrollBar.ComputeCoords();
+
+        // Recompute line sizes because we now have a scrollbar.
+        Lines = OrgLines;
+        ParseLines((CompPos[2]-ScrollWidth) / InitFontScale);
+
+        if( Components.Find(ScrollBar)==-1 )
+            Components.AddItem(ScrollBar);
+        MaxHeight = (Lines.Length * TextHeight);
+        MaxScrollRange = Max(((MaxHeight-CompPos[3])/TextHeight),1);
+        ScrollBar.UpdateScrollSize(bNoReset ? MaxScrollRange : 0,MaxScrollRange,1,1);
+    }
+    else if( ScrollBar!=None )
+        Components.RemoveItem(ScrollBar);
+}
+
+// Parse textlines to see if they're too long.
+final function ParseLines( float ClipX )
+{
+    local float X,XS,YS;
+    local int i,j,z,n;
+
+    for( i=0; i<Lines.Length; ++i )
+    {
+        Lines[i].Y = i*TextHeight;
+        X = 0.f;
+        for( j=0; j<Lines[i].Text.Length; ++j )
+        {
+            Lines[i].Text[j].X = (X*InitFontScale);
+            Canvas.TextSize(Lines[i].Text[j].S,XS,YS);
+            
+            if( (X+XS)>ClipX )
+            {
+                z = FindSplitPoint(Lines[i].Text[j].S,X,ClipX);
+
+                // Add new line.
+                Lines.Insert(i+1,1);
+                
+                // Append the remaining lines there.
+                for( n=j; n<Lines[i].Text.Length; ++n )
+                    Lines[i+1].Text.AddItem(Lines[i].Text[n]);
+                
+                // Split the string at wrapping point.
+                Lines[i+1].Text[0].S = Mid(Lines[i].Text[j].S,z);
+                
+                // Remove whitespaces in front of the string.
+                Lines[i+1].Text[0].S = StripWhiteSpaces(Lines[i+1].Text[0].S);
+                
+                // If empty, clean it up.
+                if( Lines[i+1].Text[0].S=="" )
+                    Lines[i+1].Text.Remove(0,1);
+                
+                // End the current line at wrapping point.
+                Lines[i].Text[j].S = Left(Lines[i].Text[j].S,z);
+                Lines[i].Text.Length = j+1;
+                break;
+            }
+            X+=XS;
+        }
+    }
+}
+
+// Slow, find wrapped splitting point in text.
+final function int FindSplitPoint( string S, float X, float ClipX )
+{
+    local int i,l,PrevWord;
+    local float XL,YL;
+    local bool bWasWhite,bStartedZero;
+    
+    bStartedZero = (X==0.f);
+    Canvas.TextSize(Mid(S,0,1),XL,YL);
+    X += XL;
+    i = 1;
+    l = Len(S);
+    PrevWord = 0;
+    bWasWhite = true;
+    while( i<l )
+    {
+        if( Mid(S,i,1)==" " )
+        {
+            if( !bWasWhite )
+            {
+                PrevWord = i;
+                bWasWhite = true;
+            }
+        }
+        else
+        {
+            bWasWhite = false;
+        }
+        Canvas.TextSize(Mid(S,i,1),XL,YL);
+        X+=XL;
+        if( X>ClipX ) // Split here if possible.
+        {
+            if( PrevWord==0 )
+                return (bStartedZero ? i : 0); // No wrap.
+            return PrevWord;
+        }
+        ++i;
+    }
+    return l;
+}
+final function string StripWhiteSpaces( string S )
+{
+    if( Left(S,1)==" " )
+        S = Mid(S,1);
+    return S;
+}
+
+function byte GetCursorStyle()
+{
+    return `PEN_WHITE;
+}
+
+function DrawMenu()
+{
+    local int i,j,Index;
+    local float Y;
+
+    if( Text=="" || !bVisible )
+        return;
+
+    // Need to figure out best fitting font.
+    if( OldSize[0]!=CompPos[2] || OldSize[1]!=CompPos[3] )
+        InitSize();
+        
+    if( MaxHistory != 0 )
+    {
+        if( Lines.Length >= MaxHistory )
+        {
+            Index = InStr(Text, LineSplitter);
+            if( Index == INDEX_NONE )
+                Lines.Remove(0, 1);
+            else SetText(Mid(Text, Index+Len(LineSplitter)));
+        }
+    }
+
+    Canvas.Font = InitFont;
+
+    if( bShowScrollbar )
+    {
+        Canvas.SetClip(CompPos[0]+(CompPos[2]-ScrollWidth),CompPos[1]+CompPos[3]);
+        i = ScrollBar.GetValue();
+    }
+    else i = 0;
+    
+    if( i<Lines.Length )
+    {
+        Y = Lines[i].Y;
+        for( i=i; i<Lines.Length; ++i )
+        {
+            if( Lines[i].Text.Length!=0 )
+            {
+                if( (Lines[i].Y-Y+TextHeight)>=CompPos[3] )
+                    break;
+                    
+                for( j=0; j<Lines[i].Text.Length; ++j )
+                {
+                    DrawTextField(Lines[i].Text[j].S, i, Lines[i].Text[j].X, Lines[i].Y-Y, Lines[i].Text[j].C, Lines[i].Text[j].TextType);
+                }
+            }
+        }
+    }
+}
+
+function DrawTextField(string S, int Index, float X, float Y, optional Color C, optional ETextFieldStyles TextStyle)
+{
+    local float TempSize;
+    local int FadeAlpha;
+    local Color MainColor;
+    
+    MainColor = C;
+    if( MainColor.A==0 )
+        MainColor = TextColor;
+    
+    Canvas.DrawColor = GetColorFromStyle(MainColor, TextStyle);
+        
+    if( bFadeInOut )
+    {
+        TempSize = `TimeSinceEx(GetPlayer(), FadeStartTime);
+        if ( TempSize > MessageDisplayTime )
+        {
+            return;
+        }
+        
+        if ( TempSize < MessageFadeInTime )
+        {
+            FadeAlpha = int((TempSize / MessageFadeInTime) * 255.0);
+        }
+        else if ( TempSize > MessageDisplayTime - MessageFadeOutTime )
+        {
+            FadeAlpha = int((1.0 - ((TempSize - (MessageDisplayTime - MessageFadeOutTime)) / MessageFadeOutTime)) * 255.0);
+        }
+        else
+        {
+            FadeAlpha = 255;
+        }
+    
+        Canvas.DrawColor.A = FadeAlpha;
+    }
+
+    if( bUseOutlineText )
+    {
+        Owner.CurrentStyle.DrawTextShadow(S,X,Y,OutlineSize,InitFontScale);
+    }
+    else
+    {
+        Canvas.SetPos(X,Y);
+        Canvas.DrawText(S,,InitFontScale,InitFontScale,TextFontInfo);
+    }
+}
+
+function Color GetColorFromStyle(Color MainColor, ETextFieldStyles TextStyle)
+{
+    local float ColorHUE,Value;
+    local HSVColour HSV;
+    
+    if( TextStyle == TEXT_FIELD_HSV )
+    {
+        ColorHUE = Abs(Sin(GetPlayer().WorldInfo.TimeSeconds * 0.9) * 335);
+        
+        HSV.H = ColorHUE;
+        HSV.S = 1.f;
+        HSV.V = 1.f;
+        HSV.A = MainColor.A / 255;
+            
+        return class'KFColorHelper'.static.LinearColorToColor(class'KFColorHelper'.static.HSVToRGB(HSV));
+    }
+    else if( TextStyle == TEXT_FIELD_FLASH )
+    {
+        Value = Abs(Sin(GetPlayer().WorldInfo.TimeSeconds * 0.9) * 1);
+        HSV = class'KFColorHelper'.static.RGBToHSV(ColorToLinearColor(MainColor));
+        HSV.V = Value;
+        
+        return class'KFColorHelper'.static.LinearColorToColor(class'KFColorHelper'.static.HSVToRGB(HSV));
+    }
+    
+    return MainColor;
+}
+
+function bool CaptureMouse()
+{
+    return (bShowScrollbar ? Super.CaptureMouse() : false); // Nope.
+}
+
+function ScrollMouseWheel( bool bUp )
+{
+    if( bShowScrollbar )
+        ScrollBar.ScrollMouseWheel(bUp);
+}
+
+function SetVisibility(bool Visible)
+{
+    Super.SetVisibility(Visible);
+    
+    if( ScrollBar != None )
+    {
+        ScrollBar.SetVisibility(Visible);
+    }
+}
+
+defaultproperties
+{
+    bNoReset=false
+    LineSplitter="|"
+    FontScale=1
+    MaxHistory=0
+    OutlineSize=1
+    Text="TextField"
+    TextColor=(R=255,G=255,B=255,A=255)
+    TextFontInfo=(bClipText=true,bEnableShadow=true)
+    bCanFocus=false
+    bClickable=false
+    bUseOutlineText=false
+}

Src/KFClassicHUD/Classes/KFGUI_TextLable.uc

@@ -0,0 +1,120 @@
+Class KFGUI_TextLable extends KFGUI_Base;
+
+var() protected string Text;
+var() color TextColor;
+var() Canvas.FontRenderInfo TextFontInfo;
+var() byte AlignX,AlignY; // Alignment, 0=Left/Up, 1=Center, 2=Right/Down
+var() float FontScale;
+var() bool bUseOutline;
+var() int OutlineSize;
+
+var transient Font InitFont;
+var transient float OldSize[2],InitOffset[2],InitFontScale;
+
+function InitSize()
+{
+    local float XL,YL,TS;
+
+    OldSize[0] = CompPos[2];
+    OldSize[1] = CompPos[3];
+
+    TS = Owner.CurrentStyle.GetFontScaler();
+    TS *= FontScale;
+    
+    while( true )
+    {
+        Canvas.Font = Owner.CurrentStyle.MainFont;
+        if( TextFontInfo.bClipText )
+            Canvas.TextSize(Text,XL,YL,TS,TS);
+        else
+        {
+            Canvas.SetPos(0,0);
+            if( TS==1 )
+                Canvas.StrLen(Text,XL,YL);
+            else
+            {
+                Canvas.SetClip(CompPos[2]/TS,CompPos[3]); // Hacky, since StrLen has no TextSize support.
+                Canvas.StrLen(Text,XL,YL);
+                XL*=TS;
+                YL*=TS;
+            }
+        }
+        if( (XL<(CompPos[2]*0.99) && YL<(CompPos[3]*0.99)) )
+            break;
+            
+        TS -= 0.001;
+    }
+    Canvas.SetClip(CompPos[0]+CompPos[2],CompPos[1]+CompPos[3]);
+    InitFont = Canvas.Font;
+    InitFontScale = TS;
+    
+    switch( AlignX )
+    {
+    case 0:
+        InitOffset[0] = 0;
+        break;
+    case 1:
+        InitOffset[0] = FMax((CompPos[2]-XL)*0.5,0.f);
+        break;
+    default:
+        InitOffset[0] = CompPos[2]-(XL+1);
+    }
+    switch( AlignY )
+    {
+    case 0:
+        InitOffset[1] = 0;
+        break;
+    case 1:
+        InitOffset[1] = FMax((CompPos[3]-YL)*0.5,0.f);
+        break;
+    default:
+        InitOffset[1] = CompPos[3]-YL;
+    }
+}
+function SetText( string S )
+{
+    if( Text==S )
+        return;
+    Text = S;
+    OldSize[0] = -1; // Force to refresh.
+}
+final function string GetText()
+{
+    return Text;
+}
+
+function DrawMenu()
+{
+    if( Text=="" )
+        return;
+
+    // Need to figure out best fitting font.
+    if( OldSize[0]!=CompPos[2] || OldSize[1]!=CompPos[3] )
+        InitSize();
+
+    Canvas.Font = InitFont;
+    Canvas.DrawColor = TextColor;
+    if( bUseOutline )
+    {
+        Owner.CurrentStyle.DrawTextShadow(Text,InitOffset[0],InitOffset[1],OutlineSize,InitFontScale);
+    }
+    else
+    {
+        Canvas.SetPos(InitOffset[0],InitOffset[1]);
+        Canvas.DrawText(Text,,InitFontScale,InitFontScale,TextFontInfo);
+    }
+}
+function bool CaptureMouse()
+{
+    return false;
+}
+
+defaultproperties
+{
+    Text="Label"
+    TextColor=(R=255,G=255,B=255,A=255)
+    TextFontInfo=(bClipText=false,bEnableShadow=true)
+    FontScale=1.f
+    OutlineSize=1
+    bCanFocus=false
+}

Src/KFClassicHUD/Classes/KFGUI_TextScroll.uc

@@ -0,0 +1,185 @@
+Class KFGUI_TextScroll extends KFGUI_TextField;
+
+var float ScrollSpeed;
+
+var transient float CharStartTime;
+var transient bool bScrollCompleted, bTextDirty;
+var transient array<bool> RowsCompleted;
+var transient int MaxIndex, RowsDropped;
+
+function SetText( string S )
+{
+    Super.SetText(S);
+    
+    MaxIndex = 0;
+    RowsCompleted.Length = 0;
+    RowsDropped = 0;
+    
+    bScrollCompleted = false;
+    bTextDirty = true;
+    CharStartTime = GetPlayer().WorldInfo.TimeSeconds;
+}
+
+function DrawMenu()
+{
+    local int i,j,k,SLen,CurrentIndex;
+    local float Y, DTime, XL, YL, MainY, MainX, CharTime;
+    local string MainString;
+    local Color MainTextColor;
+    local Texture CurrentCursor;
+    local ETextFieldStyles TextStyle;
+
+    if( bScrollCompleted )
+    {
+        Super.DrawMenu();
+        return;
+    }
+    
+    if( Text=="" )
+        return;
+
+    // Need to figure out best fitting font.
+    if( OldSize[0]!=CompPos[2] || OldSize[1]!=CompPos[3] )
+        InitSize();
+
+    Canvas.Font = InitFont;
+
+    if( bShowScrollbar )
+    {
+        Canvas.SetClip(CompPos[0]+(CompPos[2]-ScrollWidth),CompPos[1]+CompPos[3]);
+        i = ScrollBar.GetValue();
+    }
+    else i = 0;
+    
+    if( ScrollBar != None )
+    {
+        if( bTextDirty )
+        {
+            ScrollBar.bDisabled = true;
+            RowsCompleted.Length = Lines.Length;
+            bTextDirty = false;
+        }
+        
+        if( RowsCompleted[Lines.Length-1] )
+        {
+            ScrollBar.AddValue(1);
+            ScrollBar.bDisabled = false;
+            bScrollCompleted = true;
+            
+            //Temp fix! The last line in the string seems to be skipped
+            AddText(LineSplitter);
+            
+            return;
+        }
+        else if( MaxIndex != 0 && RowsCompleted[MaxIndex] )
+        {
+            MaxIndex = 0;
+            ScrollBar.AddValue(1);
+            
+            RowsDropped++;
+            
+            i = ScrollBar.GetValue();
+        }
+    }
+    
+    if( RowsDropped > 0 )
+    {
+        for( i=0; i<=RowsDropped; ++i )
+        {
+            for( j=0; j<Lines[i].Text.Length; ++j )
+            {
+                for( k=0; k<=Len(Lines[i].Text[j].S); ++k )
+                {
+                    CharTime += ScrollSpeed;
+                }
+            }
+        }
+    }
+    
+    DTime = `TimeSinceEx(GetPlayer(), CharStartTime);
+    if( i<Lines.Length )
+    {
+        CurrentCursor = Owner.DefaultPens[GetCursorStyle()];
+        Y = Lines[i].Y;
+        for( i=i; i<Lines.Length; ++i )
+        {
+            if( (Lines[i].Y-Y+TextHeight)>=CompPos[3] )
+            {
+                MaxIndex = i-1;
+                break;
+            }
+            
+            if( Lines[i].Text.Length!=0 )
+            {
+                for( j=0; j<Lines[i].Text.Length; ++j )
+                {
+                    MainTextColor = Lines[i].Text[j].C;
+                    if( MainTextColor.A==0 )
+                        MainTextColor = TextColor;
+                        
+                    TextStyle = Lines[i].Text[j].TextType;
+                        
+                    MainX = Lines[i].Text[j].X;
+                    MainY = Lines[i].Y-Y;
+                    MainString = Lines[i].Text[j].S;
+                    SLen = Len(MainString);
+
+                    CurrentIndex = 0;
+                    for( k=0; k<=SLen; ++k )
+                    {
+                        CharTime += ScrollSpeed;
+                        
+                        Canvas.TextSize(Mid(MainString, 0, k), XL, YL, InitFontScale, InitFontScale);
+                        
+                        if ( CharTime > DTime )
+                        {
+                            if( CurrentIndex == k )
+                            {
+                                Canvas.SetDrawColor(255,255,255,255);
+                                Canvas.SetPos(MainX+XL,MainY);
+                                Canvas.DrawTile(CurrentCursor, YL/2, YL, 0, 0, CurrentCursor.GetSurfaceWidth(), CurrentCursor.GetSurfaceHeight());
+                            }
+                            
+                            continue;
+                        }
+                        
+                        Canvas.DrawColor = GetColorFromStyle(MainTextColor, TextStyle);
+                        Canvas.SetPos(MainX+XL,MainY);
+                        Canvas.DrawText(Mid(MainString, k, 1),,InitFontScale,InitFontScale,TextFontInfo);
+                        
+                        CurrentIndex = k+1;
+                        
+                        if( k >= SLen )
+                        {
+                            RowsCompleted[i] = true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+function bool CaptureMouse()
+{
+    return (!bScrollCompleted && Super(KFGUI_MultiComponent).CaptureMouse()) || Super.CaptureMouse();
+}
+
+function MouseClick( bool bRight )
+{
+    if( bScrollCompleted )
+        return;
+        
+    if( ScrollBar != None )
+        ScrollBar.bDisabled = false;
+        
+    bScrollCompleted = true;
+    
+    //Temp fix! The last line in the string seems to be skipped
+    AddText(LineSplitter);
+}
+
+defaultproperties
+{
+    ScrollSpeed=0.01
+}

Src/KFClassicHUD/Classes/KFGUI_Tooltip.uc

@@ -0,0 +1,42 @@
+Class KFGUI_Tooltip extends KFGUI_Base;
+
+var() array<string> Lines;
+var() Canvas.FontRenderInfo TextFontInfo;
+var byte CurrentAlpha;
+
+function InputMouseMoved()
+{
+    DropInputFocus();
+}
+function MouseClick( bool bRight )
+{
+    DropInputFocus();
+}
+function MouseRelease( bool bRight )
+{
+    DropInputFocus();
+}
+function ShowMenu()
+{
+    CurrentAlpha = 1;
+}
+
+final function SetText( string S )
+{
+    ParseStringIntoArray(S,Lines,"<SEPERATOR>",false);
+}
+
+function PreDraw()
+{
+    if( !bVisible )
+        return;
+        
+    Owner.CurrentStyle.RenderToolTip(Self);
+}
+
+defaultproperties
+{
+    TextFontInfo=(bClipText=true,bEnableShadow=true)
+    bCanFocus=false
+    bFocusedPostDrawItem=true
+}

Src/KFClassicHUD/Classes/KFScoreBoard.uc

@@ -0,0 +1,491 @@
+class KFScoreBoard extends KFGUI_Page;
+
+var transient float PerkXPos, PlayerXPos, StateXPos, TimeXPos, HealXPos, KillsXPos, AssistXPos, CashXPos, DeathXPos, PingXPos;
+var transient float NextScoreboardRefresh;
+
+var int PlayerIndex;
+var KFGUI_List PlayersList;
+var Texture2D DefaultAvatar;
+
+var KFGameReplicationInfo KFGRI;
+var array<KFPlayerReplicationInfo> KFPRIArray;
+
+var KFPlayerController OwnerPC;
+
+var Color PingColor;
+var float PingBars,IdealPing,MaxPing;
+
+function InitMenu()
+{
+    Super.InitMenu();
+    PlayersList = KFGUI_List(FindComponentID('PlayerList'));
+    OwnerPC = KFPlayerController(GetPlayer());
+}
+
+static function CheckAvatar(KFPlayerReplicationInfo KFPRI, KFPlayerController PC)
+{
+    local Texture2D Avatar;
+    
+    if( KFPRI.Avatar == None || KFPRI.Avatar == default.DefaultAvatar )
+    {
+        Avatar = FindAvatar(PC, KFPRI.UniqueId);
+        if( Avatar == None )
+            Avatar = default.DefaultAvatar;
+            
+        KFPRI.Avatar = Avatar;
+    }
+}
+
+delegate bool InOrder( KFPlayerReplicationInfo P1, KFPlayerReplicationInfo P2 )
+{
+    if( P1 == None || P2 == None )
+        return true;
+        
+    if( P1.GetTeamNum() < P2.GetTeamNum() )
+        return false;
+        
+    if( P1.Kills == P2.Kills )
+    {
+        if( P1.Assists == P2.Assists )
+            return true;
+            
+        return P1.Assists < P2.Assists;
+    }
+        
+    return P1.Kills < P2.Kills;
+}
+
+function DrawMenu()
+{
+    local string S;
+    local PlayerController PC;
+    local KFPlayerReplicationInfo KFPRI;
+    local PlayerReplicationInfo PRI;
+    local float XPos, YPos, YL, XL, FontScalar, XPosCenter, DefFontHeight, BoxW, BoxX;
+    local int i, j, NumSpec, NumPlayer, NumAlivePlayer, Width;
+
+    PC = GetPlayer();
+    if( KFGRI==None )
+    {
+        KFGRI = KFGameReplicationInfo(PC.WorldInfo.GRI);
+        if( KFGRI==None )
+            return;
+    }
+    
+    // Sort player list.
+    if( NextScoreboardRefresh < PC.WorldInfo.TimeSeconds )
+    {
+        NextScoreboardRefresh = PC.WorldInfo.TimeSeconds + 0.1;
+        
+        for( i=(KFGRI.PRIArray.Length-1); i>0; --i )
+        {
+            for( j=i-1; j>=0; --j )
+            {
+                if( !InOrder(KFPlayerReplicationInfo(KFGRI.PRIArray[i]),KFPlayerReplicationInfo(KFGRI.PRIArray[j])) )
+                {
+                    PRI = KFGRI.PRIArray[i];
+                    KFGRI.PRIArray[i] = KFGRI.PRIArray[j];
+                    KFGRI.PRIArray[j] = PRI;
+                }
+            }
+        }
+    }
+
+    // Check players.
+    PlayerIndex = -1;
+    NumPlayer = 0;
+    for( i=(KFGRI.PRIArray.Length-1); i>=0; --i )
+    {
+        KFPRI = KFPlayerReplicationInfo(KFGRI.PRIArray[i]);
+        if( KFPRI==None )
+            continue;
+        if( KFPRI.bOnlySpectator )
+        {
+            ++NumSpec;
+            continue;
+        }
+        if( KFPRI.PlayerHealth>0 && KFPRI.PlayerHealthPercent>0 && KFPRI.GetTeamNum()==0 )
+            ++NumAlivePlayer;
+        ++NumPlayer;
+    }
+    
+    KFPRIArray.Length = NumPlayer;
+    j = KFPRIArray.Length;
+    for( i=(KFGRI.PRIArray.Length-1); i>=0; --i )
+    {
+        KFPRI = KFPlayerReplicationInfo(KFGRI.PRIArray[i]);
+        if( KFPRI!=None && !KFPRI.bOnlySpectator )
+        {
+            KFPRIArray[--j] = KFPRI;
+            if( KFPRI==PC.PlayerReplicationInfo )
+                PlayerIndex = j;
+        }
+    }
+
+    // Header font info.
+    Canvas.Font = Owner.CurrentStyle.PickFont(FontScalar);
+    YL = Owner.CurrentStyle.DefaultHeight;
+    DefFontHeight = YL;
+
+    XPosCenter = (Canvas.ClipX * 0.5);
+    
+    // Server Name
+    
+    XPos = XPosCenter;
+    YPos += DefFontHeight;
+    
+    S = KFGRI.ServerName;
+    Canvas.TextSize(S, XL, YL, FontScalar, FontScalar);
+    
+    BoxW = XL + (Owner.HUDOwner.ScaledBorderSize*4);
+    BoxX = XPos - (BoxW * 0.5);
+    Canvas.SetDrawColor(10, 10, 10, 200);
+    Owner.CurrentStyle.DrawRectBox(BoxX, YPos, BoxW, DefFontHeight, 4);
+    Canvas.SetDrawColor(250, 0, 0, 255);
+    
+    Owner.CurrentStyle.DrawTextShadow(S, BoxX + ((BoxW-XL) / 2), YPos + ((DefFontHeight-YL) / 2), 1, FontScalar);
+
+    // Deficulty | Wave | MapName
+
+    XPos = XPosCenter;
+    YPos += DefFontHeight+Owner.HUDOwner.ScaledBorderSize;
+
+    S = " " $Class'KFCommon_LocalizedStrings'.Static.GetDifficultyString (KFGRI.GameDifficulty) $"  |  "$class'KFGFxHUD_ScoreboardMapInfoContainer'.default.WaveString@KFGRI.WaveNum $"  |  " $class'KFCommon_LocalizedStrings'.static.GetFriendlyMapName(PC.WorldInfo.GetMapName(true));
+    Canvas.TextSize(S, XL, YL, FontScalar, FontScalar);
+    
+    BoxW = XL + (Owner.HUDOwner.ScaledBorderSize*4);
+    BoxX = XPos - (BoxW * 0.5);
+    Canvas.SetDrawColor(10, 10, 10, 200);
+    Owner.CurrentStyle.DrawRectBox(BoxX, YPos, BoxW, DefFontHeight, 4);
+    Canvas.SetDrawColor(0, 250, 0, 255);
+    
+    Owner.CurrentStyle.DrawTextShadow(S, BoxX + ((BoxW-XL) / 2), YPos + ((DefFontHeight-YL) / 2), 1, FontScalar);
+    
+    // Players | Spectators | Alive | Time
+
+    XPos = XPosCenter;
+    YPos += DefFontHeight+Owner.HUDOwner.ScaledBorderSize;
+    
+    S = " Players : " $ NumPlayer $ "  |  Spectators : " $ NumSpec $ "  |  Alive : " $ NumAlivePlayer $ "  |  Elapsed Time : " $ Owner.CurrentStyle.GetTimeString(KFGRI.ElapsedTime) $ " ";
+    Canvas.TextSize(S, XL, YL, FontScalar, FontScalar);
+    
+    BoxW = XL + (Owner.HUDOwner.ScaledBorderSize*4);
+    BoxX = XPos - (BoxW * 0.5);
+    Canvas.SetDrawColor(10, 10, 10, 200);
+    Owner.CurrentStyle.DrawRectBox(BoxX, YPos, BoxW, DefFontHeight, 4);
+    Canvas.SetDrawColor(250, 250, 0, 255);
+    
+    Owner.CurrentStyle.DrawTextShadow(S, BoxX + ((BoxW-XL) / 2), YPos + ((DefFontHeight-YL) / 2), 1, FontScalar);
+    
+    Width = Canvas.ClipX * 0.625;
+
+    XPos = (Canvas.ClipX - Width) * 0.5;
+    YPos += DefFontHeight * 2.0;
+    
+    Canvas.SetDrawColor (10, 10, 10, 200);
+    Owner.CurrentStyle.DrawRectBox(XPos, YPos, Width, DefFontHeight, 4);
+
+    Canvas.SetDrawColor(250, 250, 250, 255);
+
+    // Calc X offsets
+    PerkXPos = Width * 0.01;
+    PlayerXPos = Width * 0.2;
+    KillsXPos = Width * 0.5;
+    AssistXPos = Width * 0.6;
+    CashXPos = Width * 0.7;
+    StateXPos = Width * 0.8;
+    PingXPos = Width * 0.92;
+
+    // Header texts
+    Canvas.SetPos (XPos + PerkXPos, YPos);
+    Canvas.DrawText (class'KFGFxMenu_Inventory'.default.PerkFilterString, , FontScalar, FontScalar);
+
+    Canvas.SetPos (XPos + KillsXPos, YPos);
+    Canvas.DrawText (class'KFGFxHUD_ScoreboardWidget'.default.KillsString, , FontScalar, FontScalar);
+
+    Canvas.SetPos (XPos + AssistXPos, YPos);
+    Canvas.DrawText (class'KFGFxHUD_ScoreboardWidget'.default.AssistsString, , FontScalar, FontScalar);
+
+    Canvas.SetPos (XPos + CashXPos, YPos);
+    Canvas.DrawText (class'KFGFxHUD_ScoreboardWidget'.default.DoshString, , FontScalar, FontScalar);
+
+    Canvas.SetPos (XPos + StateXPos, YPos);
+    Canvas.DrawText ("STATE", , FontScalar, FontScalar);
+    
+    Canvas.SetPos (XPos + PlayerXPos, YPos);
+    Canvas.DrawText (class'KFGFxHUD_ScoreboardWidget'.default.PlayerString, , FontScalar, FontScalar);
+
+    Canvas.SetPos (XPos + PingXPos, YPos);
+    Canvas.DrawText (class'KFGFxHUD_ScoreboardWidget'.default.PingString, , FontScalar, FontScalar);
+
+    PlayersList.XPosition = ((Canvas.ClipX - Width) * 0.5) / InputPos[2];
+    PlayersList.YPosition = (YPos + (YL + 4)) / InputPos[3];
+    PlayersList.YSize = (1.f - PlayersList.YPosition) - 0.15;
+    
+    PlayersList.ChangeListSize(KFPRIArray.Length);
+}
+
+function DrawPlayerEntry( Canvas C, int Index, float YOffset, float Height, float Width, bool bFocus )
+{
+    local string S, StrValue;
+    local float FontScalar, TextYOffset, XL, YL, PerkIconPosX, PerkIconPosY, PerkIconSize, PrestigeIconScale;
+    local KFPlayerReplicationInfo KFPRI;
+    local byte Level, PrestigeLevel;
+    local bool bIsZED;
+    local int Ping;
+    
+    YOffset *= 1.05;
+    KFPRI = KFPRIArray[Index];
+    
+    if( KFGRI.bVersusGame )
+        bIsZED = KFTeamInfo_Zeds(KFPRI.Team) != None;
+    
+    C.Font = Owner.CurrentStyle.PickFont(FontScalar);
+    
+    TextYOffset = YOffset + (Height / 2) - (Owner.CurrentStyle.DefaultHeight / 2);
+    if (PlayerIndex == Index)
+        C.SetDrawColor (51, 30, 101, 150);
+    else C.SetDrawColor (30, 30, 30, 150);
+    
+    Owner.CurrentStyle.DrawRectBox(0.f, YOffset, Width, Height, 4);
+    
+    C.SetDrawColor(250,250,250,255);
+
+    // Perk
+    if( bIsZED )
+    {
+        C.SetDrawColor(255,0,0,255);
+        C.SetPos (PerkXPos, YOffset - ((Height-5) / 2));
+        C.DrawRect (Height-5, Height-5, Texture2D'UI_Widgets.MenuBarWidget_SWF_IF');
+        
+        S = "ZED";
+        C.SetPos (PerkXPos + Height, TextYOffset);
+        C.DrawText (S, , FontScalar, FontScalar);
+    }
+    else
+    {
+        if( KFPRI.CurrentPerkClass!=None )
+        {
+			PrestigeLevel = KFPRI.GetActivePerkPrestigeLevel();
+			Level = KFPRI.GetActivePerkLevel();
+			
+			PerkIconPosX = PerkXPos;
+			PerkIconPosY = YOffset + (Owner.HUDOwner.ScaledBorderSize * 2);
+			PerkIconSize = Height-(Owner.HUDOwner.ScaledBorderSize * 4);
+			PrestigeIconScale = 0.6625f;
+			
+            C.DrawColor = HUDOwner.WhiteColor;
+			if (PrestigeLevel > 0)
+			{
+				C.SetPos(PerkIconPosX, PerkIconPosY);
+				C.DrawTile(KFPRI.CurrentPerkClass.default.PrestigeIcons[PrestigeLevel - 1], PerkIconSize, PerkIconSize, 0, 0, 256, 256);
+				
+				C.SetPos(PerkIconPosX + ((PerkIconSize/2) - ((PerkIconSize*PrestigeIconScale)/2)), PerkIconPosY + ((PerkIconSize/2) - ((PerkIconSize*PrestigeIconScale)/1.75)));
+				C.DrawTile(KFPRI.CurrentPerkClass.default.PerkIcon, PerkIconSize * PrestigeIconScale, PerkIconSize * PrestigeIconScale, 0, 0, 256, 256);
+			}
+			else
+			{
+				C.SetPos(PerkIconPosX, PerkIconPosY);
+				C.DrawTile(KFPRI.CurrentPerkClass.default.PerkIcon, PerkIconSize, PerkIconSize, 0, 0, 256, 256);
+			}		
+			
+			C.SetDrawColor(250,250,250,255);
+			C.SetPos(PerkIconPosX + PerkIconSize + (Owner.HUDOwner.ScaledBorderSize*2), TextYOffset);
+			C.DrawText(Level@KFPRI.CurrentPerkClass.default.PerkName, , FontScalar, FontScalar);
+        }
+        else
+        {
+            C.SetDrawColor(250,250,250,255);
+            S = "No Perk";
+            C.SetPos (PerkXPos + Height, TextYOffset);
+            C.DrawText (S, , FontScalar, FontScalar);
+        }
+    }
+    
+    // Avatar
+    if( KFPRI.Avatar != None )
+    {
+        if( KFPRI.Avatar == default.DefaultAvatar )
+            CheckAvatar(KFPRI, OwnerPC);
+            
+        C.SetDrawColor(255,255,255,255);
+        C.SetPos(PlayerXPos - (Height * 1.075), YOffset + (Height / 2) - ((Height - 6) / 2));
+        C.DrawTile(KFPRI.Avatar,Height - 6,Height - 6,0,0,KFPRI.Avatar.SizeX,KFPRI.Avatar.SizeY);
+        Owner.CurrentStyle.DrawBoxHollow(PlayerXPos - (Height * 1.075), YOffset + (Height / 2) - ((Height - 6) / 2), Height - 6, Height - 6, 1);
+    } 
+    else if( !KFPRI.bBot )
+        CheckAvatar(KFPRI, OwnerPC);
+
+    // Player
+    C.SetPos (PlayerXPos, TextYOffset);
+    
+    if( Len(KFPRI.PlayerName) > 25 )
+        S = Left(KFPRI.PlayerName, 25);
+    else S = KFPRI.PlayerName;
+    C.DrawText (S, , FontScalar, FontScalar);
+    
+    C.SetDrawColor(255,255,255,255);
+
+    // Kill
+    C.SetPos (KillsXPos, TextYOffset);
+    C.DrawText (string (KFPRI.Kills), , FontScalar, FontScalar);
+
+    // Assist
+    C.SetPos (AssistXPos, TextYOffset);
+    C.DrawText (string (KFPRI.Assists), , FontScalar, FontScalar);
+
+    // Cash
+    C.SetPos (CashXPos, TextYOffset);
+    if( bIsZED )
+    {
+        C.SetDrawColor(250, 0, 0, 255);
+        StrValue = "Brains!";
+    }
+    else
+    {
+        C.SetDrawColor(250, 250, 100, 255);
+        StrValue = "£"$GetNiceSize(int(KFPRI.Score));
+    }
+    C.DrawText (StrValue, , FontScalar, FontScalar);
+    
+    C.SetDrawColor(255,255,255,255);
+
+    // State
+    if( !KFPRI.bReadyToPlay && KFGRI.bMatchHasBegun )
+    {
+        C.SetDrawColor(250,0,0,255);
+        S = "LOBBY";
+    }
+    else if( !KFGRI.bMatchHasBegun )
+    {
+        C.SetDrawColor(250,0,0,255);
+        S = KFPRI.bReadyToPlay ? "Ready" : "Not Ready";    
+    }
+    else if( bIsZED && KFTeamInfo_Zeds(GetPlayer().PlayerReplicationInfo.Team) == None )
+    {
+        C.SetDrawColor(250,0,0,255);
+        S = "Unknown";
+    }
+    else if (KFPRI.PlayerHealth <= 0 || KFPRI.PlayerHealthPercent <= 0)
+    {
+        C.SetDrawColor(250,0,0,255);
+        S = (KFPRI.bOnlySpectator) ? "Spectator" : "DEAD";
+    }
+    else
+    {
+        if (ByteToFloat(KFPRI.PlayerHealthPercent) >= 0.8)
+            C.SetDrawColor(0,250,0,255);
+        else if (ByteToFloat(KFPRI.PlayerHealthPercent) >= 0.4)
+            C.SetDrawColor(250,250,0,255);
+        else C.SetDrawColor(250,100,100,255);
+        
+        S =  string (KFPRI.PlayerHealth) @"HP";
+    }
+
+    C.SetPos (StateXPos, TextYOffset);
+    C.DrawText (S, , FontScalar, FontScalar);
+    
+    C.SetDrawColor(250,250,250,255);
+
+    // Ping
+    if (KFPRI.bBot)
+        S = "-";
+    else
+    {
+        Ping = int(KFPRI.Ping * `PING_SCALE);
+        
+        if (Ping <= 100)
+            C.SetDrawColor(0,250,0,255);
+        else if (Ping <= 200)
+            C.SetDrawColor(250,250,0,255);
+        else C.SetDrawColor(250,100,100,255);
+        
+        S = string(Ping);
+    }
+        
+    C.TextSize(MaxPing, XL, YL, FontScalar, FontScalar);
+    
+    C.SetPos(PingXPos, TextYOffset);
+    C.DrawText(S,, FontScalar, FontScalar);
+    
+    DrawPingBars(C, YOffset + (Height/2) - ((Height*0.5)/2), Width - (Height*0.5) - (Owner.HUDOwner.ScaledBorderSize*2), Height*0.5, Height*0.5, float(Ping));
+}
+
+final function DrawPingBars( Canvas C, float YOffset, float XOffset, float W, float H, float Ping )
+{
+    local float PingMul, BarW, BarH, BaseH, XPos, YPos;
+    local byte i;
+    
+    PingMul = 1.f - FClamp(FMax(Ping - IdealPing, 1.f) / MaxPing, 0.f, 1.f);
+    BarW = W / PingBars;
+    BaseH = H / PingBars;
+
+    PingColor.R = (1.f - PingMul) * 255;
+    PingColor.G = PingMul * 255;
+
+    for(i=1; i<PingBars; i++)
+    {
+        BarH = BaseH * i;
+        XPos = XOffset + ((i - 1) * BarW);
+        YPos = YOffset + (H - BarH);
+
+        C.SetPos(XPos,YPos);
+        C.SetDrawColor(20, 20, 20, 255);
+        Owner.CurrentStyle.DrawWhiteBox(BarW,BarH);
+
+        if( PingMul >= (i / PingBars) )
+        {
+            C.SetPos(XPos,YPos);
+            C.DrawColor = PingColor;
+            Owner.CurrentStyle.DrawWhiteBox(BarW,BarH);
+        }
+
+        C.SetDrawColor(80, 80, 80, 255);
+        Owner.CurrentStyle.DrawBoxHollow(XPos,YPos,BarW,BarH,1);
+    }
+}
+
+static final function Texture2D FindAvatar( KFPlayerController PC, UniqueNetId ClientID )
+{
+    local string S;
+    
+    S = PC.GetSteamAvatar(ClientID);
+    if( S=="" )
+        return None;
+    return Texture2D(PC.FindObject(S,class'Texture2D'));
+}
+
+final static function string GetNiceSize(int Num)
+{
+    if( Num < 1000 ) return string(Num);
+    else if( Num < 1000000 ) return (Num / 1000) $ "K";
+    else if( Num < 1000000000 ) return (Num / 1000000) $ "M";
+
+    return (Num / 1000000000) $ "B";
+}
+
+function ScrollMouseWheel( bool bUp )
+{
+    PlayersList.ScrollMouseWheel(bUp);
+}
+
+defaultproperties
+{
+    bEnableInputs=true
+    
+    PingColor=(R=255,G=255,B=60,A=255)
+    IdealPing=50.0
+    MaxPing=200.0
+    PingBars=5.0
+    
+    Begin Object Class=KFGUI_List Name=PlayerList
+        XSize=0.625
+        OnDrawItem=DrawPlayerEntry
+        ID="PlayerList"
+        bClickable=false
+        ListItemsPerPage=16
+    End Object
+    Components.Add(PlayerList)
+    
+    DefaultAvatar=Texture2D'UI_HUD.ScoreBoard_Standard_SWF_I26'
+}

Src/KFClassicHUD/Globals.uci

@@ -0,0 +1,81 @@
+`define WM_WAVEINBOUND 			1
+`define WM_WAVESURVIVED 		2
+`define WM_FINALWAVEINBOUND 	3
+`define WM_BOSSINBOUND 			4
+`define WM_DEFEATED 			5
+`define WM_SURVIVED 			6
+
+`define TRADER_ALMOSTOPEN 		0
+`define TRADER_MOVING 			1
+`define TRADER_OPEN 			2
+`define TRADER_CLOSED 			3
+`define TRADER_THIRTYSECONDS 	4
+`define TRADER_TENSECONDS 		5
+`define TRADER_LASTWAVE 		6
+`define TRADER_WELCOME 			7
+`define TRADER_TOOEXPENSIVE 	8
+`define TRADER_TOOHEAVY 		9
+`define TRADER_WALKIEBEEP 		10
+
+`define BOX_INNERBORDER 					0
+`define	BOX_INNERBORDER_TRANSPARENT 		1
+`define	BOX_MEDIUM 							2
+`define	BOX_MEDIUM_SLIGHTTRANSPARENT 		3
+`define	BOX_MEDIUM_TRANSPARENT 				4
+`define	BOX_LARGE 							5
+`define	BOX_LARGE_SLIGHTTRANSPARENT 		6
+`define	BOX_LARGE_TRANSPARENT 				7
+`define	BOX_SMALL 							8
+`define	BOX_SMALL_SLIGHTTRANSPARENT 		9
+`define	BOX_SMALL_TRANSPARENT				10
+`define	BOX_CORNER_8						11
+`define	BOX_CORNER_16						12
+`define	BOX_CORNER_32						13
+`define	BOX_CORNER_64						14
+`define	BOX_CORNER_512						15
+
+`define ITEMBOX_NORMAL		0
+`define ITEMBOX_DISABLED	1
+`define ITEMBOX_HIGHLIGHTED	2
+
+`define ITEMBOX_BAR_NORMAL		3
+`define ITEMBOX_BAR_DISABLED	4
+`define ITEMBOX_BAR_HIGHLIGHTED	5
+
+`define PROGRESS_BAR_NORMAL		0
+`define PROGRESS_BAR_SELECTED	1
+
+`define CHECKMARK_NORMAL		0
+`define CHECKMARK_DISABLED		1
+`define CHECKMARK_HIGHLIGHTED	2
+
+`define PERK_BOX_SELECTED	0
+`define PERK_BOX_UNSELECTED	1
+
+`define	ARROW_DOWN		0
+`define	ARROW_LEFT		1
+`define	ARROW_RIGHT		2
+`define	ARROW_UP		3
+
+`define	BUTTON_NORMAL			0
+`define	BUTTON_DISABLED			1
+`define	BUTTON_HIGHLIGHTED		2
+`define	BUTTON_PRESSED			3
+
+`define	TAB_TOP			0
+`define	TAB_BOTTOM		1
+
+`define PEN_WHITE	0
+`define PEN_BLACK	1
+`define PEN_GRAY	2
+
+`define SLIDER_NORMAL 	0
+`define SLIDER_GRIP		1
+`define SLIDER_DISABLED	2
+
+`define CURSOR_DEFAULT 		0
+`define CURSOR_SELECTION 	1
+`define CURSOR_RESIZEVERT	2
+`define CURSOR_RESIZEHORZ 	3
+
+`define Print(log) LocalPlayer(class'WorldInfo'.static.GetWorldInfo().GetALocalPlayerController().Player).ViewportClient.ViewportConsole.OutputText(`log)